• Home
• net.sf.ehcache
• ehcache
• 2.8.5
• source code
• ScheduledRefreshCacheExtension.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

net.sf.ehcache.constructs.scheduledrefresh.ScheduledRefreshCacheExtension Maven / Gradle / Ivy

/**
 *  Copyright Terracotta, Inc.
 *
 *  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.
 */
package net.sf.ehcache.constructs.scheduledrefresh;

import net.sf.ehcache.CacheException;
import net.sf.ehcache.Ehcache;
import net.sf.ehcache.Status;
import net.sf.ehcache.extension.CacheExtension;
import net.sf.ehcache.statistics.extended.ExtendedStatistics;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.terracotta.statistics.StatisticsManager;

import java.util.Collection;
import java.util.Collections;
import java.util.LinkedList;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;

/**
 * This class provides a cache extension which allows for the scheduled refresh
 * of all keys currently in the cache, using whichever CacheLoader's are
 * defined. It uses Quartz to do the job scheduling. One extension should be
 * active for a single clustered cache, as multiple extensions will run
 * independently of each other.
 *
 * @author cschanck
 */
public class ScheduledRefreshCacheExtension implements CacheExtension {

   /**
    * Logger this package uses.
    */
   static final Logger LOG = LoggerFactory.getLogger(ScheduledRefreshCacheExtension.class);

   /**
    * Job Property key for Terracotta Job Store to use.
    */
   static final String PROP_QUARTZ_JOB_STORE_TC_CONFIG_URL = "org.quartz.jobStore.tcConfigUrl";

   /**
    * Job Property key for cache name this extension's jobs will run against
    */
   static final String PROP_CACHE_NAME = ScheduledRefreshCacheExtension.class.getName() + ".cacheName";

   /**
    * Job Property key for cache manager name this extension's jobs will run
    * against
    */
   static final String PROP_CACHE_MGR_NAME = ScheduledRefreshCacheExtension.class.getName() + "cacheManagerName";

   /**
    * Job Property key for sending config object to scheduled job
    */
   static final String PROP_CONFIG_OBJECT = ScheduledRefreshCacheExtension.class.getName() + "scheduledRefreshConfig";

   /**
    * Job Property key for sending keys to process to scheduled job
    */
   static final String PROP_KEYS_TO_PROCESS = "keyObjects";

   private static final String OVERSEER_JOB_NAME = "Overseer";
   private Ehcache underlyingCache;
   private ScheduledRefreshConfiguration config;
   private String name;
   private Scheduler scheduler;
   private String groupName;
   private Status status;
   private AtomicLong refreshCount = new AtomicLong();
   private AtomicLong jobCount = new AtomicLong();
   private AtomicLong keysProcessedCount = new AtomicLong();

   /**
    * Constructor. Create an extension with the specified config object against
    * the specified cache.
    *
    * @param config Configuration to use.
    * @param cache  Cache to process against.
    */
   public ScheduledRefreshCacheExtension(ScheduledRefreshConfiguration config, Ehcache cache) {
      if(cache == null) {
         throw new IllegalArgumentException("ScheduledRefresh Cache cannot be null");
      }
      this.underlyingCache = cache;
      if(config == null) {
         throw new IllegalArgumentException("ScheduledRefresh extension config cannot be null");
      }
      this.config = config;
      config.validate();
      this.status = Status.STATUS_UNINITIALISED;
      StatisticsManager.associate(this).withParent(cache);
   }

   @Override
   public void init() {
      try {
         if (config.getScheduledRefreshName() != null) {
            this.name = "scheduledRefresh_" + underlyingCache.getCacheManager().getName() + "_"
                + underlyingCache.getName() + "_" + config.getScheduledRefreshName();
         } else {
            this.name = "scheduledRefresh_" + underlyingCache.getCacheManager().getName() + "_"
                + underlyingCache.getName();
         }
         this.groupName = name + "_grp";
         try {
            makeAndStartQuartzScheduler();
            try {
               scheduleOverseerJob();
               status = Status.STATUS_ALIVE;
            } catch (SchedulerException e) {
               LOG.error("Unable to schedule control job for Scheduled Refresh", e);
            }

         } catch (SchedulerException e) {
            LOG.error("Unable to instantiate Quartz Job Scheduler for Scheduled Refresh", e);
         }
      } catch(RuntimeException e) {
         LOG.error("Unable to initialise ScheduledRefesh extension", e);
      }
   }

   /*
    * This is more complicated at first blush than you might expect, but it
    * attempts to prove that one and only one trigger is scheduled for this job,
    * and that it is the right one. Even if multiple cache extensions for the
    * same cache are sharing the Quartz store, it should end up with only one
    * trigger winning. If there are multiple *different* cron expressions,
    * someone will win, but it is not deterministic as to which one.
    */
   private void scheduleOverseerJob() throws SchedulerException {

      JobDetail seed = makeOverseerJob();

      // build our trigger
      CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule(config.getCronExpression());

      CronTrigger trigger = TriggerBuilder.newTrigger()
          .withIdentity(OVERSEER_JOB_NAME, groupName)
          .forJob(seed).withSchedule(cronSchedule)
          .build();

      try {
         scheduler.addJob(seed, false);
      } catch (SchedulerException e) {
         // job already present
      }
      try {
         scheduler.scheduleJob(trigger);
      } catch (SchedulerException e) {
         // trigger already present
         try {
            scheduler.rescheduleJob(trigger.getKey(), trigger);
         } catch (SchedulerException ee) {
            LOG.error("Unable to modify trigger for: " + trigger.getKey());
         }
      }

   }

   /*
    * Add the control job, an instance of the OverseerJob class.
    */
   private JobDetail makeOverseerJob() throws SchedulerException {
      JobDataMap jdm = new JobDataMap();
      jdm.put(PROP_CACHE_MGR_NAME, underlyingCache.getCacheManager().getName());
      jdm.put(PROP_CACHE_NAME, underlyingCache.getName());
      jdm.put(PROP_CONFIG_OBJECT, config);
      JobDetail seed = JobBuilder.newJob(OverseerJob.class).storeDurably()
          .withIdentity(OVERSEER_JOB_NAME, groupName)
          .usingJobData(jdm).build();
      return seed;
   }

   /*
    * Create and start the quartz job scheduler for this cache extension
    */
   private void makeAndStartQuartzScheduler() throws SchedulerException {
      Properties props = new Properties();
      props.put(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, name);
      props.put(StdSchedulerFactory.PROP_SCHED_NAME, name);
      props.put(StdSchedulerFactory.PROP_SCHED_MAKE_SCHEDULER_THREAD_DAEMON, Boolean.TRUE.toString());
      props.put("org.quartz.threadPool.threadCount", Integer.toString(config.getQuartzThreadCount() + 1));
      Properties jsProps = getJobStoreProperties();
      for (Object key : props.keySet()) {
         if (!jsProps.containsKey(key)) {
            jsProps.put(key, props.get(key));
         }
      }

      StdSchedulerFactory factory = new StdSchedulerFactory(jsProps);
      scheduler = factory.getScheduler();

      scheduler.start();
   }

   private Properties getJobStoreProperties() throws SchedulerException {
      try {
         String clzName = config.getJobStoreFactoryClass();
         Class clz = Class.forName(clzName);
         ScheduledRefreshJobStorePropertiesFactory fact = (ScheduledRefreshJobStorePropertiesFactory) clz.newInstance();
         Properties jsProps = fact.jobStoreProperties(underlyingCache, config);
         return jsProps;
      } catch (Throwable t) {
         throw new SchedulerException(t);
      }
   }

   /**
    * Note that this will not stop other instances of this refresh extension on
    * other nodes (in a clustered environment) from running. Until and unless
    * the last scheduled refresh cache extension for a particular cache/cache
    * manager/unique name is shutdown, they will continue to run. This is only
    * an issue for clustered, TerracottaJobStore-backed scheduled refresh cache
    * extensions.
    *
    * @throws CacheException
    */
   @Override
   public void dispose() throws CacheException {
      try {
         scheduler.shutdown();
      } catch (SchedulerException e) {
         throw new CacheException(e);
      } catch(Throwable t) {
         LOG.info("ScheduledRefresh cache extension exception during shutdown.",t);
      }
      status = Status.STATUS_SHUTDOWN;
   }

   @Override
   public CacheExtension clone(Ehcache cache) throws CloneNotSupportedException {
      return null;
   }

   @Override
   public Status getStatus() {
      return status;
   }

   /**
    * Gets extension group name.
    *
    * @return the extension group name
    */
   String getExtensionGroupName() {
      return groupName;
   }

   /**
    * Gets underlying cache.
    *
    * @return the underlying cache
    */
   Ehcache getUnderlyingCache() {
      return underlyingCache;
   }

  /**
   * Find extension from cache.
   *
   * @param cache the cache
   * @param groupName the group name
   * @return the scheduled refresh cache extension
   */
  static ScheduledRefreshCacheExtension findExtensionFromCache(Ehcache cache, String groupName) {
    for (CacheExtension ce : cache.getRegisteredCacheExtensions()) {
      if (ce instanceof ScheduledRefreshCacheExtension) {
        ScheduledRefreshCacheExtension probe = (ScheduledRefreshCacheExtension) ce;
        if (probe.getUnderlyingCache().getName().equals(cache.getName()) &&
          probe.getExtensionGroupName().equals(groupName)) {
          return probe;
        }
      }
    }
    return null;
  }

  /**
   * Find all the scheduled refresh cache extensions from a cache.
   *
   * @param cache the cache
   * @return the scheduled refresh cache extension
   */
  static Collection findExtensionsFromCache(Ehcache cache) {
    LinkedList exts=new LinkedList();
    for (CacheExtension ce : cache.getRegisteredCacheExtensions()) {
      if (ce instanceof ScheduledRefreshCacheExtension) {
        exts.add((ScheduledRefreshCacheExtension)ce);
      }
    }
    return exts;
  }

  /**
    * Increment refresh count.
    */
   void incrementRefreshCount() {
      refreshCount.incrementAndGet();
   }

   /**
    * Increment job count.
    */
   void incrementJobCount() {
      jobCount.incrementAndGet();
   }

   /**
    * Increment processed count.
    *
    * @param many the many
    */
   void incrementProcessedCount(int many) {
      keysProcessedCount.addAndGet(many);
   }

   /**
    * Gets refresh count.
    *
    * @return the refresh count
    */
   @org.terracotta.statistics.Statistic(name = "refresh", tags = "scheduledrefresh")
   public long getRefreshCount() {
      return refreshCount.get();
   }

   /**
    * Gets job count.
    *
    * @return the job count
    */
   @org.terracotta.statistics.Statistic(name = "job", tags = "scheduledrefresh")
   public long getJobCount() {
      return jobCount.get();
   }

   /**
    * Gets keys processed count.
    *
    * @return the keys processed count
    */
   @org.terracotta.statistics.Statistic(name = "keysprocessed", tags = "scheduledrefresh")
   public long getKeysProcessedCount() {
      return keysProcessedCount.get();
   }

   /**
    * Find refreshed counter statistic. Number of times schedule refresh has been
    * started on this node.
    *
    * @param cache the cache this statistic is attached to.
    * @return the set
    */
   public static Set> findRefreshStatistics(Ehcache cache) {
      return cache.getStatistics().getExtended().passthru("refresh",
          Collections.singletonMap("scheduledrefresh", null).keySet());
   }

   /**
    * Find job counter statistic. Number of batch jobs executed on this node.
    *
    * @param cache the cache this statistic is attached to.
    * @return the set
    */
   public static Set> findJobStatistics(Ehcache cache) {
      return cache.getStatistics().getExtended().passthru("job",
          Collections.singletonMap("scheduledrefresh", null).keySet());
   }

   /**
    * Find queued counter statistic. Number of batch jobs executed on this node.
    *
    * @param cache the cache this statistic is attached to.
    * @return the set
    */
   public static Set> findKeysProcessedStatistics(Ehcache cache) {
      return cache.getStatistics().getExtended().passthru("keysprocessed",
          Collections.singletonMap("scheduledrefresh", null).keySet());
   }

   /**
    * Finds a single refresh statistic for this cache. This is the count of scheduled
    * refresh invocations for this node. Throws {@link IllegalStateException} if
    * there are none or more than one.
    *
    * @param cache the cache
    * @return the extended statistics . statistic
    */
   public static ExtendedStatistics.Statistic findRefreshStatistic(Ehcache cache) {
      Set> set = findRefreshStatistics(cache);
      if (set.size() == 1) {
         return set.iterator().next();
      } else {
         throw new IllegalStateException("Multiple scheduled refresh stats found for this cache");
      }
   }

   /**
    * Finds a single job statistic for this cache. This is the count of refresh batch jobs
    * executed on this node. Throws {@link IllegalStateException} if there are none or
    * more than one.
    *
    * @param cache the cache
    * @return the extended statistics . statistic
    */
   public static ExtendedStatistics.Statistic findJobStatistic(Ehcache cache) {
      Set> set = findJobStatistics(cache);
      if (set.size() == 1) {
         return set.iterator().next();
      } else {
         throw new IllegalStateException("Multiple scheduled refresh stats found for this cache");
      }
   }

   /**
    * Finds a single keys processed statistic for this cache. This is the count of keys
    * refreshed on this node. Throws {@link IllegalStateException} if
    * there are none or more than one.
    *
    * @param cache the cache
    * @return the extended statistics . statistic
    */
   public static ExtendedStatistics.Statistic findKeysProcessedStatistic(Ehcache cache) {
      Set> set = findKeysProcessedStatistics(cache);
      if (set.size() == 1) {
         return set.iterator().next();
      } else {
         throw new IllegalStateException("Multiple scheduled refresh stats found for this cache");
      }
   }

}