@ThreadSafe public class RemoteStore<K,V> extends Object implements SegmentedAdvancedLoadWriteStore<K,V>, FlagAffectedStore<K,V>
RemoteStoreConfiguration
,
Hotrod Java ClientAdvancedCacheLoader.CacheLoaderTask<K,V>, AdvancedCacheLoader.TaskContext
AdvancedCacheWriter.PurgeListener<K>
Modifier and Type | Field and Description |
---|---|
protected InitializationContext |
ctx |
Constructor and Description |
---|
RemoteStore() |
Modifier and Type | Method and Description |
---|---|
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(Object key)
Returns true if the storage contains an entry associated with the given key.
|
boolean |
delete(Object key) |
RemoteStoreConfiguration |
getConfiguration() |
org.infinispan.client.hotrod.RemoteCache<Object,Object> |
getRemoteCache() |
void |
init(InitializationContext ctx)
Used to initialize a cache loader.
|
boolean |
isAvailable() |
MarshalledEntry<K,V> |
load(Object key)
Fetches an entry from the storage.
|
org.reactivestreams.Publisher<MarshalledEntry<K,V>> |
publishEntries(IntSet segments,
Predicate<? super K> filter,
boolean fetchValue,
boolean fetchMetadata)
Publishes all entries from this store.
|
org.reactivestreams.Publisher<MarshalledEntry<K,V>> |
publishEntries(Predicate<? super K> filter,
boolean fetchValue,
boolean fetchMetadata)
Publishes all entries from this store.
|
io.reactivex.Flowable<K> |
publishKeys(IntSet segments,
Predicate<? super K> filter)
Publishes all the keys that map to the given segments from this store.
|
io.reactivex.Flowable<K> |
publishKeys(Predicate<? super K> filter)
Publishes all the keys from this store.
|
void |
purge(Executor threadPool,
AdvancedCacheWriter.PurgeListener task)
Using the thread in the pool, removed all the expired data from the persistence storage.
|
void |
setInternalCacheEntryFactory(InternalEntryFactory iceFactory) |
boolean |
shouldWrite(long commandFlags) |
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(MarshalledEntry entry)
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.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
addSegments, contains, delete, load, removeSegments, write
destroy
process
deleteBatch
protected InitializationContext ctx
public void init(InitializationContext ctx)
CacheLoader
PersistenceManager
when setting up cache loaders.init
in interface CacheLoader<K,V>
init
in interface CacheWriter<K,V>
public void start() throws PersistenceException
Lifecycle
start
in interface Lifecycle
PersistenceException
public void stop() throws PersistenceException
Lifecycle
stop
in interface Lifecycle
PersistenceException
public boolean isAvailable()
isAvailable
in interface CacheLoader<K,V>
isAvailable
in interface CacheWriter<K,V>
isAvailable
in interface ExternalStore<K,V>
public MarshalledEntry<K,V> load(Object key) throws PersistenceException
CacheLoader
MarshalledEntry
needs to be created here, InitializationContext.getMarshalledEntryFactory()
and InitializationContext.getByteBufferFactory()
should be used.load
in interface CacheLoader<K,V>
PersistenceException
- in case of an error, e.g. communicating with the external storagepublic boolean contains(Object key) throws PersistenceException
CacheLoader
contains
in interface CacheLoader<K,V>
PersistenceException
- in case of an error, e.g. communicating with the external storagepublic io.reactivex.Flowable<K> publishKeys(Predicate<? super K> filter)
AdvancedCacheLoader
Subscriber
s as desired. Keys are not retrieved until a given Subscriber requests
them from the Subscription
.
Stores will return only non expired keys
publishKeys
in interface AdvancedCacheLoader<K,V>
filter
- a filter - null is treated as allowing all entriespublic io.reactivex.Flowable<K> publishKeys(IntSet segments, Predicate<? super K> filter)
SegmentedAdvancedLoadWriteStore
Subscriber
s 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()
.
publishKeys
in interface SegmentedAdvancedLoadWriteStore<K,V>
segments
- the segments that the keys must map to. Always non null.filter
- a filterpublic org.reactivestreams.Publisher<MarshalledEntry<K,V>> publishEntries(Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
AdvancedCacheLoader
Subscriber
s 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.
publishEntries
in interface AdvancedCacheLoader<K,V>
filter
- a filter - null is treated as allowing all entriesfetchValue
- 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
wellfetchMetadata
- 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 wellpublic org.reactivestreams.Publisher<MarshalledEntry<K,V>> publishEntries(IntSet segments, Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
SegmentedAdvancedLoadWriteStore
Subscriber
s 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()
.
publishEntries
in interface SegmentedAdvancedLoadWriteStore<K,V>
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 publisherfetchValue
- whether the value should be included in the marshalled entryfetchMetadata
- whether the metadata should be included in the marshalled entrypublic int size()
AdvancedCacheLoader
size
in interface AdvancedCacheLoader<K,V>
public int size(IntSet segments)
SegmentedAdvancedLoadWriteStore
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()
.
size
in interface SegmentedAdvancedLoadWriteStore<K,V>
segments
- the segments which should have their entries counted. Always non null.public void purge(Executor threadPool, AdvancedCacheWriter.PurgeListener task)
AdvancedCacheWriter
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.
purge
in interface AdvancedCacheWriter<K,V>
public void write(MarshalledEntry entry) throws PersistenceException
CacheWriter
write
in interface CacheWriter<K,V>
PersistenceException
- in case of an error, e.g. communicating with the external storageMarshalledEntry
public void writeBatch(Iterable<MarshalledEntry<? extends K,? extends V>> marshalledEntries)
CacheWriter
CacheWriter.write(MarshalledEntry)
.writeBatch
in interface CacheWriter<K,V>
marshalledEntries
- an Iterable of MarshalledEntry to be written to the store.public void clear() throws PersistenceException
AdvancedCacheWriter
clear
in interface AdvancedCacheWriter<K,V>
PersistenceException
- in case of an error, e.g. communicating with the external storagepublic void clear(IntSet segments)
SegmentedAdvancedLoadWriteStore
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.
clear
in interface SegmentedAdvancedLoadWriteStore<K,V>
segments
- data mapping to these segments are removed. Always non null.public boolean delete(Object key) throws PersistenceException
delete
in interface CacheWriter<K,V>
PersistenceException
- in case of an error, e.g. communicating with the external storagepublic void setInternalCacheEntryFactory(InternalEntryFactory iceFactory)
public RemoteStoreConfiguration getConfiguration()
public boolean shouldWrite(long commandFlags)
shouldWrite
in interface FlagAffectedStore<K,V>
Copyright © 2019 JBoss, a division of Red Hat. All rights reserved.