package org.apache.commons.jcs.auxiliary.disk.jdbc.mysql;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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 java.sql.SQLException;
  import java.text.ParseException;
  import java.util.Date;
  import java.util.concurrent.TimeUnit;
  
  import javax.sql.DataSource;
  
  import org.apache.commons.jcs.auxiliary.AuxiliaryCacheAttributes;
  import org.apache.commons.jcs.auxiliary.disk.jdbc.JDBCDiskCacheFactory;
  import org.apache.commons.jcs.auxiliary.disk.jdbc.TableState;
  import org.apache.commons.jcs.auxiliary.disk.jdbc.dsfactory.DataSourceFactory;
  import org.apache.commons.jcs.auxiliary.disk.jdbc.mysql.util.ScheduleParser;
  import org.apache.commons.jcs.engine.behavior.ICompositeCacheManager;
  import org.apache.commons.jcs.engine.behavior.IElementSerializer;
  import org.apache.commons.jcs.engine.logging.behavior.ICacheEventLogger;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * This factory should create mysql disk caches.
   * <p>
   * @author Aaron Smuts
   */
  public class MySQLDiskCacheFactory
      extends JDBCDiskCacheFactory
  {
      /** The logger */
      private static final Log log = LogFactory.getLog( MySQLDiskCacheFactory.class );
  
      /**
       * This factory method should create an instance of the mysqlcache.
       * <p>
       * @param rawAttr specific cache configuration attributes
       * @param compositeCacheManager the global cache manager
       * @param cacheEventLogger a specific logger for cache events
       * @param elementSerializer a serializer for cache elements
       * @return MySQLDiskCache the cache instance
       * @throws SQLException if the cache instance could not be created
       */
      @Override
      public <K, V> MySQLDiskCache<K, V> createCache( AuxiliaryCacheAttributes rawAttr,
              ICompositeCacheManager compositeCacheManager,
              ICacheEventLogger cacheEventLogger, IElementSerializer elementSerializer )
              throws SQLException
      {
          MySQLDiskCacheAttributes cattr = (MySQLDiskCacheAttributes) rawAttr;
          TableState tableState = getTableState( cattr.getTableName() );
          DataSourceFactory dsFactory = getDataSourceFactory(cattr, compositeCacheManager.getConfigurationProperties());
  
          MySQLDiskCache<K, V> cache = new MySQLDiskCache<K, V>( cattr, dsFactory, tableState, compositeCacheManager );
          cache.setCacheEventLogger( cacheEventLogger );
          cache.setElementSerializer( elementSerializer );
  
          // create a shrinker if we need it.
          createShrinkerWhenNeeded( cattr, cache );
          scheduleOptimizations( cattr, tableState, cache.getDataSource() );
  
          return cache;
  
      }
  
      /**
       * For each time in the optimization schedule, this calls schedule Optimization.
       * <p>
       * @param attributes configuration properties.
       * @param tableState for noting optimization in progress, etc.
       * @param ds the DataSource
       */
      protected void scheduleOptimizations( MySQLDiskCacheAttributes attributes, TableState tableState, DataSource ds  )
      {
          if ( attributes != null )
          {
              if ( attributes.getOptimizationSchedule() != null )
              {
                  if ( log.isInfoEnabled() )
                  {
                      log.info( "Will try to configure optimization for table [" + attributes.getTableName()
                          + "] on schedule [" + attributes.getOptimizationSchedule() + "]" );
                 }
 
                 MySQLTableOptimizer optimizer = new MySQLTableOptimizer( attributes, tableState, ds );
 
                 // loop through the dates.
                 try
                 {
                     Date[] dates = ScheduleParser.createDatesForSchedule( attributes.getOptimizationSchedule() );
                     if ( dates != null )
                     {
                         for ( int i = 0; i < dates.length; i++ )
                         {
                             this.scheduleOptimization( dates[i], optimizer );
                         }
                     }
                 }
                 catch ( ParseException e )
                 {
                     log.warn( "Problem creating optimization schedule for table [" + attributes.getTableName() + "]", e );
                 }
             }
             else
             {
                 if ( log.isInfoEnabled() )
                 {
                     log.info( "Optimization is not configured for table [" + attributes.getTableName() + "]" );
                 }
             }
         }
     }
 
     /**
      * This takes in a single time and schedules the optimizer to be called at that time every day.
      * <p>
      * @param startTime -- HH:MM:SS format
      * @param optimizer
      */
     protected void scheduleOptimization( Date startTime, MySQLTableOptimizer optimizer )
     {
         if ( log.isInfoEnabled() )
         {
             log.info( "startTime [" + startTime + "] for optimizer " + optimizer );
         }
 
         // get the runnable from the factory
         OptimizerTask runnable = new OptimizerTask( optimizer );
         Date now = new Date();
         long initialDelay = startTime.getTime() - now.getTime();
 
         // have the daemon execute our runnable
         getScheduledExecutorService().scheduleAtFixedRate(runnable, initialDelay, 86400000L, TimeUnit.MILLISECONDS );
     }
 
     /**
      * This calls the optimizers' optimize table method. This is used by the timer.
      * <p>
      * @author Aaron Smuts
      */
     private static class OptimizerTask
         implements Runnable
     {
         /** Handles optimization */
         private MySQLTableOptimizer optimizer = null;
 
         /**
          * Get a handle on the optimizer.
          * <p>
          * @param optimizer
          */
         public OptimizerTask( MySQLTableOptimizer optimizer )
         {
             this.optimizer = optimizer;
         }
 
         /**
          * This calls optimize on the optimizer.
          * <p>
          * @see java.lang.Runnable#run()
          */
         @Override
         public void run()
         {
             if ( optimizer != null )
             {
                 boolean success = optimizer.optimizeTable();
                 if ( log.isInfoEnabled() )
                 {
                     log.info( "Optimization success status [" + success + "]" );
                 }
             }
             else
             {
                 log.warn( "OptimizerRunner: The optimizer is null.  Could not optimize table." );
             }
         }
     }
 }