Coverage report

  %line %branch
org.apache.jcs.engine.CacheWatchRepairable
30% 
58% 

 1  
 package org.apache.jcs.engine;
 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  
 
 24  
 import java.util.HashMap;
 25  
 import java.util.HashSet;
 26  
 import java.util.Iterator;
 27  
 import java.util.Map;
 28  
 import java.util.Set;
 29  
 
 30  
 import org.apache.jcs.engine.behavior.ICacheObserver;
 31  
 import org.apache.jcs.engine.behavior.ICacheListener;
 32  
 
 33  
 import org.apache.commons.logging.Log;
 34  
 import org.apache.commons.logging.LogFactory;
 35  
 
 36  
 /**
 37  
  * Intercepts the requests to the underlying ICacheObserver object so that the
 38  
  * listeners can be recorded locally for remote connection recovery purposes.
 39  
  * (Durable subscription like those in JMS is not implemented at this stage for
 40  
  * it can be too expensive on the runtime.)
 41  
  *
 42  
  */
 43  21
 public class CacheWatchRepairable
 44  
     implements ICacheObserver
 45  
 {
 46  42
     private final static Log log = LogFactory.getLog( CacheWatchRepairable.class );
 47  
 
 48  
     // the underlying ICacheObserver.
 49  
     private ICacheObserver cacheWatch;
 50  
 
 51  21
     private Map cacheMap = new HashMap();
 52  
 
 53  
     /**
 54  
      * Replaces the underlying cache watch service and reattached all existing
 55  
      * listeners to the new cache watch.
 56  
      * <p>
 57  
      * @param cacheWatch
 58  
      *            The new cacheWatch value
 59  
      */
 60  
     public void setCacheWatch( ICacheObserver cacheWatch )
 61  
     {
 62  21
         this.cacheWatch = cacheWatch;
 63  21
         synchronized ( cacheMap )
 64  
         {
 65  21
             for ( Iterator itr = cacheMap.entrySet().iterator(); itr.hasNext(); )
 66  
             {
 67  0
                 Map.Entry entry = (Map.Entry) itr.next();
 68  0
                 String cacheName = (String) entry.getKey();
 69  0
                 Set listenerSet = (Set) entry.getValue();
 70  0
                 for ( Iterator itr2 = listenerSet.iterator(); itr2.hasNext(); )
 71  
                 {
 72  
                     try
 73  
                     {
 74  0
                         cacheWatch.addCacheListener( cacheName, (ICacheListener) itr2.next() );
 75  
                     }
 76  0
                     catch ( IOException ex )
 77  
                     {
 78  0
                         log.error( "Problem adding listener.", ex );
 79  0
                     }
 80  0
                 }
 81  0
             }
 82  21
         }
 83  21
     }
 84  
 
 85  
     /**
 86  
      * Adds a feature to the CacheListener attribute of the CacheWatchRepairable
 87  
      * object
 88  
      * <p>
 89  
      * @param cacheName
 90  
      *            The feature to be added to the CacheListener attribute
 91  
      * @param obj
 92  
      *            The feature to be added to the CacheListener attribute
 93  
      * @throws IOException
 94  
      */
 95  
     public void addCacheListener( String cacheName, ICacheListener obj )
 96  
         throws IOException
 97  
     {
 98  
         // Record the added cache listener locally, regardless of whether the
 99  
         // remote add-listener
 100  
         // operation succeeds or fails.
 101  47
         synchronized ( cacheMap )
 102  
         {
 103  47
             Set listenerSet = (Set) cacheMap.get( cacheName );
 104  47
             if ( listenerSet == null )
 105  
             {
 106  47
                 listenerSet = new HashSet();
 107  47
                 cacheMap.put( cacheName, listenerSet );
 108  
             }
 109  47
             listenerSet.add( obj );
 110  47
         }
 111  47
         cacheWatch.addCacheListener( cacheName, obj );
 112  47
     }
 113  
 
 114  
     /**
 115  
      * Adds a feature to the CacheListener attribute of the CacheWatchRepairable
 116  
      * object
 117  
      * <p>
 118  
      * @param obj
 119  
      *            The feature to be added to the CacheListener attribute
 120  
      * @throws IOException
 121  
      */
 122  
     public void addCacheListener( ICacheListener obj )
 123  
         throws IOException
 124  
     {
 125  
         // Record the added cache listener locally, regardless of whether the
 126  
         // remote add-listener
 127  
         // operation succeeds or fails.
 128  0
         synchronized ( cacheMap )
 129  
         {
 130  0
             for ( Iterator itr = cacheMap.values().iterator(); itr.hasNext(); )
 131  
             {
 132  0
                 Set listenerSet = (Set) itr.next();
 133  0
                 listenerSet.add( obj );
 134  0
             }
 135  0
         }
 136  0
         cacheWatch.addCacheListener( obj );
 137  0
     }
 138  
 
 139  
     /**
 140  
      * Tell the server to release us.
 141  
      * <p>
 142  
      * @param cacheName
 143  
      * @param obj
 144  
      * @throws IOException
 145  
      */
 146  
     public void removeCacheListener( String cacheName, ICacheListener obj )
 147  
         throws IOException
 148  
     {
 149  0
         if ( log.isInfoEnabled() )
 150  
         {
 151  0
             log.info( "removeCacheListener, cacheName [" + cacheName + "]" );
 152  
         }
 153  
         // Record the removal locally, regardless of whether the remote
 154  
         // remove-listener
 155  
         // operation succeeds or fails.
 156  0
         synchronized ( cacheMap )
 157  
         {
 158  0
             Set listenerSet = (Set) cacheMap.get( cacheName );
 159  0
             if ( listenerSet != null )
 160  
             {
 161  0
                 listenerSet.remove( obj );
 162  
             }
 163  0
         }
 164  0
         cacheWatch.removeCacheListener( cacheName, obj );
 165  0
     }
 166  
 
 167  
     /**
 168  
      * @param obj
 169  
      * @throws IOException
 170  
      */
 171  
     public void removeCacheListener( ICacheListener obj )
 172  
         throws IOException
 173  
     {
 174  0
         if ( log.isInfoEnabled() )
 175  
         {
 176  0
             log.info( "removeCacheListener, ICacheListener [" + obj + "]" );
 177  
         }
 178  
 
 179  
         // Record the removal locally, regardless of whether the remote
 180  
         // remove-listener operation succeeds or fails.
 181  0
         synchronized ( cacheMap )
 182  
         {
 183  0
             for ( Iterator itr = cacheMap.values().iterator(); itr.hasNext(); )
 184  
             {
 185  0
                 Set listenerSet = (Set) itr.next();
 186  0
                 if ( log.isDebugEnabled() )
 187  
                 {
 188  0
                     log.debug( "Before removing [" + obj + "] the listenerSet = " + listenerSet );
 189  
                 }
 190  0
                 listenerSet.remove( obj );
 191  0
             }
 192  0
         }
 193  0
         cacheWatch.removeCacheListener( obj );
 194  0
     }
 195  
 }

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