Package org.infinispan.persistence.manager

Interface PersistenceManager

All Superinterfaces:
org.infinispan.commons.api.Lifecycle
All Known Implementing Classes:
DelegatingPersistenceManager, PassivationPersistenceManager, PersistenceManagerImpl
public interface PersistenceManager extends org.infinispan.commons.api.Lifecycle
Defines the logic for interacting with the chain of external storage.
Since:
4.0
Author:
Manik Surtani, Mircea Markus

  • Method Details

    • isEnabled

      boolean isEnabled()

    • hasWriter

      boolean hasWriter()
      Returns whether the manager is enabled and has at least one store

    • hasStore

      boolean hasStore(Predicate<StoreConfiguration> test)

    • preloadPublisher

      io.reactivex.rxjava3.core.Flowable<MarshallableEntry<Object,Object>> preloadPublisher()
      Loads the data from the external store into memory during cache startup.

    • disableStore

      CompletionStage<Void> disableStore(String storeType)
      Marks the given storage as disabled.

    • addStore

      CompletionStage<Void> addStore(StoreConfiguration storeConfiguration)
      Adds a new store to the cache.
      Parameters:
      storeConfiguration - the configuration for the store
      Throws:
      org.infinispan.commons.CacheException - if the cache is was not empty

    • addStoreListener

      void addStoreListener(PersistenceManager.StoreChangeListener listener)
      Add a PersistenceManager.StoreChangeListener to be notified when a store is added or removed dynamically.

    • removeStoreListener

      void removeStoreListener(PersistenceManager.StoreChangeListener listener)
      Remote a registered PersistenceManager.StoreChangeListener

    • getStores

      <T> Set<T> getStores(Class<T> storeClass)

    • getStoresAsString

      Collection<String> getStoresAsString()

    • purgeExpired

      CompletionStage<Void> purgeExpired()
      Removes the expired entries from all the existing storage.

    • clearAllStores

      CompletionStage<Void> clearAllStores(Predicate<? super StoreConfiguration> predicate)
      Invokes AdvancedCacheWriter.clear() on all the stores that aloes it.

    • deleteFromAllStores

      CompletionStage<Boolean> deleteFromAllStores(Object key, int segment, Predicate<? super StoreConfiguration> predicate)

    • publishEntries

      default <K, V> org.reactivestreams.Publisher<MarshallableEntry<K,V>> publishEntries(boolean fetchValue, boolean fetchMetadata)
      See publishEntries(Predicate, boolean, boolean, Predicate)

    • publishEntries

      <K, V> org.reactivestreams.Publisher<MarshallableEntry<K,V>> publishEntries(Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata, Predicate<? super StoreConfiguration> predicate)
      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.

      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

      <K, V> org.reactivestreams.Publisher<MarshallableEntry<K,V>> publishEntries(org.infinispan.commons.util.IntSet segments, Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata, Predicate<? super StoreConfiguration> predicate)
      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.
      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

      <K> org.reactivestreams.Publisher<K> publishKeys(Predicate<? super K> filter, Predicate<? super StoreConfiguration> predicate)
      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 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

      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

      <K> org.reactivestreams.Publisher<K> publishKeys(org.infinispan.commons.util.IntSet segments, Predicate<? super K> filter, Predicate<? super StoreConfiguration> predicate)
      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 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

      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

      <K, V> CompletionStage<MarshallableEntry<K,V>> loadFromAllStores(Object key, boolean localInvocation, boolean includeStores)
      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.
      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

      default <K, V> CompletionStage<MarshallableEntry<K,V>> loadFromAllStores(Object key, int segment, boolean localInvocation, boolean includeStores)
      Same as loadFromAllStores(Object, boolean, boolean) except that the segment of the key is also provided to avoid having to calculate the segment.
      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

    • approximateSize

      CompletionStage<Long> approximateSize(Predicate<? super StoreConfiguration> predicate, org.infinispan.commons.util.IntSet segments)
      Returns an approximate count of how many entries are persisted in the given segments. If no store can handle the request for the given mode, a value of -1 is returned instead.
      Parameters:
      predicate - whether a loader can be used
      segments - the segments to include
      Returns:
      size or -1 if approximate size couldn't be computed

    • size

      default CompletionStage<Long> size()

    • size

      default CompletionStage<Long> size(org.infinispan.commons.util.IntSet segments)

    • size

      CompletionStage<Long> size(Predicate<? super StoreConfiguration> predicate, org.infinispan.commons.util.IntSet segments)
      Returns the count of how many entries are persisted in the given segments. If no store can handle the request for the given mode a value of -1 is returned instead.
      Parameters:
      predicate - whether a loader can be used
      segments - segments to check
      Returns:
      size or -1 if size couldn't be computed

    • size

      CompletionStage<Long> size(Predicate<? super StoreConfiguration> predicate)
      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.
      Parameters:
      predicate - whether a loader can be used
      Returns:
      size or -1 if size couldn't be computed

    • setClearOnStop

      void setClearOnStop(boolean clearOnStop)

    • writeToAllNonTxStores

      default CompletionStage<Void> writeToAllNonTxStores(MarshallableEntry marshalledEntry, int segment, Predicate<? super StoreConfiguration> predicate)
      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

      Parameters:
      marshalledEntry - the entry to be written to all non-tx stores.
      segment - the segment the entry maps to
      predicate - should we write to a given store

    • writeToAllNonTxStores

      CompletionStage<Void> writeToAllNonTxStores(MarshallableEntry marshalledEntry, int segment, Predicate<? super StoreConfiguration> predicate, long flags)
      Parameters:
      flags - Flags used during command invocation
      See Also:

    • prepareAllTxStores

      CompletionStage<Void> prepareAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext, Predicate<? super StoreConfiguration> predicate) throws PersistenceException
      Perform the prepare phase of 2PC on all Tx stores.
      Parameters:
      txInvocationContext - the tx invocation containing the modifications
      predicate - should we prepare on a given store
      Throws:
      PersistenceException - if an error is encountered at any of the underlying stores.

    • commitAllTxStores

      CompletionStage<Void> commitAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext, Predicate<? super StoreConfiguration> predicate)
      Perform the commit operation for the provided transaction on all Tx stores.
      Parameters:
      txInvocationContext - the transactional context to be committed.
      predicate - should we commit each store

    • rollbackAllTxStores

      CompletionStage<Void> rollbackAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext, Predicate<? super StoreConfiguration> predicate)
      Perform the rollback operation for the provided transaction on all Tx stores.
      Parameters:
      txInvocationContext - the transactional context to be rolledback.
      predicate - should we rollback each store

    • writeMapCommand

      CompletionStage<Long> writeMapCommand(PutMapCommand putMapCommand, InvocationContext ctx, BiPredicate<? super PutMapCommand,Object> commandKeyPredicate)
      Writes the values modified from a put map command to the stores.
      Parameters:
      putMapCommand - the put map command to write values from
      ctx - context to lookup entries
      commandKeyPredicate - predicate to control if a key/command combination should be accepted
      Returns:
      a stage of how many writes were performed

    • performBatch

      CompletionStage<Long> performBatch(TxInvocationContext<AbstractCacheTransaction> invocationContext, BiPredicate<? super WriteCommand,Object> commandKeyPredicate)
      Writes a batch for the given modifications in the transactional context
      Parameters:
      invocationContext - transactional context
      commandKeyPredicate - predicate to control if a key/command combination should be accepted
      Returns:
      a stage of how many writes were performed

    • writeEntries

      <K, V> CompletionStage<Void> writeEntries(Iterable<MarshallableEntry<K,V>> iterable, Predicate<? super StoreConfiguration> predicate)
      Writes the entries to the stores that pass the given predicate
      Type Parameters:
      K - key type
      V - value type
      Parameters:
      iterable - entries to write
      predicate - predicate to test for a store
      Returns:
      a stage that when complete the values were written

    • isAvailable

      boolean isAvailable()
      Returns:
      true if all configured stores are available and ready for read/write operations.

    • addSegments

      default CompletionStage<Boolean> addSegments(org.infinispan.commons.util.IntSet segments)
      Notifies any underlying segmented stores that the segments provided are owned by this cache and to start/configure any underlying resources required to handle requests for entries on the given segments.

      This only affects stores that are not shared as shared stores have to keep all segments running at all times

      This method returns true if all stores were able to handle the added segments. That is that either there are no stores or that all the configured stores are segmented. Note that configured loaders do not affect the return value.

      Parameters:
      segments - segments this cache owns
      Returns:
      false if a configured store couldn't configure newly added segments

    • removeSegments

      default CompletionStage<Boolean> removeSegments(org.infinispan.commons.util.IntSet segments)
      Notifies any underlying segmented stores that a given segment is no longer owned by this cache and allowing it to remove the given segments and release resources related to it.

      This only affects stores that are not shared as shared stores have to keep all segments running at all times

      This method returns true if all stores were able to handle the removed segments. That is that either there are no stores or that all the configured stores are segmented. Note that configured loaders do not affect the return value.

      Parameters:
      segments - segments this cache no longer owns
      Returns:
      false if a configured store couldn't remove configured segments

    • isReadOnly

      boolean isReadOnly()
      Returns:
      true if no CacheWriter instances have been configured.