Coverage report

  %line %branch
org.apache.jcs.auxiliary.lateral.LateralCacheNoWait
51% 
95% 

 1   
 package org.apache.jcs.auxiliary.lateral;
 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.rmi.UnmarshalException;
 25   
 import java.util.ArrayList;
 26   
 import java.util.Arrays;
 27   
 import java.util.List;
 28   
 import java.util.Set;
 29   
 
 30   
 import org.apache.commons.logging.Log;
 31   
 import org.apache.commons.logging.LogFactory;
 32   
 import org.apache.jcs.auxiliary.AuxiliaryCache;
 33   
 import org.apache.jcs.auxiliary.AuxiliaryCacheAttributes;
 34   
 import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheService;
 35   
 import org.apache.jcs.engine.CacheAdaptor;
 36   
 import org.apache.jcs.engine.CacheConstants;
 37   
 import org.apache.jcs.engine.CacheEventQueueFactory;
 38   
 import org.apache.jcs.engine.behavior.ICacheElement;
 39   
 import org.apache.jcs.engine.behavior.ICacheEventQueue;
 40   
 import org.apache.jcs.engine.stats.StatElement;
 41   
 import org.apache.jcs.engine.stats.Stats;
 42   
 import org.apache.jcs.engine.stats.behavior.IStatElement;
 43   
 import org.apache.jcs.engine.stats.behavior.IStats;
 44   
 
 45   
 /**
 46   
  * Used to queue up update requests to the underlying cache. These requests will be processed in
 47   
  * their order of arrival via the cache event queue processor.
 48   
  */
 49   
 public class LateralCacheNoWait
 50   
     implements AuxiliaryCache
 51   
 {
 52   
     private static final long serialVersionUID = -7251187566116178475L;
 53   
 
 54  26 
     private final static Log log = LogFactory.getLog( LateralCacheNoWait.class );
 55   
 
 56   
     private final LateralCache cache;
 57   
 
 58   
     private ICacheEventQueue q;
 59   
 
 60  26 
     private int getCount = 0;
 61   
 
 62  26 
     private int removeCount = 0;
 63   
 
 64  26 
     private int putCount = 0;
 65   
 
 66   
     /**
 67   
      * Constructs with the given lateral cache, and fires up an event queue for aysnchronous
 68   
      * processing.
 69   
      * <p>
 70   
      * @param cache
 71   
      */
 72   
     public LateralCacheNoWait( LateralCache cache )
 73  26 
     {
 74  26 
         this.cache = cache;
 75   
 
 76  26 
         if ( log.isDebugEnabled() )
 77   
         {
 78  0 
             log.debug( "Constructing LateralCacheNoWait, LateralCache = [" + cache + "]" );
 79   
         }
 80   
 
 81  26 
         CacheEventQueueFactory fact = new CacheEventQueueFactory();
 82  26 
         this.q = fact.createCacheEventQueue( new CacheAdaptor( cache ), LateralCacheInfo.listenerId, cache
 83   
             .getCacheName(), cache.getAuxiliaryCacheAttributes().getEventQueuePoolName(), cache
 84   
             .getAuxiliaryCacheAttributes().getEventQueueTypeFactoryCode() );
 85   
 
 86   
         // need each no wait to handle each of its real updates and removes,
 87   
         // since there may
 88   
         // be more than one per cache? alternative is to have the cache
 89   
         // perform updates using a different method that spcifies the listener
 90   
         // this.q = new CacheEventQueue(new CacheAdaptor(this),
 91   
         // LateralCacheInfo.listenerId, cache.getCacheName());
 92  26 
         if ( cache.getStatus() == CacheConstants.STATUS_ERROR )
 93   
         {
 94  26 
             q.destroy();
 95   
         }
 96  26 
     }
 97   
 
 98   
     /**
 99   
      * @param ce
 100   
      * @throws IOException
 101   
      */
 102   
     public void update( ICacheElement ce )
 103   
         throws IOException
 104   
     {
 105  32 
         putCount++;
 106   
         try
 107   
         {
 108  32 
             q.addPutEvent( ce );
 109   
         }
 110  0 
         catch ( IOException ex )
 111   
         {
 112  0 
             log.error( ex );
 113  0 
             q.destroy();
 114  32 
         }
 115  32 
     }
 116   
 
 117   
     /**
 118   
      * Synchronously reads from the lateral cache.
 119   
      * <p>
 120   
      * @param key
 121   
      * @return ICacheElement if found, else null
 122   
      */
 123   
     public ICacheElement get( Serializable key )
 124   
     {
 125  2600 
         getCount++;
 126  2600 
         if ( this.getStatus() != CacheConstants.STATUS_ERROR )
 127   
         {
 128   
             try
 129   
             {
 130  0 
                 return cache.get( key );
 131   
             }
 132  0 
             catch ( UnmarshalException ue )
 133   
             {
 134  0 
                 log.debug( "Retrying the get owing to UnmarshalException..." );
 135   
                 try
 136   
                 {
 137  0 
                     return cache.get( key );
 138   
                 }
 139  0 
                 catch ( IOException ex )
 140   
                 {
 141  0 
                     log.error( "Failed in retrying the get for the second time." );
 142  0 
                     q.destroy();
 143   
                 }
 144   
             }
 145  0 
             catch ( IOException ex )
 146   
             {
 147  0 
                 q.destroy();
 148  0 
             }
 149   
         }
 150  2600 
         return null;
 151   
     }
 152   
 
 153   
     public Set getGroupKeys( String groupName )
 154   
     {
 155  0 
         return cache.getGroupKeys( groupName );
 156   
     }
 157   
 
 158   
     /**
 159   
      * Adds a remove request to the lateral cache.
 160   
      * <p>
 161   
      * @param key
 162   
      * @return always false
 163   
      */
 164   
     public boolean remove( Serializable key )
 165   
     {
 166  0 
         removeCount++;
 167   
         try
 168   
         {
 169  0 
             q.addRemoveEvent( key );
 170   
         }
 171  0 
         catch ( IOException ex )
 172   
         {
 173  0 
             log.error( ex );
 174  0 
             q.destroy();
 175  0 
         }
 176  0 
         return false;
 177   
     }
 178   
 
 179   
     /** Adds a removeAll request to the lateral cache. */
 180   
     public void removeAll()
 181   
     {
 182   
         try
 183   
         {
 184  0 
             q.addRemoveAllEvent();
 185   
         }
 186  0 
         catch ( IOException ex )
 187   
         {
 188  0 
             log.error( ex );
 189  0 
             q.destroy();
 190  0 
         }
 191  0 
     }
 192   
 
 193   
     /** Adds a dispose request to the lateral cache. */
 194   
     public void dispose()
 195   
     {
 196   
         try
 197   
         {
 198  0 
             q.addDisposeEvent();
 199   
         }
 200  0 
         catch ( IOException ex )
 201   
         {
 202  0 
             log.error( ex );
 203  0 
             q.destroy();
 204  0 
         }
 205  0 
     }
 206   
 
 207   
     /**
 208   
      * No lateral invocation.
 209   
      * <p>
 210   
      * @return The size value
 211   
      */
 212   
     public int getSize()
 213   
     {
 214  0 
         return cache.getSize();
 215   
     }
 216   
 
 217   
     /**
 218   
      * No lateral invocation.
 219   
      * <p>
 220   
      * @return The cacheType value
 221   
      */
 222   
     public int getCacheType()
 223   
     {
 224  0 
         return cache.getCacheType();
 225   
     }
 226   
 
 227   
     /**
 228   
      * Returns the asyn cache status. An error status indicates either the lateral connection is not
 229   
      * available, or the asyn queue has been unexpectedly destroyed. No lateral invokation.
 230   
      * <p>
 231   
      * @return The status value
 232   
      */
 233   
     public int getStatus()
 234   
     {
 235  2626 
         return q.isWorking() ? cache.getStatus() : CacheConstants.STATUS_ERROR;
 236   
     }
 237   
 
 238   
     /**
 239   
      * Gets the cacheName attribute of the LateralCacheNoWait object
 240   
      * <p>
 241   
      * @return The cacheName value
 242   
      */
 243   
     public String getCacheName()
 244   
     {
 245  0 
         return cache.getCacheName();
 246   
     }
 247   
 
 248   
     /**
 249   
      * Replaces the lateral cache service handle with the given handle and reset the queue by
 250   
      * starting up a new instance.
 251   
      * <p>
 252   
      * @param lateral
 253   
      */
 254   
     public void fixCache( ILateralCacheService lateral )
 255   
     {
 256  0 
         cache.fixCache( lateral );
 257  0 
         resetEventQ();
 258  0 
         return;
 259   
     }
 260   
 
 261   
     /**
 262   
      * Resets the event q by first destroying the existing one and starting up new one.
 263   
      */
 264   
     public void resetEventQ()
 265   
     {
 266  0 
         if ( q.isWorking() )
 267   
         {
 268  0 
             q.destroy();
 269   
         }
 270  0 
         CacheEventQueueFactory fact = new CacheEventQueueFactory();
 271  0 
         this.q = fact.createCacheEventQueue( new CacheAdaptor( cache ), LateralCacheInfo.listenerId, cache
 272   
             .getCacheName(), cache.getAuxiliaryCacheAttributes().getEventQueuePoolName(), cache
 273   
             .getAuxiliaryCacheAttributes().getEventQueueTypeFactoryCode() );
 274  0 
     }
 275   
 
 276   
     /**
 277   
      * @return Returns the AuxiliaryCacheAttributes.
 278   
      */
 279   
     public AuxiliaryCacheAttributes getAuxiliaryCacheAttributes()
 280   
     {
 281  0 
         return cache.getAuxiliaryCacheAttributes();
 282   
     }
 283   
 
 284   
     /**
 285   
      * getStats
 286   
      * @return String
 287   
      */
 288   
     public String getStats()
 289   
     {
 290  0 
         return getStatistics().toString();
 291   
     }
 292   
 
 293   
     /*
 294   
      * (non-Javadoc)
 295   
      * @see org.apache.jcs.auxiliary.AuxiliaryCache#getStatistics()
 296   
      */
 297   
     public IStats getStatistics()
 298   
     {
 299  7 
         IStats stats = new Stats();
 300  7 
         stats.setTypeName( "Lateral Cache No Wait" );
 301   
 
 302  7 
         ArrayList elems = new ArrayList();
 303   
 
 304   
         // IStatElement se = null;
 305   
         // no data gathered here
 306   
 
 307   
         // get the stats from the event queue too
 308   
         // get as array, convert to list, add list to our outer list
 309  7 
         IStats eqStats = this.q.getStatistics();
 310   
 
 311  7 
         IStatElement[] eqSEs = eqStats.getStatElements();
 312  7 
         List eqL = Arrays.asList( eqSEs );
 313  7 
         elems.addAll( eqL );
 314   
 
 315  7 
         IStatElement se = null;
 316   
 
 317  7 
         se = new StatElement();
 318  7 
         se.setName( "Get Count" );
 319  7 
         se.setData( "" + this.getCount );
 320  7 
         elems.add( se );
 321   
 
 322  7 
         se = new StatElement();
 323  7 
         se.setName( "Remove Count" );
 324  7 
         se.setData( "" + this.removeCount );
 325  7 
         elems.add( se );
 326   
 
 327  7 
         se = new StatElement();
 328  7 
         se.setName( "Put Count" );
 329  7 
         se.setData( "" + this.putCount );
 330  7 
         elems.add( se );
 331   
 
 332   
         // get an array and put them in the Stats object
 333  7 
         IStatElement[] ses = (IStatElement[]) elems.toArray( new StatElement[elems.size()] );
 334  7 
         stats.setStatElements( ses );
 335   
 
 336  7 
         return stats;
 337   
     }
 338   
 
 339   
     /*
 340   
      * (non-Javadoc)
 341   
      * @see java.lang.Object#toString()
 342   
      */
 343   
     public String toString()
 344   
     {
 345  26 
         StringBuffer buf = new StringBuffer();
 346  26 
         buf.append( " LateralCacheNoWait " );
 347  26 
         buf.append( " Status = " + this.getStatus() );
 348  26 
         buf.append( " cache = [" + cache.toString() + "]" );
 349  26 
         return buf.toString();
 350   
     }
 351   
 }

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