Package org.infinispan.persistence.manager

Class PersistenceManagerImpl

java.lang.Object

org.infinispan.persistence.manager.PersistenceManagerImpl

All Implemented Interfaces:

org.infinispan.commons.api.Lifecycle, PersistenceManager

public class PersistenceManagerImpl
extends Object
implements PersistenceManager

Nested Class Summary

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

PersistenceManager.AccessMode, PersistenceManager.StoreChangeListener

Constructor Summary

Constructors

Constructor	Description
PersistenceManagerImpl()

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 storeConfiguration)	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.
<K, V> List<NonBlockingStore<K,V>>	getAllStores(Predicate<Set<NonBlockingStore.Characteristic>> predicate)
<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> ctx, TriPredicate<? super WriteCommand,Object,MVCCEntry<?,?>> commandKeyPredicate)	Writes a batch for the given modifications in the transactional context
protected CompletionStage<Void>	pollStoreAvailability()	Polls the availability of all configured stores.
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(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, 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, size, writeToAllNonTxStores

Constructor Details

PersistenceManagerImpl

public PersistenceManagerImpl()

Method Details

start

public void start()

Specified by:

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

pollStoreAvailability

protected CompletionStage<Void> pollStoreAvailability()

Polls the availability of all configured stores.

If a store is found to be unavailable all future requests to this manager will throw a StoreUnavailableException, until the stores are all available again.

Note that this method should not be called until the previous invocation's stage completed. NonBlockingManager.scheduleWithFixedDelay(java.util.function.Supplier, long, long, java.util.concurrent.TimeUnit) guarantees that.

Returns:

stage that completes when all store availability checks are done

stop

public void stop()

Specified by:

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

isEnabled

public boolean isEnabled()

Specified by:

isEnabled in interface PersistenceManager

isReadOnly

public boolean isReadOnly()

Specified by:

isReadOnly in interface PersistenceManager

Returns:

true if no CacheWriter instances have been configured.

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

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

addStore

public CompletionStage<Void> addStore(StoreConfiguration storeConfiguration)

Description copied from interface: PersistenceManager

Adds a new store to the cache.

Specified by:

addStore in interface PersistenceManager

Parameters:

storeConfiguration - the configuration for the store

disableStore

public CompletionStage<Void> disableStore(String storeType)

Description copied from interface: PersistenceManager

Marks the given storage as disabled.

Specified by:

disableStore 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(boolean fetchValue,
 boolean fetchMetadata)

Description copied from interface: PersistenceManager

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

Specified by:

publishEntries 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

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(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

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

Parameters:

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

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

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

performBatch

public CompletionStage<Long> performBatch(TxInvocationContext<AbstractCacheTransaction> ctx,
 TriPredicate<? super WriteCommand,Object,MVCCEntry<?,?>> commandKeyPredicate)

Description copied from interface: PersistenceManager

Writes a batch for the given modifications in the transactional context

Specified by:

performBatch in interface PersistenceManager

Parameters:

ctx - transactional context

commandKeyPredicate - predicate to control if a key/value/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.

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

getAllStores

public <K,
V> List<NonBlockingStore<K,V>> getAllStores(Predicate<Set<NonBlockingStore.Characteristic>> predicate)