Coverage report

  %line %branch
org.apache.jcs.auxiliary.disk.jdbc.mysql.MySQLDiskCacheManager
80% 
98% 

 1  
 package org.apache.jcs.auxiliary.disk.jdbc.mysql;
 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.Date;
 23  
 import java.util.Timer;
 24  
 import java.util.TimerTask;
 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.disk.jdbc.JDBCDiskCacheAttributes;
 30  
 import org.apache.jcs.auxiliary.disk.jdbc.JDBCDiskCacheManagerAbstractTemplate;
 31  
 import org.apache.jcs.auxiliary.disk.jdbc.TableState;
 32  
 import org.apache.jcs.auxiliary.disk.jdbc.mysql.util.ScheduleFormatException;
 33  
 import org.apache.jcs.auxiliary.disk.jdbc.mysql.util.ScheduleParser;
 34  
 
 35  
 /**
 36  
  * This manages instances of the MySQL jdbc disk cache. It maintains one for
 37  
  * each region. One for all regions would work, but this gives us more detailed
 38  
  * stats by region.
 39  
  * <p>
 40  
  * Although the generic JDBC Disk Cache Manager can be used for MySQL, the MySQL
 41  
  * JDBC Disk Cache has additional features, such as table optimization that are
 42  
  * particular to MySQL.
 43  
  */
 44  0
 public class MySQLDiskCacheManager
 45  
     extends JDBCDiskCacheManagerAbstractTemplate
 46  
 {
 47  
     private static final long serialVersionUID = -8258856770927857896L;
 48  
 
 49  14
     private static final Log log = LogFactory.getLog( MySQLDiskCacheManager.class );
 50  
 
 51  
     private static MySQLDiskCacheManager instance;
 52  
 
 53  
     private MySQLDiskCacheAttributes defaultJDBCDiskCacheAttributes;
 54  
 
 55  
     // ms in a day
 56  
     private static final int DAILY_INTERVAL = 60 * 60 * 24 * 1000;
 57  
 
 58  
     // for schedule optimizations
 59  7
     private Timer daemon = null;
 60  
 
 61  
     /**
 62  
      * Constructor for the HSQLCacheManager object
 63  
      * <p>
 64  
      * @param cattr
 65  
      */
 66  
     private MySQLDiskCacheManager( MySQLDiskCacheAttributes cattr )
 67  7
     {
 68  7
         if ( log.isInfoEnabled() )
 69  
         {
 70  7
             log.info( "Creating MySQLDiskCacheManager with " + cattr );
 71  
         }
 72  7
         defaultJDBCDiskCacheAttributes = cattr;
 73  7
     }
 74  
 
 75  
     /**
 76  
      * Gets the defaultCattr attribute of the HSQLCacheManager object
 77  
      * <p>
 78  
      * @return The defaultCattr value
 79  
      */
 80  
     public MySQLDiskCacheAttributes getDefaultJDBCDiskCacheAttributes()
 81  
     {
 82  0
         return defaultJDBCDiskCacheAttributes;
 83  
     }
 84  
 
 85  
     /**
 86  
      * Gets the instance attribute of the HSQLCacheManager class
 87  
      * <p>
 88  
      * @param cattr
 89  
      * @return The instance value
 90  
      */
 91  
     public static MySQLDiskCacheManager getInstance( MySQLDiskCacheAttributes cattr )
 92  
     {
 93  7
         synchronized ( MySQLDiskCacheManager.class )
 94  
         {
 95  7
             if ( instance == null )
 96  
             {
 97  7
                 instance = new MySQLDiskCacheManager( cattr );
 98  
             }
 99  7
         }
 100  7
         clients++;
 101  7
         return instance;
 102  
     }
 103  
 
 104  
     /**
 105  
      * Gets the cache attribute of the HSQLCacheManager object
 106  
      * <p>
 107  
      * @param cacheName
 108  
      * @return The cache value
 109  
      */
 110  
     public AuxiliaryCache getCache( String cacheName )
 111  
     {
 112  0
         MySQLDiskCacheAttributes cattr = (MySQLDiskCacheAttributes) defaultJDBCDiskCacheAttributes.copy();
 113  0
         cattr.setCacheName( cacheName );
 114  0
         return getCache( cattr );
 115  
     }
 116  
 
 117  
     /**
 118  
      * Creates a JDBCDiskCache using the supplied attributes.
 119  
      * <p>
 120  
      * @param cattr
 121  
      * @return
 122  
      */
 123  
     protected AuxiliaryCache createJDBCDiskCache( JDBCDiskCacheAttributes cattr, TableState tableState )
 124  
     {
 125  7
         AuxiliaryCache raf = new MySQLDiskCache( (MySQLDiskCacheAttributes) cattr, tableState );
 126  
 
 127  7
         scheduleOptimizations( (MySQLDiskCacheAttributes) cattr, tableState );
 128  
 
 129  7
         return raf;
 130  
     }
 131  
 
 132  
     /**
 133  
      * For each time in the optimization schedule, this calls schedule
 134  
      * Optimizaiton.
 135  
      * <p>
 136  
      * @param attributes
 137  
      * @param tableState
 138  
      */
 139  
     protected void scheduleOptimizations( MySQLDiskCacheAttributes attributes, TableState tableState )
 140  
     {
 141  7
         if ( attributes != null )
 142  
         {
 143  7
             if ( attributes.getOptimizationSchedule() != null )
 144  
             {
 145  7
                 if ( log.isInfoEnabled() )
 146  
                 {
 147  7
                     log.info( "Will try to configure optimization for table [" + attributes.getTableName()
 148  
                         + "] on schdule [" + attributes.getOptimizationSchedule() + "]" );
 149  
                 }
 150  
 
 151  7
                 MySQLTableOptimizer optimizer = new MySQLTableOptimizer( attributes, tableState );
 152  
 
 153  
                 // loop through the dates.
 154  
                 try
 155  
                 {
 156  7
                     Date[] dates = ScheduleParser.createDatesForSchedule( attributes.getOptimizationSchedule() );
 157  7
                     if ( dates != null )
 158  
                     {
 159  21
                         for ( int i = 0; i < dates.length; i++ )
 160  
                         {
 161  14
                             this.scheduleOptimization( dates[i], optimizer );
 162  
                         }
 163  
                     }
 164  
                 }
 165  0
                 catch ( ScheduleFormatException e )
 166  
                 {
 167  0
                     log.warn( "Problem creating optimization schedule for table [" + attributes.getTableName() + "]" );
 168  7
                 }
 169  7
             }
 170  
             else
 171  
             {
 172  0
                 if ( log.isInfoEnabled() )
 173  
                 {
 174  0
                     log.info( "Optimization is not configured for table [" + attributes.getTableName() + "]" );
 175  
                 }
 176  
             }
 177  
         }
 178  7
     }
 179  
 
 180  
     /**
 181  
      * This takes in a single time and schedules the optimizer to be called at
 182  
      * that time every day.
 183  
      * <p>
 184  
      * @param startTime --
 185  
      *            HH:MM:SS format
 186  
      * @param optimizer
 187  
      */
 188  
     protected void scheduleOptimization( Date startTime, MySQLTableOptimizer optimizer )
 189  
     {
 190  14
         if ( log.isInfoEnabled() )
 191  
         {
 192  14
             log.info( "startTime [" + startTime + "] for optimizer " + optimizer );
 193  
         }
 194  
 
 195  
         // create clock daemon if necessary
 196  14
         if ( daemon == null )
 197  
         {
 198  
             // true for daemon status
 199  7
             daemon = new Timer( true );
 200  
         }
 201  
 
 202  
         // get the runnable from the factory
 203  14
         TimerTask runnable = new OptimizerTask( optimizer );
 204  
 
 205  
         // have the daemon execut our runnable
 206  
         // false to not execute immediately.
 207  14
         daemon.scheduleAtFixedRate( runnable, startTime, DAILY_INTERVAL );
 208  
 
 209  14
         if ( log.isInfoEnabled() )
 210  
         {
 211  14
             log.info( "Scheduled optimization to begin at [" + startTime + "]" );
 212  
         }
 213  14
     }
 214  
 
 215  
     /**
 216  
      * This calls the optimizers' optimize table method. This is used by the
 217  
      * timer.
 218  
      * <p>
 219  
      * @author Aaron Smuts
 220  
      */
 221  
     private class OptimizerTask
 222  
         extends TimerTask
 223  
     {
 224  
         private MySQLTableOptimizer optimizer = null;
 225  
 
 226  
         /**
 227  
          * Get a handle on the optimizer.
 228  
          * <p>
 229  
          * @param optimizer
 230  
          */
 231  
         public OptimizerTask( MySQLTableOptimizer optimizer )
 232  
         {
 233  
             this.optimizer = optimizer;
 234  
         }
 235  
 
 236  
         /**
 237  
          * This calls optimize on the optimizer.
 238  
          * <p>
 239  
          * @see java.lang.Runnable#run()
 240  
          */
 241  
         public void run()
 242  
         {
 243  
             if ( optimizer != null )
 244  
             {
 245  
                 boolean success = optimizer.optimizeTable();
 246  
                 if ( log.isInfoEnabled() )
 247  
                 {
 248  
                     log.info( "Optimization success status [" + success + "]" );
 249  
                 }
 250  
             }
 251  
             else
 252  
             {
 253  
                 log.warn( "OptimizerRunner: The optimizer is null.  Could not optimize table." );
 254  
             }
 255  
         }
 256  
     }
 257  
 }

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