org.infinispan.loader.decorators
Class ChainingCacheStore

java.lang.Object
  org.infinispan.loader.decorators.ChainingCacheStore

All Implemented Interfaces:

CacheLoader, CacheStore

public class ChainingCacheStore
extends Object
implements CacheStore

A chaining cache loader that allows us to configure > 1 cache loader.

READ operations are directed to each of the cache loaders (in the order which they were configured) until a non-null (or non-empty in the case of retrieving collection objects) result is achieved.

WRITE operations are propagated to ALL registered cache stores specified, that set ignoreModifications to false.

Since:

4.0

Author:

Manik Surtani

Constructor Summary

ChainingCacheStore()

Method Summary

void	addCacheLoader(CacheLoader loader, CacheLoaderConfig config)
void	clear() Clears all entries in the store
void	commit(Transaction tx) Commits a transaction that has been previously prepared.
boolean	containsKey(Object key)
void	fromStream(ObjectInput inputStream) Writes contents of the stream to the store.
Class<? extends CacheLoaderConfig>	getConfigurationClass()
LinkedHashMap<CacheStore,CacheLoaderConfig>	getStores()
void	init(CacheLoaderConfig config, Cache cache, Marshaller m) Used to initialize a cache loader.
InternalCacheEntry	load(Object key) Loads an entry mapped to by a given key.
Set<InternalCacheEntry>	loadAll() Loads all entries in the loader.
void	prepare(List<? extends Modification> list, Transaction tx, boolean isOnePhase) Issues a prepare call with a set of modifications to be applied to the cache store
void	purgeExpired() Purges expired entries from the store.
void	purgeIfNecessary()
boolean	remove(Object key) Removes an entry in the store.
void	removeAll(Set<Object> keys) Bulk remove operation
void	rollback(Transaction 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, javax.transaction.Transaction, boolean).
void	start()
void	stop()
void	store(InternalCacheEntry ed) Stores an entry
void	toStream(ObjectOutput outputStream) Loads the entire state into a stream, using whichever format is most efficient for the cache loader implementation.

Methods inherited from class java.lang.Object

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

Constructor Detail

ChainingCacheStore

public ChainingCacheStore()

Method Detail

store

public void store(InternalCacheEntry ed)
           throws CacheLoaderException

Description copied from interface: CacheStore

Stores an entry

Specified by:

store in interface CacheStore

Parameters:

ed - entry to store

Throws:

CacheLoaderException - in the event of problems writing to the store

fromStream

public void fromStream(ObjectInput inputStream)
                throws CacheLoaderException

Description copied from interface: CacheStore

Writes contents of the stream to the store. Implementations should expect that the stream contains data in an implementation-specific format, typically generated using CacheStore.toStream(java.io.ObjectOutput). While not a requirement, it is recommended that implementations make use of the Marshaller when dealing with the stream to make use of efficient marshalling.

It is imperative that implementations do not close the stream after finishing with it.

It is also recommended that implementations use their own start and end markers on the stream since other processes may write additional data to the stream after the cache store has written to it. As such, either markers or some other mechanism to prevent the store from reading too much information should be employed when writing to the stream in CacheStore.fromStream(java.io.ObjectInput) to prevent data corruption.

It can be assumed that the stream passed in already performs buffering such that the cache store implementation doesn't have to.

Specified by:

fromStream in interface CacheStore

Parameters:

inputStream - stream to read from

Throws:

CacheLoaderException - in the event of problems writing to the store

toStream

public void toStream(ObjectOutput outputStream)
              throws CacheLoaderException

Description copied from interface: CacheStore

Loads the entire state into a stream, using whichever format is most efficient for the cache loader implementation. Typically read and parsed by CacheStore.fromStream(java.io.ObjectInput).

While not a requirement, it is recommended that implementations make use of the Marshaller when dealing with the stream to make use of efficient marshalling.

It is imperative that implementations do not flush or close the stream after finishing with it.

It is also recommended that implementations use their own start and end markers on the stream since other processes may write additional data to the stream after the cache store has written to it. As such, either markers or some other mechanism to prevent the store from reading too much information in CacheStore.fromStream(java.io.ObjectInput) should be employed, to prevent data corruption.

It can be assumed that the stream passed in already performs buffering such that the cache store implementation doesn't have to.

Specified by:

toStream in interface CacheStore

Parameters:

outputStream - stream to write to

Throws:

CacheLoaderException - in the event of problems reading from the store

clear

public void clear()
           throws CacheLoaderException

Description copied from interface: CacheStore

Clears all entries in the store

Specified by:

clear in interface CacheStore

Throws:

CacheLoaderException - in the event of problems writing to the store

remove

public boolean remove(Object key)
               throws CacheLoaderException

Description copied from interface: CacheStore

Removes an entry in the store.

Specified by:

remove in interface CacheStore

Parameters:

key - key to remove

Returns:

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

Throws:

CacheLoaderException - in the event of problems writing to the store

removeAll

public void removeAll(Set<Object> keys)
               throws CacheLoaderException

Description copied from interface: CacheStore

Bulk remove operation

Specified by:

removeAll in interface CacheStore

Parameters:

keys - to remove

Throws:

CacheLoaderException - in the event of problems writing to the store

purgeExpired

public void purgeExpired()
                  throws CacheLoaderException

Description copied from interface: CacheStore

Purges expired entries from the store.

Specified by:

purgeExpired in interface CacheStore

Throws:

CacheLoaderException - in the event of problems writing to the store

commit

public void commit(Transaction 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, javax.transaction.Transaction, boolean). The implementation would need to deal with this case acordingly. 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, javax.transaction.Transaction, boolean) invocation. As such, ThreadLocals should not be relied upon to maintain transaction context.

Specified by:

commit in interface CacheStore

Parameters:

tx - tx to commit

Throws:

CacheLoaderException - in the event of problems writing to the store

rollback

public void rollback(Transaction 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, javax.transaction.Transaction, boolean). The implementation would need to deal with this case acordingly. 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, javax.transaction.Transaction, boolean) invocation. As such, ThreadLocals should not be relied upon to maintain transaction context.

Specified by:

rollback in interface CacheStore

Parameters:

tx - tx to roll back

prepare

public void prepare(List<? extends Modification> list,
                    Transaction 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

Parameters:

list - 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

init

public void init(CacheLoaderConfig config,
                 Cache cache,
                 Marshaller m)

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

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.

load

public InternalCacheEntry load(Object key)
                        throws CacheLoaderException

Description copied from interface: CacheLoader

Loads an entry mapped to by a given key. Should return null if the entry does not exist. Expired entries are not returned.

Specified by:

load in interface CacheLoader

Parameters:

key - key

Returns:

an entry

Throws:

CacheLoaderException - in the event of problems reading from source

loadAll

public Set<InternalCacheEntry> loadAll()
                                throws CacheLoaderException

Description copied from interface: CacheLoader

Loads all entries in the loader. Expired entries are not returned.

Specified by:

loadAll in interface CacheLoader

Returns:

a set of entries, or an empty set if the loader is emptied.

Throws:

CacheLoaderException - in the event of problems reading from source

containsKey

public boolean containsKey(Object key)
                    throws CacheLoaderException

Specified by:

containsKey in interface CacheLoader

Parameters:

key - key to test

Returns:

true if the key exists, false otherwise

Throws:

CacheLoaderException - in the event of problems reading from source

getConfigurationClass

public Class<? extends CacheLoaderConfig> getConfigurationClass()

Specified by:

getConfigurationClass in interface CacheLoader

Returns:

the type of the CacheLoaderConfig bean used to configure this implementation of CacheLoader

start

public void start()
           throws CacheLoaderException

Specified by:

start in interface CacheLoader

Throws:

CacheLoaderException

stop

public void stop()
          throws CacheLoaderException

Specified by:

stop in interface CacheLoader

Throws:

CacheLoaderException

addCacheLoader

public void addCacheLoader(CacheLoader loader,
                           CacheLoaderConfig config)

purgeIfNecessary

public void purgeIfNecessary()
                      throws CacheLoaderException

Throws:

CacheLoaderException

getStores

public LinkedHashMap<CacheStore,CacheLoaderConfig> getStores()