Coverage report

  %line %branch
org.apache.jcs.auxiliary.remote.RemoteCacheListener
48% 
71% 

 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.rmi.RemoteException;
 25   
 import java.rmi.server.UnicastRemoteObject;
 26   
 
 27   
 import org.apache.commons.logging.Log;
 28   
 import org.apache.commons.logging.LogFactory;
 29   
 import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheAttributes;
 30   
 import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheConstants;
 31   
 import org.apache.jcs.auxiliary.remote.behavior.IRemoteCacheListener;
 32   
 import org.apache.jcs.engine.behavior.ICacheElement;
 33   
 import org.apache.jcs.engine.behavior.ICacheElementSerialized;
 34   
 import org.apache.jcs.engine.behavior.ICompositeCacheManager;
 35   
 import org.apache.jcs.engine.behavior.IElementSerializer;
 36   
 import org.apache.jcs.engine.control.CompositeCache;
 37   
 import org.apache.jcs.engine.control.CompositeCacheManager;
 38   
 import org.apache.jcs.utils.net.HostNameUtil;
 39   
 import org.apache.jcs.utils.serialization.SerializationConversionUtil;
 40   
 import org.apache.jcs.utils.serialization.StandardSerializer;
 41   
 
 42   
 /**
 43   
  * Registered with RemoteCache server. The server updates the local caches via this listener. Each
 44   
  * server asings a unique listener id for a listener.
 45   
  * <p>
 46   
  * One listener is used per remote cache server. The same listener is used for all the regions that
 47   
  * talk to a particular server.
 48   
  */
 49   
 public class RemoteCacheListener
 50   
     implements IRemoteCacheListener, IRemoteCacheConstants, Serializable
 51   
 {
 52   
     private static final long serialVersionUID = 1L;
 53   
 
 54  28 
     private final static Log log = LogFactory.getLog( RemoteCacheListener.class );
 55   
 
 56  14 
     private static String localHostName = HostNameUtil.getLocalHostAddress();
 57   
 
 58  35 
     boolean disposed = false;
 59   
 
 60   
     /**
 61   
      * The cache manager used to put items in differnt regions. This is set lazily and should not be
 62   
      * sent to the remote server.
 63   
      */
 64   
     protected transient ICompositeCacheManager cacheMgr;
 65   
 
 66   
     /** The remote cache configuration object. */
 67   
     protected IRemoteCacheAttributes irca;
 68   
 
 69   
     /** Number of put requests received. For debugging only. */
 70  35 
     protected int puts = 0;
 71   
 
 72   
     /** Number of remove requests received. For debugging only. */
 73  35 
     protected int removes = 0;
 74   
 
 75   
     /** This is set by the remote cache server. */
 76  35 
     protected long listenerId = 0;
 77   
 
 78  35 
     private transient IElementSerializer elementSerializer = new StandardSerializer();
 79   
 
 80   
     /**
 81   
      * Only need one since it does work for all regions, just reference by multiple region names.
 82   
      * <p>
 83   
      * The constructor exports this object, making it available to receive incoming calls. The
 84   
      * calback port is anonymous unless a local port vlaue was specified in the configurtion.
 85   
      * @param irca
 86   
      * @param cacheMgr
 87   
      */
 88   
     public RemoteCacheListener( IRemoteCacheAttributes irca, ICompositeCacheManager cacheMgr )
 89  35 
     {
 90  35 
         this.irca = irca;
 91   
 
 92  35 
         this.cacheMgr = cacheMgr;
 93   
 
 94   
         // Export this remote object to make it available to receive incoming
 95   
         // calls, using an anonymous port unless the local port is specified.
 96   
         try
 97   
         {
 98  35 
             if ( irca.getLocalPort() != 0 )
 99   
             {
 100  21 
                 UnicastRemoteObject.exportObject( this, irca.getLocalPort() );
 101  21 
             }
 102   
             else
 103   
             {
 104  14 
                 UnicastRemoteObject.exportObject( this );
 105   
             }
 106   
         }
 107  0 
         catch ( RemoteException ex )
 108   
         {
 109  0 
             log.error( "Problem exporting object.", ex );
 110  0 
             throw new IllegalStateException( ex.getMessage() );
 111  35 
         }
 112  35 
     }
 113   
 
 114   
     /**
 115   
      * Deregisters itself.
 116   
      * <p>
 117   
      * @throws IOException
 118   
      */
 119   
     public synchronized void dispose()
 120   
         throws IOException
 121   
     {
 122  0 
         if ( !disposed )
 123   
         {
 124  0 
             if ( log.isInfoEnabled() )
 125   
             {
 126  0 
                 log.info( "Unexporting listener." );
 127   
             }
 128   
             try
 129   
             {
 130  0 
                 UnicastRemoteObject.unexportObject( this, true );
 131   
             }
 132  0 
             catch ( RemoteException ex )
 133   
             {
 134  0 
                 log.error( "Problem unexporting the listener.", ex );
 135  0 
                 throw new IllegalStateException( ex.getMessage() );
 136  0 
             }
 137  0 
             disposed = true;
 138   
         }
 139  0 
     }
 140   
 
 141   
     /**
 142   
      * Let the remote cache set a listener_id. Since there is only one listerenr for all the regions
 143   
      * and every region gets registered? the id shouldn't be set if it isn't zero. If it is we
 144   
      * assume that it is a reconnect.
 145   
      * <p>
 146   
      * @param id The new listenerId value
 147   
      * @throws IOException
 148   
      */
 149   
     public void setListenerId( long id )
 150   
         throws IOException
 151   
     {
 152  21 
         listenerId = id;
 153  21 
         if ( log.isDebugEnabled() )
 154   
         {
 155  0 
             log.debug( "set listenerId = [" + id + "]" );
 156   
         }
 157  21 
     }
 158   
 
 159   
     /**
 160   
      * Gets the listenerId attribute of the RemoteCacheListener object. This is stored int he
 161   
      * object. The RemoteCache object contains a reference to the listener and get the id this way.
 162   
      * @return The listenerId value
 163   
      * @throws IOException
 164   
      */
 165   
     public long getListenerId()
 166   
         throws IOException
 167   
     {
 168  812 
         if ( log.isDebugEnabled() )
 169   
         {
 170  0 
             log.debug( "get listenerId = [" + listenerId + "]" );
 171   
         }
 172  812 
         return listenerId;
 173   
 
 174   
     }
 175   
 
 176   
     /**
 177   
      * Gets the remoteType attribute of the RemoteCacheListener object
 178   
      * @return The remoteType value
 179   
      * @throws IOException
 180   
      */
 181   
     public int getRemoteType()
 182   
         throws IOException
 183   
     {
 184  21 
         if ( log.isDebugEnabled() )
 185   
         {
 186  0 
             log.debug( "getRemoteType = [" + irca.getRemoteType() + "]" );
 187   
         }
 188  21 
         return irca.getRemoteType();
 189   
     }
 190   
 
 191   
     /**
 192   
      * If this is configured to remove on put, then remove the element since it has been updated
 193   
      * elsewhere. cd should be incomplete for faster transmission. We don't want to pass data only
 194   
      * invalidation. The next time it is used the local cache will get the new version from the
 195   
      * remote store.
 196   
      * <p>
 197   
      * If remove on put is not ocnfigured, then update the item.
 198   
      * @param cb
 199   
      * @throws IOException
 200   
      */
 201   
     public void handlePut( ICacheElement cb )
 202   
         throws IOException
 203   
     {
 204  14 
         if ( irca.getRemoveUponRemotePut() )
 205   
         {
 206  7 
             if ( log.isDebugEnabled() )
 207   
             {
 208  0 
                 log.debug( "PUTTING ELEMENT FROM REMOTE, (  invalidating ) " );
 209   
             }
 210  7 
             handleRemove( cb.getCacheName(), cb.getKey() );
 211  7 
         }
 212   
         else
 213   
         {
 214  7 
             puts++;
 215  7 
             if ( log.isDebugEnabled() )
 216   
             {
 217  0 
                 log.debug( "PUTTING ELEMENT FROM REMOTE, ( updating ) " );
 218  0 
                 log.debug( "cb = " + cb );
 219   
 
 220  0 
                 if ( puts % 100 == 0 )
 221   
                 {
 222  0 
                     log.debug( "puts = " + puts );
 223   
                 }
 224   
             }
 225   
 
 226  7 
             ensureCacheManager();
 227  7 
             CompositeCache cache = cacheMgr.getCache( cb.getCacheName() );
 228   
 
 229   
             // Eventually the instance of will not be necessary.
 230  7 
             if ( cb != null && cb instanceof ICacheElementSerialized )
 231   
             {
 232  7 
                 if ( log.isDebugEnabled() )
 233   
                 {
 234  0 
                     log.debug( "Object needs to be deserialized." );
 235   
                 }
 236   
                 try
 237   
                 {
 238  7 
                     cb = SerializationConversionUtil.getDeSerializedCacheElement( (ICacheElementSerialized) cb,
 239   
                                                                                   this.elementSerializer );
 240  7 
                     if ( log.isDebugEnabled() )
 241   
                     {
 242  0 
                         log.debug( "Deserialized result = " + cb );
 243   
                     }
 244   
                 }
 245  0 
                 catch ( IOException e )
 246   
                 {
 247  0 
                     throw e;
 248   
                 }
 249  0 
                 catch ( ClassNotFoundException e )
 250   
                 {
 251  0 
                     log.error( "Received a serialized version of a class that we don't know about.", e );
 252  7 
                 }
 253   
             }
 254   
 
 255  7 
             cache.localUpdate( cb );
 256   
         }
 257   
 
 258  14 
         return;
 259   
     }
 260   
 
 261   
     /**
 262   
      * Calls localRemove on the CompositeCache.
 263   
      * <p>
 264   
      * (non-Javadoc)
 265   
      * @see org.apache.jcs.engine.behavior.ICacheListener#handleRemove(java.lang.String,
 266   
      *      java.io.Serializable)
 267   
      */
 268   
     public void handleRemove( String cacheName, Serializable key )
 269   
         throws IOException
 270   
     {
 271  7 
         removes++;
 272  7 
         if ( log.isDebugEnabled() )
 273   
         {
 274  0 
             if ( removes % 100 == 0 )
 275   
             {
 276  0 
                 log.debug( "removes = " + removes );
 277   
             }
 278   
 
 279  0 
             log.debug( "handleRemove> cacheName=" + cacheName + ", key=" + key );
 280   
         }
 281   
 
 282  7 
         ensureCacheManager();
 283  7 
         CompositeCache cache = cacheMgr.getCache( cacheName );
 284   
 
 285  7 
         cache.localRemove( key );
 286  7 
     }
 287   
 
 288   
     /**
 289   
      * Calls localRemoveAll on the CompositeCache.
 290   
      * <p>
 291   
      * (non-Javadoc)
 292   
      * @see org.apache.jcs.engine.behavior.ICacheListener#handleRemoveAll(java.lang.String)
 293   
      */
 294   
     public void handleRemoveAll( String cacheName )
 295   
         throws IOException
 296   
     {
 297  0 
         if ( log.isDebugEnabled() )
 298   
         {
 299  0 
             log.debug( "handleRemoveAll> cacheName=" + cacheName );
 300   
         }
 301  0 
         ensureCacheManager();
 302  0 
         CompositeCache cache = cacheMgr.getCache( cacheName );
 303  0 
         cache.localRemoveAll();
 304  0 
     }
 305   
 
 306   
     /*
 307   
      * (non-Javadoc)
 308   
      * @see org.apache.jcs.engine.behavior.ICacheListener#handleDispose(java.lang.String)
 309   
      */
 310   
     public void handleDispose( String cacheName )
 311   
         throws IOException
 312   
     {
 313  0 
         if ( log.isDebugEnabled() )
 314   
         {
 315  0 
             log.debug( "handleDispose> cacheName=" + cacheName );
 316   
         }
 317   
         // TODO consider what to do here, we really don't want to
 318   
         // dispose, we just want to disconnect.
 319   
         // just allow the cache to go into error recovery mode.
 320   
         // getCacheManager().freeCache( cacheName, true );
 321  0 
     }
 322   
 
 323   
     /**
 324   
      * Gets the cacheManager attribute of the RemoteCacheListener object. This is one of the few
 325   
      * places that force the cache to be a singleton.
 326   
      */
 327   
     protected void ensureCacheManager()
 328   
     {
 329  14 
         if ( cacheMgr == null )
 330   
         {
 331  0 
             cacheMgr = CompositeCacheManager.getInstance();
 332  0 
             log.debug( "had to get cacheMgr" );
 333  0 
             if ( log.isDebugEnabled() )
 334   
             {
 335  0 
                 log.debug( "cacheMgr = " + cacheMgr );
 336  0 
             }
 337   
         }
 338   
         else
 339   
         {
 340  14 
             if ( log.isDebugEnabled() )
 341   
             {
 342  0 
                 log.debug( "already got cacheMgr = " + cacheMgr );
 343   
             }
 344   
         }
 345  14 
     }
 346   
 
 347   
     /**
 348   
      * This is for debugging. It allows the remote server to log the address of clients.
 349   
      */
 350   
     public String getLocalHostAddress()
 351   
         throws IOException
 352   
     {
 353  21 
         return localHostName;
 354   
     }
 355   
 
 356   
     /**
 357   
      * For easier debugging.
 358   
      * <p>
 359   
      * @return Basic info on this listener.
 360   
      */
 361   
     public String toString()
 362   
     {
 363  0 
         StringBuffer buf = new StringBuffer();
 364  0 
         buf.append( "\n RemoteCacheListener: " );
 365  0 
         buf.append( "\n RemoteHost = " + irca.getRemoteHost() );
 366  0 
         buf.append( "\n RemotePort = " + irca.getRemotePort() );
 367  0 
         buf.append( "\n ListenerId = " + listenerId );
 368  0 
         return buf.toString();
 369   
     }
 370   
 }

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