package org.apache.ojb.broker.cache;

 /* Copyright 2004-2005 The Apache Software Foundation

  *

  * Licensed 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.lang.ref.ReferenceQueue;

 import java.lang.ref.SoftReference;

 import java.util.ArrayList;

 import java.util.Hashtable;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import java.util.Properties;

 import org.apache.commons.lang.builder.ToStringBuilder;

 import org.apache.commons.lang.builder.ToStringStyle;

 import org.apache.ojb.broker.Identity;

 import org.apache.ojb.broker.OJBRuntimeException;

 import org.apache.ojb.broker.PBStateEvent;

 import org.apache.ojb.broker.PBStateListener;

 import org.apache.ojb.broker.PersistenceBroker;

 import org.apache.ojb.broker.util.logging.Logger;

 import org.apache.ojb.broker.util.logging.LoggerFactory;

 /**

  * This global ObjectCache stores all Objects loaded by the <code>PersistenceBroker</code>

  * from a DB using a static {@link java.util.Map}. This means each {@link ObjectCache}

  * instance associated with all {@link PersistenceBroker} instances use the same

  * <code>Map</code> to cache objects. This could lead in "dirty-reads" (similar to read-uncommitted

  * mode in DB) when a concurrent thread look up same object modified by another thread.

  * <br/>

  * When the PersistenceBroker tries to get an Object by its {@link Identity}.

  * It first lookups the cache if the object has been already loaded and cached.

  * <p/>

  * NOTE: By default objects cached via {@link SoftReference} which allows

  * objects (softly) referenced by the cache to be reclaimed by the Java Garbage Collector when

  * they are not longer referenced elsewhere, so lifetime of cached object is limited by

  * <br/> - the lifetime of the cache object - see property <code>timeout</code>.

  * <br/> - the garabage collector used memory settings - see property <code>useSoftReferences</code>.

  * <br/> - the maximum capacity of the cache - see property <code>maxEntry</code>.

  * </p>

  * <p/>

  * Implementation configuration properties:

  * </p>

  * <p/>

  * <p/>

  * <table cellspacing="2" cellpadding="2" border="3" frame="box">

  * <tr>

  * <td><strong>Property Key</strong></td>

  * <td><strong>Property Values</strong></td>

  * </tr>

  * <p/>

  * <tr>

  * <td>timeout</td>

  * <td>

  * Lifetime of the cached objects in seconds.

  * If expired the cached object was not returned

  * on lookup call (and removed from cache). Default timeout

  * value is 900 seconds. When set to <tt>-1</tt> the lifetime of

  * the cached object depends only on GC and do never get timed out.

  * </td>

  * </tr>

  * <p/>

  * <tr>

  * <td>autoSync</td>

  * <td>

  * If set <tt>true</tt> all cached/looked up objects within a PB-transaction are traced.

  * If the the PB-transaction was aborted all traced objects will be removed from

  * cache. Default is <tt>false</tt>.

  * <p/>

  * NOTE: This does not prevent "dirty-reads" (more info see above).

  * </p>

  * <p/>

  * It's not a smart solution for keeping cache in sync with DB but should do the job

  * in most cases.

  * <br/>

  * E.g. if you lookup 1000 objects within a transaction and modify one object and then abort the

  * transaction, 1000 objects will be passed to cache, 1000 objects will be traced and

  * all 1000 objects will be removed from cache. If you read these objects without tx or

  * in a former tx and then modify one object in a tx and abort the tx, only one object was

  * traced/removed.

  * </p>

  * </td>

  * </tr>

  * <p/>

  * <tr>

  * <td>cachingKeyType</td>

  * <td>

  * Determines how the key was build for the cached objects:

  * <br/>

  * 0 - Identity object was used as key, this was the <em>default</em> setting.

  * <br/>

  * 1 - Idenity + jcdAlias name was used as key. Useful when the same object metadata model

  * (DescriptorRepository instance) are used for different databases (JdbcConnectionDescriptor)

  * <br/>

  * 2 - Identity + model (DescriptorRepository) was used as key. Useful when different metadata

  * model (DescriptorRepository instance) are used for the same database. Keep in mind that there

  * was no synchronization between cached objects with same Identity but different metadata model.

  * <br/>

  * 3 - all together (1+2)

  * </td>

  * </tr>

  * <p/>

  * <tr>

  * <td>useSoftReferences</td>

  * <td>

  * If set <em>true</em> this class use {@link java.lang.ref.SoftReference} to cache

  * objects. Default value is <em>true</em>.

  * </td>

  * </tr>

  * </table>

  * <p/>

  *

  * @author <a href="mailto:thma@apache.org">Thomas Mahler<a>

  * @version $Id: ObjectCacheDefaultImpl.java,v 1.1 2007-08-24 22:17:29 ewestfal Exp $

  */

 public class ObjectCacheDefaultImpl implements ObjectCacheInternal, PBStateListener

 {

     private Logger log = LoggerFactory.getLogger(ObjectCacheDefaultImpl.class);

     public static final String TIMEOUT_PROP = "timeout";

     public static final String AUTOSYNC_PROP = "autoSync";

     public static final String CACHING_KEY_TYPE_PROP = "cachingKeyType";

     public static final String SOFT_REFERENCES_PROP = "useSoftReferences";

     /**

      * static Map held all cached objects

      */

     protected static final Map objectTable = new Hashtable();

     private static final ReferenceQueue queue = new ReferenceQueue();

     private static long hitCount = 0;

     private static long failCount = 0;

     private static long gcCount = 0;

     protected PersistenceBroker broker;

     private List identitiesInWork;

     /**

      * Timeout of the cached objects. Default was 900 seconds.

      */

     private long timeout = 1000 * 60 * 15;

     private boolean useAutoSync = false;

     /**

      * Determines how the key was build for the cached objects:

      * <br/>

      * 0 - Identity object was used as key

      * 1 - Idenity + jcdAlias name was used as key

      * 2 - Identity + model (DescriptorRepository) was used as key

      * 3 - all together (1+2)

      */

     private int cachingKeyType;

     private boolean useSoftReferences = true;

     public ObjectCacheDefaultImpl(PersistenceBroker broker, Properties prop)

     {

         this.broker = broker;

         timeout = prop == null ? timeout : (Long.parseLong(prop.getProperty(TIMEOUT_PROP, "" + (60 * 15))) * 1000);

         useSoftReferences = prop != null && (Boolean.valueOf((prop.getProperty(SOFT_REFERENCES_PROP, "true")).trim())).booleanValue();

         cachingKeyType = prop == null ? 0 : (Integer.parseInt(prop.getProperty(CACHING_KEY_TYPE_PROP, "0")));

         useAutoSync = prop != null && (Boolean.valueOf((prop.getProperty(AUTOSYNC_PROP, "false")).trim())).booleanValue();

         if(useAutoSync)

         {

             if(broker != null)

             {

                 // we add this instance as a permanent PBStateListener

                 broker.addListener(this, true);

             }

             else

             {

                 log.info("Can't enable property '" + AUTOSYNC_PROP + "', because given PB instance is null");

             }

         }

         identitiesInWork = new ArrayList();

         if(log.isEnabledFor(Logger.INFO))

         {

             ToStringBuilder buf = new ToStringBuilder(this);

             buf.append("timeout", timeout)

                     .append("useSoftReferences", useSoftReferences)

                     .append("cachingKeyType", cachingKeyType)

                     .append("useAutoSync", useAutoSync);

             log.info("Setup cache: " + buf.toString());

         }

     }

     /**

      * Clear ObjectCache. I.e. remove all entries for classes and objects.

      */

     public void clear()

     {

         //processQueue();

         objectTable.clear();

         identitiesInWork.clear();

     }

     public void doInternalCache(Identity oid, Object obj, int type)

     {

         //processQueue();

         if((obj != null))

         {

             traceIdentity(oid);

             synchronized(objectTable)

             {

                 if(log.isDebugEnabled()) log.debug("Cache object " + oid);

                 objectTable.put(buildKey(oid), buildEntry(obj, oid));

             }

         }

     }

     /**

      * Makes object persistent to the Objectcache.

      * I'm using soft-references to allow gc reclaim unused objects

      * even if they are still cached.

      */

     public void cache(Identity oid, Object obj)

     {

         doInternalCache(oid, obj, ObjectCacheInternal.TYPE_UNKNOWN);

     }

     public boolean cacheIfNew(Identity oid, Object obj)

     {

         //processQueue();

         boolean result = false;

         Object key = buildKey(oid);

         if((obj != null))

         {

             synchronized(objectTable)

             {

                 if(!objectTable.containsKey(key))

                 {

                     objectTable.put(key, buildEntry(obj, oid));

                     result = true;

                 }

             }

             if(result) traceIdentity(oid);

         }

         return result;

     }

     /**

      * Lookup object with Identity oid in objectTable.

      * Returns null if no matching id is found

      */

     public Object lookup(Identity oid)

     {

         processQueue();

         hitCount++;

         Object result = null;

         CacheEntry entry = (CacheEntry) objectTable.get(buildKey(oid));

         if(entry != null)

         {

             result = entry.get();

             if(result == null || entry.getLifetime() < System.currentTimeMillis())

             {

                 /*

                 cached object was removed by gc or lifetime was exhausted

                 remove CacheEntry from map

                 */

                 gcCount++;

                 remove(oid);

                 // make sure that we return null

                 result = null;

             }

             else

             {

                 /*

                 TODO: Not sure if this makes sense, could help to avoid corrupted objects

                 when changed in tx but not stored.

                 */

                 traceIdentity(oid);

                 if(log.isDebugEnabled()) log.debug("Object match " + oid);

             }

         }

         else

         {

             failCount++;

         }

         return result;

     }

     /**

      * Removes an Object from the cache.

      */

     public void remove(Identity oid)

     {

         //processQueue();

         if(oid != null)

         {

             removeTracedIdentity(oid);

             objectTable.remove(buildKey(oid));

             if(log.isDebugEnabled()) log.debug("Remove object " + oid);

         }

     }

     public String toString()

     {

         ToStringBuilder buf = new ToStringBuilder(this, ToStringStyle.DEFAULT_STYLE);

         buf.append("Count of cached objects", objectTable.keySet().size());

         buf.append("Lookup hits", hitCount);

         buf.append("Failures", failCount);

         buf.append("Reclaimed", gcCount);

         return buf.toString();

     }

     private void traceIdentity(Identity oid)

     {

         if(useAutoSync && (broker != null) && broker.isInTransaction())

         {

             identitiesInWork.add(oid);

         }

     }

     private void removeTracedIdentity(Identity oid)

     {

         identitiesInWork.remove(oid);

     }

     private void synchronizeWithTracedObjects()

     {

         Identity oid;

         log.info("tx was aborted," +

                 " remove " + identitiesInWork.size() + " traced (potentially modified) objects from cache");

         for(Iterator iterator = identitiesInWork.iterator(); iterator.hasNext();)

         {

             oid = (Identity) iterator.next();

             objectTable.remove(buildKey(oid));

         }

     }

     public void beforeRollback(PBStateEvent event)

     {

         synchronizeWithTracedObjects();

         identitiesInWork.clear();

     }

     public void beforeCommit(PBStateEvent event)

     {

         // identitiesInWork.clear();

     }

     public void beforeClose(PBStateEvent event)

     {

         /*

         arminw: In managed environments listener method "beforeClose" is called twice

         (when the PB handle is closed and when the real PB instance is closed/returned to pool).

         We are only interested in the real close call when all work is done.

         */

         if(!broker.isInTransaction())

         {

             identitiesInWork.clear();

         }

     }

     public void afterRollback(PBStateEvent event)

     {

     }

     public void afterCommit(PBStateEvent event)

     {

         identitiesInWork.clear();

     }

     public void afterBegin(PBStateEvent event)

     {

     }

     public void beforeBegin(PBStateEvent event)

     {

     }

     public void afterOpen(PBStateEvent event)

     {

     }

     private CacheEntry buildEntry(Object obj, Identity oid)

     {

         if(useSoftReferences)

         {

             return new CacheEntrySoft(obj, oid, queue, timeout);

         }

         else

         {

             return new CacheEntryHard(obj, oid, timeout);

         }

     }

     private void processQueue()

     {

         CacheEntry sv;

         while((sv = (CacheEntry) queue.poll()) != null)

         {

             removeTracedIdentity(sv.getOid());

             objectTable.remove(buildKey(sv.getOid()));

         }

     }

     private Object buildKey(Identity oid)

     {

         Object key;

         switch(cachingKeyType)

         {

             case 0:

                 key = oid;

                 break;

             case 1:

                 key = new OrderedTuple(oid, broker.getPBKey().getAlias());

                 break;

             case 2:

                 /*

                 this ObjectCache implementation only works in single JVM, so the hashCode

                 of the DescriptorRepository class is unique

                 TODO: problem when different versions of same DR are used

                 */

                 key = new OrderedTuple(oid,

                         new Integer(broker.getDescriptorRepository().hashCode()));

                 break;

             case 3:

                 key = new OrderedTuple(oid, broker.getPBKey().getAlias(),

                         new Integer(broker.getDescriptorRepository().hashCode()));

                 break;

             default:

                 throw new OJBRuntimeException("Unexpected error, 'cacheType =" + cachingKeyType + "' was not supported");

         }

         return key;

     }

     //-----------------------------------------------------------

     // inner class to build unique key for cached objects

     //-----------------------------------------------------------

     /**

      * Implements equals() and hashCode() for an ordered tuple of constant(!)

      * objects

      *

      * @author Gerhard Grosse

      * @since Oct 12, 2004

      */

     static final class OrderedTuple

     {

         private static int[] multipliers =

                 new int[]{13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 51};

         private Object[] elements;

         private int hashCode;

         public OrderedTuple(Object element)

         {

             elements = new Object[1];

             elements[0] = element;

             hashCode = calcHashCode();

         }

         public OrderedTuple(Object element1, Object element2)

         {

             elements = new Object[2];

             elements[0] = element1;

             elements[1] = element2;

             hashCode = calcHashCode();

         }

         public OrderedTuple(Object element1, Object element2, Object element3)

         {

             elements = new Object[3];

             elements[0] = element1;

             elements[1] = element2;

             elements[2] = element3;

             hashCode = calcHashCode();

         }

         public OrderedTuple(Object[] elements)

         {

             this.elements = elements;

             this.hashCode = calcHashCode();

         }

         private int calcHashCode()

         {

             int code = 7;

             for(int i = 0; i < elements.length; i++)

             {

                 int m = i % multipliers.length;

                 code += elements[i].hashCode() * multipliers[m];

             }

             return code;

         }

         public boolean equals(Object obj)

         {

             if(!(obj instanceof OrderedTuple))

             {

                 return false;

             }

             else

             {

                 OrderedTuple other = (OrderedTuple) obj;

                 if(this.hashCode != other.hashCode)

                 {

                     return false;

                 }

                 else if(this.elements.length != other.elements.length)

                 {

                     return false;

                 }

                 else

                 {

                     for(int i = 0; i < elements.length; i++)

                     {

                         if(!this.elements[i].equals(other.elements[i]))

                         {

                             return false;

                         }

                     }

                     return true;

                 }

             }

         }

         public int hashCode()

         {

             return hashCode;

         }

         public String toString()

         {

             StringBuffer s = new StringBuffer();

             s.append('{');

             for(int i = 0; i < elements.length; i++)

             {

                 s.append(elements[i]).append('#').append(elements[i].hashCode()).append(',');

             }

             s.setCharAt(s.length() - 1, '}');

             s.append("#").append(hashCode);

             return s.toString();

         }

     }

     //-----------------------------------------------------------

     // inner classes to wrap cached objects

     //-----------------------------------------------------------

     interface CacheEntry

     {

         Object get();

         Identity getOid();

         long getLifetime();

     }

     final static class CacheEntrySoft extends SoftReference implements CacheEntry

     {

         private final long lifetime;

         private final Identity oid;

         CacheEntrySoft(Object object, final Identity k, final ReferenceQueue q, long timeout)

         {

             super(object, q);

             oid = k;

             // if timeout is negative, lifetime of object never expire

             if(timeout < 0)

             {

                 lifetime = Long.MAX_VALUE;

             }

             else

             {

                 lifetime = System.currentTimeMillis() + timeout;

             }

         }

         public Identity getOid()

         {

             return oid;

         }

         public long getLifetime()

         {

             return lifetime;

         }

     }

     final static class CacheEntryHard implements CacheEntry

     {

         private final long lifetime;

         private final Identity oid;

         private Object obj;

         CacheEntryHard(Object object, final Identity k, long timeout)

         {

             obj = object;

             oid = k;

             // if timeout is negative, lifetime of object never expire

             if(timeout < 0)

             {

                 lifetime = Long.MAX_VALUE;

             }

             else

             {

                 lifetime = System.currentTimeMillis() + timeout;

             }

         }

         public Object get()

         {

             return obj;

         }

         public Identity getOid()

         {

             return oid;

         }

         public long getLifetime()

         {

             return lifetime;

         }

     }

 }