org.infinispan.persistence.rocksdb

Class RocksDBStore<K,V>

java.lang.Object

org.infinispan.persistence.rocksdb.RocksDBStore<K,V>

All Implemented Interfaces:

Lifecycle, AdvancedCacheLoader<K,V>, AdvancedCacheWriter<K,V>, AdvancedLoadWriteStore<K,V>, CacheLoader<K,V>, CacheWriter<K,V>, ExternalStore<K,V>

public class RocksDBStore<K,V>
extends Object
implements AdvancedLoadWriteStore<K,V>

Nested Class Summary

Nested classes/interfaces inherited from interface org.infinispan.persistence.spi.AdvancedCacheLoader

AdvancedCacheLoader.CacheLoaderTask<K,V>, AdvancedCacheLoader.TaskContext

Nested classes/interfaces inherited from interface org.infinispan.persistence.spi.AdvancedCacheWriter

AdvancedCacheWriter.PurgeListener<K>

Constructor Summary

Constructors

Constructor and Description
RocksDBStore()

Method Summary

Modifier and Type	Method and Description
void	clear() Removes all the data from the storage.
boolean	contains(Object key) Returns true if the storage contains an entry associated with the given key.
boolean	delete(Object key)
protected void	destroyDatabase(String location)
void	init(InitializationContext ctx) Used to initialize a cache loader.
MarshalledEntry	load(Object key) Fetches an entry from the storage.
protected org.rocksdb.RocksDB	openDatabase(String location, org.rocksdb.Options options) Creates database if it doesn't exist.
void	process(KeyFilter keyFilter, AdvancedCacheLoader.CacheLoaderTask cacheLoaderTask, Executor executor, boolean loadValues, boolean loadMetadata) Iterates in parallel over the entries in the storage using the threads from the executor pool.
void	purge(Executor executor, AdvancedCacheWriter.PurgeListener purgeListener) Using the thread in the pool, removed all the expired data from the persistence storage.
protected void	reinitAllDatabases()
protected org.rocksdb.RocksDB	reinitDatabase(String location, org.rocksdb.Options options)
int	size() Returns the number of elements in the store.
void	start() Invoked on component start
void	stop() Invoked on component stop
void	write(MarshalledEntry me) Persists the entry to the storage.
void	writeBatch(Iterable<MarshalledEntry<? extends K,? extends V>> marshalledEntries) Persist all provided entries to the store in a single batch update.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.infinispan.persistence.spi.CacheWriter

deleteBatch

Constructor Detail

RocksDBStore

public RocksDBStore()

Method Detail

init

public void init(InitializationContext ctx)

Description copied from interface: CacheLoader

Used to initialize a cache loader. Typically invoked by the PersistenceManager when setting up cache loaders.

Specified by:

init in interface CacheLoader<K,V>

Specified by:

init in interface CacheWriter<K,V>

start

public void start()

Description copied from interface: Lifecycle

Invoked on component start

Specified by:

start in interface Lifecycle

openDatabase

protected org.rocksdb.RocksDB openDatabase(String location,
                                           org.rocksdb.Options options)
                                    throws IOException,
                                           org.rocksdb.RocksDBException

Creates database if it doesn't exist.

Throws:

IOException

org.rocksdb.RocksDBException

destroyDatabase

protected void destroyDatabase(String location)
                        throws IOException

Throws:

IOException

reinitDatabase

protected org.rocksdb.RocksDB reinitDatabase(String location,
                                             org.rocksdb.Options options)
                                      throws IOException,
                                             org.rocksdb.RocksDBException

Throws:

IOException

org.rocksdb.RocksDBException

reinitAllDatabases

protected void reinitAllDatabases()
                           throws IOException,
                                  org.rocksdb.RocksDBException

Throws:

IOException

org.rocksdb.RocksDBException

stop

public void stop()

Description copied from interface: Lifecycle

Invoked on component stop

Specified by:

stop in interface Lifecycle

clear

public void clear()

Description copied from interface: AdvancedCacheWriter

Removes all the data from the storage.

Specified by:

clear in interface AdvancedCacheWriter<K,V>

size

public int size()

Description copied from interface: AdvancedCacheLoader

Returns the number of elements in the store.

Specified by:

size in interface AdvancedCacheLoader<K,V>

contains

public boolean contains(Object key)

Description copied from interface: CacheLoader

Returns true if the storage contains an entry associated with the given key.

Specified by:

contains in interface CacheLoader<K,V>

process

public void process(KeyFilter keyFilter,
                    AdvancedCacheLoader.CacheLoaderTask cacheLoaderTask,
                    Executor executor,
                    boolean loadValues,
                    boolean loadMetadata)

Description copied from interface: AdvancedCacheLoader

Iterates in parallel over the entries in the storage using the threads from the executor pool. For each entry the CacheLoaderTask#processEntry(MarshalledEntry, TaskContext) is invoked. Before passing an entry to the callback task, the entry should be validated against the filter. Implementors should build an AdvancedCacheLoader.TaskContext instance (implementation) that is fed to the AdvancedCacheLoader.CacheLoaderTask on every invocation. The AdvancedCacheLoader.CacheLoaderTask might invoke AdvancedCacheLoader.TaskContext.stop() at any time, so implementors of this method should verify TaskContext's state for early termination of iteration. The method should only return once the iteration is complete or as soon as possible in the case TaskContext.stop() is invoked.

Specified by:

process in interface AdvancedCacheLoader<K,V>

Parameters:

keyFilter - to validate which entries should be feed into the task. Might be null.

cacheLoaderTask - callback to be invoked in parallel for each stored entry that passes the filter check

executor - an external thread pool to be used for parallel iteration

loadValues - whether or not to fetch the value from the persistent store. E.g. if the iteration is intended only over the key set, no point fetching the values from the persistent store as well

loadMetadata - whether or not to fetch the metadata from the persistent store. E.g. if the iteration is intended only ove the key set, then no pint fetching the metadata from the persistent store as well

delete

public boolean delete(Object key)

Specified by:

delete in interface CacheWriter<K,V>

Returns:

true if the entry existed in the persistent store and it was deleted.

write

public void write(MarshalledEntry me)

Description copied from interface: CacheWriter

Persists the entry to the storage.

Specified by:

write in interface CacheWriter<K,V>

See Also:

MarshalledEntry

load

public MarshalledEntry load(Object key)

Description copied from interface: CacheLoader

Fetches an entry from the storage. If a MarshalledEntry needs to be created here, InitializationContext.getMarshalledEntryFactory() and InitializationContext.getByteBufferFactory() should be used.

Specified by:

load in interface CacheLoader<K,V>

Returns:

the entry, or null if the entry does not exist

writeBatch

public void writeBatch(Iterable<MarshalledEntry<? extends K,? extends V>> marshalledEntries)

Description copied from interface: CacheWriter

Persist all provided entries to the store in a single batch update. If this is not supported by the underlying store, then entries are written to the store individually via CacheWriter.write(MarshalledEntry).

Specified by:

writeBatch in interface CacheWriter<K,V>

Parameters:

marshalledEntries - an Iterable of MarshalledEntry to be written to the store. Implementations should take into account that the passed iterable may contain no entries.

purge

public void purge(Executor executor,
                  AdvancedCacheWriter.PurgeListener purgeListener)

Description copied from interface: AdvancedCacheWriter

Using the thread in the pool, removed all the expired data from the persistence storage. For each removed entry, the supplied listener is invoked.

When this method returns all entries will be purged and no tasks will be running due to this loader in the provided executor. If however an exception is thrown there could be tasks still pending or running in the executor.

Specified by:

purge in interface AdvancedCacheWriter<K,V>