Class SingleFileStore<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 SingleFileStore<K,​V>
    extends java.lang.Object
    implements AdvancedLoadWriteStore<K,​V>
    A filesystem-based implementation of a AdvancedLoadWriteStore. 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
    • Constructor Detail

      • SingleFileStore

        public SingleFileStore()
    • Method Detail

      • start

        public void start()
        Description copied from interface: Lifecycle
        Invoked on component start
        Specified by:
        start in interface Lifecycle
      • 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>
      • contains

        public boolean contains​(java.lang.Object key)
        The base class implementation calls load(Object) for this, we can do better because we keep all keys in memory.
        Specified by:
        contains in interface CacheLoader<K,​V>
      • 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.
      • publishKeys

        public io.reactivex.Flowable<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
      • publishEntries

        public io.reactivex.Flowable<MarshalledEntry<K,​V>> publishEntries​(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:
        publishEntries 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
      • purge

        public void purge​(java.util.concurrent.Executor threadPool,
                          AdvancedCacheWriter.PurgeListener task)
        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>