Class SingleFileStore<K,​V>

  • All Implemented Interfaces:
    org.infinispan.commons.api.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 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()
        Specified by:
        start in interface org.infinispan.commons.api.Lifecycle
      • stop

        public void stop()
        Specified by:
        stop in interface org.infinispan.commons.api.Lifecycle
      • contains

        public boolean contains​(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​(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​(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
        Returns:
        a publisher that will provide the keys from the store
      • publishEntries

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

        public void purge​(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>