org.infinispan.loaders.decorators

Class AsyncStore

java.lang.Object

org.infinispan.loaders.decorators.AbstractDelegatingStore

org.infinispan.loaders.decorators.AsyncStore

All Implemented Interfaces:

CacheLoader, CacheStore

public class AsyncStore
extends AbstractDelegatingStore

The AsyncStore is a delegating CacheStore that extends AbstractDelegatingStore, overriding methods to that should not just delegate the operation to the underlying store.

Read operations are done synchronously, while write operations are done asynchronously. 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

Field Summary

Fields

Modifier and Type	Field and Description
boolean	lastAsyncProcessorShutsDownExecutor
protected ConcurrentMap<Object,Modification>	state

Constructor Summary

Constructors

Constructor and Description
AsyncStore(CacheStore delegate, AsyncStoreConfig asyncStoreConfig)

Method Summary

Methods

Modifier and Type	Method and Description
protected boolean	applyClear()
protected void	applyModificationsSync(ConcurrentMap<Object,Modification> mods)
void	clear() Clears all entries in the store
void	commit(GlobalTransaction tx) Commits a transaction that has been previously prepared.
protected void	delegatePurgeExpired()
protected void	enqueueModificationsList(List<? extends Modification> mods)
void	init(CacheLoaderConfig config, Cache<?,?> cache, StreamingMarshaller m) Used to initialize a cache loader.
void	prepare(List<? extends Modification> mods, GlobalTransaction tx, boolean isOnePhase) Issues a prepare call with a set of modifications to be applied to the cache store
boolean	remove(Object key) Removes an entry in the store.
void	rollback(GlobalTransaction tx) Rolls back a transaction that has been previously prepared This method may be invoked on a transaction for which there is no prior CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean).
void	start()
void	stop()
void	store(InternalCacheEntry ed) Stores an entry

Methods inherited from class org.infinispan.loaders.decorators.AbstractDelegatingStore

containsKey, fromStream, getCacheStoreConfig, getConfigurationClass, getDelegate, load, load, loadAll, loadAllKeys, purgeExpired, removeAll, setDelegate, toStream

Methods inherited from class java.lang.Object

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

Field Detail

state

protected ConcurrentMap<Object,Modification> state

lastAsyncProcessorShutsDownExecutor

public volatile boolean lastAsyncProcessorShutsDownExecutor

Constructor Detail

AsyncStore

public AsyncStore(CacheStore delegate,
          AsyncStoreConfig asyncStoreConfig)

Method Detail

init

public void init(CacheLoaderConfig config,
        Cache<?,?> cache,
        StreamingMarshaller m)
          throws CacheLoaderException

Description copied from interface: CacheLoader

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

Specified by:

init in interface CacheLoader

Overrides:

init in class AbstractDelegatingStore

Parameters:

config - the cache loader configuration bean

cache - cache associated with this cache loader. Implementations may use this to determine cache name when selecting where refer to state in storage, for example, a different database table name.

m - marshaller to use when loading state from a stream, if supported by the implementation.

Throws:

CacheLoaderException

store

public void store(InternalCacheEntry ed)

Description copied from interface: CacheStore

Stores an entry

Specified by:

store in interface CacheStore

Overrides:

store in class AbstractDelegatingStore

Parameters:

ed - entry to store

remove

public boolean remove(Object key)

Description copied from interface: CacheStore

Removes an entry in the store.

Specified by:

remove in interface CacheStore

Overrides:

remove in class AbstractDelegatingStore

Parameters:

key - key to remove

Returns:

true if the entry was removed; false if the entry wasn't found.

clear

public void clear()

Description copied from interface: CacheStore

Clears all entries in the store

Specified by:

clear in interface CacheStore

Overrides:

clear in class AbstractDelegatingStore

prepare

public void prepare(List<? extends Modification> mods,
           GlobalTransaction tx,
           boolean isOnePhase)
             throws CacheLoaderException

Description copied from interface: CacheStore

Issues a prepare call with a set of modifications to be applied to the cache store

Specified by:

prepare in interface CacheStore

Overrides:

prepare in class AbstractDelegatingStore

Parameters:

mods - modifications to be applied

tx - transaction identifier

isOnePhase - if true, there will not be a commit or rollback phase and changes should be flushed immediately

Throws:

CacheLoaderException - in the event of problems writing to the store

rollback

public void rollback(GlobalTransaction tx)

Description copied from interface: CacheStore

Rolls back a transaction that has been previously prepared

This method may be invoked on a transaction for which there is no prior CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean). The implementation would need to deal with this case accordingly. Typically, this would be a no-op, after ensuring any resources attached to the transaction are cleared up.

Also note that this method may be invoked on a thread which is different from the CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean) invocation. As such, ThreadLocals should not be relied upon to maintain transaction context.

Specified by:

rollback in interface CacheStore

Overrides:

rollback in class AbstractDelegatingStore

Parameters:

tx - tx to roll back

commit

public void commit(GlobalTransaction tx)
            throws CacheLoaderException

Description copied from interface: CacheStore

Commits a transaction that has been previously prepared.

This method may be invoked on a transaction for which there is no prior CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean). The implementation would need to deal with this case accordingly. Typically, this would be a no-op, after ensuring any resources attached to the transaction are cleared up.

Also note that this method may be invoked on a thread which is different from the CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean) invocation. As such, ThreadLocals should not be relied upon to maintain transaction context.

Specified by:

commit in interface CacheStore

Overrides:

commit in class AbstractDelegatingStore

Parameters:

tx - tx to commit

Throws:

CacheLoaderException - in the event of problems writing to the store

enqueueModificationsList

protected void enqueueModificationsList(List<? extends Modification> mods)

start

public void start()
           throws CacheLoaderException

Specified by:

start in interface CacheLoader

Overrides:

start in class AbstractDelegatingStore

Throws:

CacheLoaderException

stop

public void stop()
          throws CacheLoaderException

Specified by:

stop in interface CacheLoader

Overrides:

stop in class AbstractDelegatingStore

Throws:

CacheLoaderException

applyModificationsSync

protected void applyModificationsSync(ConcurrentMap<Object,Modification> mods)
                               throws CacheLoaderException

Throws:

CacheLoaderException

applyClear

protected boolean applyClear()

delegatePurgeExpired

protected void delegatePurgeExpired()