org.infinispan.persistence.support

Class SingletonCacheWriter

java.lang.Object

org.infinispan.persistence.support.DelegatingCacheWriter

org.infinispan.persistence.support.SingletonCacheWriter

All Implemented Interfaces:

Lifecycle, CacheWriter

Direct Known Subclasses:

AdvancedSingletonCacheWriter

public class SingletonCacheWriter
extends DelegatingCacheWriter

SingletonStore is a delegating cache store used for situations when only one instance should interact with the underlying store. The coordinator of the cluster will be responsible for the underlying CacheStore.

SingletonStore is a simply facade to a real CacheStore implementation. It always delegates reads to the real CacheStore.

Writes are delegated only if this SingletonStore is currently the coordinator. This avoids having all stores in a cluster writing the same data to the same underlying store. Although not incorrect (e.g. a DB will just discard additional INSERTs for the same key, and throw an exception), this will avoid a lot of redundant work.

Whenever the current coordinator dies (or leaves), the second in line will take over. That SingletonStore will then pass writes through to its underlying CacheStore. Optionally, when a new coordinator takes over the Singleton, it can push the in-memory state to the cache cacheStore, within a time constraint.

Since:

6.0

Author:

Mircea Markus

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SingletonCacheWriter.PushStateException Exception representing any issues that arise from pushing the in-memory state to the cache loader.
class	SingletonCacheWriter.SingletonStoreListener Cache listener that reacts to cluster topology changes to find out whether a new coordinator is elected.

Field Summary

Fields

Modifier and Type	Field and Description
protected boolean	active Whether the the current cache is the coordinator and therefore SingletonStore is active.
protected ExecutorService	executor Executor service used to submit tasks to push in-memory state.

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

actual, ctx

Constructor Summary

Constructors

Constructor and Description
SingletonCacheWriter(CacheWriter actual, SingletonStoreConfiguration singletonConfiguration)

Method Summary

Modifier and Type	Method and Description
protected void	activeStatusChanged(boolean newActiveState) Method called when the cache either becomes the coordinator or stops being the coordinator.
protected void	awaitForPushToFinish(Future<?> future, long timeout, TimeUnit unit) Method that waits for the in-memory to cache loader state to finish.
protected Callable<?>	createPushStateTask()
boolean	delete(Object key)
protected void	pushState(Cache cache) Pushes the state of a specific cache by reading the cache's data and putting in the cache store.
void	start() Invoked on component start
void	stop() Invoked on component stop
String	toString()
void	write(MarshalledEntry entry) Persists the entry to the storage.

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

init, undelegate

Methods inherited from class java.lang.Object

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

Field Detail

executor

protected final ExecutorService executor

Executor service used to submit tasks to push in-memory state.

active

protected volatile boolean active

Whether the the current cache is the coordinator and therefore SingletonStore is active. Being active means delegating calls to the underlying cache loader.

Constructor Detail

SingletonCacheWriter

public SingletonCacheWriter(CacheWriter actual,
                            SingletonStoreConfiguration singletonConfiguration)

Method Detail

start

public void start()

Description copied from interface: Lifecycle

Invoked on component start

Specified by:

start in interface Lifecycle

Overrides:

start in class DelegatingCacheWriter

stop

public void stop()

Description copied from interface: Lifecycle

Invoked on component stop

Specified by:

stop in interface Lifecycle

Overrides:

stop in class DelegatingCacheWriter

write

public void write(MarshalledEntry entry)

Description copied from interface: CacheWriter

Persists the entry to the storage.

Specified by:

write in interface CacheWriter

Overrides:

write in class DelegatingCacheWriter

See Also:

MarshalledEntry

delete

public boolean delete(Object key)

Specified by:

delete in interface CacheWriter

Overrides:

delete in class DelegatingCacheWriter

Returns:

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

createPushStateTask

protected Callable<?> createPushStateTask()

pushState

protected void pushState(Cache cache)
                  throws Exception

Pushes the state of a specific cache by reading the cache's data and putting in the cache store.

Throws:

Exception

awaitForPushToFinish

protected void awaitForPushToFinish(Future<?> future,
                                    long timeout,
                                    TimeUnit unit)

Method that waits for the in-memory to cache loader state to finish. This method's called in case a push state is already in progress and we need to wait for it to finish.

activeStatusChanged

protected void activeStatusChanged(boolean newActiveState)
                            throws SingletonCacheWriter.PushStateException

Method called when the cache either becomes the coordinator or stops being the coordinator. If it becomes the coordinator, it can optionally start the in-memory state transfer to the underlying cache store.

Throws:

SingletonCacheWriter.PushStateException

toString

public String toString()

Overrides:

toString in class Object