jakarta-jcs-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From asm...@apache.org
Subject svn commit: r431961 - in /jakarta/jcs/trunk/src: java/org/apache/jcs/engine/ java/org/apache/jcs/engine/behavior/ java/org/apache/jcs/engine/control/ test-conf/ test/org/apache/jcs/engine/control/
Date Wed, 16 Aug 2006 17:40:27 GMT
Author: asmuts
Date: Wed Aug 16 10:40:26 2006
New Revision: 431961

URL: http://svn.apache.org/viewvc?rev=431961&view=rev
Log:
https://issues.apache.org/jira/browse/JCS-2

I'm adding a configuration option to the CompositeCacheAttributes.  It's called DiskUsagePattern.
 There are two patterns: update and swap.  The changes are isolated to the CompositeCache
class and they are very easy to unit test.

SWAP is the default.  Under the swap pattern, data is only put to disk when the max memory
size is reached.  Since items puled from disk are put into memory, if the memory cache is
full and you get an item off disk, the lest recently used item will be spooled to disk.  If
you have a low memory hit ration, you end up thrashing.

The UPDATE usage pattern allows items to go to disk on an update.  It disables the swap. 
This allows you to persist all items to disk.  If you are using the JDBC disk cache for instance,
you can get all item on disk use the memory cache for performance, and not worry aobut lossing
data on a system crash or improper shutdown.  Also, since all items are on disk, there is
no need to swap to disk.  This prevents the possibility of threashing.

The configuration is done at the region level.   The attrribute is called DiskUsagePatternName
and takes two values: SWAP and UPDATE.

For example, below there is a region defined called "Swap" that uses the SWAP disk usage pattern
and another called "Update" that uses the UPDATE usage pattern.

##### CACHE REGIONS FOR TEST
jcs.region.Swap=indexedDiskCache
jcs.region.Swap.cacheattributes=org.apache.jcs.engine.CompositeCacheAttributes
jcs.region.Swap.cacheattributes.MaxObjects=100
jcs.region.Swap.cacheattributes.MemoryCacheName=org.apache.jcs.engine.memory.lru.LRUMemoryCache
jcs.region.Swap.cacheattributes.DiskUsagePatternName=SWAP

jcs.region.Update=indexedDiskCache
jcs.region.Update.cacheattributes=org.apache.jcs.engine.CompositeCacheAttributes
jcs.region.Update.cacheattributes.MaxObjects=100
jcs.region.Update.cacheattributes.MemoryCacheName=org.apache.jcs.engine.memory.lru.LRUMemoryCache
jcs.region.Update.cacheattributes.DiskUsagePatternName=UPDATE

Added:
    jakarta/jcs/trunk/src/test-conf/TestDiskCacheUsagePattern.ccf
    jakarta/jcs/trunk/src/test/org/apache/jcs/engine/control/CompositeCacheDiskUsageUnitTest.java
Modified:
    jakarta/jcs/trunk/src/java/org/apache/jcs/engine/CompositeCacheAttributes.java
    jakarta/jcs/trunk/src/java/org/apache/jcs/engine/behavior/ICompositeCacheAttributes.java
    jakarta/jcs/trunk/src/java/org/apache/jcs/engine/control/CompositeCache.java

Modified: jakarta/jcs/trunk/src/java/org/apache/jcs/engine/CompositeCacheAttributes.java
URL: http://svn.apache.org/viewvc/jakarta/jcs/trunk/src/java/org/apache/jcs/engine/CompositeCacheAttributes.java?rev=431961&r1=431960&r2=431961&view=diff
==============================================================================
--- jakarta/jcs/trunk/src/java/org/apache/jcs/engine/CompositeCacheAttributes.java (original)
+++ jakarta/jcs/trunk/src/java/org/apache/jcs/engine/CompositeCacheAttributes.java Wed Aug
16 10:40:26 2006
@@ -1,25 +1,22 @@
 package org.apache.jcs.engine;
 
 /*
- * Copyright 2001-2004 The Apache Software Foundation. Licensed under the Apache
- * 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.apache.org/licenses/LICENSE-2.0 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.
+ * Copyright 2001-2004 The Apache Software Foundation. Licensed under the Apache 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.apache.org/licenses/LICENSE-2.0 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.
  */
 
 import org.apache.jcs.engine.behavior.ICompositeCacheAttributes;
 
 /**
- * The CompositeCacheAttributes defines the general cache region settings. If a
- * region is not explicitly defined in the cache.ccf then it inherits the cache
- * default settings.
+ * The CompositeCacheAttributes defines the general cache region settings. If a region is
not
+ * explicitly defined in the cache.ccf then it inherits the cache default settings.
  * <p>
- * If all the default attributes are not defined in the default region
- * definition in the cache.ccf, the hard coded defaults will be used.
+ * If all the default attributes are not defined in the default region definition in the
cache.ccf,
+ * the hard coded defaults will be used.
  */
 public class CompositeCacheAttributes
     implements ICompositeCacheAttributes, Cloneable
@@ -72,6 +69,8 @@
     /** The name of the memory cache implementation class. */
     private String memoryCacheName;
 
+    private short diskUsagePattern = DISK_USAGE_PATTERN_SWAP;
+
     /**
      * Constructor for the CompositeCacheAttributes object
      */
@@ -85,8 +84,7 @@
     /**
      * Sets the maxObjects attribute of the CompositeCacheAttributes object
      * <p>
-     * @param maxObjs
-     *            The new maxObjects value
+     * @param maxObjs The new maxObjects value
      */
     public void setMaxObjects( int maxObjs )
     {
@@ -106,8 +104,7 @@
     /**
      * Sets the useDisk attribute of the CompositeCacheAttributes object
      * <p>
-     * @param useDisk
-     *            The new useDisk value
+     * @param useDisk The new useDisk value
      */
     public void setUseDisk( boolean useDisk )
     {
@@ -127,8 +124,7 @@
     /**
      * Sets the useLateral attribute of the CompositeCacheAttributes object
      * <p>
-     * @param b
-     *            The new useLateral value
+     * @param b The new useLateral value
      */
     public void setUseLateral( boolean b )
     {
@@ -148,8 +144,7 @@
     /**
      * Sets the useRemote attribute of the CompositeCacheAttributes object
      * <p>
-     * @param useRemote
-     *            The new useRemote value
+     * @param useRemote The new useRemote value
      */
     public void setUseRemote( boolean useRemote )
     {
@@ -169,8 +164,7 @@
     /**
      * Sets the cacheName attribute of the CompositeCacheAttributes object
      * <p>
-     * @param s
-     *            The new cacheName value
+     * @param s The new cacheName value
      */
     public void setCacheName( String s )
     {
@@ -190,8 +184,7 @@
     /**
      * Sets the memoryCacheName attribute of the CompositeCacheAttributes object
      * <p>
-     * @param s
-     *            The new memoryCacheName value
+     * @param s The new memoryCacheName value
      */
     public void setMemoryCacheName( String s )
     {
@@ -211,8 +204,7 @@
     /**
      * Whether the memory cache should perform background memory shrinkage.
      * <p>
-     * @param useShrinker
-     *            The new UseMemoryShrinker value
+     * @param useShrinker The new UseMemoryShrinker value
      */
     public void setUseMemoryShrinker( boolean useShrinker )
     {
@@ -230,11 +222,9 @@
     }
 
     /**
-     * If UseMemoryShrinker is true the memory cache should auto-expire elements
-     * to reclaim space.
+     * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim
space.
      * <p>
-     * @param seconds
-     *            The new MaxMemoryIdleTimeSeconds value
+     * @param seconds The new MaxMemoryIdleTimeSeconds value
      */
     public void setMaxMemoryIdleTimeSeconds( long seconds )
     {
@@ -242,8 +232,7 @@
     }
 
     /**
-     * If UseMemoryShrinker is true the memory cache should auto-expire elements
-     * to reclaim space.
+     * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim
space.
      * <p>
      * @return The MaxMemoryIdleTimeSeconds value
      */
@@ -253,11 +242,10 @@
     }
 
     /**
-     * If UseMemoryShrinker is true the memory cache should auto-expire elements
-     * to reclaim space. This sets the shrinker interval.
+     * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim
space.
+     * This sets the shrinker interval.
      * <p>
-     * @param seconds
-     *            The new ShrinkerIntervalSeconds value
+     * @param seconds The new ShrinkerIntervalSeconds value
      */
     public void setShrinkerIntervalSeconds( long seconds )
     {
@@ -265,8 +253,8 @@
     }
 
     /**
-     * If UseMemoryShrinker is true the memory cache should auto-expire elements
-     * to reclaim space. This gets the shrinker interval.
+     * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim
space.
+     * This gets the shrinker interval.
      * <p>
      * @return The ShrinkerIntervalSeconds value
      */
@@ -276,14 +264,12 @@
     }
 
     /**
-     * If UseMemoryShrinker is true the memory cache should auto-expire elements
-     * to reclaim space. This sets the maximum number of items to spool per run.
+     * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim
space.
+     * This sets the maximum number of items to spool per run.
      * <p>
-     * If the value is -1, then there is no limit to the number of items to be
-     * spooled.
+     * If the value is -1, then there is no limit to the number of items to be spooled.
      * <p>
-     * @param maxSpoolPerRun
-     *            The new maxSpoolPerRun value
+     * @param maxSpoolPerRun The new maxSpoolPerRun value
      */
     public void setMaxSpoolPerRun( int maxSpoolPerRun )
     {
@@ -291,8 +277,8 @@
     }
 
     /**
-     * If UseMemoryShrinker is true the memory cache should auto-expire elements
-     * to reclaim space. This gets the maximum number of items to spool per run.
+     * If UseMemoryShrinker is true the memory cache should auto-expire elements to reclaim
space.
+     * This gets the maximum number of items to spool per run.
      * <p>
      * @return The maxSpoolPerRun value
      */
@@ -302,6 +288,47 @@
     }
 
     /**
+     * By default this is SWAP_ONLY.
+     * <p>
+     * @param diskUsagePattern The diskUsagePattern to set.
+     */
+    public void setDiskUsagePattern( short diskUsagePattern )
+    {
+        this.diskUsagePattern = diskUsagePattern;
+    }
+
+    /**
+     * Translates the name to the disk usage pattern short value.
+     * <p>
+     * The allowed values are SWAP and UPDATE.
+     * <p>
+     * @param diskUsagePatternName The diskUsagePattern to set.
+     */
+    public void setDiskUsagePatternName( String diskUsagePatternName )
+    {
+        if ( diskUsagePatternName != null )
+        {
+            diskUsagePatternName = diskUsagePatternName.toUpperCase().trim();
+            if ( diskUsagePatternName.startsWith( "SWAP" ) )
+            {
+                this.setDiskUsagePattern( DISK_USAGE_PATTERN_SWAP );
+            }
+            else if ( diskUsagePatternName.startsWith( "UPDATE" ) )
+            {
+                this.setDiskUsagePattern( DISK_USAGE_PATTERN_UPDATE );
+            }
+        }
+    }
+
+    /**
+     * @return Returns the diskUsagePattern.
+     */
+    public short getDiskUsagePattern()
+    {
+        return diskUsagePattern;
+    }
+
+    /**
      * Description of the Method
      * <p>
      * @return
@@ -321,9 +348,9 @@
     }
 
     /**
-     * Description of the Method
+     * Dumps the core attributes.
      * <p>
-     * @return
+     * @return For debugging.
      */
     public String toString()
     {
@@ -335,10 +362,9 @@
         dump.append( ", useDisk = " ).append( useDisk );
         dump.append( ", maxObjs = " ).append( maxObjs );
         dump.append( ", maxSpoolPerRun = " ).append( maxSpoolPerRun );
+        dump.append( ", diskUsagePattern = " ).append( diskUsagePattern );
         dump.append( " ]" );
 
         return dump.toString();
     }
-
 }
-// end class

Modified: jakarta/jcs/trunk/src/java/org/apache/jcs/engine/behavior/ICompositeCacheAttributes.java
URL: http://svn.apache.org/viewvc/jakarta/jcs/trunk/src/java/org/apache/jcs/engine/behavior/ICompositeCacheAttributes.java?rev=431961&r1=431960&r2=431961&view=diff
==============================================================================
--- jakarta/jcs/trunk/src/java/org/apache/jcs/engine/behavior/ICompositeCacheAttributes.java
(original)
+++ jakarta/jcs/trunk/src/java/org/apache/jcs/engine/behavior/ICompositeCacheAttributes.java
Wed Aug 16 10:40:26 2006
@@ -19,21 +19,28 @@
 import java.io.Serializable;
 
 /**
- * Description of the Interface
- *  
+ * This defines the minimla behavior for the Cache Configuration settings.
  */
 public interface ICompositeCacheAttributes
     extends Serializable
 {
+    /** Items will only go to disk when the memory limit is reached. This is the default.
*/
+    public static final short DISK_USAGE_PATTERN_SWAP = 0;
 
     /**
+     * Items will go to disk on a normal put. If The disk usage pattern is UPDATE, the swap
will be
+     * disabled.
+     */
+    public static final short DISK_USAGE_PATTERN_UPDATE = 1;
+    
+    /**
      * SetMaxObjects is used to set the attribute to determine the maximum
      * number of objects allowed in the memory cache. If the max number of
      * objects or the cache size is set, the default for the one not set is
      * ignored. If both are set, both are used to determine the capacity of the
      * cache, i.e., object will be removed from the cache if either limit is
      * reached. TODO: move to MemoryCache config file.
-     * 
+     * <p>
      * @param size
      *            The new maxObjects value
      */
@@ -41,14 +48,14 @@
 
     /**
      * Gets the maxObjects attribute of the ICompositeCacheAttributes object
-     * 
+     * <p>
      * @return The maxObjects value
      */
     public int getMaxObjects();
 
     /**
      * Sets the useDisk attribute of the ICompositeCacheAttributes object
-     * 
+     * <p>
      * @param useDisk
      *            The new useDisk value
      */
@@ -56,14 +63,14 @@
 
     /**
      * Gets the useDisk attribute of the ICompositeCacheAttributes object
-     * 
+     * <p>
      * @return The useDisk value
      */
     public boolean getUseDisk();
 
     /**
      * set whether the cache should use a lateral cache
-     * 
+     * <p>
      * @param d
      *            The new useLateral value
      */
@@ -71,14 +78,14 @@
 
     /**
      * Gets the useLateral attribute of the ICompositeCacheAttributes object
-     * 
+     * <p>
      * @return The useLateral value
      */
     public boolean getUseLateral();
 
     /**
      * Sets whether the cache is remote enabled
-     * 
+     * <p>
      * @param isRemote
      *            The new useRemote value
      */
@@ -86,14 +93,14 @@
 
     /**
      * returns whether the cache is remote enabled
-     * 
+     * <p>
      * @return The useRemote value
      */
     public boolean getUseRemote();
 
     /**
      * Sets the name of the cache, referenced by the appropriate manager.
-     * 
+     * <p>
      * @param s
      *            The new cacheName value
      */
@@ -101,7 +108,7 @@
 
     /**
      * Gets the cacheName attribute of the ICompositeCacheAttributes object
-     * 
+     * <p>
      * @return The cacheName value
      */
     public String getCacheName();
@@ -109,7 +116,7 @@
     /**
      * Sets the name of the MemoryCache, referenced by the appropriate manager.
      * TODO: create a separate memory cache attribute class.
-     * 
+     * <p>
      * @param s
      *            The new memoryCacheName value
      */
@@ -118,14 +125,14 @@
     /**
      * Gets the memoryCacheName attribute of the ICompositeCacheAttributes
      * object
-     * 
+     * <p>
      * @return The memoryCacheName value
      */
     public String getMemoryCacheName();
 
     /**
      * Whether the memory cache should perform background memory shrinkage.
-     * 
+     * <p>
      * @param useShrinker
      *            The new UseMemoryShrinker value
      */
@@ -133,7 +140,7 @@
 
     /**
      * Whether the memory cache should perform background memory shrinkage.
-     * 
+     * <p>
      * @return The UseMemoryShrinker value
      */
     public boolean getUseMemoryShrinker();
@@ -141,7 +148,7 @@
     /**
      * If UseMemoryShrinker is true the memory cache should auto-expire elements
      * to reclaim space.
-     * 
+     * <p>
      * @param seconds
      *            The new MaxMemoryIdleTimeSeconds value
      */
@@ -150,7 +157,7 @@
     /**
      * If UseMemoryShrinker is true the memory cache should auto-expire elements
      * to reclaim space.
-     * 
+     * <p>
      * @return The MaxMemoryIdleTimeSeconds value
      */
     public long getMaxMemoryIdleTimeSeconds();
@@ -158,7 +165,7 @@
     /**
      * If UseMemoryShrinker is true the memory cache should auto-expire elements
      * to reclaim space. This sets the shrinker interval.
-     * 
+     * <p>
      * @param seconds
      *            The new ShrinkerIntervalSeconds value
      */
@@ -167,7 +174,7 @@
     /**
      * If UseMemoryShrinker is true the memory cache should auto-expire elements
      * to reclaim space. This gets the shrinker interval.
-     * 
+     * <p>
      * @return The ShrinkerIntervalSeconds value
      */
     public long getShrinkerIntervalSeconds();
@@ -175,7 +182,7 @@
     /**
      * If UseMemoryShrinker is true the memory cache should auto-expire elements
      * to reclaim space. This sets the maximum number of items to spool per run.
-     * 
+     * <p>
      * @param maxSpoolPerRun
      *            The new maxSpoolPerRun value
      */
@@ -184,17 +191,36 @@
     /**
      * If UseMemoryShrinker is true the memory cache should auto-expire elements
      * to reclaim space. This gets the maximum number of items to spool per run.
-     * 
+     * <p>
      * @return The maxSpoolPerRun value
      */
     public int getMaxSpoolPerRun();
 
-    // soultion to interface cloning
     /**
-     * Description of the Method
-     * 
-     * @return
+     * Clones the attributes.
+     * <p>
+     * @return a new object with the same settings.
      */
     public ICompositeCacheAttributes copy();
 
+    /**
+     * By default this is SWAP_ONLY.
+     * <p>
+     * @param diskUsagePattern The diskUsagePattern to set.
+     */
+    public void setDiskUsagePattern( short diskUsagePattern );
+
+    /**
+     * Translates the name to the disk usage pattern short value.
+     * <p>
+     * The allowed values are SWAP and UPDATE.
+     * <p>
+     * @param diskUsagePatternName The diskUsagePattern to set.
+     */
+    public void setDiskUsagePatternName( String diskUsagePatternName );    
+    
+    /**
+     * @return Returns the diskUsagePattern.
+     */
+    public short getDiskUsagePattern();   
 }

Modified: jakarta/jcs/trunk/src/java/org/apache/jcs/engine/control/CompositeCache.java
URL: http://svn.apache.org/viewvc/jakarta/jcs/trunk/src/java/org/apache/jcs/engine/control/CompositeCache.java?rev=431961&r1=431960&r2=431961&view=diff
==============================================================================
--- jakarta/jcs/trunk/src/java/org/apache/jcs/engine/control/CompositeCache.java (original)
+++ jakarta/jcs/trunk/src/java/org/apache/jcs/engine/control/CompositeCache.java Wed Aug 16
10:40:26 2006
@@ -210,11 +210,13 @@
      * <p>
      * This is called by update( cacheElement, localOnly ) after it updates the memory cache.
      * <p>
+     * This is protected to make it testable.
+     * <p>
      * @param cacheElement
      * @param localOnly
      * @throws IOException
      */
-    private void updateAuxiliaries( ICacheElement cacheElement, boolean localOnly )
+    protected void updateAuxiliaries( ICacheElement cacheElement, boolean localOnly )
         throws IOException
     {
         // UPDATE AUXILLIARY CACHES
@@ -280,8 +282,7 @@
             else if ( aux.getCacheType() == ICache.LATERAL_CACHE )
             {
                 // lateral can't do the checking since it is dependent on the
-                // cache region
-                // restrictions
+                // cache region restrictions
                 if ( log.isDebugEnabled() )
                 {
                     log.debug( "lateralcache in aux list: cattr " + cacheAttr.getUseLateral()
);
@@ -301,18 +302,34 @@
                     }
                 }
             }
+            // update disk if the usage pattern permits
             else if ( aux.getCacheType() == ICache.DISK_CACHE )
             {
-                // do nothing, the memory manager will call spool where necesary
-                // TODO: add option to put all element on disk
+                if ( log.isDebugEnabled() )
+                {
+                    log.debug( "diskcache in aux list: cattr " + cacheAttr.getUseDisk() );
+                }
+                if ( cacheAttr.getUseDisk()
+                    && ( cacheAttr.getDiskUsagePattern() == ICompositeCacheAttributes.DISK_USAGE_PATTERN_UPDATE
)
+                    && cacheElement.getElementAttributes().getIsSpool() )
+                {
+                    aux.update( cacheElement );
+                    if ( log.isDebugEnabled() )
+                    {
+                        log.debug( "updated disk cache for " + cacheElement.getKey() );
+                    }
+                }
             }
         }
     }
 
     /**
-     * Writes the specified element to any disk auxilliaries .Might want to rename this "overflow"
+     * Writes the specified element to any disk auxilliaries. Might want to rename this "overflow"
      * incase the hub wants to do something else.
      * <p>
+     * If JCS is not configured to use the disk as a swap, that is if the the
+     * CompositeCacheAttribute diskUsagePattern is not SWAP_ONLY, then the item will not
be spooled.
+     * <p>
      * @param ce The CacheElement
      */
     public void spoolToDisk( ICacheElement ce )
@@ -336,26 +353,36 @@
             {
                 diskAvailable = true;
 
-                // write the last items to disk.2
-                try
+                if ( cacheAttr.getDiskUsagePattern() == ICompositeCacheAttributes.DISK_USAGE_PATTERN_SWAP
)
                 {
-                    handleElementEvent( ce, IElementEventConstants.ELEMENT_EVENT_SPOOLED_DISK_AVAILABLE
);
+                    // write the last items to disk.2
+                    try
+                    {
+                        handleElementEvent( ce, IElementEventConstants.ELEMENT_EVENT_SPOOLED_DISK_AVAILABLE
);
 
-                    aux.update( ce );
-                }
-                catch ( IOException ex )
-                {
-                    // impossible case.
-                    ex.printStackTrace();
-                    throw new IllegalStateException( ex.getMessage() );
-                }
-                catch ( Exception oee )
-                {
-                    // swallow
+                        aux.update( ce );
+                    }
+                    catch ( IOException ex )
+                    {
+                        // impossible case.
+                        log.error( "Problem spooling item to disk cache.", ex );
+                        throw new IllegalStateException( ex.getMessage() );
+                    }
+                    catch ( Exception oee )
+                    {
+                        // swallow
+                    }
+                    if ( log.isDebugEnabled() )
+                    {
+                        log.debug( "spoolToDisk done for: " + ce.getKey() + " on disk cache["
+ i + "]" );
+                    }
                 }
-                if ( log.isDebugEnabled() )
+                else
                 {
-                    log.debug( "spoolToDisk done for: " + ce.getKey() + " on disk cache["
+ i + "]" );
+                    if ( log.isDebugEnabled() )
+                    {
+                        log.debug( "DiskCache avaialbe, but JCS is not configured to use
the DiskCache as a swap." );
+                    }
                 }
             }
         }
@@ -901,7 +928,7 @@
 
                     log.info( "In dispose, " + this.cacheName + " put " + cnt + " into auxiliary
" + aux );
                 }
-                
+
                 // Dispose of the auxiliary
                 aux.dispose();
             }

Added: jakarta/jcs/trunk/src/test-conf/TestDiskCacheUsagePattern.ccf
URL: http://svn.apache.org/viewvc/jakarta/jcs/trunk/src/test-conf/TestDiskCacheUsagePattern.ccf?rev=431961&view=auto
==============================================================================
--- jakarta/jcs/trunk/src/test-conf/TestDiskCacheUsagePattern.ccf (added)
+++ jakarta/jcs/trunk/src/test-conf/TestDiskCacheUsagePattern.ccf Wed Aug 16 10:40:26 2006
@@ -0,0 +1,69 @@
+# Cache configuration for the 'TestDiskCache' test. The memory cache has a
+# a maximum of 100 objects, so objects should get pushed into the disk cache
+
+jcs.default=indexedDiskCache
+jcs.default.cacheattributes=org.apache.jcs.engine.CompositeCacheAttributes
+jcs.default.cacheattributes.MaxObjects=100
+jcs.default.cacheattributes.MemoryCacheName=org.apache.jcs.engine.memory.lru.LRUMemoryCache
+
+
+##### CACHE REGIONS FOR TEST
+jcs.region.Swap=indexedDiskCache
+jcs.region.Swap.cacheattributes=org.apache.jcs.engine.CompositeCacheAttributes
+jcs.region.Swap.cacheattributes.MaxObjects=100
+jcs.region.Swap.cacheattributes.MemoryCacheName=org.apache.jcs.engine.memory.lru.LRUMemoryCache
+jcs.region.Swap.cacheattributes.DiskUsagePatternName=SWAP
+
+jcs.region.Update=indexedDiskCache
+jcs.region.Update.cacheattributes=org.apache.jcs.engine.CompositeCacheAttributes
+jcs.region.Update.cacheattributes.MaxObjects=100
+jcs.region.Update.cacheattributes.MemoryCacheName=org.apache.jcs.engine.memory.lru.LRUMemoryCache
+jcs.region.Update.cacheattributes.DiskUsagePatternName=UPDATE
+
+
+##### AUXILIARY CACHES
+# Indexed Disk Cache
+jcs.auxiliary.indexedDiskCache=org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheFactory
+jcs.auxiliary.indexedDiskCache.attributes=org.apache.jcs.auxiliary.disk.indexed.IndexedDiskCacheAttributes
+jcs.auxiliary.indexedDiskCache.attributes.DiskPath=target/test-sandbox/indexed-disk-cache-conc
+jcs.auxiliary.indexedDiskCache.attributes.MaxPurgatorySize=10000
+jcs.auxiliary.indexedDiskCache.attributes.MaxKeySize=10000
+jcs.auxiliary.indexedDiskCache.attributes.MaxRecycleBinSize=5000
+jcs.auxiliary.indexedDiskCache.attributes.OptimizeAtRemoveCount=300000
+jcs.auxiliary.indexedDiskCache.attributes.EventQueueType=SINGLE
+jcs.auxiliary.indexedDiskCache.attributes.EventQueuePoolName=disk_cache_event_queue
+
+
+##############################################################
+################## THREAD POOL CONFIGURATION ###################
+# Default thread pool config
+thread_pool.default.boundarySize=2000
+thread_pool.default.maximumPoolSize=150
+thread_pool.default.minimumPoolSize=4
+thread_pool.default.keepAliveTime=350000
+#RUN ABORT WAIT BLOCK DISCARDOLDEST
+thread_pool.default.whenBlockedPolicy=RUN
+thread_pool.default.startUpSize=4
+
+# Default Cache Event Queue thread pool config, used by auxiliaries
+thread_pool.cache_event_queue.useBoundary=false
+#thread_pool.cache_event_queue.boundarySize=2000
+#thread_pool.cache_event_queue.maximumPoolSize=10
+thread_pool.cache_event_queue.minimumPoolSize=1
+thread_pool.cache_event_queue.keepAliveTime=3500
+#thread_pool.cache_event_queue.whenBlockedPolicy=RUN
+thread_pool.cache_event_queue.startUpSize=1
+
+# Disk Cache pool
+thread_pool.disk_cache_event_queue.useBoundary=false
+thread_pool.disk_cache_event_queue.minimumPoolSize=2
+thread_pool.disk_cache_event_queue.keepAliveTime=3500
+thread_pool.disk_cache_event_queue.startUpSize=10
+
+# Remote cache client thread pool config
+thread_pool.remote_cache_client.boundarySize=75
+thread_pool.remote_cache_client.maximumPoolSize=150
+thread_pool.remote_cache_client.minimumPoolSize=4
+thread_pool.remote_cache_client.keepAliveTime=350000
+thread_pool.remote_cache_client.whenBlockedPolicy=RUN
+thread_pool.remote_cache_client.startUpSize=4

Added: jakarta/jcs/trunk/src/test/org/apache/jcs/engine/control/CompositeCacheDiskUsageUnitTest.java
URL: http://svn.apache.org/viewvc/jakarta/jcs/trunk/src/test/org/apache/jcs/engine/control/CompositeCacheDiskUsageUnitTest.java?rev=431961&view=auto
==============================================================================
--- jakarta/jcs/trunk/src/test/org/apache/jcs/engine/control/CompositeCacheDiskUsageUnitTest.java
(added)
+++ jakarta/jcs/trunk/src/test/org/apache/jcs/engine/control/CompositeCacheDiskUsageUnitTest.java
Wed Aug 16 10:40:26 2006
@@ -0,0 +1,421 @@
+package org.apache.jcs.engine.control;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+import org.apache.jcs.JCS;
+import org.apache.jcs.access.exception.CacheException;
+import org.apache.jcs.auxiliary.AuxiliaryCache;
+import org.apache.jcs.engine.CacheElement;
+import org.apache.jcs.engine.CompositeCacheAttributes;
+import org.apache.jcs.engine.ElementAttributes;
+import org.apache.jcs.engine.behavior.ICacheElement;
+import org.apache.jcs.engine.behavior.ICompositeCacheAttributes;
+import org.apache.jcs.engine.behavior.IElementAttributes;
+import org.apache.jcs.engine.stats.behavior.IStats;
+
+/**
+ * Tests of the disk usage settings for the CompositeCache.
+ * <p>
+ * @author Aaron Smuts
+ */
+public class CompositeCacheDiskUsageUnitTest
+    extends TestCase
+{
+    /**
+     * Test setup
+     */
+    public void setUp()
+    {
+        JCS.setConfigFilename( "/TestDiskCacheUsagePattern.ccf" );
+    }
+
+    /**
+     * Verify that the swap region is set to the correct pattern.
+     * <p>
+     * @throws CacheException
+     */
+    public void testSwapConfig() throws CacheException
+    {
+        JCS swap = JCS.getInstance( "Swap" );
+        assertEquals( ICompositeCacheAttributes.DISK_USAGE_PATTERN_SWAP, swap.getCacheAttributes().getDiskUsagePattern()
);
+    }
+    
+    /**
+     * Verify that the swap region is set to the correct pattern.
+     * <p>
+     * @throws CacheException
+     */
+    public void testUpdateConfig() throws CacheException
+    {
+        JCS swap = JCS.getInstance( "Update" );
+        assertEquals( ICompositeCacheAttributes.DISK_USAGE_PATTERN_UPDATE, swap.getCacheAttributes().getDiskUsagePattern()
);
+    }    
+    
+    /**
+     * Setup a disk cache. Configure the disk usage pattern to swap. Call spool. Verify that
the
+     * item is put to disk.
+     */
+    public void testSpoolAllowed()
+    {
+        // SETUP
+        ICompositeCacheAttributes cattr = new CompositeCacheAttributes();
+        cattr.setDiskUsagePattern( ICompositeCacheAttributes.DISK_USAGE_PATTERN_SWAP );
+
+        IElementAttributes attr = new ElementAttributes();
+
+        CompositeCache cache = new CompositeCache( "testSpoolAllowed", cattr, attr );
+
+        MockAuxCache mock = new MockAuxCache();
+        mock.cacheType = AuxiliaryCache.DISK_CACHE;
+
+        cache.setAuxCaches( new AuxiliaryCache[] { mock } );
+
+        ICacheElement inputElement = new CacheElement( "testSpoolAllowed", "key", "value"
);
+
+        // DO WORK
+        cache.spoolToDisk( inputElement );
+
+        // VERIFY
+        assertEquals( "Wrong number of calls to the disk cache update.", 1, mock.updateCount
);
+        assertEquals( "Wrong element updated.", inputElement, mock.lastUpdatedItem );
+    }
+
+    /**
+     * Setup a disk cache. Configure the disk usage pattern to not swap. Call spool. Verify
that the
+     * item is not put to disk.
+     */
+    public void testSpoolNotAllowed()
+    {
+        // SETUP
+        ICompositeCacheAttributes cattr = new CompositeCacheAttributes();
+        cattr.setDiskUsagePattern( ICompositeCacheAttributes.DISK_USAGE_PATTERN_UPDATE );
+
+        IElementAttributes attr = new ElementAttributes();
+
+        CompositeCache cache = new CompositeCache( "testSpoolAllowed", cattr, attr );
+
+        MockAuxCache mock = new MockAuxCache();
+        mock.cacheType = AuxiliaryCache.DISK_CACHE;
+
+        cache.setAuxCaches( new AuxiliaryCache[] { mock } );
+
+        ICacheElement inputElement = new CacheElement( "testSpoolAllowed", "key", "value"
);
+
+        // DO WORK
+        cache.spoolToDisk( inputElement );
+
+        // VERIFY
+        assertEquals( "Wrong number of calls to the disk cache update.", 0, mock.updateCount
);
+    }
+
+    /**
+     * Setup a disk cache. Configure the disk usage pattern to UPDATE. Call updateAuxiliaries.
+     * Verify that the item is put to disk.
+     * <p>
+     * This tests that the items are put to disk on a normal put when the usage pattern is
set
+     * appropriately.
+     * @throws IOException
+     */
+    public void testUpdateAllowed()
+        throws IOException
+    {
+        // SETUP
+        ICompositeCacheAttributes cattr = new CompositeCacheAttributes();
+        cattr.setDiskUsagePattern( ICompositeCacheAttributes.DISK_USAGE_PATTERN_UPDATE );
+
+        IElementAttributes attr = new ElementAttributes();
+
+        CompositeCache cache = new CompositeCache( "testSpoolAllowed", cattr, attr );
+
+        MockAuxCache mock = new MockAuxCache();
+        mock.cacheType = AuxiliaryCache.DISK_CACHE;
+
+        cache.setAuxCaches( new AuxiliaryCache[] { mock } );
+
+        ICacheElement inputElement = new CacheElement( "testSpoolAllowed", "key", "value"
);
+
+        // DO WORK
+        cache.updateAuxiliaries( inputElement, true );
+
+        // VERIFY
+        assertEquals( "Wrong number of calls to the disk cache update.", 1, mock.updateCount
);
+        assertEquals( "Wrong element updated.", inputElement, mock.lastUpdatedItem );
+    }
+
+    /**
+     * Setup a disk cache. Configure the disk usage pattern to UPDATE. Call updateAuxiliaries
with
+     * local only set to false. Verify that the item is put to disk.
+     * <p>
+     * This tests that the items are put to disk on a normal put when the usage pattern is
set
+     * appropriately. The local setting should have no impact on whether the item goes to
disk.
+     * <p>
+     * @throws IOException
+     */
+    public void testUpdateAllowed_localFalse()
+        throws IOException
+    {
+        // SETUP
+        ICompositeCacheAttributes cattr = new CompositeCacheAttributes();
+        cattr.setDiskUsagePattern( ICompositeCacheAttributes.DISK_USAGE_PATTERN_UPDATE );
+
+        IElementAttributes attr = new ElementAttributes();
+
+        CompositeCache cache = new CompositeCache( "testSpoolAllowed", cattr, attr );
+
+        MockAuxCache mock = new MockAuxCache();
+        mock.cacheType = AuxiliaryCache.DISK_CACHE;
+
+        cache.setAuxCaches( new AuxiliaryCache[] { mock } );
+
+        ICacheElement inputElement = new CacheElement( "testSpoolAllowed", "key", "value"
);
+
+        // DO WORK
+        cache.updateAuxiliaries( inputElement, false );
+
+        // VERIFY
+        assertEquals( "Wrong number of calls to the disk cache update.", 1, mock.updateCount
);
+        assertEquals( "Wrong element updated.", inputElement, mock.lastUpdatedItem );
+    }
+
+    /**
+     * Setup a disk cache. Configure the disk usage pattern to SWAP. Call updateAuxiliaries.
Verify
+     * that the item is not put to disk.
+     * <p>
+     * This tests that the items are not put to disk on a normal put when the usage pattern
is set
+     * to SWAP.
+     * <p>
+     * @throws IOException
+     */
+    public void testUpdateNotAllowed()
+        throws IOException
+    {
+        // SETUP
+        ICompositeCacheAttributes cattr = new CompositeCacheAttributes();
+        cattr.setDiskUsagePattern( ICompositeCacheAttributes.DISK_USAGE_PATTERN_SWAP );
+
+        IElementAttributes attr = new ElementAttributes();
+
+        CompositeCache cache = new CompositeCache( "testSpoolAllowed", cattr, attr );
+
+        MockAuxCache mock = new MockAuxCache();
+        mock.cacheType = AuxiliaryCache.DISK_CACHE;
+
+        cache.setAuxCaches( new AuxiliaryCache[] { mock } );
+
+        ICacheElement inputElement = new CacheElement( "testSpoolAllowed", "key", "value"
);
+
+        // DO WORK
+        cache.updateAuxiliaries( inputElement, true );
+
+        // VERIFY
+        assertEquals( "Wrong number of calls to the disk cache update.", 0, mock.updateCount
);
+    }
+
+    /**
+     * Setup a disk cache. Configure the disk usage pattern to UPDATE. Call updateAuxiliaries.
+     * Verify that the item is put to disk.
+     * <p>
+     * This tests that the items are put to disk on a normal put when the usage pattern is
set
+     * appropriately.
+     * @throws IOException
+     */
+    public void testUpdateAllowed_withOtherCaches()
+        throws IOException
+    {
+        // SETUP
+        ICompositeCacheAttributes cattr = new CompositeCacheAttributes();
+        cattr.setDiskUsagePattern( ICompositeCacheAttributes.DISK_USAGE_PATTERN_UPDATE );
+
+        IElementAttributes attr = new ElementAttributes();
+
+        CompositeCache cache = new CompositeCache( "testSpoolAllowed", cattr, attr );
+
+        MockAuxCache mock = new MockAuxCache();
+        mock.cacheType = AuxiliaryCache.DISK_CACHE;
+
+        MockAuxCache mockLateral = new MockAuxCache();
+        mockLateral.cacheType = AuxiliaryCache.LATERAL_CACHE;
+
+        cache.setAuxCaches( new AuxiliaryCache[] { mock, mockLateral } );
+
+        ICacheElement inputElement = new CacheElement( "testSpoolAllowed", "key", "value"
);
+
+        // DO WORK
+        cache.updateAuxiliaries( inputElement, false );
+
+        // VERIFY
+        assertEquals( "Wrong number of calls to the disk cache update.", 1, mock.updateCount
);
+        assertEquals( "Wrong element updated.", inputElement, mock.lastUpdatedItem );
+
+        assertEquals( "Wrong number of calls to the lateral cache update.", 1, mockLateral.updateCount
);
+        assertEquals( "Wrong element updated with lateral.", inputElement, mockLateral.lastUpdatedItem
);
+    }
+
+    /**
+     * Used to test the disk cache functionality.
+     * <p>
+     * @author Aaron Smuts
+     */
+    public class MockAuxCache
+        implements AuxiliaryCache
+    {
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * The last item passed to update.
+         */
+        public ICacheElement lastUpdatedItem;
+
+        /**
+         * The number of times update was called.
+         */
+        public int updateCount = 0;
+
+        /**
+         * The type that should be returned from getCacheType.
+         */
+        public int cacheType = AuxiliaryCache.DISK_CACHE;
+
+        /**
+         * Resets counters and catchers.
+         */
+        public void reset()
+        {
+            updateCount = 0;
+            lastUpdatedItem = null;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#update(org.apache.jcs.engine.behavior.ICacheElement)
+         */
+        public void update( ICacheElement ce )
+            throws IOException
+        {
+            lastUpdatedItem = ce;
+            updateCount++;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#get(java.io.Serializable)
+         */
+        public ICacheElement get( Serializable key )
+            throws IOException
+        {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#remove(java.io.Serializable)
+         */
+        public boolean remove( Serializable key )
+            throws IOException
+        {
+            // TODO Auto-generated method stub
+            return false;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#removeAll()
+         */
+        public void removeAll()
+            throws IOException
+        {
+            // TODO Auto-generated method stub
+
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#dispose()
+         */
+        public void dispose()
+            throws IOException
+        {
+            // TODO Auto-generated method stub
+
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#getSize()
+         */
+        public int getSize()
+        {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#getStatus()
+         */
+        public int getStatus()
+        {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#getCacheName()
+         */
+        public String getCacheName()
+        {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#getGroupKeys(java.lang.String)
+         */
+        public Set getGroupKeys( String group )
+            throws IOException
+        {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.auxiliary.AuxiliaryCache#getStatistics()
+         */
+        public IStats getStatistics()
+        {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        /*
+         * (non-Javadoc)
+         * @see org.apache.jcs.engine.behavior.ICache#getStats()
+         */
+        public String getStats()
+        {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        /**
+         * Returns the setup cache type. This allows you to use this mock as multiple cache
types.
+         * <p>
+         * (non-Javadoc)
+         * @see org.apache.jcs.engine.behavior.ICacheType#getCacheType()
+         */
+        public int getCacheType()
+        {
+            return cacheType;
+        }
+
+    }
+
+}



---------------------------------------------------------------------
To unsubscribe, e-mail: jcs-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: jcs-dev-help@jakarta.apache.org


Mime
View raw message