KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > javax > util > jcache > CacheAttributes


1 /* Open Source Java Caching Service
2 * Copyright (C) 2002 Frank Karlstrøm
3 * This library is free software; you can redistribute it and/or
4 * modify it under the terms of the GNU Lesser General Public
5 * License as published by the Free Software Foundation; either
6 * version 2.1 of the License, or (at your option) any later version.
7 *
8 * This library is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 * Lesser General Public License for more details.
12 *
13 * You should have received a copy of the GNU Lesser General Public
14 * License along with this library; if not, write to the Free Software
15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 *
17 * The author can be contacted by email: fjankk@users.sourceforge.net
18 */
19 package javax.util.jcache;
20
21 import java.net.InetAddress JavaDoc;
22 import java.util.Enumeration JavaDoc;
23 import java.util.Vector JavaDoc;
24 import org.fjank.jcache.CacheImpl;
25 import org.fjank.jcache.DefaultCacheLogger;
26
27
28 /**
29  * An administrative interface to the cache.
30  * Invalid parameters to the methods of this class will be silently ignored.
31  * @deprecated removed with no replacement.
32  * @author Frank Karlstrøm
33  */
34 public class CacheAttributes implements Cloneable JavaDoc {
35     private CacheImpl cache;
36
37     public void registerCache(CacheImpl cache) {
38         this.cache=cache;
39     }
40     /**a boolean indication wether thihs object is local or distributed.
41      */
42     private boolean local = false;
43
44     
45     /**
46      *the default log-file name.
47      */
48     private String JavaDoc defaultLogFileName = "jcache.log";
49
50     /**
51      * the default clean interval.
52      */
53     private int cleanInterval = 30;
54
55     /**
56      * the default size of the disk cache.
57      */
58     private int diskSize = 10;
59
60     /**
61      * the default path the the disk file(s)
62      */
63     private String JavaDoc diskPath = null;
64
65     /**
66      * the default maximum number of objects in the cache.
67      */
68     private int maxObjects = 5000;
69
70     /**
71      *the default maximum size of the in-memory cache.
72      */
73     private int maxSize = 1;
74
75     /**
76      * the default CacheLogger.
77      */
78     private CacheLogger logger = new DefaultCacheLogger();
79
80     /**
81      * Default constructor.
82      */
83     private CacheAttributes() {
84     }
85     /**
86      * sets the attribute to indicate the cache is local. Invalidations and
87      * updates will not be propagated to other caches in the system.
88      */
89     public void setLocal() {
90         local = true;
91     }
92
93     /**
94      * is used to set the attribute to determine the maximum number of objects
95      * allowed in the memory cache. If the max number of objects or the cache
96      * size is set, the default for one not set is ignored. if both are set,
97      * both are used to determine the capacity of the cache, i.e. object will
98      * be reomved from the cache if either limit is reached.
99      *
100      * @param size the maximum number of objects in the cache.
101      */
102     public void setMaxObjects(int size) {
103         this.maxObjects = size;
104     }
105
106     /**
107      * sets the attribute to indicate the maximum size of the memory cache. If
108      * the max number of objects in the cache are set, the default for the one
109      * not set is ignored. if both are set, both are used to determine the
110      * capacity of the cache, i.e. object will be reomved from the cache if
111      * either limit is reached.
112      *
113      * @param size the maximum size of the memory cache in megabytes.
114      */
115     public void setMemoryCacheSize(int size) {
116         this.maxSize = size;
117     }
118
119     /**
120      * sets the attribute to indicate the maximum size of the disk cache.
121      *
122      * @param size the maximum size of the disk cache in megabytes.
123      */
124     public void setDiskCacheSize(int size) {
125         this.diskSize = size;
126         
127     }
128
129     /**
130      * sets the attribute indicating the root location for the disk cache.
131      *
132      * @param path the path to the root location for the disk cache.
133      */
134     public void setDiskPath(String JavaDoc path) {
135         this.diskPath = path;
136     }
137
138     /**
139      * sets the logger object wich will be used to log cache messages.
140      *
141      * @param logger the logger wich will log cache messages.
142      */
143     public void setLogger(CacheLogger logger) {
144         this.logger = logger;
145     }
146
147     /**
148      * sets the log file name for the DefaultCacheLogger. If the default logger
149      * is being used (a new CacheLogger has not been implemented and set), all
150      * cache log messages will be written to the file "jcache.log" wich is
151      * created in the directory where the server process is started up. This
152      * method changes the location and name of the file to be used.
153      *
154      * @param pDefaultLogFileName is a full path name for the log file.
155      */
156     public void setDefaultLogFileName(String JavaDoc pDefaultLogFileName) {
157         this.defaultLogFileName = pDefaultLogFileName;
158     }
159
160     /**
161      * sets the attribute indicating how often the cacha should be checked for
162      * objects invalidated by "time to live" or "idle time" attributes.
163      *
164      * @param seconds how many seconds between each check.
165      */
166     public void setCleanInterval(int seconds) {
167         this.cleanInterval = seconds;
168     }
169
170     /**
171      * is used to specify the network address and port to be used by the cache
172      * messaging system. At least one address is required by the cache to
173      * allow discovery when a process using the cache is first brought online.
174      * If no address is specified, localhost with a default port is used. If
175      * the system of caches is across multiple nodes, it is best to have an
176      * address specified for each node to protect against unavailable nodes.
177      *
178      * The implementation of this method will do nothing, as the caches
179      * auto-discover themselves. As long as a cache is marked as distributed,
180      * it will automatically register itselves with the other cache nodes.
181      * @param address the address of the remote cache.
182      * @param port the port of the remote cache.
183      */
184     public void addCacheAddr(InetAddress JavaDoc address, int port) {
185         //cacheAddresses.add(address + ":" + port);
186 }
187
188     /**
189      * returns an Enumeration of Strings representing the address for all the
190      * cache addresses configured. if no address were configured, the default
191      * value is returned. The address is in the form ipaddress:port
192      *
193      * @return an Enumeration of Strings representing the address for all the
194      * cache addresses configured.
195      */
196     public Enumeration JavaDoc getCacheAddr() {
197         if (cache!=null) {
198             return cache.getDistributionEngine().getCacheAddr();
199         }
200         return new Vector JavaDoc().elements();
201     }
202
203     /**
204      * returns the cachelogger for this cache.
205      *
206      * @return the cachelogger for this cache.
207      */
208     public CacheLogger getLogger() {
209         return logger;
210     }
211
212     /**
213      * returns an boolean indication wether this cache is distributed or not.
214      *
215      * @return an boolean indication wether this cache is distributed or not.
216      */
217     public boolean isDistributed() {
218         return !local;
219     }
220
221     /**
222      * gets the attribute indicating the root location for the disk cache.
223      *
224      * @return the attribute indicating the root location for the disk cache.
225      */
226     public String JavaDoc getDiskPath() {
227         return diskPath;
228     }
229     /**
230      * Returns a string representation of these CacheAttributes.
231      *
232      * @return a string representation of these CacheAttributes.
233      */
234     public String JavaDoc toString() {
235         StringBuffer JavaDoc ret = new StringBuffer JavaDoc(128);
236         ret.append("distributed:" + !local);
237         ret.append(", clean interval:" + cleanInterval);
238         ret.append(", memory size:" + maxSize);
239         ret.append(", max number of objects:" + maxObjects);
240         ret.append(", disk size:" + diskSize);
241         ret.append(", disk path:" + diskPath);
242         ret.append(", logger:" + logger);
243         if (!local) {
244             ret.append(", cacheAddresses:" + logger);
245         }
246         return ret.toString();
247     }
248     /**
249      * Gets the attribute to indicate the maximum size of the memory cache.
250      *
251      * @return the attribute to indicate the maximum size of the memory cache.
252      */
253     public int getMemoryCacheSize() {
254         return maxSize;
255     }
256
257     /**
258      * Returns a copy of these CacheAttributes.
259      *
260      * @return a copy of these CacheAttributes.
261      * @todo return value is never used.
262      */
263     
264     public CacheAttributes copy() {
265         try {
266             return (CacheAttributes) this.clone();
267         } catch (CloneNotSupportedException JavaDoc e) {
268             throw new IllegalStateException JavaDoc(this.getClass().getName()
269                     + " is not Cloneable.");
270         }
271     }
272     /** Returns the cleanInterval.
273      * @return an int representing the cleanInterval.
274      */
275     public int getCleanInterval() {
276         return cleanInterval;
277     }
278
279     public static CacheAttributes getDefaultCacheAttributes() {
280         CacheAttributes attr = new CacheAttributes();
281         attr.getLogger().init(attr.defaultLogFileName, CacheLogger.DEFAULT);
282         return attr;
283         
284     }
285
286     /**Returns the maximum number of Objects.
287      * @return Returns the maximum number of Objects.
288      */
289     public final int getMaxObjects() {
290         return maxObjects;
291     }
292     /**
293      * Returns the maximum size for the disk cache.
294      * @return the maximum size for the disk cache.
295      */
296     public final int getDiskSize() {
297         return diskSize;
298     }
299 }
300
Popular Tags