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>, SegmentedAdvancedLoadWriteStore<K,V>

public class RocksDBStore<K,V>
extends java.lang.Object
implements SegmentedAdvancedLoadWriteStore<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	addSegments(IntSet segments) Invoked when a node becomes an owner of the given segments.
java.util.concurrent.CompletionStage<java.lang.Void>	bulkUpdate(org.reactivestreams.Publisher<MarshallableEntry<? extends K,? extends V>> publisher) Persist all provided entries to the store in chunks, with the size of each chunk determined by the store implementation.
void	clear() Removes all the data from the storage.
void	clear(IntSet segments) Removes all the data that maps to the given segments from the storage.
boolean	contains(int segment, java.lang.Object key) Returns true if the storage contains an entry associated with the given key in the given segment
boolean	contains(java.lang.Object key) Returns true if the storage contains an entry associated with the given key.
boolean	delete(int segment, java.lang.Object key) Removes the entry for the provided key which is in the given segment.
boolean	delete(java.lang.Object key)
void	deleteBatch(java.lang.Iterable<java.lang.Object> keys) Remove all provided keys from the store in a single batch operation.
void	destroy() Method to be used to destroy and clean up any resources associated with this store.
org.reactivestreams.Publisher<MarshallableEntry<K,V>>	entryPublisher(IntSet segments, java.util.function.Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata) Publishes all entries from this store.
org.reactivestreams.Publisher<MarshallableEntry<K,V>>	entryPublisher(java.util.function.Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata) Publishes all entries from this store.
MarshallableEntry<K,V>	get(int segment, java.lang.Object key) Fetches an entry from the storage given a segment to optimize this lookup based on.
void	init(InitializationContext ctx) Used to initialize a cache loader.
boolean	isAvailable()
MarshallableEntry	loadEntry(java.lang.Object key) Fetches an entry from the storage.
protected org.rocksdb.RocksDB	openDatabase(java.lang.String location, org.rocksdb.Options options) Creates database if it doesn't exist.
org.reactivestreams.Publisher<K>	publishKeys(IntSet segments, java.util.function.Predicate<? super K> filter) Publishes all the keys that map to the given segments from this store.
org.reactivestreams.Publisher<K>	publishKeys(java.util.function.Predicate<? super K> filter) Publishes all the keys from this store.
void	purge(java.util.concurrent.Executor executor, AdvancedCacheWriter.PurgeListener purgeListener) Using the thread in the pool, removed all the expired data from the persistence storage.
void	removeSegments(IntSet segments) Invoked when a node loses ownership of a segment.
int	size() Returns the number of elements in the store.
int	size(IntSet segments) Returns the number of elements in the store that map to the given segments that aren't expired.
void	start() Invoked on component start
void	stop() Invoked on component stop
void	write(int segment, MarshallableEntry<? extends K,? extends V> entry) Persists the entry to the storage with the given segment to optimize future lookups.
void	write(MarshallableEntry entry) Persists the entry to the storage.

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.SegmentedAdvancedLoadWriteStore

load, publishEntries, write

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

process, publishEntries

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

load

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

write, writeBatch

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(java.lang.String location,
                                           org.rocksdb.Options options)
                                    throws java.io.IOException,
                                           org.rocksdb.RocksDBException

Creates database if it doesn't exist.

Throws:

java.io.IOException

org.rocksdb.RocksDBException

stop

public void stop()

Description copied from interface: Lifecycle

Invoked on component stop

Specified by:

stop in interface Lifecycle

destroy

public void destroy()

Description copied from interface: ExternalStore

Method to be used to destroy and clean up any resources associated with this store. This is normally only useful for non shared stores.

This method will ensure the store is stopped and properly cleans up all resources for it.

Specified by:

destroy in interface ExternalStore<K,V>

isAvailable

public boolean isAvailable()

Specified by:

isAvailable in interface CacheLoader<K,V>

Specified by:

isAvailable in interface CacheWriter<K,V>

Specified by:

isAvailable in interface ExternalStore<K,V>

Returns:

true if the writer can be connected to, otherwise false

clear

public void clear()

Description copied from interface: AdvancedCacheWriter

Removes all the data from the storage.

Specified by:

clear in interface AdvancedCacheWriter<K,V>

clear

public void clear(IntSet segments)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Removes all the data that maps to the given segments from the storage.

This method must only remove entries that map to the provided segments.

This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not.

Specified by:

clear in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segments - data mapping to these segments are removed. Always non null.

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>

size

public int size(IntSet segments)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Returns the number of elements in the store that map to the given segments that aren't expired.

The segments here must be adhered to and the size must not count any entries that don't belong to the provided segments.

This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented().

Specified by:

size in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segments - the segments which should have their entries counted. Always non null.

Returns:

the count of entries in the given segments

contains

public boolean contains(java.lang.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>

contains

public boolean contains(int segment,
                        java.lang.Object key)

Description copied from interface: SegmentedAdvancedLoadWriteStore

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

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Specified by:

contains in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segment - the segment that the key maps to

key - the key to see if exists

Returns:

true if the key is present in this loader with a given segment

publishKeys

public org.reactivestreams.Publisher<K> publishKeys(java.util.function.Predicate<? super K> filter)

Description copied from interface: AdvancedCacheLoader

Publishes all the keys from this store. The given publisher can be used by as many Subscribers as desired. Keys are not retrieved until a given Subscriber requests them from the Subscription.

Stores will return only non expired keys

Specified by:

publishKeys in interface AdvancedCacheLoader<K,V>

Parameters:

filter - a filter - null is treated as allowing all entries

Returns:

a publisher that will provide the keys from the store

publishKeys

public org.reactivestreams.Publisher<K> publishKeys(IntSet segments,
                                                    java.util.function.Predicate<? super K> filter)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Publishes all the keys that map to the given segments from this store. The given publisher can be used by as many Subscribers as desired. Keys are not retrieved until a given Subscriber requests them from the Subscription.

Stores will return only non expired keys

The segments here must be adhered to and the keys published must not include any that don't belong to the provided segments.

This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented().

Specified by:

publishKeys in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segments - the segments that the keys must map to. Always non null.

filter - a filter

Returns:

a publisher that will provide the keys from the store

entryPublisher

public org.reactivestreams.Publisher<MarshallableEntry<K,V>> entryPublisher(java.util.function.Predicate<? super K> filter,
                                                                            boolean fetchValue,
                                                                            boolean fetchMetadata)

Description copied from interface: AdvancedCacheLoader

Publishes all entries from this store. The given publisher can be used by as many Subscribers as desired. Entries are not retrieved until a given Subscriber requests them from the Subscription.

If fetchMetadata is true this store must guarantee to not return any expired entries.

Specified by:

entryPublisher in interface AdvancedCacheLoader<K,V>

Parameters:

filter - a filter - null is treated as allowing all entries

fetchValue - 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

fetchMetadata - 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 point fetching the metadata from the persistent store as well

Returns:

a publisher that will provide the entries from the store

entryPublisher

public org.reactivestreams.Publisher<MarshallableEntry<K,V>> entryPublisher(IntSet segments,
                                                                            java.util.function.Predicate<? super K> filter,
                                                                            boolean fetchValue,
                                                                            boolean fetchMetadata)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Publishes all entries from this store. The given publisher can be used by as many Subscribers as desired. Entries are not retrieved until a given Subscriber requests them from the Subscription.

If fetchMetadata is true this store must guarantee to not return any expired entries.

The segments here must be adhered to and the entries published must not include any that don't belong to the provided segments.

This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented(). StoreConfiguration.segmented().

Specified by:

entryPublisher in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segments - the segments that the keys of the entries must map to. Always non null.

filter - a filter on the keys of the entries that if passed will allow the given entry to be returned from the publisher

fetchValue - whether the value should be included in the marshalled entry

fetchMetadata - whether the metadata should be included in the marshalled entry

Returns:

a publisher that will provide the entries from the store that map to the given segments

delete

public boolean delete(java.lang.Object key)

Specified by:

delete in interface CacheWriter<K,V>

Returns:

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

delete

public boolean delete(int segment,
                      java.lang.Object key)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Removes the entry for the provided key which is in the given segment. This method then returns whether the entry was removed or not.

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Specified by:

delete in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segment - the segment that this key maps to

key - the key of the entry to remove

Returns:

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

write

public void write(MarshallableEntry entry)

Description copied from interface: CacheWriter

Persists the entry to the storage.

Specified by:

write in interface CacheWriter<K,V>

See Also:

MarshallableEntry

write

public void write(int segment,
                  MarshallableEntry<? extends K,? extends V> entry)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Persists the entry to the storage with the given segment to optimize future lookups.

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Specified by:

write in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segment - the segment to persist this entry to

entry - the entry to write to the store

See Also:

MarshallableEntry

loadEntry

public MarshallableEntry loadEntry(java.lang.Object key)

Description copied from interface: CacheLoader

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

Specified by:

loadEntry in interface CacheLoader<K,V>

Returns:

the entry, or null if the entry does not exist

get

public MarshallableEntry<K,V> get(int segment,
                                  java.lang.Object key)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Fetches an entry from the storage given a segment to optimize this lookup based on. If a MarshallableEntry needs to be created here, InitializationContext.getMarshallableEntryFactory() and InitializationContext.getByteBufferFactory() should be used.

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Specified by:

get in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segment - the segment that the key maps to

key - the key of the entry to fetch

Returns:

the entry, or null if the entry does not exist

bulkUpdate

public java.util.concurrent.CompletionStage<java.lang.Void> bulkUpdate(org.reactivestreams.Publisher<MarshallableEntry<? extends K,? extends V>> publisher)

Description copied from interface: CacheWriter

Persist all provided entries to the store in chunks, with the size of each chunk determined by the store implementation. If chunking is not supported by the underlying store, then entries are written to the store individually via CacheWriter.write(MarshallableEntry).

Specified by:

bulkUpdate in interface CacheWriter<K,V>

Parameters:

publisher - a Publisher of MarshallableEntry instances

deleteBatch

public void deleteBatch(java.lang.Iterable<java.lang.Object> keys)

Description copied from interface: CacheWriter

Remove all provided keys from the store in a single batch operation. If this is not supported by the underlying store, then keys are removed from the store individually via CacheWriter.delete(Object).

Specified by:

deleteBatch in interface CacheWriter<K,V>

Parameters:

keys - an Iterable of entry Keys to be removed from the store.

purge

public void purge(java.util.concurrent.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>

addSegments

public void addSegments(IntSet segments)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Invoked when a node becomes an owner of the given segments. Note this method is only invoked for non shared store implementations.

This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not.

Specified by:

addSegments in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segments - segments to associate with this store

removeSegments

public void removeSegments(IntSet segments)

Description copied from interface: SegmentedAdvancedLoadWriteStore

Invoked when a node loses ownership of a segment. The provided segments are the ones this node no longer owns. Note this method is only invoked for non shared store implementations.

This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not. StoreConfiguration.segmented().

Specified by:

removeSegments in interface SegmentedAdvancedLoadWriteStore<K,V>

Parameters:

segments - segments that should no longer be associated with this store