package org.apache.commons.jcs.auxiliary.remote;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
   * with the License.  You may obtain a copy of the License at
   *
   *   http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing,
   * software distributed under the License is distributed on an
   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
   * KIND, either express or implied.  See the License for the
   * specific language governing permissions and limitations
   * under the License.
   */
  
  import java.io.IOException;
  import java.net.UnknownHostException;
  
  import org.apache.commons.jcs.access.exception.CacheException;
  import org.apache.commons.jcs.auxiliary.remote.behavior.IRemoteCacheAttributes;
  import org.apache.commons.jcs.auxiliary.remote.behavior.IRemoteCacheListener;
  import org.apache.commons.jcs.auxiliary.remote.server.behavior.RemoteType;
  import org.apache.commons.jcs.engine.behavior.ICacheElement;
  import org.apache.commons.jcs.engine.behavior.ICacheElementSerialized;
  import org.apache.commons.jcs.engine.behavior.ICompositeCacheManager;
  import org.apache.commons.jcs.engine.behavior.IElementSerializer;
  import org.apache.commons.jcs.engine.control.CompositeCacheManager;
  import org.apache.commons.jcs.utils.net.HostNameUtil;
  import org.apache.commons.jcs.utils.serialization.SerializationConversionUtil;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /** Shared listener base. */
  public abstract class AbstractRemoteCacheListener<K, V>
      implements IRemoteCacheListener<K, V>
  {
      /** The logger */
      private static final Log log = LogFactory.getLog( AbstractRemoteCacheListener.class );
  
      /** The cached name of the local host. The remote server gets this for logging purposes. */
      private static String localHostName = null;
  
      /**
       * The cache manager used to put items in different regions. This is set lazily and should not
       * be sent to the remote server.
       */
      private ICompositeCacheManager cacheMgr;
  
      /** The remote cache configuration object. */
      private final IRemoteCacheAttributes irca;
  
      /** This is set by the remote cache server. */
      private long listenerId = 0;
  
      /** Custom serializer. */
      private IElementSerializer elementSerializer;
  
      /**
       * Only need one since it does work for all regions, just reference by multiple region names.
       * <p>
       * The constructor exports this object, making it available to receive incoming calls. The
       * callback port is anonymous unless a local port value was specified in the configuration.
       * <p>
       * @param irca cache configuration
       * @param cacheMgr the cache hub
       * @param elementSerializer a custom serializer
       */
      public AbstractRemoteCacheListener( IRemoteCacheAttributes irca, ICompositeCacheManager cacheMgr, IElementSerializer elementSerializer )
      {
          this.irca = irca;
          this.cacheMgr = cacheMgr;
          this.elementSerializer = elementSerializer;
      }
  
      /**
       * Let the remote cache set a listener_id. Since there is only one listener for all the regions
       * and every region gets registered? the id shouldn't be set if it isn't zero. If it is we
       * assume that it is a reconnect.
       * <p>
       * @param id The new listenerId value
       * @throws IOException
       */
      @Override
      public void setListenerId( long id )
          throws IOException
      {
          listenerId = id;
          if ( log.isInfoEnabled() )
          {
              log.info( "set listenerId = [" + id + "]" );
          }
      }
  
     /**
      * Gets the listenerId attribute of the RemoteCacheListener object. This is stored in the
      * object. The RemoteCache object contains a reference to the listener and get the id this way.
      * <p>
      * @return The listenerId value
      * @throws IOException
      */
     @Override
     public long getListenerId()
         throws IOException
     {
         if ( log.isDebugEnabled() )
         {
             log.debug( "get listenerId = [" + listenerId + "]" );
         }
         return listenerId;
 
     }
 
     /**
      * Gets the remoteType attribute of the RemoteCacheListener object
      * <p>
      * @return The remoteType value
      * @throws IOException
      */
     @Override
     public RemoteType getRemoteType()
         throws IOException
     {
         if ( log.isDebugEnabled() )
         {
             log.debug( "getRemoteType = [" + irca.getRemoteType() + "]" );
         }
         return irca.getRemoteType();
     }
 
     /**
      * If this is configured to remove on put, then remove the element since it has been updated
      * elsewhere. cd should be incomplete for faster transmission. We don't want to pass data only
      * invalidation. The next time it is used the local cache will get the new version from the
      * remote store.
      * <p>
      * If remove on put is not configured, then update the item.
      * @param cb
      * @throws IOException
      */
     @Override
     public void handlePut( ICacheElement<K, V> cb )
         throws IOException
     {
         if ( irca.getRemoveUponRemotePut() )
         {
             if ( log.isDebugEnabled() )
             {
                 log.debug( "PUTTING ELEMENT FROM REMOTE, (  invalidating ) " );
             }
             handleRemove( cb.getCacheName(), cb.getKey() );
         }
         else
         {
             if ( log.isDebugEnabled() )
             {
                 log.debug( "PUTTING ELEMENT FROM REMOTE, ( updating ) " );
                 log.debug( "cb = " + cb );
             }
 
             // Eventually the instance of will not be necessary.
             if ( cb instanceof ICacheElementSerialized )
             {
                 if ( log.isDebugEnabled() )
                 {
                     log.debug( "Object needs to be deserialized." );
                 }
                 try
                 {
                     cb = SerializationConversionUtil.getDeSerializedCacheElement(
                             (ICacheElementSerialized<K, V>) cb, this.elementSerializer );
                     if ( log.isDebugEnabled() )
                     {
                         log.debug( "Deserialized result = " + cb );
                     }
                 }
                 catch ( IOException e )
                 {
                     throw e;
                 }
                 catch ( ClassNotFoundException e )
                 {
                     log.error( "Received a serialized version of a class that we don't know about.", e );
                 }
             }
 
             getCacheManager().<K, V>getCache( cb.getCacheName() ).localUpdate( cb );
         }
     }
 
     /**
      * Calls localRemove on the CompositeCache.
      * <p>
      * @param cacheName
      * @param key
      * @throws IOException
      */
     @Override
     public void handleRemove( String cacheName, K key )
         throws IOException
     {
         if ( log.isDebugEnabled() )
         {
             log.debug( "handleRemove> cacheName=" + cacheName + ", key=" + key );
         }
 
         getCacheManager().<K, V>getCache( cacheName ).localRemove( key );
     }
 
     /**
      * Calls localRemoveAll on the CompositeCache.
      * <p>
      * @param cacheName
      * @throws IOException
      */
     @Override
     public void handleRemoveAll( String cacheName )
         throws IOException
     {
         if ( log.isDebugEnabled() )
         {
             log.debug( "handleRemoveAll> cacheName=" + cacheName );
         }
 
         getCacheManager().<K, V>getCache( cacheName ).localRemoveAll();
     }
 
     /**
      * @param cacheName
      * @throws IOException
      */
     @Override
     public void handleDispose( String cacheName )
         throws IOException
     {
         if ( log.isDebugEnabled() )
         {
             log.debug( "handleDispose> cacheName=" + cacheName );
         }
         // TODO consider what to do here, we really don't want to
         // dispose, we just want to disconnect.
         // just allow the cache to go into error recovery mode.
         // getCacheManager().freeCache( cacheName, true );
     }
 
     /**
      * Gets the cacheManager attribute of the RemoteCacheListener object. This is one of the few
      * places that force the cache to be a singleton.
      */
     protected ICompositeCacheManager getCacheManager()
     {
         if ( cacheMgr == null )
         {
             try
             {
                 cacheMgr = CompositeCacheManager.getInstance();
 
                 if ( log.isDebugEnabled() )
                 {
                     log.debug( "had to get cacheMgr" );
                     log.debug( "cacheMgr = " + cacheMgr );
                 }
             }
             catch (CacheException e)
             {
                 log.error( "Could not get cacheMgr", e );
             }
         }
         else
         {
             if ( log.isDebugEnabled() )
             {
                 log.debug( "already got cacheMgr = " + cacheMgr );
             }
         }
 
         return cacheMgr;
     }
 
     /**
      * This is for debugging. It allows the remote server to log the address of clients.
      * <p>
      * @return String
      * @throws IOException
      */
     @Override
     public synchronized String getLocalHostAddress()
         throws IOException
     {
         if ( localHostName == null )
         {
             try
             {
                 localHostName = HostNameUtil.getLocalHostAddress();
             }
             catch ( UnknownHostException uhe )
             {
                 localHostName = "unknown";
             }
         }
         return localHostName;
     }
 
     /**
      * For easier debugging.
      * <p>
      * @return Basic info on this listener.
      */
     @Override
     public String toString()
     {
         StringBuilder buf = new StringBuilder();
         buf.append( "\n AbstractRemoteCacheListener: " );
         buf.append( "\n RemoteHost = " + irca.getRemoteLocation().toString() );
         buf.append( "\n ListenerId = " + listenerId );
         return buf.toString();
     }
 }