Coverage report

  %line %branch
org.apache.jcs.auxiliary.lateral.socket.tcp.LateralTCPCacheManager
74% 
92% 

 1  
 package org.apache.jcs.auxiliary.lateral.socket.tcp;
 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.util.HashMap;
 24  
 import java.util.Map;
 25  
 
 26  
 import org.apache.commons.logging.Log;
 27  
 import org.apache.commons.logging.LogFactory;
 28  
 import org.apache.jcs.auxiliary.AuxiliaryCache;
 29  
 import org.apache.jcs.auxiliary.lateral.LateralCache;
 30  
 import org.apache.jcs.auxiliary.lateral.LateralCacheAbstractManager;
 31  
 import org.apache.jcs.auxiliary.lateral.LateralCacheAttributes;
 32  
 import org.apache.jcs.auxiliary.lateral.LateralCacheMonitor;
 33  
 import org.apache.jcs.auxiliary.lateral.LateralCacheNoWait;
 34  
 import org.apache.jcs.auxiliary.lateral.LateralCacheWatchRepairable;
 35  
 import org.apache.jcs.auxiliary.lateral.ZombieLateralCacheService;
 36  
 import org.apache.jcs.auxiliary.lateral.ZombieLateralCacheWatch;
 37  
 import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheListener;
 38  
 import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheManager;
 39  
 import org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheService;
 40  
 import org.apache.jcs.auxiliary.lateral.socket.tcp.behavior.ITCPLateralCacheAttributes;
 41  
 import org.apache.jcs.engine.behavior.ICompositeCacheManager;
 42  
 
 43  
 /**
 44  
  * Creates lateral caches. Lateral caches are primarily used for removing non
 45  
  * laterally configured caches. Non laterally configured cache regions should
 46  
  * still be able to participate in removal. But if there is a non laterally
 47  
  * configured cache hub, then lateral removals may be necessary. For flat
 48  
  * webserver production environments, without a strong machine at the app server
 49  
  * level, distribution and search may need to occur at the lateral cache level.
 50  
  * This is currently not implemented in the lateral cache.
 51  
  * <p>
 52  
  *
 53  
  * @TODO: - need freeCache, release, getStats - need to find an interface
 54  
  *        acceptable for all - cache managers or a manager within a type
 55  
  */
 56  
 public class LateralTCPCacheManager
 57  
     extends LateralCacheAbstractManager
 58  
 {
 59  
     private static final long serialVersionUID = -9213011856644392480L;
 60  
 
 61  28
     private final static Log log = LogFactory.getLog( LateralTCPCacheManager.class );
 62  
 
 63  
     private static LateralCacheMonitor monitor;
 64  
 
 65  
     /** Address to instance map.  */
 66  14
     protected static Map instances = new HashMap();
 67  
 
 68  
     /** ITCPLateralCacheAttributes  */
 69  
     protected ITCPLateralCacheAttributes lca;
 70  
 
 71  
     private int clients;
 72  
 
 73  
     /**
 74  
      * Handle to the lateral cache service; or a zombie handle if failed to
 75  
      * connect.
 76  
      */
 77  
     private ILateralCacheService lateralService;
 78  
 
 79  
     /**
 80  
      * Wrapper of the lateral cache watch service; or wrapper of a zombie
 81  
      * service if failed to connect.
 82  
      */
 83  
     private LateralCacheWatchRepairable lateralWatch;
 84  
 
 85  
     /** This is set in the constructor.  */
 86  
     private ICompositeCacheManager cacheMgr;
 87  
 
 88  
     /**
 89  
      * Returns an instance of the LateralCacheManager.
 90  
      * <p>
 91  
      * @param lca
 92  
      * @param cacheMgr
 93  
      *            this allows the auxiliary to be passed a cache manager.
 94  
      * @return
 95  
      */
 96  
     public static LateralTCPCacheManager getInstance( ITCPLateralCacheAttributes lca, ICompositeCacheManager cacheMgr )
 97  
     {
 98  27
         LateralTCPCacheManager ins = (LateralTCPCacheManager) instances.get( lca.toString() );
 99  27
         synchronized ( instances )
 100  
         {
 101  27
             if ( ins == null )
 102  
             {
 103  14
                 log.info( "Instance for [" + lca.toString() + "] is null, creating" );
 104  
 
 105  14
                 ins = (LateralTCPCacheManager) instances.get( lca.toString() );
 106  14
                 if ( ins == null )
 107  
                 {
 108  14
                     ins = new LateralTCPCacheManager( lca, cacheMgr );
 109  14
                     instances.put( lca.toString(), ins );
 110  
                 }
 111  
             }
 112  27
             createMonitor( ins );
 113  27
         }
 114  27
         ins.clients++;
 115  
 
 116  27
         return ins;
 117  
     }
 118  
 
 119  
     /**
 120  
      * The monitor needs reference to one instance, actually just a type.
 121  
      * <p>
 122  
      * TODO refactor this.
 123  
      * <p>
 124  
      * @param instance
 125  
      */
 126  
     private static synchronized void createMonitor( ILateralCacheManager instance )
 127  
     {
 128  
         // only want one monitor per lateral type
 129  
         // Fires up the monitoring daemon.
 130  41
         if ( monitor == null )
 131  
         {
 132  14
             monitor = new LateralCacheMonitor( instance );
 133  
             // Should never be null
 134  14
             if ( monitor != null )
 135  
             {
 136  14
                 Thread t = new Thread( monitor );
 137  14
                 t.setDaemon( true );
 138  14
                 t.start();
 139  
             }
 140  
         }
 141  41
     }
 142  
 
 143  
     /**
 144  
      * Constructor for the LateralCacheManager object.
 145  
      * <p>
 146  
      * @param lcaA
 147  
      * @param cacheMgr
 148  
      */
 149  
     private LateralTCPCacheManager( ITCPLateralCacheAttributes lcaA, ICompositeCacheManager cacheMgr )
 150  14
     {
 151  14
         this.lca = lcaA;
 152  
 
 153  14
         this.cacheMgr = cacheMgr;
 154  
 
 155  14
         if ( log.isDebugEnabled() )
 156  
         {
 157  0
             log.debug( "Creating lateral cache service, lca = " + this.lca );
 158  
         }
 159  
 
 160  
         // Create the service
 161  
         try
 162  
         {
 163  14
             if ( log.isInfoEnabled() )
 164  
             {
 165  14
                 log.info( "Creating TCP service, lca = " + this.lca );
 166  
             }
 167  14
             this.lateralService = new LateralTCPService( class="keyword">this.lca );
 168  
 
 169  0
             if ( this.lateralService == null )
 170  
             {
 171  0
                 log.error( "No service created, must zombie" );
 172  0
                 throw new Exception( "No service created for lateral cache." );
 173  
             }
 174  
 
 175  0
             this.lateralWatch = new LateralCacheWatchRepairable();
 176  0
             this.lateralWatch.setCacheWatch( new ZombieLateralCacheWatch() );
 177  
         }
 178  14
         catch ( Exception ex )
 179  
         {
 180  
             // Failed to connect to the lateral server.
 181  
             // Configure this LateralCacheManager instance to use the
 182  
             // "zombie" services.
 183  14
             log.error( "Failure, lateral instance will use zombie service", ex );
 184  
 
 185  14
             this.lateralService = new ZombieLateralCacheService();
 186  14
             this.lateralWatch = new LateralCacheWatchRepairable();
 187  14
             this.lateralWatch.setCacheWatch( new ZombieLateralCacheWatch() );
 188  
 
 189  
             // Notify the cache monitor about the error, and kick off
 190  
             // the recovery process.
 191  14
             createMonitor( this );
 192  14
             monitor.notifyError();
 193  0
         }
 194  14
     }
 195  
 
 196  
     /**
 197  
      * Adds the lateral cache listener to the underlying cache-watch service.
 198  
      * <p>
 199  
      * @param cacheName
 200  
      *            The feature to be added to the LateralCacheListener attribute
 201  
      * @param listener
 202  
      *            The feature to be added to the LateralCacheListener attribute
 203  
      * @exception IOException
 204  
      */
 205  
     public void addLateralCacheListener( String cacheName, ILateralCacheListener listener )
 206  
         throws IOException
 207  
     {
 208  26
         synchronized ( this.caches )
 209  
         {
 210  26
             this.lateralWatch.addCacheListener( cacheName, listener );
 211  26
         }
 212  26
     }
 213  
 
 214  
     /**
 215  
      * Called to access a precreated region or construct one with defaults.
 216  
      * Since all aux cache access goes through the manager, this will never be
 217  
      * called.
 218  
      * <p>
 219  
      * After getting the manager instance for a server, the factory gets a cache
 220  
      * for the region name it is constructing.
 221  
      * <p>
 222  
      * There should be one manager per server and one cache per region per
 223  
      * manager.
 224  
      * <p>
 225  
      * @return AuxiliaryCache
 226  
      * @param cacheName
 227  
      */
 228  
     public AuxiliaryCache getCache( String cacheName )
 229  
     {
 230  27
         LateralCacheNoWait lateralNoWait = null;
 231  1
         synchronized ( this.caches )
 232  
         {
 233  26
             lateralNoWait = (LateralCacheNoWait) this.caches.get( cacheName );
 234  26
             if ( lateralNoWait == null )
 235  
             {
 236  26
                 LateralCacheAttributes attr = (LateralCacheAttributes) lca.copy();
 237  26
                 attr.setCacheName( cacheName );
 238  
 
 239  26
                 LateralCache cache = new LateralCache( attr, this.lateralService, monitor );
 240  26
                 if ( log.isDebugEnabled() )
 241  
                 {
 242  0
                     log.debug( "Created cache for noWait, cache [" + cache + "]" );
 243  
                 }
 244  26
                 lateralNoWait = new LateralCacheNoWait( cache );
 245  26
                 this.caches.put( cacheName, lateralNoWait );
 246  
 
 247  26
                 if ( log.isInfoEnabled() )
 248  
                 {
 249  26
                     log.info( "Created LateralCacheNoWait for [" + this.lca + "] LateralCacheNoWait = ["
 250  
                         + lateralNoWait + "]" );
 251  
                 }
 252  
             }
 253  26
         }
 254  
 
 255  
         // don't create a listener if we are not receiving.
 256  26
         if ( lca.isReceive() )
 257  
         {
 258  
             try
 259  
             {
 260  26
                 addLateralCacheListener( cacheName, LateralTCPListener.getInstance( this.lca, cacheMgr ) );
 261  
             }
 262  0
             catch ( IOException ioe )
 263  
             {
 264  0
                 log.error( "Problem creating lateral listener", ioe );
 265  
             }
 266  0
             catch ( Exception e )
 267  
             {
 268  0
                 log.error( "Problem creating lateral listener", e );
 269  26
             }
 270  0
         }
 271  
         else
 272  
         {
 273  0
             if ( log.isDebugEnabled() )
 274  
             {
 275  0
                 log.debug( "Not creating a listener since we are not receiving." );
 276  
             }
 277  
         }
 278  
         // TODO: need listener repair
 279  
 
 280  26
         return lateralNoWait;
 281  
     }
 282  
 
 283  
     /*
 284  
      * (non-Javadoc)
 285  
      *
 286  
      * @see org.apache.jcs.auxiliary.lateral.LateralCacheAbstractManager#getInstances()
 287  
      */
 288  
     public Map getInstances()
 289  
     {
 290  28
         return instances;
 291  
     }
 292  
 
 293  
     /*
 294  
      * (non-Javadoc)
 295  
      *
 296  
      * @see org.apache.jcs.auxiliary.lateral.behavior.ILateralCacheManager#fixService()
 297  
      */
 298  
     public Object fixService()
 299  
         throws IOException
 300  
     {
 301  0
         Object service = null;
 302  
         try
 303  
         {
 304  0
             service = new LateralTCPService( lca );
 305  
         }
 306  0
         catch ( Exception ex )
 307  
         {
 308  0
             log.error( "Can't fix " + ex.getMessage() );
 309  0
             throw new IOException( "Can't fix " + ex.getMessage() );
 310  0
         }
 311  0
         return service;
 312  
     }
 313  
 }

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