Clover coverage report -
Coverage timestamp: Fri Jul 2 2004 18:04:44 CEST
file stats: LOC: 178   Methods: 15
NCLOC: 93   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
AbstractBroadcastingListener.java 0% 0% 0% 0%
coverage
 1   
 /*
 2   
  * Copyright (c) 2002-2003 by OpenSymphony
 3   
  * All rights reserved.
 4   
  */
 5   
 package com.opensymphony.oscache.plugins.clustersupport;
 6   
 
 7   
 import com.opensymphony.oscache.base.*;
 8   
 import com.opensymphony.oscache.base.events.*;
 9   
 
 10   
 import org.apache.commons.logging.Log;
 11   
 import org.apache.commons.logging.LogFactory;
 12   
 
 13   
 import java.util.Date;
 14   
 
 15   
 /**
 16   
  * Implementation of a CacheEntryEventListener. It broadcasts the flush events
 17   
  * across a cluster to other listening caches. Note that this listener cannot
 18   
  * be used in conjection with session caches.
 19   
  *
 20   
  * @version        $Revision: 1.1 $
 21   
  * @author <a href="&#109;a&#105;&#108;&#116;&#111;:chris&#64;swebtec.&#99;&#111;&#109;">Chris Miller</a>
 22   
  */
 23   
 public abstract class AbstractBroadcastingListener implements CacheEntryEventListener, LifecycleAware {
 24   
     private final static Log log = LogFactory.getLog(AbstractBroadcastingListener.class);
 25   
 
 26   
     /**
 27   
      * The name to use for the origin of cluster events. Using this ensures
 28   
      * events are not fired recursively back over the cluster.
 29   
      */
 30   
     protected static final String CLUSTER_ORIGIN = "CLUSTER";
 31   
     protected Cache cache = null;
 32   
 
 33  0
     public AbstractBroadcastingListener() {
 34  0
         if (log.isInfoEnabled()) {
 35  0
             log.info("AbstractBroadcastingListener registered");
 36   
         }
 37   
     }
 38   
 
 39   
     /**
 40   
      * Event fired when an entry is flushed from the cache. This broadcasts
 41   
      * the flush message to any listening nodes on the network.
 42   
      */
 43  0
     public void cacheEntryFlushed(CacheEntryEvent event) {
 44  0
         if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
 45  0
             if (log.isDebugEnabled()) {
 46  0
                 log.debug("cacheEntryFlushed called (" + event + ")");
 47   
             }
 48   
 
 49  0
             sendNotification(new ClusterNotification(ClusterNotification.FLUSH_KEY, event.getKey()));
 50   
         }
 51   
     }
 52   
 
 53   
     /**
 54   
      * Event fired when an entry is removed from the cache. This broadcasts
 55   
      * the remove method to any listening nodes on the network, as long as
 56   
      * this event wasn't from a broadcast in the first place.
 57   
      */
 58  0
     public void cacheGroupFlushed(CacheGroupEvent event) {
 59  0
         if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
 60  0
             if (log.isDebugEnabled()) {
 61  0
                 log.debug("cacheGroupFushed called (" + event + ")");
 62   
             }
 63   
 
 64  0
             sendNotification(new ClusterNotification(ClusterNotification.FLUSH_GROUP, event.getGroup()));
 65   
         }
 66   
     }
 67   
 
 68  0
     public void cachePatternFlushed(CachePatternEvent event) {
 69  0
         if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
 70  0
             if (log.isDebugEnabled()) {
 71  0
                 log.debug("cachePatternFushed called (" + event + ")");
 72   
             }
 73   
 
 74  0
             sendNotification(new ClusterNotification(ClusterNotification.FLUSH_PATTERN, event.getPattern()));
 75   
         }
 76   
     }
 77   
 
 78  0
     public void cacheFlushed(CachewideEvent event) {
 79  0
         if (!Cache.NESTED_EVENT.equals(event.getOrigin()) && !CLUSTER_ORIGIN.equals(event.getOrigin())) {
 80  0
             if (log.isDebugEnabled()) {
 81  0
                 log.debug("cacheFushed called (" + event + ")");
 82   
             }
 83   
 
 84  0
             sendNotification(new ClusterNotification(ClusterNotification.FLUSH_CACHE, event.getDate()));
 85   
         }
 86   
     }
 87   
 
 88   
     // --------------------------------------------------------
 89   
     // The remaining events are of no interest to this listener
 90   
     // --------------------------------------------------------
 91  0
     public void cacheEntryAdded(CacheEntryEvent event) {
 92   
     }
 93   
 
 94  0
     public void cacheEntryRemoved(CacheEntryEvent event) {
 95   
     }
 96   
 
 97  0
     public void cacheEntryUpdated(CacheEntryEvent event) {
 98   
     }
 99   
 
 100  0
     public void cacheGroupAdded(CacheGroupEvent event) {
 101   
     }
 102   
 
 103  0
     public void cacheGroupEntryAdded(CacheGroupEvent event) {
 104   
     }
 105   
 
 106  0
     public void cacheGroupEntryRemoved(CacheGroupEvent event) {
 107   
     }
 108   
 
 109  0
     public void cacheGroupRemoved(CacheGroupEvent event) {
 110   
     }
 111   
 
 112  0
     public void cacheGroupUpdated(CacheGroupEvent event) {
 113   
     }
 114   
 
 115   
     /**
 116   
      * Called by the cache administrator class when a cache is instantiated.
 117   
      *
 118   
      * @param cache the cache instance that this listener is attached to.
 119   
      * @param config The cache's configuration details. This allows the event handler
 120   
      * to initialize itself based on the cache settings, and also to receive <em>additional</em>
 121   
      * settings that were part of the cache configuration but that the cache
 122   
      * itself does not care about. If you are using <code>cache.properties</code>
 123   
      * for your configuration, simply add any additional properties that your event
 124   
      * handler requires and they will be passed through in this parameter.
 125   
      *
 126   
      * @throws InitializationException thrown when there was a problem initializing the
 127   
      * listener. The cache administrator will log this error and disable the listener.
 128   
      */
 129  0
     public void initialize(Cache cache, Config config) throws InitializationException {
 130  0
         this.cache = cache;
 131   
     }
 132   
 
 133   
     /**
 134   
      * Handles incoming notification messages. This method should be called by the
 135   
      * underlying broadcasting implementation when a message is received from another
 136   
      * node in the cluster.
 137   
      *
 138   
      * @param message The incoming cluster notification message object.
 139   
      */
 140  0
     public void handleClusterNotification(ClusterNotification message) {
 141  0
         if (cache == null) {
 142  0
             log.warn("A cluster notification (" + message + ") was received, but no cache is registered on this machine. Notification ignored.");
 143   
 
 144  0
             return;
 145   
         }
 146   
 
 147  0
         if (log.isInfoEnabled()) {
 148  0
             log.info("Cluster notification (" + message + ") was received.");
 149   
         }
 150   
 
 151  0
         switch (message.getType()) {
 152   
             case ClusterNotification.FLUSH_KEY:
 153  0
                 cache.flushEntry((String) message.getData(), CLUSTER_ORIGIN);
 154  0
                 break;
 155   
             case ClusterNotification.FLUSH_GROUP:
 156  0
                 cache.flushGroup((String) message.getData(), CLUSTER_ORIGIN);
 157  0
                 break;
 158   
             case ClusterNotification.FLUSH_PATTERN:
 159  0
                 cache.flushPattern((String) message.getData(), CLUSTER_ORIGIN);
 160  0
                 break;
 161   
             case ClusterNotification.FLUSH_CACHE:
 162  0
                 cache.flushAll((Date) message.getData(), CLUSTER_ORIGIN);
 163  0
                 break;
 164   
             default:
 165  0
                 log.error("The cluster notification (" + message + ") is of an unknown type. Notification ignored.");
 166   
         }
 167   
     }
 168   
 
 169   
     /**
 170   
      * Called when a cluster notification message is to be broadcast. Implementing
 171   
      * classes should use their underlying transport to broadcast the message across
 172   
      * the cluster.
 173   
      *
 174   
      * @param message The notification message to broadcast.
 175   
      */
 176   
     abstract protected void sendNotification(ClusterNotification message);
 177   
 }
 178