Class PersistenceManagerStub

    • Constructor Detail

      • PersistenceManagerStub

        public PersistenceManagerStub()
    • Method Detail

      • start

        public void start()
        Description copied from interface: Lifecycle
        Invoked on component start
        Specified by:
        start in interface Lifecycle
      • stop

        public void stop()
        Description copied from interface: Lifecycle
        Invoked on component stop
        Specified by:
        stop in interface Lifecycle
      • isPreloaded

        public boolean isPreloaded()
        Specified by:
        isPreloaded in interface PersistenceManager
        Returns:
        true if all entries from the store have been inserted to the cache. If the persistence/preload is disabled or eviction limit was reached when preloading, returns false.
      • preload

        public void preload()
        Description copied from interface: PersistenceManager
        Loads the data from the external store into memory during cache startup.
        Specified by:
        preload in interface PersistenceManager
      • getStores

        public <T> java.util.Set<T> getStores​(java.lang.Class<T> storeClass)
        Specified by:
        getStores in interface PersistenceManager
      • publishEntries

        public <K,​V> org.reactivestreams.Publisher<MarshalledEntry<K,​V>> publishEntries​(java.util.function.Predicate<? super K> filter,
                                                                                                    boolean fetchValue,
                                                                                                    boolean fetchMetadata,
                                                                                                    java.util.function.Predicate<? super StoreConfiguration> predicate)
        Description copied from interface: PersistenceManager
        Returns a publisher that will publish all entries stored by the underlying cache store. Only the first cache store that implements AdvancedCacheLoader will be used. Predicate is applied by the underlying loader in a best attempt to improve performance.

        Caller can tell the store to also fetch the value or metadata. In some cases this can improve performance. If metadata is not fetched the publisher may include expired entries.

        Specified by:
        publishEntries in interface PersistenceManager
        Type Parameters:
        K - key type
        V - value type
        Parameters:
        filter - filter so that only entries whose key matches are returned
        fetchValue - whether to fetch value or not
        fetchMetadata - whether to fetch metadata or not
        predicate - whether a store can be used by publish entries
        Returns:
        publisher that will publish entries
      • publishEntries

        public <K,​V> org.reactivestreams.Publisher<MarshalledEntry<K,​V>> publishEntries​(IntSet segments,
                                                                                                    java.util.function.Predicate<? super K> filter,
                                                                                                    boolean fetchValue,
                                                                                                    boolean fetchMetadata,
                                                                                                    java.util.function.Predicate<? super StoreConfiguration> predicate)
        Description copied from interface: PersistenceManager
        Returns a publisher that will publish entries that map to the provided segments. It will attempt to find the first segmented store if one is available. If not it will fall back to the first non segmented store and filter out entries that don't map to the provided segment.
        Specified by:
        publishEntries in interface PersistenceManager
        Type Parameters:
        K - key type
        V - value type
        Parameters:
        segments - only entries that map to these segments are processed
        filter - filter so that only entries whose key matches are returned
        fetchValue - whether to fetch value or not
        fetchMetadata - whether to fetch metadata or not
        predicate - whether a store can be used by publish entries
        Returns:
        publisher that will publish entries belonging to the given segments
      • publishKeys

        public <K> org.reactivestreams.Publisher<K> publishKeys​(java.util.function.Predicate<? super K> filter,
                                                                java.util.function.Predicate<? super StoreConfiguration> predicate)
        Description copied from interface: PersistenceManager
        Returns a publisher that will publish all keys stored by the underlying cache store. Only the first cache store that implements AdvancedCacheLoader will be used. Predicate is applied by the underlying loader in a best attempt to improve performance.

        This method should be preferred over PersistenceManager.publishEntries(Predicate, boolean, boolean, Predicate) when only keys are desired as many stores can do this in a significantly more performant way.

        This publisher will never return a key which belongs to an expired entry

        Specified by:
        publishKeys in interface PersistenceManager
        Type Parameters:
        K - key type
        Parameters:
        filter - filter so that only keys which match are returned
        predicate - access mode to choose what type of loader to use
        Returns:
        publisher that will publish keys
      • publishKeys

        public <K> org.reactivestreams.Publisher<K> publishKeys​(IntSet segments,
                                                                java.util.function.Predicate<? super K> filter,
                                                                java.util.function.Predicate<? super StoreConfiguration> predicate)
        Description copied from interface: PersistenceManager
        Returns a publisher that will publish keys that map to the provided segments. It will attempt to find the first segmented store if one is available. If not it will fall back to the first non segmented store and filter out entries that don't map to the provided segment.

        This method should be preferred over PersistenceManager.publishEntries(IntSet, Predicate, boolean, boolean, Predicate) when only keys are desired as many stores can do this in a significantly more performant way.

        This publisher will never return a key which belongs to an expired entry

        Specified by:
        publishKeys in interface PersistenceManager
        Type Parameters:
        K - key type
        Parameters:
        segments - only keys that map to these segments are processed
        filter - filter so that only keys which match are returned
        predicate - access mode to choose what type of loader to use
        Returns:
        publisher that will publish keys belonging to the given segments
      • loadFromAllStores

        public MarshalledEntry loadFromAllStores​(java.lang.Object key,
                                                 boolean localInvocation,
                                                 boolean includeStores)
        Description copied from interface: PersistenceManager
        Loads an entry from the persistence store for the given key. The returned value may be null. This value is guaranteed to not be expired when it was returned.
        Specified by:
        loadFromAllStores in interface PersistenceManager
        Parameters:
        key - key to read the entry from
        localInvocation - whether this invocation is a local invocation. Some loaders may be ignored if it is not local
        includeStores - if a loader that is also a store can be loaded from
        Returns:
        entry that maps to the key
      • loadFromAllStores

        public MarshalledEntry loadFromAllStores​(java.lang.Object key,
                                                 int segment,
                                                 boolean localInvocation,
                                                 boolean includeStores)
        Description copied from interface: PersistenceManager
        Same as PersistenceManager.loadFromAllStores(Object, boolean, boolean) except that the segment of the key is also provided to avoid having to calculate the segment.
        Specified by:
        loadFromAllStores in interface PersistenceManager
        Parameters:
        key - key to read the entry from
        segment - segment the key maps to
        localInvocation - whether this invocation is a local invocation. Some loaders may be ignored if it is not local
        includeStores - if a loader that is also a store can be loaded from
        Returns:
        entry that maps to the key
      • writeToAllNonTxStores

        public void writeToAllNonTxStores​(MarshalledEntry marshalledEntry,
                                          int segment,
                                          java.util.function.Predicate<? super StoreConfiguration> predicates)
        Description copied from interface: PersistenceManager
        Write to all stores that are not transactional. A store is considered transactional if all of the following are true:

        • The store implements TransactionalCacheWriter
        • The store is configured to be transactional
        • The cache's TransactionMode === TRANSACTIONAL

        Specified by:
        writeToAllNonTxStores in interface PersistenceManager
        Parameters:
        marshalledEntry - the entry to be written to all non-tx stores.
        segment - the segment the entry maps to
        predicates - should we write to a given store
      • size

        public int size​(java.util.function.Predicate<? super StoreConfiguration> predicate)
        Description copied from interface: PersistenceManager
        Returns the count of how many entries are persisted. If no store can handle the request for the given mode a value of -1 is returned instead.
        Specified by:
        size in interface PersistenceManager
        Parameters:
        predicate - whether a loader can be used
        Returns:
        size or -1 if size couldn't be computed
      • size

        public int size​(IntSet segments)
        Description copied from interface: PersistenceManager
        Returns the count of how many entries are persisted within the given segments. The returned value will always be 0 or greater.
        Specified by:
        size in interface PersistenceManager
        Parameters:
        segments - which segments to count entries from
        Returns:
        how many entries are in the store which map to the given segments
      • prepareAllTxStores

        public void prepareAllTxStores​(javax.transaction.Transaction transaction,
                                       BatchModification batchModification,
                                       java.util.function.Predicate<? super StoreConfiguration> predicate)
                                throws PersistenceException
        Description copied from interface: PersistenceManager
        Perform the prepare phase of 2PC on all Tx stores.
        Specified by:
        prepareAllTxStores in interface PersistenceManager
        Parameters:
        transaction - the current transactional context.
        batchModification - an object containing the write/remove operations required for this transaction.
        predicate - should we prepare on a given store
        Throws:
        PersistenceException - if an error is encountered at any of the underlying stores.
      • commitAllTxStores

        public void commitAllTxStores​(javax.transaction.Transaction transaction,
                                      java.util.function.Predicate<? super StoreConfiguration> predicate)
        Description copied from interface: PersistenceManager
        Perform the commit operation for the provided transaction on all Tx stores.
        Specified by:
        commitAllTxStores in interface PersistenceManager
        Parameters:
        transaction - the transactional context to be committed.
        predicate - should we commit each store
      • rollbackAllTxStores

        public void rollbackAllTxStores​(javax.transaction.Transaction transaction,
                                        java.util.function.Predicate<? super StoreConfiguration> predicate)
        Description copied from interface: PersistenceManager
        Perform the rollback operation for the provided transaction on all Tx stores.
        Specified by:
        rollbackAllTxStores in interface PersistenceManager
        Parameters:
        transaction - the transactional context to be rolledback.
        predicate - should we rollback each store
      • writeBatchToAllNonTxStores

        public void writeBatchToAllNonTxStores​(java.lang.Iterable<MarshalledEntry> entries,
                                               java.util.function.Predicate<? super StoreConfiguration> predicate,
                                               long flags)
        Description copied from interface: PersistenceManager
        Write all entries to the underlying non-transactional stores as a single batch.
        Specified by:
        writeBatchToAllNonTxStores in interface PersistenceManager
        Parameters:
        entries - a List of MarshalledEntry to be written to the store.
        predicate - whether a given store should write the entry
        flags - Flags used during command invocation
      • deleteBatchFromAllNonTxStores

        public void deleteBatchFromAllNonTxStores​(java.lang.Iterable<java.lang.Object> keys,
                                                  java.util.function.Predicate<? super StoreConfiguration> predicate,
                                                  long flags)
        Description copied from interface: PersistenceManager
        Remove all entries from the underlying non-transactional stores as a single batch.
        Specified by:
        deleteBatchFromAllNonTxStores in interface PersistenceManager
        Parameters:
        keys - a List of Keys to be removed from the store.
        predicate - whether a given store should delete the entries
        flags - Flags used during command invocation
      • isAvailable

        public boolean isAvailable()
        Specified by:
        isAvailable in interface PersistenceManager
        Returns:
        true if all configured stores are available and ready for read/write operations.