Package org.infinispan.persistence.rocksdb

Class RocksDBStore<K,​V>

    • Constructor Summary

      Constructors 
      Constructor Description
      RocksDBStore()  

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method 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​(java.util.function.Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
      Publishes all entries from 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.
      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.nio.file.Path location, org.rocksdb.Options options)
      Creates database if it doesn't exist.
      org.reactivestreams.Publisher<K> publishKeys​(java.util.function.Predicate<? super K> filter)
      Publishes all the keys from this store.
      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.
      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.CacheLoader

        load

    • Constructor Detail

      • RocksDBStore

        public RocksDBStore()

    • Method Detail

      • 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.nio.file.Path location,
                                           org.rocksdb.Options options)
                                    throws org.rocksdb.RocksDBException
        Creates database if it doesn't exist.
        Throws:
        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>

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

      • 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 AdvancedCacheExpirationWriter<K,​V>
        Specified by:
        purge in interface AdvancedCacheWriter<K,​V>