public abstract class AbstractDelegatingCacheLoader extends AbstractCacheLoader
buddyFqnTransformer, cache, regionManager, transactions
Constructor and Description |
---|
AbstractDelegatingCacheLoader(CacheLoader cl) |
Modifier and Type | Method and Description |
---|---|
void |
commit(Object tx)
Commits the transaction.
|
void |
create() |
void |
destroy() |
boolean |
exists(Fqn name)
Returns true if the CacheLoader has a node with a
Fqn . |
Map |
get(Fqn name)
Returns all keys and values from the persistent store, given a
Fqn |
CacheLoader |
getCacheLoader() |
Set |
getChildrenNames(Fqn fqn)
Returns a set of children node names.
|
CacheLoaderConfig.IndividualCacheLoaderConfig |
getConfig()
Gets the configuration.
|
void |
loadEntireState(ObjectOutputStream os)
Fetches the entire state for this cache from secondary storage (disk, database)
and writes it to a provided ObjectOutputStream.
|
void |
loadState(Fqn subtree,
ObjectOutputStream os)
Fetches a portion of the state for this cache from secondary storage (disk, database)
and writes it to a provided ObjectOutputStream.
|
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 |
setCache(CacheSPI c)
Sets the
CacheSPI that is maintaining this CacheLoader. |
void |
setCacheLoader(CacheLoader cacheLoader) |
void |
setConfig(CacheLoaderConfig.IndividualCacheLoaderConfig config)
Sets the configuration.
|
void |
setRegionManager(RegionManager manager)
Sets the
RegionManager this object should use to manage
marshalling/unmarshalling of different regions using different
classloaders. |
void |
start() |
void |
stop() |
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.
|
doMarshall, doUnmarshall, getMarshaller, getNodeDataList, loadStateHelper, move, put, regionAwareMarshall, regionAwareUnmarshall, storeStateHelper
public AbstractDelegatingCacheLoader(CacheLoader cl)
public CacheLoader getCacheLoader()
public void setCacheLoader(CacheLoader cacheLoader)
public void setConfig(CacheLoaderConfig.IndividualCacheLoaderConfig config)
CacheLoader
Lifecycle.create()
and Lifecycle.start()
.config
- May be an instance of the CacheLoaderConfig.IndividualCacheLoaderConfig
base
class, in which case the cache loader should use the
PluggableConfigurationComponent.getProperties()
method to find configuration information. Alternatively,
may be a type-specific subclass of CacheLoaderConfig.IndividualCacheLoaderConfig
,
if there is one.public CacheLoaderConfig.IndividualCacheLoaderConfig getConfig()
CacheLoader
CacheLoaderConfig.IndividualCacheLoaderConfig
object.public void setCache(CacheSPI c)
CacheLoader
CacheSPI
that is maintaining this CacheLoader.
This method allows this CacheLoader to set a reference to the CacheSPI
.
This method is called be called after the CacheLoader instance has been constructed.setCache
in interface CacheLoader
setCache
in class AbstractCacheLoader
c
- The cache on which this loader workspublic Set getChildrenNames(Fqn fqn) throws Exception
CacheLoader
Fqn
.
Returns null if the named node is not found or there are no children.
The returned set must not be modifiable. Implementors can use
Collections.unmodifiableSet(java.util.Set)
to make the set unmodifiable.
Implementors may impose restrictions on the contents of an Fqn (such as Strings-only) and as such, indirectly
impose the same restriction on the contents of a Set returned by getChildrenNames().
public Map get(Fqn name) throws Exception
CacheLoader
Fqn
public boolean exists(Fqn name) throws Exception
CacheLoader
Fqn
.Exception
public Object put(Fqn name, Object key, Object value) throws Exception
CacheLoader
Exception
public void put(Fqn name, Map attributes) throws Exception
CacheLoader
Map.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.name
- The fully qualified name of the nodeattributes
- A Map of attributes. Can be nullException
public void put(List<Modification> modifications) throws Exception
CacheLoader
put
in interface CacheLoader
put
in class AbstractCacheLoader
modifications
- A ListException
public Object remove(Fqn fqn, Object key) throws Exception
CacheLoader
Exception
public void remove(Fqn fqn) throws Exception
CacheLoader
public void removeData(Fqn fqn) throws Exception
CacheLoader
public void prepare(Object tx, List<Modification> modifications, boolean one_phase) throws Exception
CacheLoader
tx
(tx is the key)
prepare
in interface CacheLoader
prepare
in class AbstractCacheLoader
tx
- 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 Modification
s, 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 laterException
public void commit(Object tx) throws Exception
CacheLoader
tx
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 CacheLoader
commit
in class AbstractCacheLoader
tx
- transaction to commitException
public void rollback(Object tx)
CacheLoader
tx
and roll back that
transaction.rollback
in interface CacheLoader
rollback
in class AbstractCacheLoader
tx
- transaction to roll backpublic void loadEntireState(ObjectOutputStream os) throws Exception
CacheLoader
CacheLoader.storeEntireState(ObjectInputStream)
Implementations of this method should not catch any exception or close the
given ObjectOutputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are written to the ObjectOutputStream 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.loadEntireState
in interface CacheLoader
loadEntireState
in class AbstractCacheLoader
os
- ObjectOutputStream to write stateException
AbstractCacheLoader.loadEntireState(ObjectOutputStream)
,
NodeData
public void storeEntireState(ObjectInputStream is) throws Exception
CacheLoader
CacheLoader.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 CacheLoader
storeEntireState
in class AbstractCacheLoader
is
- ObjectInputStream to read stateException
AbstractCacheLoader.storeEntireState(ObjectInputStream)
,
NodeData
public void loadState(Fqn subtree, ObjectOutputStream os) throws Exception
CacheLoader
CacheLoader.storeState(Fqn,ObjectInputStream)
.
Implementations of this method should not catch any exception or close the
given ObjectOutputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are written to the ObjectOutputStream 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.loadState
in interface CacheLoader
loadState
in class AbstractCacheLoader
subtree
- Fqn naming the root (i.e. highest level parent) node of
the subtree for which state is requested.os
- ObjectOutputStream to write stateException
AbstractCacheLoader.loadState(Fqn,ObjectOutputStream)
,
Region.activate()
,
NodeData
public void storeState(Fqn subtree, ObjectInputStream is) throws Exception
CacheLoader
subtree
,
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 CacheLoader
storeState
in class AbstractCacheLoader
subtree
- 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 stateException
AbstractCacheLoader.storeState(Fqn,ObjectInputStream)
,
NodeData
public void setRegionManager(RegionManager manager)
CacheLoader
RegionManager
this object should use to manage
marshalling/unmarshalling of different regions using different
classloaders.
NOTE: This method is only intended to be used
by the CacheSPI
instance this cache loader is
associated with.
setRegionManager
in interface CacheLoader
setRegionManager
in class AbstractCacheLoader
manager
- the region manager to use, or null
.public void create() throws Exception
create
in interface Lifecycle
create
in class AbstractCacheLoader
Exception
public void start() throws Exception
start
in interface Lifecycle
start
in class AbstractCacheLoader
Exception
public void stop()
stop
in interface Lifecycle
stop
in class AbstractCacheLoader
public void destroy()
destroy
in interface Lifecycle
destroy
in class AbstractCacheLoader
Copyright © 2012 JBoss, a division of Red Hat. All Rights Reserved.