Coverage report

  %line %branch
org.apache.jcs.auxiliary.remote.ZombieRemoteCacheService$PutEvent
100% 
100% 

 1  
 package org.apache.jcs.auxiliary.remote;
 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.io.IOException;
 23  
 import java.io.Serializable;
 24  
 import java.util.Collections;
 25  
 import java.util.Set;
 26  
 
 27  
 import org.apache.commons.logging.Log;
 28  
 import org.apache.commons.logging.LogFactory;
 29  
 import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheService;
 30  
 import org.apache.jcs.engine.ZombieCacheService;
 31  
 import org.apache.jcs.engine.behavior.ICacheElement;
 32  
 import org.apache.jcs.utils.struct.BoundedQueue;
 33  
 import org.apache.jcs.utils.timing.ElapsedTimer;
 34  
 
 35  
 /**
 36  
  * Zombie adapter for the remote cache service. It just balks if there is no queue configured. If a
 37  
  * queue is configured, then events will be added to the queue. The idea is that when proper
 38  
  * operation is restored, the remote cache will walk the queue. The queue must be bounded so it does
 39  
  * not eat memory.
 40  
  * <p>
 41  
  * Much of this is potentially reusable.
 42  
  * <p>
 43  
  * TODO figure out a way to get the propagate method into an interface for Zombies.
 44  
  */
 45  
 public class ZombieRemoteCacheService
 46  
     extends ZombieCacheService
 47  
     implements IRemoteCacheService
 48  
 {
 49  
     private final static Log log = LogFactory.getLog( ZombieRemoteCacheService.class );
 50  
 
 51  
     private int maxQueueSize = 0;
 52  
 
 53  
     private BoundedQueue queue;
 54  
 
 55  
     /**
 56  
      * Default.
 57  
      */
 58  
     public ZombieRemoteCacheService()
 59  
     {
 60  
         queue = new BoundedQueue( 0 );
 61  
     }
 62  
 
 63  
     /**
 64  
      * Sets the maximum number of items that will be allowed on the queue.
 65  
      * <p>
 66  
      * @param maxQueueSize
 67  
      */
 68  
     public ZombieRemoteCacheService( int maxQueueSize )
 69  
     {
 70  
         this.maxQueueSize = maxQueueSize;
 71  
         queue = new BoundedQueue( maxQueueSize );
 72  
     }
 73  
 
 74  
     /**
 75  
      * Gets the number of items on the queue.
 76  
      * <p>
 77  
      * @return size of the queue.
 78  
      */
 79  
     public int getQueueSize()
 80  
     {
 81  
         return queue.size();
 82  
     }
 83  
 
 84  
     /**
 85  
      * Adds an update event to the queue if the maxSize is greater than 0;
 86  
      * <p>
 87  
      * (non-Javadoc)
 88  
      * @see org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheService#update(org.apache.jcs.engine.behavior.ICacheElement,
 89  
      *      long)
 90  
      */
 91  
     public void update( ICacheElement item, long listenerId )
 92  
     {
 93  
         if ( maxQueueSize > 0 )
 94  
         {
 95  
             PutEvent event = new PutEvent( item, listenerId );
 96  
             queue.add( event );
 97  
         }
 98  
         // Zombies have no inner life
 99  
         return;
 100  
     }
 101  
 
 102  
     /**
 103  
      * Adds a removeAll event to the queue if the maxSize is greater than 0;
 104  
      * <p>
 105  
      * (non-Javadoc)
 106  
      * @see org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheService#remove(java.lang.String,
 107  
      *      java.io.Serializable, long)
 108  
      */
 109  
     public void remove( String cacheName, Serializable key, long listenerId )
 110  
     {
 111  
         if ( maxQueueSize > 0 )
 112  
         {
 113  
             RemoveEvent event = new RemoveEvent( cacheName, key, listenerId );
 114  
             queue.add( event );
 115  
         }
 116  
         // Zombies have no inner life
 117  
         return;
 118  
     }
 119  
 
 120  
     /**
 121  
      * Adds a removeAll event to the queue if the maxSize is greater than 0;
 122  
      * <p>
 123  
      * (non-Javadoc)
 124  
      * @see org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheService#removeAll(java.lang.String,
 125  
      *      long)
 126  
      */
 127  
     public void removeAll( String cacheName, long listenerId )
 128  
     {
 129  
         if ( maxQueueSize > 0 )
 130  
         {
 131  
             RemoveAllEvent event = new RemoveAllEvent( cacheName, listenerId );
 132  
             queue.add( event );
 133  
         }
 134  
         // Zombies have no inner life
 135  
         return;
 136  
     }
 137  
 
 138  
     /**
 139  
      * Does nothing. Gets are synchronous and cannot be added to a queue.
 140  
      * <p>
 141  
      * (non-Javadoc)
 142  
      * @see org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheService#get(java.lang.String,
 143  
      *      java.io.Serializable, long)
 144  
      */
 145  
     public ICacheElement get( String cacheName, Serializable key, long requesterId )
 146  
         throws IOException
 147  
     {
 148  
         // Zombies have no inner life
 149  
         return null;
 150  
     }
 151  
 
 152  
     /**
 153  
      * Does nothing.
 154  
      * <p>
 155  
      * (non-Javadoc)
 156  
      * @see org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheService#getGroupKeys(java.lang.String,
 157  
      *      java.lang.String)
 158  
      */
 159  
     public Set getGroupKeys( String cacheName, String groupName )
 160  
     {
 161  
         return Collections.EMPTY_SET;
 162  
     }
 163  
 
 164  
     /**
 165  
      * Walk the queue, calling the service for each queue operation.
 166  
      * <p>
 167  
      * @param service
 168  
      * @throws Exception
 169  
      */
 170  
     protected void propagateEvents( IRemoteCacheService service )
 171  
         throws Exception
 172  
     {
 173  
         int cnt = 0;
 174  
         if ( log.isInfoEnabled() )
 175  
         {
 176  
             log.info( "Propagating events to the new RemoteService." );
 177  
         }
 178  
         ElapsedTimer timer = new ElapsedTimer();
 179  
         while ( !queue.isEmpty() )
 180  
         {
 181  
             cnt++;
 182  
 
 183  
             // for each item, call the appropriate service method
 184  
             ZombieEvent event = (ZombieEvent) queue.take();
 185  
 
 186  
             if ( event instanceof PutEvent )
 187  
             {
 188  
                 PutEvent putEvent = (PutEvent) event;
 189  
                 service.update( putEvent.element, event.requesterId );
 190  
             }
 191  
             else if ( event instanceof RemoveEvent )
 192  
             {
 193  
                 RemoveEvent removeEvent = (RemoveEvent) event;
 194  
                 service.remove( event.cacheName, removeEvent.key, event.requesterId );
 195  
             }
 196  
             else if ( event instanceof RemoveAllEvent )
 197  
             {
 198  
                 service.removeAll( event.cacheName, event.requesterId );
 199  
             }
 200  
         }
 201  
         if ( log.isInfoEnabled() )
 202  
         {
 203  
             log.info( "Propagated " + cnt + " events to the new RemoteService in " + timer.getElapsedTimeString() );
 204  
         }
 205  
     }
 206  
 
 207  
     /**
 208  
      * Base of the other events.
 209  
      */
 210  
     private abstract class ZombieEvent
 211  
     {
 212  
         String cacheName;
 213  
 
 214  
         long requesterId;
 215  
     }
 216  
 
 217  
     /**
 218  
      * A basic put event.
 219  
      */
 220  
     private class PutEvent
 221  
         extends ZombieEvent
 222  
     {
 223  
         ICacheElement element;
 224  
 
 225  
         /**
 226  
          * Set the element
 227  
          * @param element
 228  
          * @param requesterId
 229  
          */
 230  
         public PutEvent( ICacheElement element, long requesterId )
 231  14
         {
 232  14
             this.requesterId = requesterId;
 233  14
             this.element = element;
 234  14
         }
 235  
     }
 236  
 
 237  
     /**
 238  
      * A basic Remove event.
 239  
      */
 240  
     private class RemoveEvent
 241  
         extends ZombieEvent
 242  
     {
 243  
         Serializable key;
 244  
 
 245  
         /**
 246  
          * Set the element
 247  
          * @param cacheName
 248  
          * @param key
 249  
          * @param requesterId
 250  
          */
 251  
         public RemoveEvent( String cacheName, Serializable key, long requesterId )
 252  
         {
 253  
             this.cacheName = cacheName;
 254  
             this.requesterId = requesterId;
 255  
             this.key = key;
 256  
         }
 257  
     }
 258  
 
 259  
     /**
 260  
      * A basic RemoveAll event.
 261  
      */
 262  
     private class RemoveAllEvent
 263  
         extends ZombieEvent
 264  
     {
 265  
         /**
 266  
          * @param cacheName
 267  
          * @param requesterId
 268  
          */
 269  
         public RemoveAllEvent( String cacheName, long requesterId )
 270  
         {
 271  
             this.cacheName = cacheName;
 272  
             this.requesterId = requesterId;
 273  
         }
 274  
     }
 275  
 }

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