Coverage report

  %line %branch
org.apache.jcs.auxiliary.disk.block.BlockDiskCacheManager
45% 
78% 

 1  
 package org.apache.jcs.auxiliary.disk.block;
 2  
 
 3  
 /*
 4  
  * Licensed to the Apache Software Foundation (ASF) under one
 5  
  * or more contributor license agreements.  See the NOTICE file
 6  
  * distributed with this work for additional information
 7  
  * regarding copyright ownership.  The ASF licenses this file
 8  
  * to you under the Apache License, Version 2.0 (the
 9  
  * "License"); you may not use this file except in compliance
 10  
  * with the License.  You may obtain a copy of the License at
 11  
  *
 12  
  *   http://www.apache.org/licenses/LICENSE-2.0
 13  
  *
 14  
  * Unless required by applicable law or agreed to in writing,
 15  
  * software distributed under the License is distributed on an
 16  
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 17  
  * KIND, either express or implied.  See the License for the
 18  
  * specific language governing permissions and limitations
 19  
  * under the License.
 20  
  */
 21  
 
 22  
 import java.util.Enumeration;
 23  
 import java.util.Hashtable;
 24  
 
 25  
 import org.apache.commons.logging.Log;
 26  
 import org.apache.commons.logging.LogFactory;
 27  
 import org.apache.jcs.auxiliary.AuxiliaryCache;
 28  
 import org.apache.jcs.auxiliary.AuxiliaryCacheManager;
 29  
 import org.apache.jcs.engine.behavior.ICache;
 30  
 
 31  
 /**
 32  
  * Cache manager for BlockDiskCaches. This manages the instances of the disk
 33  
  * cache.
 34  
  */
 35  
 public class BlockDiskCacheManager
 36  
     implements AuxiliaryCacheManager
 37  
 {
 38  
     /** Don't change */
 39  
     private static final long serialVersionUID = -4153287154512274626L;
 40  
 
 41  
     /** The logger */
 42  32
     private final static Log log = LogFactory.getLog( BlockDiskCacheManager.class );
 43  
 
 44  
     /** ? */
 45  
     private static int clients;
 46  
 
 47  
     /** The singleton instance */
 48  
     private static BlockDiskCacheManager instance;
 49  
 
 50  
     /** block disks for a region. */
 51  16
     private Hashtable caches = new Hashtable();
 52  
 
 53  
     /** Attributes. */
 54  
     private BlockDiskCacheAttributes defaultCacheAttributes;
 55  
 
 56  
     /**
 57  
      * Constructor for the BlockDiskCacheManager object
 58  
      * <p>
 59  
      * @param defaultCacheAttributes
 60  
      *            Default attributes for caches managed by the instance.
 61  
      */
 62  
     private BlockDiskCacheManager( BlockDiskCacheAttributes defaultCacheAttributes )
 63  16
     {
 64  16
         this.defaultCacheAttributes = defaultCacheAttributes;
 65  16
     }
 66  
 
 67  
     /**
 68  
      * Gets the singleton instance of the manager
 69  
      * <p>
 70  
      * @param defaultCacheAttributes
 71  
      *            If the instance has not yet been created, it will be
 72  
      *            initialized with this set of default attributes.
 73  
      * @return The instance value
 74  
      */
 75  
     public static BlockDiskCacheManager getInstance( BlockDiskCacheAttributes defaultCacheAttributes )
 76  
     {
 77  96
         synchronized ( BlockDiskCacheManager.class )
 78  
         {
 79  96
             if ( instance == null )
 80  
             {
 81  16
                 instance = new BlockDiskCacheManager( defaultCacheAttributes );
 82  
             }
 83  96
         }
 84  
 
 85  96
         clients++;
 86  
 
 87  96
         return instance;
 88  
     }
 89  
 
 90  
     /**
 91  
      * Gets an BlockDiskCache for the supplied name using the default
 92  
      * attributes.
 93  
      * <p>
 94  
      * @param cacheName
 95  
      *            Name that will be used when creating attributes.
 96  
      * @return A cache.
 97  
      */
 98  
     public AuxiliaryCache getCache( String cacheName )
 99  
     {
 100  0
         BlockDiskCacheAttributes cacheAttributes = (BlockDiskCacheAttributes) defaultCacheAttributes.copy();
 101  
 
 102  0
         cacheAttributes.setCacheName( cacheName );
 103  
 
 104  0
         return getCache( cacheAttributes );
 105  
     }
 106  
 
 107  
     /**
 108  
      * Get an BlockDiskCache for the supplied attributes. Will provide an
 109  
      * existing cache for the name attribute if one has been created, or will
 110  
      * create a new cache.
 111  
      * <p>
 112  
      * @param cacheAttributes
 113  
      *            Attributes the cache should have.
 114  
      * @return A cache, either from the existing set or newly created.
 115  
      */
 116  
     public AuxiliaryCache getCache( BlockDiskCacheAttributes cacheAttributes )
 117  
     {
 118  96
         AuxiliaryCache cache = null;
 119  
 
 120  96
         String cacheName = cacheAttributes.getCacheName();
 121  
 
 122  96
         log.debug( "Getting cache named: " + cacheName );
 123  
 
 124  96
         synchronized ( caches )
 125  
         {
 126  
             // Try to load the cache from the set that have already been
 127  
             // created. This only looks at the name attribute.
 128  
 
 129  96
             cache = (AuxiliaryCache) caches.get( cacheName );
 130  
 
 131  
             // If it was not found, create a new one using the supplied
 132  
             // attributes
 133  
 
 134  96
             if ( cache == null )
 135  
             {
 136  96
                 cache = new BlockDiskCache( cacheAttributes );
 137  
 
 138  96
                 caches.put( cacheName, cache );
 139  
             }
 140  96
         }
 141  
 
 142  96
         return cache;
 143  
     }
 144  
 
 145  
     /**
 146  
      * Disposes the cache with the given name, if found in the set of managed
 147  
      * caches.
 148  
      * <p>
 149  
      * @param cacheName
 150  
      *            Name of cache to dispose.
 151  
      */
 152  
     public void freeCache( String cacheName )
 153  
     {
 154  0
         ICache cache = (ICache) caches.get( cacheName );
 155  
 
 156  0
         if ( cache != null )
 157  
         {
 158  
             try
 159  
             {
 160  0
                 cache.dispose();
 161  
             }
 162  0
             catch ( Exception e )
 163  
             {
 164  0
                 log.error( "Failure disposing cache: " + cacheName, e );
 165  0
             }
 166  
         }
 167  0
     }
 168  
 
 169  
     /**
 170  
      * Gets the cacheType attribute of the DiskCacheManager object
 171  
      * <p>
 172  
      * @return The cacheType value
 173  
      */
 174  
     public int getCacheType()
 175  
     {
 176  0
         return DISK_CACHE;
 177  
     }
 178  
 
 179  
     /**
 180  
      * Releases the cache manager instance. When all clients have released the
 181  
      * cache manager, all contained caches will be disposed.
 182  
      */
 183  
     public void release()
 184  
     {
 185  0
         clients--;
 186  
 
 187  0
         if ( --clients != 0 )
 188  
         {
 189  0
             return;
 190  
         }
 191  
 
 192  0
         synchronized ( caches )
 193  
         {
 194  0
             Enumeration allCaches = caches.elements();
 195  
 
 196  0
             while ( allCaches.hasMoreElements() )
 197  
             {
 198  0
                 ICache cache = (ICache) allCaches.nextElement();
 199  
 
 200  0
                 if ( cache != null )
 201  
                 {
 202  
                     try
 203  
                     {
 204  0
                         cache.dispose();
 205  
                     }
 206  0
                     catch ( Exception e )
 207  
                     {
 208  0
                         log.error( "Failure disposing cache: " + cache.getCacheName(), e );
 209  0
                     }
 210  
                 }
 211  0
             }
 212  0
         }
 213  0
     }
 214  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.