net.sf.ehcache.store
Class XATransactionalStore

java.lang.Object
  net.sf.ehcache.store.XATransactionalStore

All Implemented Interfaces:

Store

public class XATransactionalStore
extends java.lang.Object
implements Store

A transaction aware store that wraps the actual Store. It will provide proper READ_COMMITED transaction isolation. It does so by queuing write operations on the cache. These will eventually be executed at transaction commit time, or discarded in case of rollback.

Author:

Alex Snaps, Nabib El-Rahman

Constructor Summary

XATransactionalStore(EhcacheXAResource xaResource)
Constructor

Method Summary

boolean	bufferFull() Non transactional Some store types, such as the disk stores can fill their write buffers if puts come in too fast.
boolean	containsKey(java.lang.Object key) A check to see if a key is in the Store.
void	dispose() Non transactional
void	expireElements() Non transactional Expire all elements.
void	flush() Non transactional Flush elements to persistent store.
Element	get(java.lang.Object key) Gets an item from the cache.
Policy	getEvictionPolicy() Non transactional
java.lang.Object	getInternalContext() Non transactional This should not be used, and will generally return null
java.lang.Object[]	getKeyArray() Gets an Array of the keys for all elements in the disk store.
Element	getQuiet(java.lang.Object key) Gets an Element from the Store, without updating statistics
int	getSize() TransactionContext impacted size of the store
long	getSizeInBytes() Gets the size of the store, in bytes.
Status	getStatus() Non transactional
int	getTerracottaClusteredSize() Returns the current Terracotta clustered store size
boolean	isCacheCoherent() Non transactional Indicates whether this store provides a coherent view of all the elements in a cache.
boolean	isClusterCoherent() Returns true if the cache is in coherent mode cluster-wide.
boolean	isNodeCoherent() Returns true if the cache is in coherent mode for the current node.
boolean	put(Element element) Puts an item into the store.
boolean	putWithWriter(Element element, CacheWriterManager writerManager) XATransactionalStore to put including to the underlying data store.
Element	remove(java.lang.Object key) Removes an item from the cache.
void	removeAll() Remove all of the elements from the store.
Element	removeWithWriter(java.lang.Object key, CacheWriterManager writerManager) XATransactionalStore to remove including from the underlying data store.
void	setEvictionPolicy(Policy policy) Non transactional Sets the eviction policy strategy.
void	setNodeCoherent(boolean coherent) Sets the cache in coherent or incoherent mode for the current node depending on the parameter.
void	waitUntilClusterCoherent() This method waits until the cache is in coherent mode in all the connected nodes.

Methods inherited from class java.lang.Object

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

Constructor Detail

XATransactionalStore

public XATransactionalStore(EhcacheXAResource xaResource)

Constructor

Parameters:

xaResource - the xaResource wrapping the Cache this store is backing up

Method Detail

put

public boolean put(Element element)
            throws CacheException

Puts an item into the store.

Specified by:

put in interface Store

Returns:

true if this is a new put for the key or element is null. Returns false if it was an update.

Throws:

CacheException

putWithWriter

public boolean putWithWriter(Element element,
                             CacheWriterManager writerManager)
                      throws CacheException

XATransactionalStore to put including to the underlying data store. That needs to be registered with the TransactionManager and participate in the XA Transaction. The call to CacheWriterManager.put(net.sf.ehcache.Element) will be held back until commit time!

Specified by:

putWithWriter in interface Store

Parameters:

element - the element to add to the store

writerManager - will only work properly with WriteThroughManager

Returns:

true if this is a new put for the key or element is null. Returns false if it was an update.

Throws:

CacheException

get

public Element get(java.lang.Object key)

Gets an item from the cache.

Specified by:

get in interface Store

getQuiet

public Element getQuiet(java.lang.Object key)

Gets an Element from the Store, without updating statistics

Specified by:

getQuiet in interface Store

Returns:

The element

getKeyArray

public java.lang.Object[] getKeyArray()

Gets an Array of the keys for all elements in the disk store.

Specified by:

getKeyArray in interface Store

Returns:

An Object[] of Serializable keys

remove

public Element remove(java.lang.Object key)

Removes an item from the cache.

Specified by:

remove in interface Store

removeWithWriter

public Element removeWithWriter(java.lang.Object key,
                                CacheWriterManager writerManager)
                         throws CacheException

XATransactionalStore to remove including from the underlying data store. That needs to be registered with the TransactionManager and participate in the XA Transaction. The call to CacheWriterManager.remove(net.sf.ehcache.CacheEntry) will be not held back until commit time!

Specified by:

removeWithWriter in interface Store

Parameters:

key - the key to remove

writerManager - will only work properly with WriteThroughManager

Returns:

the value to be removed

Throws:

CacheException

removeAll

public void removeAll()
               throws CacheException

Remove all of the elements from the store.

If there are registered CacheEventListeners they are notified of the expiry or removal of the Element as each is removed.

Specified by:

removeAll in interface Store

Throws:

CacheException

dispose

public void dispose()

Non transactional

Prepares for shutdown.

Specified by:

dispose in interface Store

getSize

public int getSize()

TransactionContext impacted size of the store

Specified by:

getSize in interface Store

Returns:

size of the store, including tx local pending changes

getTerracottaClusteredSize

public int getTerracottaClusteredSize()

Returns the current Terracotta clustered store size

Specified by:

getTerracottaClusteredSize in interface Store

Returns:

the count of the Elements in the Store across the cluster

getSizeInBytes

public long getSizeInBytes()

Gets the size of the store, in bytes.

This method may be expensive to run, depending on implementation. Implementers may choose to return an approximate size.

Specified by:

getSizeInBytes in interface Store

Returns:

the approximate size of the store in bytes

getStatus

public Status getStatus()

Non transactional

Returns the cache status.

Specified by:

getStatus in interface Store

containsKey

public boolean containsKey(java.lang.Object key)

A check to see if a key is in the Store.

Specified by:

containsKey in interface Store

Parameters:

key - The Element key

Returns:

whether the element is currently in the cache, or pending put

expireElements

public void expireElements()

Non transactional Expire all elements.

Specified by:

expireElements in interface Store

flush

public void flush()
           throws java.io.IOException

Non transactional Flush elements to persistent store.

Specified by:

flush in interface Store

Throws:

java.io.IOException - if any IO error occurs

bufferFull

public boolean bufferFull()

Non transactional Some store types, such as the disk stores can fill their write buffers if puts come in too fast. The thread will wait for a short time before checking again.

Specified by:

bufferFull in interface Store

Returns:

true if the store write buffer is backed up.

getEvictionPolicy

public Policy getEvictionPolicy()

Non transactional

Specified by:

getEvictionPolicy in interface Store

Returns:

the current eviction policy. This may not be the configured policy, if it has been dynamically set.

See Also:

Store.setEvictionPolicy(Policy)

setEvictionPolicy

public void setEvictionPolicy(Policy policy)

Non transactional Sets the eviction policy strategy. The Store will use a policy at startup. The store may allow changing the eviction policy strategy dynamically. Otherwise implementations will throw an exception if this method is called.

Specified by:

setEvictionPolicy in interface Store

Parameters:

policy - the new policy

getInternalContext

public java.lang.Object getInternalContext()

Non transactional This should not be used, and will generally return null

Specified by:

getInternalContext in interface Store

Returns:

some internal context (probably null)

isCacheCoherent

public boolean isCacheCoherent()

Non transactional Indicates whether this store provides a coherent view of all the elements in a cache. Note that this is same as calling Store.isClusterCoherent() (introduced since 2.0) Use Store.isNodeCoherent() to find out if the cache is coherent in the current node in the cluster

Specified by:

isCacheCoherent in interface Store

Returns:

true if the store is coherent; or false if the store potentially splits the cache storage with another store or isn't internally coherent

isClusterCoherent

public boolean isClusterCoherent()

Returns true if the cache is in coherent mode cluster-wide. Returns false otherwise.

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

isClusterCoherent in interface Store

Returns:

true if the cache is in coherent mode cluster-wide, false otherwise

isNodeCoherent

public boolean isNodeCoherent()

Returns true if the cache is in coherent mode for the current node. Returns false otherwise.

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

isNodeCoherent in interface Store

Returns:

true if the cache is in coherent mode cluster-wide, false otherwise

setNodeCoherent

public void setNodeCoherent(boolean coherent)

Sets the cache in coherent or incoherent mode for the current node depending on the parameter. Calling setNodeCoherent(true) when the cache is already in coherent mode or calling setNodeCoherent(false) when already in incoherent mode will be a no-op.

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

setNodeCoherent in interface Store

Parameters:

coherent - true transitions to coherent mode, false to incoherent mode

waitUntilClusterCoherent

public void waitUntilClusterCoherent()

This method waits until the cache is in coherent mode in all the connected nodes. If the cache is already in coherent mode it returns immediately

It applies to coherent clustering mechanisms only e.g. Terracotta

Specified by:

waitUntilClusterCoherent in interface Store