org.infinispan.persistence.remote

Class RemoteStore<K,V>

java.lang.Object

org.infinispan.persistence.remote.RemoteStore<K,V>

All Implemented Interfaces:

Lifecycle, AdvancedCacheLoader<K,V>, AdvancedCacheWriter<K,V>, AdvancedLoadWriteStore<K,V>, CacheLoader<K,V>, CacheWriter<K,V>, ExternalStore<K,V>, FlagAffectedStore<K,V>

@ThreadSafe
public class RemoteStore<K,V>
extends Object
implements AdvancedLoadWriteStore<K,V>, FlagAffectedStore<K,V>

Cache store that delegates the call to a infinispan cluster. Communication between this cache store and the remote cluster is achieved through the java HotRod client: this assures fault tolerance and smart dispatching of calls to the nodes that have the highest chance of containing the given key. This cache store supports both preloading and fetchPersistentState.

Purging elements is not possible, as HotRod does not support the fetching of all remote keys (this would be a very costly operation as well). Purging takes place at the remote end (infinispan cluster).

Since:

4.1

Author:

Mircea.Markus@jboss.com

See Also:

RemoteStoreConfiguration, Hotrod Java Client

Nested Class Summary

Nested classes/interfaces inherited from interface org.infinispan.persistence.spi.AdvancedCacheLoader

AdvancedCacheLoader.CacheLoaderTask<K,V>, AdvancedCacheLoader.TaskContext

Nested classes/interfaces inherited from interface org.infinispan.persistence.spi.AdvancedCacheWriter

AdvancedCacheWriter.PurgeListener<K>

Field Summary

Fields

Modifier and Type	Field and Description
protected InitializationContext	ctx

Constructor Summary

Constructors

Constructor and Description
RemoteStore()

Method Summary

Modifier and Type	Method and Description
void	clear() Removes all the data from the storage.
boolean	contains(Object key) Returns true if the storage contains an entry associated with the given key.
boolean	delete(Object key)
RemoteStoreConfiguration	getConfiguration()
RemoteCache<Object,Object>	getRemoteCache()
void	init(InitializationContext ctx) Used to initialize a cache loader.
boolean	isAvailable()
MarshalledEntry<K,V>	load(Object key) Fetches an entry from the storage.
org.reactivestreams.Publisher<MarshalledEntry<K,V>>	publishEntries(Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata) Publishes all entries from this store.
io.reactivex.Flowable<K>	publishKeys(Predicate<? super K> filter) Publishes all the keys from this store.
void	purge(Executor threadPool, AdvancedCacheWriter.PurgeListener task) Using the thread in the pool, removed all the expired data from the persistence storage.
void	setInternalCacheEntryFactory(InternalEntryFactory iceFactory)
boolean	shouldWrite(long commandFlags)
int	size() Returns the number of elements in the store.
void	start() Invoked on component start
void	stop() Invoked on component stop
void	write(MarshalledEntry entry) Persists the entry to the storage.
void	writeBatch(Iterable<MarshalledEntry<? extends K,? extends V>> marshalledEntries) Persist all provided entries to the store in a single batch update.

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.spi.AdvancedCacheLoader

process

Methods inherited from interface org.infinispan.persistence.spi.CacheWriter

deleteBatch

Field Detail

ctx

protected InitializationContext ctx

Constructor Detail

RemoteStore

public RemoteStore()

Method Detail

init

public void init(InitializationContext ctx)

Description copied from interface: CacheLoader

Used to initialize a cache loader. Typically invoked by the PersistenceManager when setting up cache loaders.

Specified by:

init in interface CacheLoader<K,V>

Specified by:

init in interface CacheWriter<K,V>

start

public void start()
           throws PersistenceException

Description copied from interface: Lifecycle

Invoked on component start

Specified by:

start in interface Lifecycle

Throws:

PersistenceException

stop

public void stop()
          throws PersistenceException

Description copied from interface: Lifecycle

Invoked on component stop

Specified by:

stop in interface Lifecycle

Throws:

PersistenceException

isAvailable

public boolean isAvailable()

Specified by:

isAvailable in interface CacheLoader<K,V>

Specified by:

isAvailable in interface CacheWriter<K,V>

Specified by:

isAvailable in interface ExternalStore<K,V>

Returns:

true if the writer can be connected to, otherwise false

load

public MarshalledEntry<K,V> load(Object key)
                          throws PersistenceException

Description copied from interface: CacheLoader

Fetches an entry from the storage. If a MarshalledEntry needs to be created here, InitializationContext.getMarshalledEntryFactory() and InitializationContext.getByteBufferFactory() should be used.

Specified by:

load in interface CacheLoader<K,V>

Returns:

the entry, or null if the entry does not exist

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

contains

public boolean contains(Object key)
                 throws PersistenceException

Description copied from interface: CacheLoader

Returns true if the storage contains an entry associated with the given key.

Specified by:

contains in interface CacheLoader<K,V>

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

publishKeys

public io.reactivex.Flowable<K> publishKeys(Predicate<? super K> filter)

Description copied from interface: AdvancedCacheLoader

Publishes all the keys from this store. The given publisher can be used by as many Subscribers as desired. Keys are not retrieved until a given Subscriber requests them from the Subscription.

Stores will return only non expired keys

Specified by:

publishKeys in interface AdvancedCacheLoader<K,V>

Parameters:

filter - a filter

Returns:

a publisher that will provide the keys from the store

publishEntries

public org.reactivestreams.Publisher<MarshalledEntry<K,V>> publishEntries(Predicate<? super K> filter,
                                                                          boolean fetchValue,
                                                                          boolean fetchMetadata)

Description copied from interface: AdvancedCacheLoader

Publishes all entries from this store. The given publisher can be used by as many Subscribers as desired. Entries are not retrieved until a given Subscriber requests them from the Subscription.

If fetchMetadata is true this store must guarantee to not return any expired entries.

Specified by:

publishEntries in interface AdvancedCacheLoader<K,V>

Returns:

size

public int size()

Description copied from interface: AdvancedCacheLoader

Returns the number of elements in the store.

Specified by:

size in interface AdvancedCacheLoader<K,V>

purge

public void purge(Executor threadPool,
                  AdvancedCacheWriter.PurgeListener task)

Description copied from interface: AdvancedCacheWriter

Using the thread in the pool, removed all the expired data from the persistence storage. For each removed entry, the supplied listener is invoked.

When this method returns all entries will be purged and no tasks will be running due to this loader in the provided executor. If however an exception is thrown there could be tasks still pending or running in the executor.

Specified by:

purge in interface AdvancedCacheWriter<K,V>

write

public void write(MarshalledEntry entry)
           throws PersistenceException

Description copied from interface: CacheWriter

Persists the entry to the storage.

Specified by:

write in interface CacheWriter<K,V>

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

See Also:

MarshalledEntry

writeBatch

public void writeBatch(Iterable<MarshalledEntry<? extends K,? extends V>> marshalledEntries)

Description copied from interface: CacheWriter

Persist all provided entries to the store in a single batch update. If this is not supported by the underlying store, then entries are written to the store individually via CacheWriter.write(MarshalledEntry).

Specified by:

writeBatch in interface CacheWriter<K,V>

Parameters:

marshalledEntries - an Iterable of MarshalledEntry to be written to the store.

clear

public void clear()
           throws PersistenceException

Description copied from interface: AdvancedCacheWriter

Removes all the data from the storage.

Specified by:

clear in interface AdvancedCacheWriter<K,V>

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

delete

public boolean delete(Object key)
               throws PersistenceException

Specified by:

delete in interface CacheWriter<K,V>

Returns:

true if the entry existed in the persistent store and it was deleted.

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

setInternalCacheEntryFactory

public void setInternalCacheEntryFactory(InternalEntryFactory iceFactory)

getRemoteCache

public RemoteCache<Object,Object> getRemoteCache()

getConfiguration

public RemoteStoreConfiguration getConfiguration()

shouldWrite

public boolean shouldWrite(long commandFlags)

Specified by:

shouldWrite in interface FlagAffectedStore<K,V>