Class SingleFileStore<K,V>
- All Implemented Interfaces:
NonBlockingStore<K,
V>
NonBlockingStore
.
This file store stores cache values in a single file <location>/<cache name>.dat,
keys and file positions are kept in memory.
Note: this CacheStore implementation keeps keys and file positions in memory!
The current implementation needs about 100 bytes per cache entry, plus the
memory for the key objects.
So, the space taken by this cache store is both the space in the file
itself plus the in-memory index with the keys and their file positions.
With this in mind and to avoid the cache store leading to
OutOfMemoryExceptions, you can optionally configure the maximum number
of entries to maintain in this cache store, which affects both the size
of the file and the size of the in-memory index. However, setting this
maximum limit results in older entries in the cache store to be eliminated,
and hence, it only makes sense configuring a maximum limit if Infinispan
is used as a cache where loss of data in the cache store does not lead to
data loss, and data can be recomputed or re-queried from the original data
source.
This class is fully thread safe, yet allows for concurrent load / store
of individual cache entries.- Since:
- 6.0
- Author:
- Karsten Blees, Mircea Markus
-
Nested Class Summary
Nested classes/interfaces inherited from interface org.infinispan.persistence.spi.NonBlockingStore
NonBlockingStore.Characteristic, NonBlockingStore.SegmentedPublisher<Type>
-
Field Summary
Modifier and TypeFieldDescriptionprotected InitializationContext
static final int
static final int
static final int
static final byte[]
static final byte[]
static final byte[]
static final byte[]
static final byte[]
Fields inherited from interface org.infinispan.persistence.spi.NonBlockingStore
SIZE_UNAVAILABLE_FUTURE
-
Constructor Summary
-
Method Summary
Modifier and TypeMethodDescriptionaddSegments
(IntSet segments) Invoked when a node becomes an owner of the given segments.approximateSize
(IntSet segments) Returns an estimation of the amount of entries that map to the given segments in the store.Returns a set of characteristics for this store and its elements.clear()
Clears all entries from the store.containsKey
(int segment, Object key) The base class implementation callsload(int, Object)
for this, we can do better because we keep all keys in memory.Removes the entry for given key and segment from the store and optionally report if the entry was actually removed or not.static File
getStoreFile
(String directoryPath, String cacheName) Returns a stage that, when complete, returns a boolean indicating whether the current store can be accessed for requests.Returns a stage that will contain the value loaded from the store.org.reactivestreams.Publisher<MarshallableEntry<K,
V>> publishEntries
(IntSet segments, Predicate<? super K> filter, boolean includeValues) Publishes entries from this store that are in one of the provided segments and also pass the provided filter.org.reactivestreams.Publisher<K>
publishKeys
(IntSet segments, Predicate<? super K> filter) Publishes keys from this store that are in one of the provided segments and also pass the provided filter.org.reactivestreams.Publisher<MarshallableEntry<K,
V>> Returns a Publisher that, after it is subscribed to, removes any expired entries from the store and publishes them to the returned Publisher.removeSegments
(IntSet segments) Invoked when a node loses ownership of the given segments.Returns the amount of entries that map to the given segments in the store.The first method to invoke so that the store can be configured and additional steps, such as connecting through a socket or opening file descriptors, are performed.stop()
This method is invoked when the cache is being shutdown.write
(int segment, MarshallableEntry<? extends K, ? extends V> marshalledEntry) Writes the entry to the store for the given segment returning a stage that completes normally when it is finished.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.NonBlockingStore
batch, commit, destroy, ignoreCommandWithFlags, prepareWithModifications, rollback
-
Field Details
-
MAGIC_BEFORE_11
public static final byte[] MAGIC_BEFORE_11 -
MAGIC_11_0
public static final byte[] MAGIC_11_0 -
MAGIC_12_0
public static final byte[] MAGIC_12_0 -
MAGIC_12_1
public static final byte[] MAGIC_12_1 -
MAGIC_LATEST
public static final byte[] MAGIC_LATEST -
KEY_POS_BEFORE_11
public static final int KEY_POS_BEFORE_11- See Also:
-
KEY_POS_11_0
public static final int KEY_POS_11_0- See Also:
-
KEY_POS_LATEST
public static final int KEY_POS_LATEST- See Also:
-
ctx
-
-
Constructor Details
-
SingleFileStore
public SingleFileStore()
-
-
Method Details
-
getStoreFile
-
start
Description copied from interface:NonBlockingStore
The first method to invoke so that the store can be configured and additional steps, such as connecting through a socket or opening file descriptors, are performed.The provided
InitializationContext
contains many helpful objects, including the configuration of the cache and store, concurrency utilities such asBlockingManager
or an executor reserved for non-blocking operations onlyInitializationContext.getNonBlockingExecutor()
.This method is guaranteed not to be invoked concurrently with other operations. This means other methods are not invoked on this store until after the returned Stage completes.
It is expected that an implementation should be able to "restart" by invoking
start
a second time ifNonBlockingStore.stop()
has been invoked and allowed for its stage to complete.- Specified by:
start
in interfaceNonBlockingStore<K,
V> - Parameters:
ctx
- initialization context used to initialize this store.- Returns:
- a stage that, when complete, indicates that this store has started successfully.
-
stop
Description copied from interface:NonBlockingStore
This method is invoked when the cache is being shutdown. It is expected that all resources related to the store are freed when the returned stage is complete.This method is guaranteed not to be invoked concurrently with other operations. This means other methods are not invoked on this store until after the returned Stage completes.
It is expected that an implementation should be able to "restart" by invoking
NonBlockingStore.start(InitializationContext)
a second time ifstop
has been invoked and allowed for its stage to complete.- Specified by:
stop
in interfaceNonBlockingStore<K,
V> - Returns:
- a stage that, when complete, indicates that this store has stopped.
-
characteristics
Description copied from interface:NonBlockingStore
Returns a set of characteristics for this store and its elements. This method may be invoked multiple times to determine which methods of the store can be used and how the data in the store can be handled.Refer to
NonBlockingStore.Characteristic
and its values for descriptions of each characteristic for stores.- Specified by:
characteristics
in interfaceNonBlockingStore<K,
V> - Returns:
- the set of characteristics that this store supports.
-
isAvailable
Description copied from interface:NonBlockingStore
Returns a stage that, when complete, returns a boolean indicating whether the current store can be accessed for requests. This can be useful for store implementations that rely on an external source, such as a remote database, that may become unreachable. This can reduce sending requests to a store that is not available, as subsequent cache requests will result in aStoreUnavailableException
being thrown until the store becomes available again.Store availability is polled periodically to update the status of stores if their availability changes. This method is not invoked concurrently with itself. In other words, this method is not invoked until after the previous stage has completed. However, this method is invoked concurrently with other operations, except for
NonBlockingStore.start(InitializationContext)
andNonBlockingStore.stop()
.If a store is configured to be
StoreConfiguration.async()
and the store becomes unavailable, then it is possible for the cache operations to be accepted in the interim period between the loss of availability and the modification-queue becoming full. This allows for this store to be unavailable for short periods of time without aStoreUnavailableException
being thrown; however if the store does not become available before the queue fills, then aStoreUnavailableException
is thrown.- Specified by:
isAvailable
in interfaceNonBlockingStore<K,
V> - Returns:
- stage that, when complete, indicates if the store is available.
-
containsKey
The base class implementation callsload(int, Object)
for this, we can do better because we keep all keys in memory.- Specified by:
containsKey
in interfaceNonBlockingStore<K,
V> - Parameters:
segment
- the segment for the given key if segmentation is enabled, otherwise 0.key
- key of the entry to check.- Returns:
- a stage that, when complete, contains a boolean stating if the value is contained in the store.
-
write
public CompletionStage<Void> write(int segment, MarshallableEntry<? extends K, ? extends V> marshalledEntry) Description copied from interface:NonBlockingStore
Writes the entry to the store for the given segment returning a stage that completes normally when it is finished.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.READ_ONLY
This method will never be invoked. NonBlockingStore.Characteristic.EXPIRATION
When set, this method must store the expiration metadata. NonBlockingStore.Characteristic.SEGMENTABLE
When set and segmentation is not disabled in the configuration
, this method must ensure the segment is stored with the entry.If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
write
in interfaceNonBlockingStore<K,
V> - Parameters:
segment
- the segment for the given key if segmentation is enabled, otherwise 0.marshalledEntry
- the entry to persist to the store.- Returns:
- a stage that when complete indicates that the store has written the value.
-
clear
Description copied from interface:NonBlockingStore
Clears all entries from the store.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.READ_ONLY
This method will never be invoked. If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
clear
in interfaceNonBlockingStore<K,
V> - Returns:
- a stage that, when complete, indicates that the store has been cleared.
-
delete
Description copied from interface:NonBlockingStore
Removes the entry for given key and segment from the store and optionally report if the entry was actually removed or not.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.READ_ONLY
This method will never be invoked. NonBlockingStore.Characteristic.SEGMENTABLE
When this is not set or segmentation is disabled in the configuration
, thesegment
parameter may be ignored.If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
delete
in interfaceNonBlockingStore<K,
V> - Parameters:
segment
- the segment for the given key if segmentation is enabled, otherwise 0.key
- key of the entry to delete from the store.- Returns:
- a stage that completes with
TRUE
if the key existed in the store,FALSE
if the key did not exist in the store, ornull
if the store does not report this information.
-
load
Description copied from interface:NonBlockingStore
Returns a stage that will contain the value loaded from the store. If aMarshallableEntry
needs to be created here,InitializationContext.getMarshallableEntryFactory()
andInitializationContext.getByteBufferFactory()
should be used.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.WRITE_ONLY
This method will never be invoked. NonBlockingStore.Characteristic.EXPIRATION
When set this method must not return expired entries. NonBlockingStore.Characteristic.SEGMENTABLE
When this is not set or segmentation is disabled in the configuration
, thesegment
parameter may be ignored.If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
load
in interfaceNonBlockingStore<K,
V> - Parameters:
segment
- the segment for the given key if segmentation is enabled, otherwise 0.key
- key of the entry to load.- Returns:
- a stage that, when complete, contains the store value or null if not present.
-
publishKeys
Description copied from interface:NonBlockingStore
Publishes keys from this store that are in one of the provided segments and also pass the provided filter. The returned publisher must support being subscribed to any number of times. That is subsequent invocations ofPublisher.subscribe(Subscriber)
should provide independent views of the underlying keys to the Subscribers. Keys should not be retrieved until a given Subscriber requests them via theSubscription.request(long)
method.Subscribing to the returned
Publisher
should not block the invoking thread. It is the responsibility of the store implementation to ensure this occurs. If however the store must block to perform an operation it is recommended to wrap your Publisher before returning with theBlockingManager.blockingPublisher(Publisher)
method and it will handle subscription and observation on the blocking and non-blocking executors respectively.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.BULK_READ
This method is only invoked if the store has this characteristic. NonBlockingStore.Characteristic.EXPIRATION
When set the returned publisher must not return expired keys. NonBlockingStore.Characteristic.SEGMENTABLE
When this is not set or segmentation is disabled in the configuration
, thesegment
parameter may be ignored.- Specified by:
publishKeys
in interfaceNonBlockingStore<K,
V> - Parameters:
segments
- a set of segments to filter keys by. This will always be non-null.filter
- a filter to filter the keys by. If this is null then no additional filtering should be done after segments.- Returns:
- a publisher that provides the keys from the store.
-
publishEntries
public org.reactivestreams.Publisher<MarshallableEntry<K,V>> publishEntries(IntSet segments, Predicate<? super K> filter, boolean includeValues) Description copied from interface:NonBlockingStore
Publishes entries from this store that are in one of the provided segments and also pass the provided filter. The returned publisher must support being subscribed to any number of times. That is subsequent invocations ofPublisher.subscribe(Subscriber)
should provide independent views of the underlying entries to the Subscribers. Entries should not be retrieved until a given Subscriber requests them via theSubscription.request(long)
method.Subscribing to the returned
Publisher
should not block the invoking thread. It is the responsibility of the store implementation to ensure this occurs. If however the store must block to perform an operation it is recommended to wrap your Publisher before returning with theBlockingManager.blockingPublisher(Publisher)
method and it will handle subscription and observation on the blocking and non-blocking executors respectively.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.BULK_READ
This method is only invoked if the store has this characteristic. NonBlockingStore.Characteristic.EXPIRATION
When set the returned publisher must not return expired entries. NonBlockingStore.Characteristic.SEGMENTABLE
When this is not set or segmentation is disabled in the configuration
, thesegment
parameter may be ignored.- Specified by:
publishEntries
in interfaceNonBlockingStore<K,
V> - Parameters:
segments
- a set of segments to filter entries by. This will always be non-null.filter
- a filter to filter the keys by. If this is null then no additional filtering should be done after segments.- Returns:
- a publisher that provides the keys from the store.
-
purgeExpired
Description copied from interface:NonBlockingStore
Returns a Publisher that, after it is subscribed to, removes any expired entries from the store and publishes them to the returned Publisher.When the Publisher is subscribed to, it is expected to do point-in-time expiration and should not return a Publisher that has infinite entries or never completes.
Subscribing to the returned
Publisher
should not block the invoking thread. It is the responsibility of the store implementation to ensure this occurs. If however the store must block to perform an operation it is recommended to wrap your Publisher before returning with theBlockingManager.blockingPublisher(Publisher)
method and it will handle subscription and observation on the blocking and non-blocking executors respectively.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.EXPIRATION
This method is only invoked if the store has this characteristic. If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
purgeExpired
in interfaceNonBlockingStore<K,
V> - Returns:
- a Publisher that publishes the entries that are expired at the time of subscription.
-
size
Description copied from interface:NonBlockingStore
Returns the amount of entries that map to the given segments in the store.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.BULK_READ
This method is only invoked if the store has this characteristic. NonBlockingStore.Characteristic.SEGMENTABLE
When this is not set or segmentation is disabled in the configuration
, thesegments
parameter may be ignored.If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
size
in interfaceNonBlockingStore<K,
V> - Parameters:
segments
- the segments for which the entries are counted.- Returns:
- a stage that, when complete, contains the count of how many entries are present for the given segments.
-
approximateSize
Description copied from interface:NonBlockingStore
Returns an estimation of the amount of entries that map to the given segments in the store. This is similar toNonBlockingStore.size(IntSet)
except that it is not strict about the returned size. For instance, this method might ignore if an entry is expired or if the store has some underlying optimizations to eventually have a consistent size.The implementations should be O(1). If a size approximation cannot be returned without iterating over all the entries in the store, the implementation should return
-1L
.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.BULK_READ
This method is only invoked if the store has this characteristic. NonBlockingStore.Characteristic.SEGMENTABLE
When the store does not have this characteristic or segmentation is disabled in the configuration
, thesegment
parameter is alwaysIntSets.immutableRangeSet(numSegments)
.If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
approximateSize
in interfaceNonBlockingStore<K,
V> - Parameters:
segments
- the segments for which the entries are counted.- Returns:
- a stage that, when complete, contains the approximate count of the entries in the given segments,
or
-1L
if an approximate count cannot be provided.
-
getConfiguration
-
addSegments
Description copied from interface:NonBlockingStore
Invoked when a node becomes an owner of the given segments. Some store implementations may require initializing additional resources when a new segment is required. For example a store could store entries in a different file per segment.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.SHAREABLE
If the store has this characteristic and is configured to be StoreConfiguration.shared()
, this method will never be invoked.NonBlockingStore.Characteristic.SEGMENTABLE
This method is invoked only if the store has this characteristic and is configured to be segmented
.If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
addSegments
in interfaceNonBlockingStore<K,
V> - Parameters:
segments
- the segments to add.- Returns:
- a stage that, when complete, indicates that the segments have been added.
-
removeSegments
Description copied from interface:NonBlockingStore
Invoked when a node loses ownership of the given segments. A store must then remove any entries that map to the given segments and can remove any resources related to the given segments. For example, a database store can delete rows of the given segment or a file-based store can delete files related to the given segments.Summary of Characteristics Effects
Characteristic Effect NonBlockingStore.Characteristic.SHAREABLE
If the store has this characteristic and is configured to be shared
, this method will never be invoked.NonBlockingStore.Characteristic.SEGMENTABLE
This method is invoked only if the store has this characteristic and is configured to be segmented
.If a problem is encountered, it is recommended to wrap any created/caught Throwable in a
PersistenceException
and the stage be completed exceptionally.- Specified by:
removeSegments
in interfaceNonBlockingStore<K,
V> - Parameters:
segments
- the segments to remove.- Returns:
- a stage that, when complete, indicates that the segments have been removed.
-