Package org.apache.jackrabbit.core.persistence.bundle

Class AbstractBundlePersistenceManager

    • Constructor Detail

      • AbstractBundlePersistenceManager

        public AbstractBundlePersistenceManager()

    • Method Detail

      • getBundleCacheSize

        public String getBundleCacheSize()
        Returns the size of the bundle cache in megabytes.
        Returns:
        the size of the bundle cache in megabytes.

      • setBundleCacheSize

        public void setBundleCacheSize​(String bundleCacheSize)
        Sets the size of the bundle cache in megabytes. the default is 8.
        Parameters:
        bundleCacheSize - the bundle cache size in megabytes.

      • buildNodeFolderPath

        protected StringBuffer buildNodeFolderPath​(StringBuffer buf,
                                           NodeId id)
        Creates the folder path for the given node id that is suitable for storing states in a filesystem.
        Parameters:
        buf - buffer to append to or null
        id - the id of the node
        Returns:
        the buffer with the appended data.

      • buildPropFilePath

        protected StringBuffer buildPropFilePath​(StringBuffer buf,
                                         PropertyId id)
        Creates the folder path for the given property id that is suitable for storing states in a filesystem.
        Parameters:
        buf - buffer to append to or null
        id - the id of the property
        Returns:
        the buffer with the appended data.

      • buildBlobFilePath

        protected StringBuffer buildBlobFilePath​(StringBuffer buf,
                                         PropertyId id,
                                         int i)
        Creates the file path for the given property id and value index that is suitable for storing property values in a filesystem.
        Parameters:
        buf - buffer to append to or null
        id - the id of the property
        i - the index of the property value
        Returns:
        the buffer with the appended data.

      • buildNodeFilePath

        protected StringBuffer buildNodeFilePath​(StringBuffer buf,
                                         NodeId id)
        Creates the file path for the given node id that is suitable for storing node states in a filesystem.
        Parameters:
        buf - buffer to append to or null
        id - the id of the node
        Returns:
        the buffer with the appended data.

      • buildNodeReferencesFilePath

        protected StringBuffer buildNodeReferencesFilePath​(StringBuffer buf,
                                                   NodeId id)
        Creates the file path for the given references id that is suitable for storing reference states in a filesystem.
        Parameters:
        buf - buffer to append to or null
        id - the id of the node
        Returns:
        the buffer with the appended data.

      • getNameIndex

        public StringIndex getNameIndex()
        Returns the local name index
        Returns:
        the local name index
        Throws:
        IllegalStateException - if an error occurs.

      • onExternalUpdate

        public void onExternalUpdate​(ChangeLog changes)
        Notifies the persistence manager that an external (cluster) modification occurred.
        Specified by:
        onExternalUpdate in interface CachingPersistenceManager
        Parameters:
        changes - the set of changes of the external modification.

      • getAllNodeInfos

        public Map<NodeId,​NodeInfo> getAllNodeInfos​(NodeId after,
                                                  int maxCount)
                                           throws ItemStateException,
                                                  RepositoryException
        Description copied from interface: IterablePersistenceManager
        Get all NodeInfos. A typical application will call this method multiple time, where 'after' is the last row read previously. The maxCount parameter defines the maximum number of node ids returned, 0 meaning no limit. The order of the node ids is specific for the given persistence manager. Items that are added concurrently may not be included.
        Specified by:
        getAllNodeInfos in interface IterablePersistenceManager
        Parameters:
        after - the lower limit, or null for no limit.
        maxCount - the maximum number of node infos to return, or 0 for no limit.
        Returns:
        a list of all node infos.
        Throws:
        ItemStateException - if an error while loading occurs.
        RepositoryException - if a repository exception occurs.

      • loadBundle

        protected abstract NodePropBundle loadBundle​(NodeId id)
                                      throws ItemStateException
        Loads a bundle from the underlying system.
        Parameters:
        id - the node id of the bundle
        Returns:
        the loaded bundle or null if the bundle does not exist.
        Throws:
        ItemStateException - if an error while loading occurs.

      • storeBundle

        protected abstract void storeBundle​(NodePropBundle bundle)
                             throws ItemStateException
        Stores a bundle to the underlying system.
        Parameters:
        bundle - the bundle to store
        Throws:
        ItemStateException - if an error while storing occurs.

      • destroyBundle

        protected abstract void destroyBundle​(NodePropBundle bundle)
                               throws ItemStateException
        Deletes the bundle from the underlying system.
        Parameters:
        bundle - the bundle to destroy
        Throws:
        ItemStateException - if an error while destroying occurs.

      • destroy

        protected abstract void destroy​(NodeReferences refs)
                         throws ItemStateException
        Deletes the node references from the underlying system.
        Parameters:
        refs - the node references to destroy.
        Throws:
        ItemStateException - if an error while destroying occurs.

      • store

        protected abstract void store​(NodeReferences refs)
                       throws ItemStateException
        Stores a node references to the underlying system.
        Parameters:
        refs - the node references to store.
        Throws:
        ItemStateException - if an error while storing occurs.

      • getBlobStore

        protected abstract BLOBStore getBlobStore()
        Returns the BLOB store used by this persistence manager.
        Returns:
        BLOB store

      • init

        public void init​(PMContext context)
          throws Exception
        Initializes the persistence manager. The persistence manager is permanently bound to the given context, and any required external resources are acquired.

        An appropriate exception is thrown if the persistence manager initialization fails for whatever reason. In this case the state of the persistence manager is undefined and the instance should be discarded. Initializes the internal structures of this abstract persistence manager.

        Specified by:
        init in interface PersistenceManager
        Parameters:
        context - persistence manager context
        Throws:
        Exception - if the persistence manager initialization failed

      • close

        public void close()
           throws Exception
        Closes the persistence manager. The consistency of the persistent storage is guaranteed and all acquired resources are released. It is an error to invoke any methods on a closed persistence manager, and implementations are free to enforce this constraint by throwing IllegalStateExceptions in such cases.

        An appropriate exception is thrown if the persistence manager could not be closed properly. In this case the state of the persistence manager is undefined and the instance should be discarded. Closes the persistence manager, release acquired resources.

        Specified by:
        close in interface PersistenceManager
        Throws:
        Exception - if the persistence manager failed to close properly

      • exists

        public boolean exists​(PropertyId id)
               throws ItemStateException
        Checks whether the identified property exists. Loads the state via the appropriate NodePropBundle.
        Specified by:
        exists in interface PersistenceManager
        Parameters:
        id - property id
        Returns:
        true if the property exists, false otherwise
        Throws:
        ItemStateException - on persistence manager errors

      • exists

        public boolean exists​(NodeId id)
               throws ItemStateException
        Checks whether the identified node exists. Checks the existence via the appropriate NodePropBundle.
        Specified by:
        exists in interface PersistenceManager
        Parameters:
        id - node id
        Returns:
        true if the node exists, false otherwise
        Throws:
        ItemStateException - on persistence manager errors

      • createNew

        public NodeState createNew​(NodeId id)
        Creates a new node state instance with the given id.
        Specified by:
        createNew in interface PersistenceManager
        Parameters:
        id - node id
        Returns:
        node state instance

      • store

        public void store​(ChangeLog changeLog)
           throws ItemStateException
        Right now, this iterates over all items in the changelog and calls the individual methods that handle single item states or node references objects. Properly implemented, this method should ensure that changes are either written completely to the underlying persistence layer, or not at all. Atomically saves the given set of changes.
        Specified by:
        store in interface PersistenceManager
        Parameters:
        changeLog - change log containing states that were changed
        Throws:
        ItemStateException - if the changes could not be saved

      • checkConsistency

        public void checkConsistency​(String[] uuids,
                             boolean recursive,
                             boolean fix)
        Perform a consistency check of the data. An example are non-existent nodes referenced in a child node entry. The existence of this feature and the scope of the implementation can vary in different PersistenceManager implementations.
        Specified by:
        checkConsistency in interface PersistenceManager
        Parameters:
        uuids - list of UUIDs of nodes to be checked. if null, all nodes will be checked
        recursive - if true, the tree(s) below the given node(s) will be traversed and checked as well
        fix - if true, any problems found that can be repaired will be repaired. if false, no data will be modified, instead all inconsistencies will only get logged

      • setEventChannel

        public void setEventChannel​(UpdateEventChannel eventChannel)
        Description copied from interface: ConsistencyChecker
        Set the update event channel. Needed to inform the cluster of any changes made during repairs.
        Specified by:
        setEventChannel in interface ConsistencyChecker
        Parameters:
        eventChannel - the update event channel

      • check

        public ConsistencyReport check​(String[] uuids,
                               boolean recursive,
                               boolean fix,
                               String lostNFoundId,
                               ConsistencyCheckListener listener)
                        throws RepositoryException
        Perform a consistency check of the data. An example are non-existent nodes referenced in a child node entry. The existence of this feature and the scope of the implementation can vary in different PersistenceManager implementations.
        Specified by:
        check in interface ConsistencyChecker
        Parameters:
        uuids - list of UUIDs of nodes to be checked. if null, all nodes will be checked
        recursive - if true, the tree(s) below the given node(s) will be traversed and checked as well
        fix - if true, any problems found that can be repaired will be repaired. if false, no data will be modified, instead all inconsistencies will only get logged
        lostNFoundId - node to which to attach orphaned nodes (or null, in which case orphaned nodes will not get moved); this node should be of a node type that allows adding arbitrary child nodes
        listener - to be called on each node that was checked (may be null)
        Throws:
        RepositoryException

      • evictBundle

        protected void evictBundle​(NodeId id)
        Evicts the bundle with id from the bundle cache.
        Parameters:
        id - the id of the bundle.

      • cacheAccessed

        public void cacheAccessed​(long accessCount)
        Description copied from interface: CacheAccessListener
        The cache calls this method after a number of cache accesses.
        For statistical purposes, the cache access count since the last call is included. In normal circumstances this is equal to CacheAccessListener.ACCESS_INTERVAL
        Specified by:
        cacheAccessed in interface CacheAccessListener
        Parameters:
        accessCount - number of cache accesses since the last call