Package org.infinispan.persistence.support

Class DelegatingPersistenceManager

java.lang.Object

org.infinispan.persistence.support.DelegatingPersistenceManager

All Implemented Interfaces:

org.infinispan.commons.api.Lifecycle, PersistenceManager

Direct Known Subclasses:

PassivationPersistenceManager

public class DelegatingPersistenceManager
extends Object
implements PersistenceManager, org.infinispan.commons.api.Lifecycle

Nested Class Summary

Nested classes/interfaces inherited from interface org.infinispan.persistence.manager.PersistenceManager

PersistenceManager.AccessMode, PersistenceManager.StoreChangeListener

Field Summary

Fields

Modifier and Type	Field	Description
protected final PersistenceManager	persistenceManager

Constructor Summary

Constructors

Constructor	Description
DelegatingPersistenceManager(PersistenceManager persistenceManager)

Method Summary

Modifier and Type	Method	Description
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.
CompletionStage<Void>	addStore(StoreConfiguration persistenceConfiguration)	Adds a new store to the cache.
void	addStoreListener(PersistenceManager.StoreChangeListener listener)	Add a PersistenceManager.StoreChangeListener to be notified when a store is added or removed dynamically.
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.
CompletionStage<Void>	clearAllStores(Predicate<? super StoreConfiguration> predicate)	Invokes AdvancedCacheWriter.clear() on all the stores that aloes it.
CompletionStage<Void>	commitAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext, Predicate<? super StoreConfiguration> predicate)	Perform the commit operation for the provided transaction on all Tx stores.
CompletionStage<Boolean>	deleteFromAllStores(Object key, int segment, Predicate<? super StoreConfiguration> predicate)
CompletionStage<Void>	disableStore(String storeType)	Marks the given storage as disabled.
PersistenceManager	getActual()
<T> Set<T>	getStores(Class<T> storeClass)
Collection<String>	getStoresAsString()
boolean	hasStore(Predicate<StoreConfiguration> test)
boolean	hasWriter()	Returns whether the manager is enabled and has at least one store
boolean	isAvailable()
boolean	isEnabled()
boolean	isReadOnly()
<K, V> CompletionStage<MarshallableEntry<K,V>>	loadFromAllStores(Object key, boolean localInvocation, boolean includeStores)	Loads an entry from the persistence store for the given key.
<K, V> CompletionStage<MarshallableEntry<K,V>>	loadFromAllStores(Object key, int segment, boolean localInvocation, boolean includeStores)	Same as PersistenceManager.loadFromAllStores(Object, boolean, boolean) except that the segment of the key is also provided to avoid having to calculate the segment.
CompletionStage<Long>	performBatch(TxInvocationContext<AbstractCacheTransaction> invocationContext, BiPredicate<? super WriteCommand,Object> commandKeyPredicate)	Writes a batch for the given modifications in the transactional context
io.reactivex.rxjava3.core.Flowable<MarshallableEntry<Object,Object>>	preloadPublisher()	Loads the data from the external store into memory during cache startup.
CompletionStage<Void>	prepareAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext, Predicate<? super StoreConfiguration> predicate)	Perform the prepare phase of 2PC on all Tx stores.
<K, V> org.reactivestreams.Publisher<MarshallableEntry<K,V>>	publishEntries(boolean fetchValue, boolean fetchMetadata)	See PersistenceManager.publishEntries(Predicate, boolean, boolean, Predicate)
<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.
<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.
<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.
<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.
CompletionStage<Void>	purgeExpired()	Removes the expired entries from all the existing storage.
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.
void	removeStoreListener(PersistenceManager.StoreChangeListener listener)	Remote a registered PersistenceManager.StoreChangeListener
CompletionStage<Void>	rollbackAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext, Predicate<? super StoreConfiguration> predicate)	Perform the rollback operation for the provided transaction on all Tx stores.
void	setClearOnStop(boolean clearOnStop)
CompletionStage<Long>	size()
CompletionStage<Long>	size(Predicate<? super StoreConfiguration> predicate)	Returns the count of how many entries are persisted.
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.
void	start()
void	stop()
<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
CompletionStage<Long>	writeMapCommand(PutMapCommand putMapCommand, InvocationContext ctx, BiPredicate<? super PutMapCommand,Object> commandKeyPredicate)	Writes the values modified from a put map command to the stores.
CompletionStage<Void>	writeToAllNonTxStores(MarshallableEntry marshalledEntry, int segment, Predicate<? super StoreConfiguration> predicate)	Write to all stores that are not transactional.
CompletionStage<Void>	writeToAllNonTxStores(MarshallableEntry marshalledEntry, int segment, Predicate<? super StoreConfiguration> predicate, long flags)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.infinispan.persistence.manager.PersistenceManager

size

Field Details

persistenceManager

protected final PersistenceManager persistenceManager

Constructor Details

DelegatingPersistenceManager

public DelegatingPersistenceManager(PersistenceManager persistenceManager)

Method Details

start

public void start()

Specified by:

start in interface org.infinispan.commons.api.Lifecycle

stop

public void stop()

Specified by:

stop in interface org.infinispan.commons.api.Lifecycle

getActual

public PersistenceManager getActual()

isEnabled

public boolean isEnabled()

Specified by:

isEnabled in interface PersistenceManager

hasWriter

public boolean hasWriter()

Description copied from interface: PersistenceManager

Returns whether the manager is enabled and has at least one store

Specified by:

hasWriter in interface PersistenceManager

hasStore

public boolean hasStore(Predicate<StoreConfiguration> test)

Specified by:

hasStore in interface PersistenceManager

preloadPublisher

public io.reactivex.rxjava3.core.Flowable<MarshallableEntry<Object,Object>> preloadPublisher()

Description copied from interface: PersistenceManager

Loads the data from the external store into memory during cache startup.

Specified by:

preloadPublisher in interface PersistenceManager

disableStore

public CompletionStage<Void> disableStore(String storeType)

Description copied from interface: PersistenceManager

Marks the given storage as disabled.

Specified by:

disableStore in interface PersistenceManager

addStore

public CompletionStage<Void> addStore(StoreConfiguration persistenceConfiguration)

Description copied from interface: PersistenceManager

Adds a new store to the cache.

Specified by:

addStore in interface PersistenceManager

Parameters:

persistenceConfiguration - the configuration for the store

addStoreListener

public void addStoreListener(PersistenceManager.StoreChangeListener listener)

Description copied from interface: PersistenceManager

Add a PersistenceManager.StoreChangeListener to be notified when a store is added or removed dynamically.

Specified by:

addStoreListener in interface PersistenceManager

removeStoreListener

public void removeStoreListener(PersistenceManager.StoreChangeListener listener)

Description copied from interface: PersistenceManager

Remote a registered PersistenceManager.StoreChangeListener

Specified by:

removeStoreListener in interface PersistenceManager

getStores

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

Specified by:

getStores in interface PersistenceManager

getStoresAsString

public Collection<String> getStoresAsString()

Specified by:

getStoresAsString in interface PersistenceManager

purgeExpired

public CompletionStage<Void> purgeExpired()

Description copied from interface: PersistenceManager

Removes the expired entries from all the existing storage.

Specified by:

purgeExpired in interface PersistenceManager

clearAllStores

public CompletionStage<Void> clearAllStores(Predicate<? super StoreConfiguration> predicate)

Description copied from interface: PersistenceManager

Invokes AdvancedCacheWriter.clear() on all the stores that aloes it.

Specified by:

clearAllStores in interface PersistenceManager

deleteFromAllStores

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

Specified by:

deleteFromAllStores in interface PersistenceManager

publishEntries

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

size

public CompletionStage<Long> size(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

setClearOnStop

public void setClearOnStop(boolean clearOnStop)

Specified by:

setClearOnStop in interface PersistenceManager

writeToAllNonTxStores

public CompletionStage<Void> writeToAllNonTxStores(MarshallableEntry marshalledEntry,
 int segment,
 Predicate<? super StoreConfiguration> predicate,
 long flags)

Specified by:

writeToAllNonTxStores in interface PersistenceManager

flags - Flags used during command invocation

See Also:

• PersistenceManager.writeToAllNonTxStores(MarshallableEntry, int, Predicate)

prepareAllTxStores

public CompletionStage<Void> prepareAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext,
 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:

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

public CompletionStage<Void> commitAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext,
 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:

txInvocationContext - the transactional context to be committed.

predicate - should we commit each store

rollbackAllTxStores

public CompletionStage<Void> rollbackAllTxStores(TxInvocationContext<AbstractCacheTransaction> txInvocationContext,
 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:

txInvocationContext - the transactional context to be rolledback.

predicate - should we rollback each store

writeMapCommand

public CompletionStage<Long> writeMapCommand(PutMapCommand putMapCommand,
 InvocationContext ctx,
 BiPredicate<? super PutMapCommand,Object> commandKeyPredicate)

Description copied from interface: PersistenceManager

Writes the values modified from a put map command to the stores.

Specified by:

writeMapCommand in interface PersistenceManager

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

writeEntries

public <K,
V> CompletionStage<Void> writeEntries(Iterable<MarshallableEntry<K,V>> iterable,
 Predicate<? super StoreConfiguration> predicate)

Description copied from interface: PersistenceManager

Writes the entries to the stores that pass the given predicate

Specified by:

writeEntries in interface PersistenceManager

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

performBatch

public CompletionStage<Long> performBatch(TxInvocationContext<AbstractCacheTransaction> invocationContext,
 BiPredicate<? super WriteCommand,Object> commandKeyPredicate)

Description copied from interface: PersistenceManager

Writes a batch for the given modifications in the transactional context

Specified by:

performBatch in interface PersistenceManager

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

isAvailable

public boolean isAvailable()

Specified by:

isAvailable in interface PersistenceManager

Returns:

true if all configured stores are available and ready for read/write operations.

isReadOnly

public boolean isReadOnly()

Specified by:

isReadOnly in interface PersistenceManager

Returns:

true if no CacheWriter instances have been configured.

publishEntries

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

Description copied from interface: PersistenceManager

See PersistenceManager.publishEntries(Predicate, boolean, boolean, Predicate)

Specified by:

publishEntries in interface PersistenceManager

loadFromAllStores

public <K,
V>
CompletionStage<MarshallableEntry<K,V>> loadFromAllStores(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

approximateSize

public CompletionStage<Long> approximateSize(Predicate<? super StoreConfiguration> predicate,
 org.infinispan.commons.util.IntSet segments)

Description copied from interface: PersistenceManager

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.

Specified by:

approximateSize in interface PersistenceManager

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

public CompletionStage<Long> size()

Specified by:

size in interface PersistenceManager

size

public CompletionStage<Long> size(Predicate<? super StoreConfiguration> predicate,
 org.infinispan.commons.util.IntSet segments)

Description copied from interface: PersistenceManager

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.

Specified by:

size in interface PersistenceManager

Parameters:

predicate - whether a loader can be used

segments - segments to check

Returns:

size or -1 if size couldn't be computed

writeToAllNonTxStores

public CompletionStage<Void> writeToAllNonTxStores(MarshallableEntry marshalledEntry,
 int segment,
 Predicate<? super StoreConfiguration> predicate)

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

predicate - should we write to a given store

addSegments

public CompletionStage<Boolean> addSegments(org.infinispan.commons.util.IntSet segments)

Description copied from interface: PersistenceManager

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.

Specified by:

addSegments in interface PersistenceManager

Parameters:

segments - segments this cache owns

Returns:

false if a configured store couldn't configure newly added segments

removeSegments

public CompletionStage<Boolean> removeSegments(org.infinispan.commons.util.IntSet segments)

Description copied from interface: PersistenceManager

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.

Specified by:

removeSegments in interface PersistenceManager

Parameters:

segments - segments this cache no longer owns

Returns:

false if a configured store couldn't remove configured segments