Package org.infinispan.persistence.async

Class AsyncCacheWriter

java.lang.Object

org.infinispan.persistence.support.DelegatingCacheWriter

org.infinispan.persistence.async.AsyncCacheWriter

All Implemented Interfaces:

Lifecycle, CacheWriter

Direct Known Subclasses:

AdvancedAsyncCacheWriter

public class AsyncCacheWriter
extends DelegatingCacheWriter

The AsyncCacheWriter is a delegating CacheStore that buffers changes and writes them asynchronously to the underlying CacheStore.

Read operations are done synchronously, taking into account the current state of buffered changes.

There is no provision for exception handling for problems encountered with the underlying store during a write operation, and the exception is just logged.

When configuring the loader, use the following element:

<async enabled="true" />

to define whether cache loader operations are to be asynchronous. If not specified, a cache loader operation is assumed synchronous and this decorator is not applied.

Write operations affecting same key are now coalesced so that only the final state is actually stored.

Since:

4.0

Author:

Manik Surtani, Galder Zamarreño, Sanne Grinovero, Karsten Blees, Mircea Markus

Field Summary

Fields

Modifier and Type	Field	Description
protected AsyncStoreConfiguration	asyncConfiguration
protected java.util.concurrent.atomic.AtomicReference<State>	state
protected org.infinispan.persistence.async.BufferLock	stateLock

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

actual, ctx

Constructor Summary

Constructors

Constructor	Description
AsyncCacheWriter(CacheWriter delegate)

Method Summary

Modifier and Type	Method	Description
protected void	applyModificationsSync(java.util.List<Modification> mods)
java.util.concurrent.CompletionStage<java.lang.Void>	bulkUpdate(org.reactivestreams.Publisher publisher)	Persist all provided entries to the store in chunks, with the size of each chunk determined by the store implementation.
protected void	clearStore()
boolean	delete(java.lang.Object key)
void	deleteBatch(java.lang.Iterable keys)	Remove all provided keys from the store in a single batch operation.
java.util.concurrent.atomic.AtomicReference<State>	getState()
void	init(InitializationContext ctx)	Used to initialize a cache loader.
boolean	isAvailable()
protected State	newState(boolean clear, State next)
void	start()	Invoked on component start
void	stop()	Invoked on component stop
void	write(MarshallableEntry entry)	Persists the entry to the storage.

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

undelegate

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

write, writeBatch

Field Detail

stateLock

protected org.infinispan.persistence.async.BufferLock stateLock

state

protected final java.util.concurrent.atomic.AtomicReference<State> state

asyncConfiguration

protected AsyncStoreConfiguration asyncConfiguration

Constructor Detail

AsyncCacheWriter

public AsyncCacheWriter(CacheWriter delegate)

Method Detail

init

public void init(InitializationContext ctx)

Description copied from interface: CacheWriter

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

Specified by:

init in interface CacheWriter

Overrides:

init in class DelegatingCacheWriter

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

isAvailable

public boolean isAvailable()

Returns:

true if the writer can be connected to, otherwise false

write

public void write(MarshallableEntry 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:

MarshallableEntry

bulkUpdate

public java.util.concurrent.CompletionStage<java.lang.Void> bulkUpdate(org.reactivestreams.Publisher publisher)

Description copied from interface: CacheWriter

Persist all provided entries to the store in chunks, with the size of each chunk determined by the store implementation. If chunking is not supported by the underlying store, then entries are written to the store individually via CacheWriter.write(MarshallableEntry).

Parameters:

publisher - a Publisher of MarshallableEntry instances

deleteBatch

public void deleteBatch(java.lang.Iterable keys)

Description copied from interface: CacheWriter

Remove all provided keys from the store in a single batch operation. If this is not supported by the underlying store, then keys are removed from the store individually via CacheWriter.delete(Object).

Parameters:

keys - an Iterable of entry Keys to be removed from the store.

delete

public boolean delete(java.lang.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.

applyModificationsSync

protected void applyModificationsSync(java.util.List<Modification> mods)
                               throws PersistenceException

Throws:

PersistenceException

newState

protected State newState(boolean clear,
                         State next)

getState

public java.util.concurrent.atomic.AtomicReference<State> getState()

clearStore

protected void clearStore()