net.sf.ehcache.transaction.xa
Class SyncAwareStore

java.lang.Object
  net.sf.ehcache.transaction.xa.SyncAwareStore

All Implemented Interfaces:

Store

public class SyncAwareStore
extends java.lang.Object
implements Store

The class has a CacheLockProvider for entry level write methods. It is used to enforce XA Isolation for standalone mode.

Author:

nelrahma

Constructor Summary

SyncAwareStore(Store store)

Method Summary

boolean	bufferFull() 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() Prepares for shutdown.
void	expireElements() Expire all elements.
void	flush() Flush elements to persistent store.
Element	get(java.lang.Object key) Gets an item from the cache.
Policy	getEvictionPolicy()
java.lang.Object	getInternalContext() 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() Returns the current local store size
long	getSizeInBytes() Gets the size of the store, in bytes.
Status	getStatus() Returns the cache status.
int	getTerracottaClusteredSize() Returns the current Terracotta clustered store size
boolean	isCacheCoherent() 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) does underlying store.put after acquiring write lock for key
boolean	putWithWriter(Element element, CacheWriterManager writerManager) Puts an item into the store and the cache writer manager in an atomic operation
Element	remove(java.lang.Object key) does underlying store.remove after acquiring write lock for key
void	removeAll() Remove all of the elements from the store.
Element	removeWithWriter(java.lang.Object key, CacheWriterManager writerManager) Removes an item from the store and the cache writer manager in an atomic operation.
void	setEvictionPolicy(Policy policy) 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

SyncAwareStore

public SyncAwareStore(Store store)

Parameters:

store -

Method Detail

put

public boolean put(Element element)
            throws CacheException

does underlying store.put after acquiring write lock for key

Specified by:

put in interface Store

Parameters:

element -

Returns:

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

Throws:

CacheException

remove

public Element remove(java.lang.Object key)

does underlying store.remove after acquiring write lock for key

Specified by:

remove in interface Store

Parameters:

key -

bufferFull

public boolean bufferFull()

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.

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:

true if found. No check is made to see if the Element is expired. 1.2

dispose

public void dispose()

Prepares for shutdown.

Specified by:

dispose in interface Store

expireElements

public void expireElements()

Expire all elements.

Specified by:

expireElements in interface Store

flush

public void flush()
           throws java.io.IOException

Flush elements to persistent store.

Specified by:

flush in interface Store

Throws:

java.io.IOException - if any IO error occurs

get

public Element get(java.lang.Object key)

Gets an item from the cache.

Specified by:

get in interface Store

getEvictionPolicy

public Policy getEvictionPolicy()

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)

getInternalContext

public java.lang.Object getInternalContext()

This should not be used, and will generally return null

Specified by:

getInternalContext in interface Store

Returns:

some internal context (probably null)

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

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

getSize

public int getSize()

Returns the current local store size

Specified by:

getSize in interface Store

Returns:

the count of the Elements in the Store on the local machine

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()

Returns the cache status.

Specified by:

getStatus in interface Store

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

isCacheCoherent

public boolean isCacheCoherent()

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

putWithWriter

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

Puts an item into the store and the cache writer manager in an atomic operation

Specified by:

putWithWriter 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

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

removeWithWriter

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

Removes an item from the store and the cache writer manager in an atomic operation.

Specified by:

removeWithWriter in interface Store

Throws:

CacheException

setEvictionPolicy

public void setEvictionPolicy(Policy policy)

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

setNodeCoherent

public void setNodeCoherent(boolean coherent)
                     throws java.lang.UnsupportedOperationException

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

Throws:

java.lang.UnsupportedOperationException - if this store does not support cache coherence, like RMI replication

waitUntilClusterCoherent

public void waitUntilClusterCoherent()
                              throws java.lang.UnsupportedOperationException

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

Throws:

java.lang.UnsupportedOperationException - if this store does not support cache coherence, like RMI replication