Coverage report

  %line %branch
org.apache.jcs.auxiliary.lateral.LateralCache
26% 
84% 

 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.util.Set;
 25   
 
 26   
 import org.apache.commons.logging.Log;
 27   
 import org.apache.commons.logging.LogFactory;
 28   
 import org.apache.jcs.auxiliary.AuxiliaryCacheAttributes;
 29   
 import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheAttributes;
 30   
 import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheService;
 31   
 import org.apache.jcs.engine.CacheConstants;
 32   
 import org.apache.jcs.engine.behavior.ICache;
 33   
 import org.apache.jcs.engine.behavior.ICacheElement;
 34   
 import org.apache.jcs.engine.behavior.ICacheType;
 35   
 import org.apache.jcs.engine.behavior.IZombie;
 36   
 
 37   
 /**
 38   
  * Lateral distributor. Returns null on get by default. Net search not
 39   
  * implemented.
 40   
  */
 41   
 public class LateralCache
 42   
     implements ICache
 43   
 {
 44   
     private static final long serialVersionUID = 6274549256562382782L;
 45   
 
 46  26 
     private final static Log log = LogFactory.getLog( LateralCache.class );
 47   
 
 48   
     // generalize this, use another interface
 49   
     private ILateralCacheAttributes cattr;
 50   
 
 51   
     final String cacheName;
 52   
 
 53   
     /** either http, socket.udp, or socket.tcp can set in config */
 54   
     private ILateralCacheService lateral;
 55   
 
 56   
     private LateralCacheMonitor monitor;
 57   
 
 58   
     /**
 59   
      * Constructor for the LateralCache object
 60   
      * <p>
 61   
      * @param cattr
 62   
      * @param lateral
 63   
      * @param monitor
 64   
      */
 65   
     public LateralCache( ILateralCacheAttributes cattr, ILateralCacheService lateral, LateralCacheMonitor monitor )
 66  26 
     {
 67  26 
         this.cacheName = cattr.getCacheName();
 68  26 
         this.cattr = cattr;
 69  26 
         this.lateral = lateral;
 70  26 
         this.monitor = monitor;
 71  26 
     }
 72   
 
 73   
     /**
 74   
      * Constructor for the LateralCache object
 75   
      * <p>
 76   
      * @param cattr
 77   
      */
 78   
     protected LateralCache( ILateralCacheAttributes cattr )
 79  0 
     {
 80  0 
         this.cacheName = cattr.getCacheName();
 81  0 
         this.cattr = cattr;
 82  0 
     }
 83   
 
 84   
     /**
 85   
      * Update lateral.
 86   
      * <p>
 87   
      * @param ce
 88   
      * @throws IOException
 89   
      */
 90   
     public void update( ICacheElement ce )
 91   
         throws IOException
 92   
     {
 93   
         try
 94   
         {
 95  32 
             if ( log.isDebugEnabled() )
 96   
             {
 97  0 
                 log.debug( "update: lateral = [" + lateral + "], " + "LateralCacheInfo.listenerId = "
 98   
                     + LateralCacheInfo.listenerId );
 99   
             }
 100  32 
             lateral.update( ce, LateralCacheInfo.listenerId );
 101   
         }
 102  0 
         catch ( NullPointerException npe )
 103   
         {
 104  0 
             log.error( "Failure updating lateral. lateral = " + lateral, npe );
 105  0 
             handleException( npe, "Failed to put [" + ce.getKey() + "] to " + ce.getCacheName() );
 106  0 
             return;
 107   
         }
 108  0 
         catch ( Exception ex )
 109   
         {
 110  0 
             handleException( ex, "Failed to put [" + ce.getKey() + "] to " + ce.getCacheName() );
 111  32 
         }
 112  32 
     }
 113   
 
 114   
     /**
 115   
      * The performace costs are too great. It is not recommended that you enable
 116   
      * lateral gets.
 117   
      * <p>
 118   
      * @param key
 119   
      * @return
 120   
      * @throws IOException
 121   
      */
 122   
     public ICacheElement get( Serializable key )
 123   
         throws IOException
 124   
     {
 125  0 
         ICacheElement obj = null;
 126   
 
 127  0 
         if ( this.cattr.getPutOnlyMode() )
 128   
         {
 129  0 
             return null;
 130   
         }
 131   
         try
 132   
         {
 133  0 
             obj = lateral.get( cacheName, key );
 134   
         }
 135  0 
         catch ( Exception e )
 136   
         {
 137  0 
             log.error( e );
 138  0 
             handleException( e, "Failed to get " + key + " from " + this.cattr.getCacheName() );
 139  0 
         }
 140  0 
         return obj;
 141   
     }
 142   
 
 143   
     /**
 144   
      *
 145   
      * @param groupName
 146   
      * @return A set of group keys.
 147   
      */
 148   
     public Set getGroupKeys( String groupName )
 149   
     {
 150  0 
         return lateral.getGroupKeys( cacheName, groupName );
 151   
     }
 152   
 
 153   
     /**
 154   
      * Synchronously remove from the remote cache; if failed, replace the remote
 155   
      * handle with a zombie.
 156   
      * <p>
 157   
      * @param key
 158   
      * @return
 159   
      * @throws IOException
 160   
      */
 161   
     public boolean remove( Serializable key )
 162   
         throws IOException
 163   
     {
 164  0 
         log.debug( "removing key:" + key );
 165   
 
 166   
         try
 167   
         {
 168  0 
             lateral.remove( cacheName, key, LateralCacheInfo.listenerId );
 169   
         }
 170  0 
         catch ( Exception ex )
 171   
         {
 172  0 
             handleException( ex, "Failed to remove " + key + " from " + this.cattr.getCacheName() );
 173  0 
         }
 174  0 
         return false;
 175   
     }
 176   
 
 177   
     /**
 178   
      * Synchronously removeAll from the remote cache; if failed, replace the
 179   
      * remote handle with a zombie.
 180   
      * <p>
 181   
      * @throws IOException
 182   
      */
 183   
     public void removeAll()
 184   
         throws IOException
 185   
     {
 186   
         try
 187   
         {
 188  0 
             lateral.removeAll( cacheName, LateralCacheInfo.listenerId );
 189   
         }
 190  0 
         catch ( Exception ex )
 191   
         {
 192  0 
             handleException( ex, "Failed to remove all from " + this.cattr.getCacheName() );
 193  0 
         }
 194  0 
     }
 195   
 
 196   
     /**
 197   
      * Synchronously dispose the cache. Not sure we want this.
 198   
      *
 199   
      * @throws IOException
 200   
      */
 201   
     public void dispose()
 202   
         throws IOException
 203   
     {
 204  0 
         log.debug( "Disposing of lateral cache" );
 205   
 
 206   
         ///* HELP: This section did nothing but generate compilation warnings.
 207   
         // TODO: may limit this funcionality. It is dangerous.
 208   
         // asmuts -- Added functionality to help with warnings. I'm not getting
 209   
         // any.
 210   
         try
 211   
         {
 212  0 
             lateral.dispose( this.cattr.getCacheName() );
 213   
             // Should remove connection
 214   
         }
 215  0 
         catch ( Exception ex )
 216   
         {
 217  0 
             log.error( "Couldn't dispose", ex );
 218  0 
             handleException( ex, "Failed to dispose " + this.cattr.getCacheName() );
 219  0 
         }
 220   
         //*/
 221  0 
     }
 222   
 
 223   
     /**
 224   
      * Returns the cache status.
 225   
      * <p>
 226   
      * @return The status value
 227   
      */
 228   
     public int getStatus()
 229   
     {
 230  2652 
         return this.lateral instanceof IZombie ? CacheConstants.STATUS_ERROR : CacheConstants.STATUS_ALIVE;
 231   
     }
 232   
 
 233   
     /**
 234   
      * Returns the current cache size.
 235   
      * <p>
 236   
      * @return The size value
 237   
      */
 238   
     public int getSize()
 239   
     {
 240  0 
         return 0;
 241   
     }
 242   
 
 243   
     /**
 244   
      * Gets the cacheType attribute of the LateralCache object
 245   
      * <p>
 246   
      * @return The cacheType value
 247   
      */
 248   
     public int getCacheType()
 249   
     {
 250  0 
         return ICacheType.LATERAL_CACHE;
 251   
     }
 252   
 
 253   
     /**
 254   
      * Gets the cacheName attribute of the LateralCache object
 255   
      * <p>
 256   
      * @return The cacheName value
 257   
      */
 258   
     public String getCacheName()
 259   
     {
 260  26 
         return cacheName;
 261   
     }
 262   
 
 263   
     /**
 264   
      * Not yet sure what to do here.
 265   
      * <p>
 266   
      * @param ex
 267   
      * @param msg
 268   
      * @throws IOException
 269   
      */
 270   
     private void handleException( Exception ex, String msg )
 271   
         throws IOException
 272   
     {
 273  0 
         log.error( "Disabling lateral cache due to error " + msg, ex );
 274   
 
 275  0 
         lateral = new ZombieLateralCacheService();
 276   
         // may want to flush if region specifies
 277   
         // Notify the cache monitor about the error, and kick off the recovery
 278   
         // process.
 279  0 
         monitor.notifyError();
 280   
 
 281   
         // could stop the net serach if it is built and try to reconnect?
 282  0 
         if ( ex instanceof IOException )
 283   
         {
 284  0 
             throw (IOException) ex;
 285   
         }
 286  0 
         throw new IOException( ex.getMessage() );
 287   
     }
 288   
 
 289   
     /**
 290   
      * Replaces the current remote cache service handle with the given handle.
 291   
      * <p>
 292   
      * @param lateral
 293   
      */
 294   
     public void fixCache( ILateralCacheService lateral )
 295   
     {
 296  0 
         if ( lateral != null )
 297   
         {
 298  0 
             this.lateral = lateral;
 299  0 
         }
 300   
         else
 301   
         {
 302  0 
             log.warn( "Fix cache called with null lateral." );
 303   
         }
 304  0 
         return;
 305   
     }
 306   
 
 307   
     /**
 308   
      * getStats
 309   
      * <p>
 310   
      * @return String
 311   
      */
 312   
     public String getStats()
 313   
     {
 314  0 
         return "";
 315   
     }
 316   
 
 317   
     /**
 318   
      * @return Returns the AuxiliaryCacheAttributes.
 319   
      */
 320   
     public AuxiliaryCacheAttributes getAuxiliaryCacheAttributes()
 321   
     {
 322  52 
         return cattr;
 323   
     }
 324   
 
 325   
     /*
 326   
      * (non-Javadoc)
 327   
      *
 328   
      * @see java.lang.Object#toString()
 329   
      */
 330   
     public String toString()
 331   
     {
 332  26 
         StringBuffer buf = new StringBuffer();
 333  26 
         buf.append( "\n LateralCache " );
 334  26 
         buf.append( "\n Cache Name [" + cattr.getCacheName() + "]" );
 335  26 
         buf.append( "\n cattr =  [" + cattr + "]" );
 336  26 
         return buf.toString();
 337   
     }
 338   
 
 339   
 }

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