org.infinispan.persistence.manager

Class PersistenceManagerImpl

java.lang.Object

org.infinispan.persistence.manager.PersistenceManagerImpl

All Implemented Interfaces:

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

Constructor Summary

Constructors

Constructor and Description
PersistenceManagerImpl()

Method Summary

Modifier and Type	Method and Description
CompletionStage<Boolean>	addSegments(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>	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	hasWriter() Returns whether the manager is enabled and has at least one store
boolean	isAvailable()
boolean	isEnabled()
boolean	isPreloaded()
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, BiPredicate<? super WriteCommand,Object> commandKeyPredicate) Writes a batch for the given modifications in the transactional context
protected CompletionStage<Void>	pollStoreAvailability() Polls the availability of all configured stores.
CompletionStage<Void>	preload() 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(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,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> org.reactivestreams.Publisher<K>	publishKeys(IntSet segments, Predicate<? super K> filter, Predicate<? super StoreConfiguration> predicate) Returns a publisher that will publish keys 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.
CompletionStage<Void>	purgeExpired() Removes the expired entries from all the existing storage.
CompletionStage<Boolean>	removeSegments(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.
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(IntSet segments) Returns the count of how many entries are persisted within the given segments.
CompletionStage<Long>	size(Predicate<? super StoreConfiguration> predicate) Returns the count of how many entries are persisted.
void	start() Invoked on component start
void	stop() Invoked on component 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, writeToAllNonTxStores

Constructor Detail

PersistenceManagerImpl

public PersistenceManagerImpl()

Method Detail

start

public void start()

Description copied from interface: Lifecycle

Invoked on component start

Specified by:

start in interface 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 encounter an StoreUnavailableException. Note that this method should only have one availability check running at a time. This is currently guaranteed as it is using a non overlapping scheduler.

Returns:

stage that signals that all store availability checks are done

stop

public void stop()

Description copied from interface: Lifecycle

Invoked on component stop

Specified by:

stop in interface 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

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

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

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

size

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

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

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,
                                          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:

ctx - 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.

addSegments

public CompletionStage<Boolean> addSegments(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(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)