001package org.apache.commons.jcs3.engine; 002 003/* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022import org.apache.commons.jcs3.engine.behavior.ICompositeCacheAttributes; 023 024/** 025 * The CompositeCacheAttributes defines the general cache region settings. If a region is not 026 * explicitly defined in the cache.ccf then it inherits the cache default settings. 027 * <p> 028 * If all the default attributes are not defined in the default region definition in the cache.ccf, 029 * the hard coded defaults will be used. 030 */ 031public class CompositeCacheAttributes 032 implements ICompositeCacheAttributes 033{ 034 /** Don't change */ 035 private static final long serialVersionUID = 6754049978134196787L; 036 037 /** default lateral switch */ 038 private static final boolean DEFAULT_USE_LATERAL = true; 039 040 /** default remote switch */ 041 private static final boolean DEFAULT_USE_REMOTE = true; 042 043 /** default disk switch */ 044 private static final boolean DEFAULT_USE_DISK = true; 045 046 /** default shrinker setting */ 047 private static final boolean DEFAULT_USE_SHRINKER = false; 048 049 /** default max objects value */ 050 private static final int DEFAULT_MAX_OBJECTS = 100; 051 052 /** default */ 053 private static final int DEFAULT_MAX_MEMORY_IDLE_TIME_SECONDS = 60 * 120; 054 055 /** default interval to run the shrinker */ 056 private static final int DEFAULT_SHRINKER_INTERVAL_SECONDS = 30; 057 058 /** default */ 059 private static final int DEFAULT_MAX_SPOOL_PER_RUN = -1; 060 061 /** default */ 062 private static final String DEFAULT_MEMORY_CACHE_NAME = "org.apache.commons.jcs3.engine.memory.lru.LRUMemoryCache"; 063 064 /** Default number to send to disk at a time when memory fills. */ 065 private static final int DEFAULT_CHUNK_SIZE = 2; 066 067 /** allow lateral caches */ 068 private boolean useLateral = DEFAULT_USE_LATERAL; 069 070 /** allow remote caches */ 071 private boolean useRemote = DEFAULT_USE_REMOTE; 072 073 /** Whether we should use a disk cache if it is configured. */ 074 private boolean useDisk = DEFAULT_USE_DISK; 075 076 /** Whether or not we should run the memory shrinker thread. */ 077 private boolean useMemoryShrinker = DEFAULT_USE_SHRINKER; 078 079 /** The maximum objects that the memory cache will be allowed to hold. */ 080 private int maxObjs = DEFAULT_MAX_OBJECTS; 081 082 /** maxMemoryIdleTimeSeconds */ 083 private long maxMemoryIdleTimeSeconds = DEFAULT_MAX_MEMORY_IDLE_TIME_SECONDS; 084 085 /** shrinkerIntervalSeconds */ 086 private long shrinkerIntervalSeconds = DEFAULT_SHRINKER_INTERVAL_SECONDS; 087 088 /** The maximum number the shrinker will spool to disk per run. */ 089 private int maxSpoolPerRun = DEFAULT_MAX_SPOOL_PER_RUN; 090 091 /** The name of this cache region. */ 092 private String cacheName; 093 094 /** The name of the memory cache implementation class. */ 095 private String memoryCacheName; 096 097 /** Set via DISK_USAGE_PATTERN_NAME */ 098 private DiskUsagePattern diskUsagePattern = DiskUsagePattern.SWAP; 099 100 /** How many to spool to disk at a time. */ 101 private int spoolChunkSize = DEFAULT_CHUNK_SIZE; 102 103 /** 104 * Constructor for the CompositeCacheAttributes object 105 */ 106 public CompositeCacheAttributes() 107 { 108 // set this as the default so the configuration is a bit simpler 109 memoryCacheName = DEFAULT_MEMORY_CACHE_NAME; 110 } 111 112 /** 113 * Sets the maxObjects attribute of the CompositeCacheAttributes object 114 * <p> 115 * @param maxObjs The new maxObjects value 116 */ 117 @Override 118 public void setMaxObjects( final int maxObjs ) 119 { 120 this.maxObjs = maxObjs; 121 } 122 123 /** 124 * Gets the maxObjects attribute of the CompositeCacheAttributes object 125 * <p> 126 * @return The maxObjects value 127 */ 128 @Override 129 public int getMaxObjects() 130 { 131 return this.maxObjs; 132 } 133 134 /** 135 * Sets the useDisk attribute of the CompositeCacheAttributes object 136 * <p> 137 * @param useDisk The new useDisk value 138 */ 139 @Override 140 public void setUseDisk( final boolean useDisk ) 141 { 142 this.useDisk = useDisk; 143 } 144 145 /** 146 * Gets the useDisk attribute of the CompositeCacheAttributes object 147 * <p> 148 * @return The useDisk value 149 */ 150 @Override 151 public boolean isUseDisk() 152 { 153 return useDisk; 154 } 155 156 /** 157 * Sets the useLateral attribute of the CompositeCacheAttributes object 158 * <p> 159 * @param b The new useLateral value 160 */ 161 @Override 162 public void setUseLateral( final boolean b ) 163 { 164 this.useLateral = b; 165 } 166 167 /** 168 * Gets the useLateral attribute of the CompositeCacheAttributes object 169 * <p> 170 * @return The useLateral value 171 */ 172 @Override 173 public boolean isUseLateral() 174 { 175 return this.useLateral; 176 } 177 178 /** 179 * Sets the useRemote attribute of the CompositeCacheAttributes object 180 * <p> 181 * @param useRemote The new useRemote value 182 */ 183 @Override 184 public void setUseRemote( final boolean useRemote ) 185 { 186 this.useRemote = useRemote; 187 } 188 189 /** 190 * Gets the useRemote attribute of the CompositeCacheAttributes object 191 * <p> 192 * @return The useRemote value 193 */ 194 @Override 195 public boolean isUseRemote() 196 { 197 return this.useRemote; 198 } 199 200 /** 201 * Sets the cacheName attribute of the CompositeCacheAttributes object 202 * <p> 203 * @param s The new cacheName value 204 */ 205 @Override 206 public void setCacheName( final String s ) 207 { 208 this.cacheName = s; 209 } 210 211 /** 212 * Gets the cacheName attribute of the CompositeCacheAttributes object 213 * <p> 214 * @return The cacheName value 215 */ 216 @Override 217 public String getCacheName() 218 { 219 return this.cacheName; 220 } 221 222 /** 223 * Sets the memoryCacheName attribute of the CompositeCacheAttributes object 224 * <p> 225 * @param s The new memoryCacheName value 226 */ 227 @Override 228 public void setMemoryCacheName( final String s ) 229 { 230 this.memoryCacheName = s; 231 } 232 233 /** 234 * Gets the memoryCacheName attribute of the CompositeCacheAttributes object 235 * <p> 236 * @return The memoryCacheName value 237 */ 238 @Override 239 public String getMemoryCacheName() 240 { 241 return this.memoryCacheName; 242 } 243 244 /** 245 * Whether the memory cache should perform background memory shrinkage. 246 * <p> 247 * @param useShrinker The new UseMemoryShrinker value 248 */ 249 @Override 250 public void setUseMemoryShrinker( final boolean useShrinker ) 251 { 252 this.useMemoryShrinker = useShrinker; 253 } 254 255 /** 256 * Whether the memory cache should perform background memory shrinkage. 257 * <p> 258 * @return The UseMemoryShrinker value 259 */ 260 @Override 261 public boolean isUseMemoryShrinker() 262 { 263 return this.useMemoryShrinker; 264 } 265 266 /** 267 * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim space. 268 * <p> 269 * @param seconds The new MaxMemoryIdleTimeSeconds value 270 */ 271 @Override 272 public void setMaxMemoryIdleTimeSeconds( final long seconds ) 273 { 274 this.maxMemoryIdleTimeSeconds = seconds; 275 } 276 277 /** 278 * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim space. 279 * <p> 280 * @return The MaxMemoryIdleTimeSeconds value 281 */ 282 @Override 283 public long getMaxMemoryIdleTimeSeconds() 284 { 285 return this.maxMemoryIdleTimeSeconds; 286 } 287 288 /** 289 * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim space. 290 * This sets the shrinker interval. 291 * <p> 292 * @param seconds The new ShrinkerIntervalSeconds value 293 */ 294 @Override 295 public void setShrinkerIntervalSeconds( final long seconds ) 296 { 297 this.shrinkerIntervalSeconds = seconds; 298 } 299 300 /** 301 * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim space. 302 * This gets the shrinker interval. 303 * <p> 304 * @return The ShrinkerIntervalSeconds value 305 */ 306 @Override 307 public long getShrinkerIntervalSeconds() 308 { 309 return this.shrinkerIntervalSeconds; 310 } 311 312 /** 313 * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim space. 314 * This sets the maximum number of items to spool per run. 315 * <p> 316 * If the value is -1, then there is no limit to the number of items to be spooled. 317 * <p> 318 * @param maxSpoolPerRun The new maxSpoolPerRun value 319 */ 320 @Override 321 public void setMaxSpoolPerRun( final int maxSpoolPerRun ) 322 { 323 this.maxSpoolPerRun = maxSpoolPerRun; 324 } 325 326 /** 327 * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim space. 328 * This gets the maximum number of items to spool per run. 329 * <p> 330 * @return The maxSpoolPerRun value 331 */ 332 @Override 333 public int getMaxSpoolPerRun() 334 { 335 return this.maxSpoolPerRun; 336 } 337 338 /** 339 * By default this is SWAP_ONLY. 340 * <p> 341 * @param diskUsagePattern The diskUsagePattern to set. 342 */ 343 @Override 344 public void setDiskUsagePattern( final DiskUsagePattern diskUsagePattern ) 345 { 346 this.diskUsagePattern = diskUsagePattern; 347 } 348 349 /** 350 * Translates the name to the disk usage pattern short value. 351 * <p> 352 * The allowed values are SWAP and UPDATE. 353 * <p> 354 * @param diskUsagePatternName The diskUsagePattern to set. 355 */ 356 @Override 357 public void setDiskUsagePatternName( final String diskUsagePatternName ) 358 { 359 if ( diskUsagePatternName != null ) 360 { 361 final String name = diskUsagePatternName.toUpperCase().trim(); 362 if ( name.startsWith( "SWAP" ) ) 363 { 364 this.setDiskUsagePattern( DiskUsagePattern.SWAP ); 365 } 366 else if ( name.startsWith( "UPDATE" ) ) 367 { 368 this.setDiskUsagePattern( DiskUsagePattern.UPDATE ); 369 } 370 } 371 } 372 373 /** 374 * Number to send to disk at the time when memory is full. 375 * <p> 376 * @return int 377 */ 378 @Override 379 public int getSpoolChunkSize() 380 { 381 return spoolChunkSize; 382 } 383 384 /** 385 * Number to send to disk at a time. 386 * <p> 387 * @param spoolChunkSize 388 */ 389 @Override 390 public void setSpoolChunkSize( final int spoolChunkSize ) 391 { 392 this.spoolChunkSize = spoolChunkSize; 393 } 394 395 /** 396 * @return Returns the diskUsagePattern. 397 */ 398 @Override 399 public DiskUsagePattern getDiskUsagePattern() 400 { 401 return diskUsagePattern; 402 } 403 404 /** 405 * Dumps the core attributes. 406 * <p> 407 * @return For debugging. 408 */ 409 @Override 410 public String toString() 411 { 412 final StringBuilder dump = new StringBuilder(); 413 414 dump.append( "[ " ); 415 dump.append( "useLateral = " ).append( useLateral ); 416 dump.append( ", useRemote = " ).append( useRemote ); 417 dump.append( ", useDisk = " ).append( useDisk ); 418 dump.append( ", maxObjs = " ).append( maxObjs ); 419 dump.append( ", maxSpoolPerRun = " ).append( maxSpoolPerRun ); 420 dump.append( ", diskUsagePattern = " ).append( diskUsagePattern ); 421 dump.append( ", spoolChunkSize = " ).append( spoolChunkSize ); 422 dump.append( " ]" ); 423 424 return dump.toString(); 425 } 426 427 /** 428 * @see Object#clone() 429 */ 430 @Override 431 public ICompositeCacheAttributes clone() 432 { 433 try 434 { 435 return (ICompositeCacheAttributes)super.clone(); 436 } 437 catch (final CloneNotSupportedException e) 438 { 439 throw new RuntimeException("Clone not supported. This should never happen.", e); 440 } 441 } 442}