Coverage report

  %line %branch
org.apache.jcs.auxiliary.disk.jdbc.JDBCDiskCacheManagerAbstractTemplate$MyThreadFactory
100% 
100% 

 1  
 package org.apache.jcs.auxiliary.disk.jdbc;
 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  
 import java.util.Map;
 25  
 
 26  
 import org.apache.commons.logging.Log;
 27  
 import org.apache.commons.logging.LogFactory;
 28  
 import org.apache.jcs.auxiliary.AuxiliaryCache;
 29  
 import org.apache.jcs.auxiliary.AuxiliaryCacheManager;
 30  
 
 31  
 import EDU.oswego.cs.dl.util.concurrent.ClockDaemon;
 32  
 import EDU.oswego.cs.dl.util.concurrent.ThreadFactory;
 33  
 
 34  
 /**
 35  
  * This class serves as an abstract template for JDBCDiskCache Manager. The MySQL JDBC Disk Cache
 36  
  * needs many of the same features as the generic maanger.
 37  
  * <p>
 38  
  * @author Aaron Smuts
 39  
  */
 40  
 public abstract class JDBCDiskCacheManagerAbstractTemplate
 41  
     implements AuxiliaryCacheManager
 42  
 {
 43  
     /** The logger. */
 44  
     private static final Log log = LogFactory.getLog( JDBCDiskCacheManagerAbstractTemplate.class );
 45  
 
 46  
     /**
 47  
      * Incremented on getIntance, decremented on release.
 48  
      */
 49  
     protected static int clients;
 50  
 
 51  
     /**
 52  
      * A map of JDBCDiskCache objects to region names.
 53  
      */
 54  
     protected static Hashtable caches = new Hashtable();
 55  
 
 56  
     /**
 57  
      * A map of TableState objects to table names. Each cache has a table state object, which is
 58  
      * used to determin if any long processes such as deletes or optimizations are running.
 59  
      */
 60  
     protected static Hashtable tableStates = new Hashtable();
 61  
 
 62  
     /**
 63  
      * The background disk shrinker, one for all regions.
 64  
      */
 65  
     private ClockDaemon shrinkerDaemon;
 66  
 
 67  
     /**
 68  
      * A map of table name to shrinker threads. This allows each table to have a different setting.
 69  
      * It assumes that there is only one jdbc disk cache auxiliary defined per table.
 70  
      */
 71  
     private Map shrinkerThreadMap = new Hashtable();
 72  
 
 73  
     /**
 74  
      * Children must implement this method.
 75  
      * <p>
 76  
      * @param cattr
 77  
      * @param tableState An object used by multiple processes to indicate state.
 78  
      * @return AuxiliaryCache -- a JDBCDiskCache
 79  
      */
 80  
     protected abstract AuxiliaryCache createJDBCDiskCache( JDBCDiskCacheAttributes cattr, TableState tableState );
 81  
 
 82  
     /**
 83  
      * Creates a JDBCDiskCache for the region if one doesn't exist, else it returns the precreated
 84  
      * instance. It also adds the region to the shrinker thread if needed.
 85  
      * <p>
 86  
      * @param cattr
 87  
      * @return The cache value
 88  
      */
 89  
     public AuxiliaryCache getCache( JDBCDiskCacheAttributes cattr )
 90  
     {
 91  
         AuxiliaryCache diskCache = null;
 92  
 
 93  
         log.debug( "cacheName = " + cattr.getCacheName() );
 94  
 
 95  
         synchronized ( caches )
 96  
         {
 97  
             diskCache = (AuxiliaryCache) caches.get( cattr.getCacheName() );
 98  
 
 99  
             if ( diskCache == null )
 100  
             {
 101  
                 TableState tableState = (TableState) tableStates.get( cattr.getTableName() );
 102  
 
 103  
                 if ( tableState == null )
 104  
                 {
 105  
                     tableState = new TableState( cattr.getTableName() );
 106  
                 }
 107  
 
 108  
                 diskCache = createJDBCDiskCache( cattr, tableState );
 109  
 
 110  
                 caches.put( cattr.getCacheName(), diskCache );
 111  
             }
 112  
         }
 113  
 
 114  
         if ( log.isDebugEnabled() )
 115  
         {
 116  
             log.debug( "JDBC cache = " + diskCache );
 117  
         }
 118  
 
 119  
         // create a shrinker if we need it.
 120  
         createShrinkerWhenNeeded( cattr, diskCache );
 121  
 
 122  
         return diskCache;
 123  
     }
 124  
 
 125  
     /**
 126  
      * If UseDiskShrinker is true then we will create a shrinker daemon if necessary.
 127  
      * <p>
 128  
      * @param cattr
 129  
      * @param raf
 130  
      */
 131  
     protected void createShrinkerWhenNeeded( JDBCDiskCacheAttributes cattr, AuxiliaryCache raf )
 132  
     {
 133  
         // add cache to shrinker.
 134  
         if ( cattr.isUseDiskShrinker() )
 135  
         {
 136  
             if ( shrinkerDaemon == null )
 137  
             {
 138  
                 shrinkerDaemon = new ClockDaemon();
 139  
                 shrinkerDaemon.setThreadFactory( new MyThreadFactory() );
 140  
             }
 141  
 
 142  
             ShrinkerThread shrinkerThread = (ShrinkerThread) shrinkerThreadMap.get( cattr.getTableName() );
 143  
             if ( shrinkerThread == null )
 144  
             {
 145  
                 shrinkerThread = new ShrinkerThread();
 146  
                 shrinkerThreadMap.put( cattr.getTableName(), shrinkerThread );
 147  
 
 148  
                 long intervalMillis = Math.max( 999, cattr.getShrinkerIntervalSeconds() * 1000 );
 149  
                 if ( log.isInfoEnabled() )
 150  
                 {
 151  
                     log.info( "Setting the shrinker to run every [" + intervalMillis + "] ms. for table ["
 152  
                         + cattr.getTableName() + "]" );
 153  
                 }
 154  
                 shrinkerDaemon.executePeriodically( intervalMillis, shrinkerThread, false );
 155  
             }
 156  
             shrinkerThread.addDiskCacheToShrinkList( (JDBCDiskCache) raf );
 157  
         }
 158  
     }
 159  
 
 160  
     /**
 161  
      * @param name
 162  
      */
 163  
     public void freeCache( String name )
 164  
     {
 165  
         JDBCDiskCache raf = (JDBCDiskCache) caches.get( name );
 166  
         if ( raf != null )
 167  
         {
 168  
             raf.dispose();
 169  
         }
 170  
     }
 171  
 
 172  
     /**
 173  
      * Gets the cacheType attribute of the HSQLCacheManager object
 174  
      * <p>
 175  
      * @return The cacheType value
 176  
      */
 177  
     public int getCacheType()
 178  
     {
 179  
         return DISK_CACHE;
 180  
     }
 181  
 
 182  
     /** Disposes of all regions. */
 183  
     public void release()
 184  
     {
 185  
         // Wait until called by the last client
 186  
         if ( --clients != 0 )
 187  
         {
 188  
             return;
 189  
         }
 190  
         synchronized ( caches )
 191  
         {
 192  
             Enumeration allCaches = caches.elements();
 193  
 
 194  
             while ( allCaches.hasMoreElements() )
 195  
             {
 196  
                 JDBCDiskCache raf = (JDBCDiskCache) allCaches.nextElement();
 197  
                 if ( raf != null )
 198  
                 {
 199  
                     raf.dispose();
 200  
                 }
 201  
             }
 202  
         }
 203  
     }
 204  
 
 205  
     /**
 206  
      * Allows us to set the daemon status on the clockdaemon
 207  
      * <p>
 208  
      * @author aaronsm
 209  
      */
 210  28
     class MyThreadFactory
 211  
         implements ThreadFactory
 212  
     {
 213  
         /**
 214  
          * Set the priority to min and daemon to true.
 215  
          * <p>
 216  
          * @param runner
 217  
          * @return the daemon thread.
 218  
          */
 219  
         public Thread newThread( Runnable runner )
 220  
         {
 221  28
             Thread t = new Thread( runner );
 222  28
             t.setDaemon( true );
 223  28
             t.setPriority( Thread.MIN_PRIORITY );
 224  28
             return t;
 225  
         }
 226  
     }
 227  
 }

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