Coverage Report

Coverage Report - org.kuali.rice.ksb.cache.RiceCacheAdministratorImpl

Classes in this File

Line Coverage

Branch Coverage

Complexity

RiceCacheAdministratorImpl

0/63

0/12

1.5

 /*
  * Copyright 2006-2011 The Kuali Foundation
  *
  * Licensed under the Educational Community License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.opensource.org/licenses/ecl2.php
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.kuali.rice.ksb.cache;
 
 import com.opensymphony.oscache.base.AbstractCacheAdministrator;
 import com.opensymphony.oscache.base.NeedsRefreshException;
 import com.opensymphony.oscache.general.GeneralCacheAdministrator;
 import org.apache.commons.lang.StringUtils;
 import org.apache.log4j.Logger;
 import org.kuali.rice.core.api.config.property.ConfigContext;
 import org.kuali.rice.ksb.messaging.RemotedServiceRegistry;
 
 import java.util.Properties;
 
 /**
  * Default implementation of the {@link RiceCacheAdministrator}.
  *
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public class RiceCacheAdministratorImpl implements RiceCacheAdministrator {
 
     private static final String DEFAULT_SERVICE_NAME = "OSCacheNotificationService";
     
         private static final String CACHE_PREFIX = "cache.";
         private GeneralCacheAdministrator cacheAdministrator;
         private boolean started;
         private boolean forceRegistryRefresh;
         private String serviceName;
         protected RemotedServiceRegistry remotedServiceRegistry;
         private static final Logger LOG = Logger.getLogger(RiceCacheAdministratorImpl.class);
         
         /**
          * @return the remotedServiceRegistry
          */
         public RemotedServiceRegistry getRemotedServiceRegistry() {
                 return this.remotedServiceRegistry;
         }
 
         /**
          * @param remotedServiceRegistry the remotedServiceRegistry to set
          */
         public void setRemotedServiceRegistry(
                         RemotedServiceRegistry remotedServiceRegistry) {
                 this.remotedServiceRegistry = remotedServiceRegistry;
         }
 
         public boolean isStarted() {
                 return this.started;
         }
 
         public Object getFromCache(String key) {
                 try {
                         return getCacheAdministrator().getFromCache(key);
                 } catch (NeedsRefreshException e) {
                         getCacheAdministrator().cancelUpdate(key);
                         return null;
                 }
         }
 
         public void putInCache(String key, Object content, String[] groups) {
             try {
                 getCacheAdministrator().putInCache(key, content, groups);
             } catch (IllegalStateException e) {
                 LOG.warn("Failed to insert object into cache with key: " + key);
             }
         }
 
         public void putInCache(String key, Object content) {
             try {
                 getCacheAdministrator().putInCache(key, content);
             } catch (IllegalStateException e) {
             LOG.warn("Failed to insert object into cache with key: " + key);
         }
         }
 
 
         public void flushEntry(String key) {
                 getCacheAdministrator().flushEntry(key);
         }
 
 
         public void flushGroup(String group) {
                 getCacheAdministrator().flushGroup(group);
         }
 
         public void flushAll() {
                 getCacheAdministrator().flushAll();
         }
 
         public void setCacheCapacity(int capacity) {
                 getCacheAdministrator().setCacheCapacity(capacity);
         }
 
         public int getCacheCapacity() {
                 return getCacheAdministrator().getCache().getCapacity();
         }
 
         public int getSize() {
                 return getCacheAdministrator().getCache().getSize();
         }
 
         public void start() throws Exception {
                 Properties props = loadCacheSettings();
                 this.cacheAdministrator = new GeneralCacheAdministrator(props);
         }
 
         protected Properties loadCacheSettings() {
                 Properties properties = new Properties();
                 Properties configProperties = ConfigContext.getCurrentContextConfig().getProperties();
                 for (Object keyObject : configProperties.keySet()) {
                         String key = (String)keyObject;
                         if (key.startsWith(CACHE_PREFIX)) {
                                 properties.put(key, configProperties.getProperty(key));
                         }
                 }
                 // setup defaults if certain properties aren't set
                 if (!properties.containsKey(AbstractCacheAdministrator.CACHE_MEMORY_KEY)) {
                         properties.put(AbstractCacheAdministrator.CACHE_MEMORY_KEY, "true");
                 }
                 if (!properties.containsKey(AbstractCacheAdministrator.CACHE_ENTRY_EVENT_LISTENERS_KEY)) {
                         properties.put(AbstractCacheAdministrator.CACHE_ENTRY_EVENT_LISTENERS_KEY, RiceDistributedCacheListener.class.getName());
                 }
                 if (!properties.containsKey(AbstractCacheAdministrator.CACHE_BLOCKING_KEY)) {
                         properties.put(AbstractCacheAdministrator.CACHE_BLOCKING_KEY, "false");
                 }
                 properties.put(RiceCacheAdministrator.FORCE_REGISTRY_REFRESH_KEY, new Boolean(this.forceRegistryRefresh));
                 properties.put(RiceCacheAdministrator.REMOTED_SERVICE_REGISTRY, remotedServiceRegistry);
                 if (StringUtils.isBlank(this.serviceName)) {
                     this.serviceName = DEFAULT_SERVICE_NAME;
                 }
                 properties.put(RiceCacheAdministrator.SERVICE_NAME_KEY, this.serviceName);
                 return properties;
         }
 
         public void stop() throws Exception {
                 getCacheAdministrator().destroy();
                 this.started = false;
         }
 
         public void putInCache(String key, Object content, String group) {
                 putInCache(key, content, new String[] {group});
         }
 
         protected GeneralCacheAdministrator getCacheAdministrator() {
                 return this.cacheAdministrator;
         }
 
         public void setForceRegistryRefresh(boolean forceRegistryRefresh) {
                 this.forceRegistryRefresh = forceRegistryRefresh;
         }
 
         public String getServiceName() {
             return this.serviceName;
         }
 
         public void setServiceName(String serviceName) {
             this.serviceName = serviceName;
         }
         
 }

1		/*
2		* Copyright 2006-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16
17		package org.kuali.rice.ksb.cache;
18
19		import com.opensymphony.oscache.base.AbstractCacheAdministrator;
20		import com.opensymphony.oscache.base.NeedsRefreshException;
21		import com.opensymphony.oscache.general.GeneralCacheAdministrator;
22		import org.apache.commons.lang.StringUtils;
23		import org.apache.log4j.Logger;
24		import org.kuali.rice.core.api.config.property.ConfigContext;
25		import org.kuali.rice.ksb.messaging.RemotedServiceRegistry;
26
27		import java.util.Properties;
28
29		/**
30		* Default implementation of the {@link RiceCacheAdministrator}.
31		*
32		* @author Kuali Rice Team (rice.collab@kuali.org)
33		*/
34	0	public class RiceCacheAdministratorImpl implements RiceCacheAdministrator {
35
36		private static final String DEFAULT_SERVICE_NAME = "OSCacheNotificationService";
37
38		private static final String CACHE_PREFIX = "cache.";
39		private GeneralCacheAdministrator cacheAdministrator;
40		private boolean started;
41		private boolean forceRegistryRefresh;
42		private String serviceName;
43		protected RemotedServiceRegistry remotedServiceRegistry;
44	0	private static final Logger LOG = Logger.getLogger(RiceCacheAdministratorImpl.class);
45
46		/**
47		* @return the remotedServiceRegistry
48		*/
49		public RemotedServiceRegistry getRemotedServiceRegistry() {
50	0	return this.remotedServiceRegistry;
51		}
52
53		/**
54		* @param remotedServiceRegistry the remotedServiceRegistry to set
55		*/
56		public void setRemotedServiceRegistry(
57		RemotedServiceRegistry remotedServiceRegistry) {
58	0	this.remotedServiceRegistry = remotedServiceRegistry;
59	0	}
60
61		public boolean isStarted() {
62	0	return this.started;
63		}
64
65		public Object getFromCache(String key) {
66		try {
67	0	return getCacheAdministrator().getFromCache(key);
68	0	} catch (NeedsRefreshException e) {
69	0	getCacheAdministrator().cancelUpdate(key);
70	0	return null;
71		}
72		}
73
74		public void putInCache(String key, Object content, String[] groups) {
75		try {
76	0	getCacheAdministrator().putInCache(key, content, groups);
77	0	} catch (IllegalStateException e) {
78	0	LOG.warn("Failed to insert object into cache with key: " + key);
79	0	}
80	0	}
81
82		public void putInCache(String key, Object content) {
83		try {
84	0	getCacheAdministrator().putInCache(key, content);
85	0	} catch (IllegalStateException e) {
86	0	LOG.warn("Failed to insert object into cache with key: " + key);
87	0	}
88	0	}
89
90
91		public void flushEntry(String key) {
92	0	getCacheAdministrator().flushEntry(key);
93	0	}
94
95
96		public void flushGroup(String group) {
97	0	getCacheAdministrator().flushGroup(group);
98	0	}
99
100		public void flushAll() {
101	0	getCacheAdministrator().flushAll();
102	0	}
103
104		public void setCacheCapacity(int capacity) {
105	0	getCacheAdministrator().setCacheCapacity(capacity);
106	0	}
107
108		public int getCacheCapacity() {
109	0	return getCacheAdministrator().getCache().getCapacity();
110		}
111
112		public int getSize() {
113	0	return getCacheAdministrator().getCache().getSize();
114		}
115
116		public void start() throws Exception {
117	0	Properties props = loadCacheSettings();
118	0	this.cacheAdministrator = new GeneralCacheAdministrator(props);
119	0	}
120
121		protected Properties loadCacheSettings() {
122	0	Properties properties = new Properties();
123	0	Properties configProperties = ConfigContext.getCurrentContextConfig().getProperties();
124	0	for (Object keyObject : configProperties.keySet()) {
125	0	String key = (String)keyObject;
126	0	if (key.startsWith(CACHE_PREFIX)) {
127	0	properties.put(key, configProperties.getProperty(key));
128		}
129	0	}
130		// setup defaults if certain properties aren't set
131	0	if (!properties.containsKey(AbstractCacheAdministrator.CACHE_MEMORY_KEY)) {
132	0	properties.put(AbstractCacheAdministrator.CACHE_MEMORY_KEY, "true");
133		}
134	0	if (!properties.containsKey(AbstractCacheAdministrator.CACHE_ENTRY_EVENT_LISTENERS_KEY)) {
135	0	properties.put(AbstractCacheAdministrator.CACHE_ENTRY_EVENT_LISTENERS_KEY, RiceDistributedCacheListener.class.getName());
136		}
137	0	if (!properties.containsKey(AbstractCacheAdministrator.CACHE_BLOCKING_KEY)) {
138	0	properties.put(AbstractCacheAdministrator.CACHE_BLOCKING_KEY, "false");
139		}
140	0	properties.put(RiceCacheAdministrator.FORCE_REGISTRY_REFRESH_KEY, new Boolean(this.forceRegistryRefresh));
141	0	properties.put(RiceCacheAdministrator.REMOTED_SERVICE_REGISTRY, remotedServiceRegistry);
142	0	if (StringUtils.isBlank(this.serviceName)) {
143	0	this.serviceName = DEFAULT_SERVICE_NAME;
144		}
145	0	properties.put(RiceCacheAdministrator.SERVICE_NAME_KEY, this.serviceName);
146	0	return properties;
147		}
148
149		public void stop() throws Exception {
150	0	getCacheAdministrator().destroy();
151	0	this.started = false;
152	0	}
153
154		public void putInCache(String key, Object content, String group) {
155	0	putInCache(key, content, new String[] {group});
156	0	}
157
158		protected GeneralCacheAdministrator getCacheAdministrator() {
159	0	return this.cacheAdministrator;
160		}
161
162		public void setForceRegistryRefresh(boolean forceRegistryRefresh) {
163	0	this.forceRegistryRefresh = forceRegistryRefresh;
164	0	}
165
166		public String getServiceName() {
167	0	return this.serviceName;
168		}
169
170		public void setServiceName(String serviceName) {
171	0	this.serviceName = serviceName;
172	0	}
173
174		}