Package org.apache.manifoldcf.core.cachemanager

Class CacheManager

  • All Implemented Interfaces:
    ICacheManager
    public class CacheManager
extends java.lang.Object
implements ICacheManager
    This class implements the cache manager interface, and provides generic cache management services. See the interface for a description of how the services work. However, since this service requires the lock manager, and there is one lock manager per thread, there will be one of these service instances per thread as well.

    • Method Detail

      • findObjectsAndExecute

        public void findObjectsAndExecute​(ICacheDescription[] locateObjectDescriptions,
                                  StringSet invalidateKeys,
                                  ICacheExecutor execObject,
                                  java.lang.String transactionID)
                           throws ManifoldCFException
        Locate or create a set of objects in the cached object pool, and/or destroy and invalidate the same or other objects. For each "locate" object described below, one of two things will happen: the execObject's exists() method will be called (if the object exists in the cache already), or the execObject's create*() family of methods will be called. When all objects have been declared to the execObject, finally the execute() method will be called. In both cases, all objects are considered to be locked, and cannot be invalidated until the lock is cleared (after the end of the called method). For the invalidation descriptions, the execObject's destroy() method will be called instead. The object will be invalidated from the cache at the end of the findObjectsAndExecute() operation. It is perfectly legal to include the same object in both the locate set and the invalidate set! If an error occurs during object creation, the execute() method will NOT be called. If the execute() method has an error, the objects that were created will still be recorded in the cache.
        Specified by:
        findObjectsAndExecute in interface ICacheManager
        Parameters:
        locateObjectDescriptions - is a set of description objects that uniquely describe the objects needed.
        invalidateKeys - is the set of keys to invalidate at the end of the execution.
        execObject - is the cache execution object whose create() or execute() methods will be called.
        transactionID - is the current transaction identifier, or null. Objects created within this call will be associated with this transaction; they will be purged from the cache should the transaction be rolled back.
        Throws:
        ManifoldCFException

      • enterCache

        public ICacheHandle enterCache​(ICacheDescription[] locateObjectDescriptions,
                               StringSet invalidateKeys,
                               java.lang.String transactionID)
                        throws ManifoldCFException
        Second way of doing cache management. Basically, this approach breaks the findObjectsAndExecute() method down into bite-sized chunks. The goal is additional flexibility, and an executor object does not need to be defined. Pretty much everything else is identical. The objects returned by the manager methods provide context control and enforce the proper ordering and nesting. This method enters the cacher and builds a cache handle. Once a cache handle is returned, the calling code MUST, under all circumstances, leave the cache using the same handle.
        Specified by:
        enterCache in interface ICacheManager
        Parameters:
        locateObjectDescriptions - is a set of description objects that uniquely describe the objects needed. May be null if no objects are desired.
        invalidateKeys - are the keys to invalidate after successful execution. May be null.
        transactionID - is the current transaction identifier, or null. Objects created within this block will be associated with this transaction; they will be purged from the cache should the transaction be rolled back.
        Returns:
        a cache handle.
        Throws:
        ManifoldCFException

      • lookupObject

        public java.lang.Object lookupObject​(ICacheCreateHandle handle,
                                     ICacheDescription objectDescription)
                              throws ManifoldCFException
        Lookup an object. Returns null if object not found. If it is found, object's LRU and expiration info are updated. The objectDescription passed MUST be one of the ones specified in the enclosing enterCache() method.
        Specified by:
        lookupObject in interface ICacheManager
        Parameters:
        handle - is the handle to use for the create.
        objectDescription - is the description of the object to look up.
        Returns:
        the object, or null if not found.
        Throws:
        ManifoldCFException

      • hasExpired

        protected boolean hasExpired​(java.lang.String key,
                             long createTime)
                      throws ManifoldCFException
        Check if object has expired (by looking at file system).
        Parameters:
        key - is the invalidation key.
        createTime - is the creation time.
        Returns:
        true if expired, false otherwise.
        Throws:
        ManifoldCFException

      • resetObjectExpiration

        protected void resetObjectExpiration​(ICacheDescription objectDescription,
                                     long currentTime)
        Set object's expiration and LRU.
        Parameters:
        objectDescription - is the description object.
        currentTime - is the current time in milliseconds since epoch.

      • performInvalidation

        protected void performInvalidation​(StringSet keys)
                            throws ManifoldCFException
        Perform an invalidation. Assume all appropriate locks are in place.
        Parameters:
        keys - is the set of keys to invalidate.
        Throws:
        ManifoldCFException

      • startTransaction

        public void startTransaction​(java.lang.String startingTransactionID,
                             java.lang.String enclosingTransactionID)
                      throws ManifoldCFException
        Begin a cache transaction. This keeps track of the relationship between objects cached within transactions.
        Specified by:
        startTransaction in interface ICacheManager
        Parameters:
        startingTransactionID - is the id of the transaction that is starting.
        enclosingTransactionID - is the id of the transaction that is in effect, or null.
        Throws:
        ManifoldCFException

      • commitTransaction

        public void commitTransaction​(java.lang.String transactionID)
                       throws ManifoldCFException
        Commit a cache transaction. This method MUST be called when a transaction successfully ends, or open locks will not be closed!!! All cache activity that has taken place inside the transaction will be resolved, and the cache locks held open will be released.
        Specified by:
        commitTransaction in interface ICacheManager
        Parameters:
        transactionID - is the id of the transaction that is ending.
        Throws:
        ManifoldCFException

      • rollbackTransaction

        public void rollbackTransaction​(java.lang.String transactionID)
                         throws ManifoldCFException
        Roll back a cache transaction. This method releases all objects cached against the ending transaction ID, and releases all locks held for the transaction.
        Specified by:
        rollbackTransaction in interface ICacheManager
        Parameters:
        transactionID - is the id of the transaction that is ending.
        Throws:
        ManifoldCFException

      • expireObjects

        public void expireObjects​(long currentTimestamp)
                   throws ManifoldCFException
        Timed invalidation. Call this periodically to get rid of all objects that have expired.
        Specified by:
        expireObjects in interface ICacheManager
        Parameters:
        currentTimestamp - is the current time in milliseconds since epoch.
        Throws:
        ManifoldCFException

      • readSharedData

        protected long readSharedData​(java.lang.String key)
                       throws ManifoldCFException
        Read an invalidation file contents.
        Parameters:
        key - is the cache key name.
        Returns:
        the invalidation time, or 0 if none.
        Throws:
        ManifoldCFException

      • writeSharedData

        protected void writeSharedData​(java.lang.String key,
                               long value)
                        throws ManifoldCFException
        Write the invalidation file contents.
        Parameters:
        key - is the cache key name.
        value - is the invalidation timestamp.
        Throws:
        ManifoldCFException