org.infinispan.persistence.manager

Class PassivationPersistenceManager

java.lang.Object

org.infinispan.persistence.support.DelegatingPersistenceManager

org.infinispan.persistence.manager.PassivationPersistenceManager

All Implemented Interfaces:

Lifecycle, PersistenceManager

public class PassivationPersistenceManager
extends DelegatingPersistenceManager

Nested Class Summary

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

PersistenceManager.AccessMode

Field Summary

Fields inherited from class org.infinispan.persistence.support.DelegatingPersistenceManager

componentRegistry, persistenceManager

Constructor Summary

Constructors

Constructor and Description
PassivationPersistenceManager(PersistenceManager persistenceManager)

Method Summary

Modifier and Type	Method and Description
<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<Void>	passivate(MarshallableEntry marshallableEntry, int segment)
int	pendingPassivations()
<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<Long>	size(Predicate<? super StoreConfiguration> predicate) Returns the count of how many entries are persisted.

Methods inherited from class org.infinispan.persistence.support.DelegatingPersistenceManager

addSegments, clearAllStores, commitAllTxStores, deleteFromAllStores, disableStore, getActual, getStores, getStoresAsString, hasWriter, isAvailable, isEnabled, isPreloaded, isReadOnly, performBatch, preload, prepareAllTxStores, purgeExpired, removeSegments, rollbackAllTxStores, setClearOnStop, size, size, start, stop, writeEntries, writeMapCommand, writeToAllNonTxStores, writeToAllNonTxStores

Methods inherited from class java.lang.Object

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

Constructor Detail

PassivationPersistenceManager

public PassivationPersistenceManager(PersistenceManager persistenceManager)

Method Detail

passivate

public CompletionStage<Void> passivate(MarshallableEntry marshallableEntry,
                                       int segment)

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

Overrides:

loadFromAllStores in class DelegatingPersistenceManager

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

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

Overrides:

loadFromAllStores in class DelegatingPersistenceManager

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

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

Overrides:

publishKeys in class DelegatingPersistenceManager

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

Overrides:

publishKeys in class DelegatingPersistenceManager

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

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

Overrides:

publishEntries in class DelegatingPersistenceManager

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

Overrides:

publishEntries in class DelegatingPersistenceManager

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

Overrides:

publishEntries in class DelegatingPersistenceManager

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

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

Overrides:

size in class DelegatingPersistenceManager

Parameters:

predicate - whether a loader can be used

Returns:

size or -1 if size couldn't be computed

pendingPassivations

public int pendingPassivations()