com.hazelcast.map.impl.mapstore.writebehind

Class WriteBehindStore

java.lang.Object

com.hazelcast.map.impl.mapstore.AbstractMapDataStore<Data,Object>

com.hazelcast.map.impl.mapstore.writebehind.WriteBehindStore

All Implemented Interfaces:

MapDataStore<Data,Object>

public class WriteBehindStore
extends AbstractMapDataStore<Data,Object>

Write behind map data store implementation. Created per every record-store. Only called from one thread.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	WriteBehindStore.Sequence The purpose of this class is to provide distinction between flushes caused by eviction and IMap.flush()

Constructor Summary

Constructors

Constructor and Description
WriteBehindStore(MapStoreContext mapStoreContext, int partitionId, InternalSerializationService serializationService)

Method Summary

Modifier and Type	Method and Description
Object	add(Data key, Object value, long now)
void	add(DelayedEntry<Data,Object> delayedEntry)
Object	addBackup(Data key, Object value, long time)
void	addTransient(Data key, long now)
Object	flush(Data key, Object value, boolean backup) Flushes the supplied key to the map-store.
Queue<WriteBehindStore.Sequence>	getFlushSequences()
long	getSequenceToFlush()
WriteBehindQueue<DelayedEntry>	getWriteBehindQueue()
void	hardFlush() Flushes write-behind-queue into map-store in calling thread.
Object	load(Data key)
boolean	loadable(Data key) Used in IMap.loadAll(boolean) calls.
Map	loadAll(Collection keys) Loads values for the provided keys if a MapLoader is configured for this map.
int	notFinishedOperationsCount()
void	notifyFlush()
void	remove(Data key, long now)
void	removeBackup(Data key, long time)
protected void	removeFromStagingArea(DelayedEntry delayedEntry)
void	reset() Returns all associated resources of this map-data-store back to the initial state.
void	setFlushSequences(Queue<WriteBehindStore.Sequence> flushSequences)
void	setSequence(long newSequence)
void	setWriteBehindProcessor(WriteBehindProcessor writeBehindProcessor)
void	setWriteBehindQueue(WriteBehindQueue<DelayedEntry> writeBehindQueue)
long	softFlush() Only marks this MapDataStore as flush-able.

Methods inherited from class com.hazelcast.map.impl.mapstore.AbstractMapDataStore

getStore, isPostProcessingMapStore, removeAll, toHeapData, toObject

Methods inherited from class java.lang.Object

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

Constructor Detail

WriteBehindStore

public WriteBehindStore(MapStoreContext mapStoreContext,
                        int partitionId,
                        InternalSerializationService serializationService)

Method Detail

add

public Object add(Data key,
                  Object value,
                  long now)

add

public void add(DelayedEntry<Data,Object> delayedEntry)

addTransient

public void addTransient(Data key,
                         long now)

addBackup

public Object addBackup(Data key,
                        Object value,
                        long time)

remove

public void remove(Data key,
                   long now)

removeBackup

public void removeBackup(Data key,
                         long time)

reset

public void reset()

Description copied from interface: MapDataStore

Returns all associated resources of this map-data-store back to the initial state.

load

public Object load(Data key)

loadAll

public Map loadAll(Collection keys)

Loads values for the provided keys if a MapLoader is configured for this map. This method never returns null. The returned map will contain deserialised keys and values. The method first checks if some of the keys to be loaded have entries that are staged to be persisted to the underlying store and returns those values instead of loading the values from the store. The keys which don't have staged entries to be persisted will be loaded from the underlying store.

Specified by:

loadAll in interface MapDataStore<Data,Object>

Overrides:

loadAll in class AbstractMapDataStore<Data,Object>

Parameters:

keys - the keys for which values are loaded

Returns:

the map from deserialised key to deserialised value

See Also:

MapLoader.loadAll(Collection)

loadable

public boolean loadable(Data key)

Description copied from interface: MapDataStore

Used in IMap.loadAll(boolean) calls. If the write-behind map-store feature is enabled, some things may lead to possible data inconsistencies. These are: - calling evict/evictAll, - calling remove, and - not yet stored write-behind queue operations.

With this method, we can be sure if a key can be loadable from map-store or not.

Parameters:

key - the key to query whether it is loadable or not

Returns:

true if the key is loadable

notFinishedOperationsCount

public int notFinishedOperationsCount()

flush

public Object flush(Data key,
                    Object value,
                    boolean backup)

Description copied from interface: MapDataStore

Flushes the supplied key to the map-store.

Parameters:

key - key to be flushed

value - value to be flushed

backup - true calling this method for backup partition, false for owner partition.

Returns:

flushed value.

softFlush

public long softFlush()

Description copied from interface: MapDataStore

Only marks this MapDataStore as flush-able. Flush means storing entries from write-behind-queue into map-store regardless of the scheduled store-time. Actual flushing is done by another thread than partition-operation thread which runs StoreWorker.

Returns:

last given sequence number to the last store operation

See Also:

MapFlushOperation

hardFlush

public void hardFlush()

Description copied from interface: MapDataStore

Flushes write-behind-queue into map-store in calling thread.

After calling of this method, all elements in the WriteBehindQueue of this MapDataStore should be in map-store regardless of the scheduled store-time.

The only call to this method is in node-shutdown.

See Also:

MapManagedService.shutdown(boolean)

getWriteBehindQueue

public WriteBehindQueue<DelayedEntry> getWriteBehindQueue()

setWriteBehindQueue

public void setWriteBehindQueue(WriteBehindQueue<DelayedEntry> writeBehindQueue)

setWriteBehindProcessor

public void setWriteBehindProcessor(WriteBehindProcessor writeBehindProcessor)

setSequence

public void setSequence(long newSequence)

notifyFlush

public void notifyFlush()

removeFromStagingArea

protected void removeFromStagingArea(DelayedEntry delayedEntry)

getFlushSequences

public Queue<WriteBehindStore.Sequence> getFlushSequences()

getSequenceToFlush

public long getSequenceToFlush()

setFlushSequences

public void setFlushSequences(Queue<WriteBehindStore.Sequence> flushSequences)