public class ReadOnlyDelegatingCacheLoader extends AbstractDelegatingCacheLoader
buddyFqnTransformer, cache, regionManager, transactions| Constructor and Description |
|---|
ReadOnlyDelegatingCacheLoader(CacheLoader cl) |
| Modifier and Type | Method and Description |
|---|---|
void |
commit(Object tx)
Commits the transaction.
|
void |
prepare(Object tx,
List<Modification> modifications,
boolean one_phase)
Prepares a list of modifications.
|
void |
put(Fqn name,
Map attributes)
Puts all entries of the map into the existing map of the given node,
overwriting existing keys, but not clearing the existing map before
insertion.
|
Object |
put(Fqn name,
Object key,
Object value)
Puts a key and value into the attribute map of a given node.
|
void |
put(List<Modification> modifications)
Applies all modifications to the backend store.
|
void |
remove(Fqn fqn)
Removes the given node and all its subnodes, does nothing if the node does not exist.
|
Object |
remove(Fqn fqn,
Object key)
Removes the given key and value from the attributes of the given node.
|
void |
removeData(Fqn fqn)
Removes all attributes from a given node, but doesn't delete the node
itself or any subnodes.
|
void |
rollback(Object tx)
Rolls the transaction back.
|
void |
storeEntireState(ObjectInputStream is)
Stores the entire state for this cache by reading it from a provided ObjectInputStream.
|
void |
storeState(Fqn subtree,
ObjectInputStream is)
Stores the given portion of the cache tree's state in secondary storage.
|
create, destroy, exists, get, getCacheLoader, getChildrenNames, getConfig, loadEntireState, loadState, setCache, setCacheLoader, setConfig, setRegionManager, start, stopdoMarshall, doUnmarshall, getMarshaller, getNodeDataList, loadStateHelper, move, put, regionAwareMarshall, regionAwareUnmarshall, storeStateHelperpublic ReadOnlyDelegatingCacheLoader(CacheLoader cl)
public Object put(Fqn name, Object key, Object value) throws Exception
CacheLoaderput in interface CacheLoaderput in class AbstractDelegatingCacheLoaderExceptionpublic void put(Fqn name, Map attributes) throws Exception
CacheLoaderMap.putAll(java.util.Map<? extends K, ? extends V>).
If the node does not exist, all parent nodes from the root down are created automatically
Note since 3.0, as an optimization, this method will require a definitive attribute map and
not just a subset. This will allow cache loader implementations to overwrite rather than merge, if that is
deemed more efficient. This will not break backward compatibility since performing a merge will not cause
any loss of data even though it is an unnecessary step.put in interface CacheLoaderput in class AbstractDelegatingCacheLoadername - The fully qualified name of the nodeattributes - A Map of attributes. Can be nullExceptionpublic void put(List<Modification> modifications) throws Exception
CacheLoaderput in interface CacheLoaderput in class AbstractDelegatingCacheLoadermodifications - A ListExceptionpublic Object remove(Fqn fqn, Object key) throws Exception
CacheLoaderremove in interface CacheLoaderremove in class AbstractDelegatingCacheLoaderExceptionpublic void remove(Fqn fqn) throws Exception
CacheLoaderremove in interface CacheLoaderremove in class AbstractDelegatingCacheLoaderfqn - the Fqn of the nodeExceptionpublic void removeData(Fqn fqn) throws Exception
CacheLoaderremoveData in interface CacheLoaderremoveData in class AbstractDelegatingCacheLoaderfqn - the Fqn of the nodeExceptionpublic void prepare(Object tx, List<Modification> modifications, boolean one_phase) throws Exception
CacheLoadertx (tx is the key)
prepare in interface CacheLoaderprepare in class AbstractDelegatingCacheLoadertx - The transaction, indended to be used by implementations as an identifier of the transaction (and not necessarily a JTA Transaction object)modifications - A List containing Modifications, for the given transactionone_phase - Persist immediately and (for example) commit the local JDBC transaction as well. When true,
we won't get a CacheLoader.commit(Object) or CacheLoader.rollback(Object) method call laterExceptionpublic void commit(Object tx) throws Exception
CacheLoadertx and commit that
transaction. Non-transactional CacheLoaders could simply write the data
that was previously saved transiently under the given tx
key, to (for example) a file system.
Note this only holds if the previous prepare() did not define one_phase=true
commit in interface CacheLoadercommit in class AbstractDelegatingCacheLoadertx - transaction to commitExceptionpublic void rollback(Object tx)
CacheLoadertx and roll back that
transaction.rollback in interface CacheLoaderrollback in class AbstractDelegatingCacheLoadertx - transaction to roll backpublic void storeEntireState(ObjectInputStream is) throws Exception
CacheLoaderCacheLoader.loadEntireState(ObjectOutputStream)}
on some other cache instance. State currently in storage gets overwritten.
Implementations of this method should not catch any exception or close the
given ObjectInputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are read from the ObjectInputStream as a sequence of
NodeData objects.
Default implementation is provided by AbstractCacheLoader and ensures cacheloader
interoperability. Implementors are encouraged to consider extending AbstractCacheLoader
prior to implementing completely custom cacheloader.storeEntireState in interface CacheLoaderstoreEntireState in class AbstractDelegatingCacheLoaderis - ObjectInputStream to read stateExceptionAbstractCacheLoader.storeEntireState(ObjectInputStream),
NodeDatapublic void storeState(Fqn subtree, ObjectInputStream is) throws Exception
CacheLoadersubtree,
then no special behavior is required. Otherwise, ensure that
the state is integrated under the given subtree. Typically
in the latter case subtree would be the Fqn of the buddy
backup region for
a buddy group; e.g.
If the the transferred state had Fqns starting with "/a" and
subtree was "/_BUDDY_BACKUP_/192.168.1.2:5555" then the
state should be stored in the local persistent store under
"/_BUDDY_BACKUP_/192.168.1.2:5555/a"
Implementations of this method should not catch any exception or close the
given ObjectInputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are read from the ObjectInputStream as a sequence of
NodeData objects.
Default implementation is provided by AbstractCacheLoader and ensures cacheloader
interoperability. Implementors are encouraged to consider extending AbstractCacheLoader
prior to implementing completely custom cacheloader.storeState in interface CacheLoaderstoreState in class AbstractDelegatingCacheLoadersubtree - Fqn naming the root (i.e. highest level parent) node of
the subtree included in state. If the Fqns
of the data included in state are not
already children of subtree, then their
Fqns should be altered to make them children of
subtree before they are persisted.is - ObjectInputStream to read stateExceptionAbstractCacheLoader.storeState(Fqn,ObjectInputStream),
NodeDataCopyright © 2012 JBoss, a division of Red Hat. All Rights Reserved.