Package org.infinispan.persistence.support

Class ComposedSegmentedLoadWriteStore<K,V,T extends AbstractSegmentedStoreConfiguration>

java.lang.Object
org.infinispan.persistence.support.AbstractSegmentedAdvancedLoadWriteStore<K,V>
org.infinispan.persistence.support.ComposedSegmentedLoadWriteStore<K,V,T>
All Implemented Interfaces:
Lifecycle, AdvancedCacheExpirationWriter<K,V>, AdvancedCacheLoader<K,V>, AdvancedCacheWriter<K,V>, AdvancedLoadWriteStore<K,V>, CacheLoader<K,V>, CacheWriter<K,V>, ExternalStore<K,V>, SegmentedAdvancedLoadWriteStore<K,V>
public class ComposedSegmentedLoadWriteStore<K,V,T extends AbstractSegmentedStoreConfiguration> extends AbstractSegmentedAdvancedLoadWriteStore<K,V>
Segmented store that creates multiple inner stores for each segment. This is used by stores that are not segmented but have a configuration that implements AbstractSegmentedStoreConfiguration.
Since:
9.4
Author:
wburns

  • Constructor Details

  • Method Details

    • getKeyMapper

      public ToIntFunction<Object> getKeyMapper()
      Specified by:
      getKeyMapper in class AbstractSegmentedAdvancedLoadWriteStore<K,V>

    • get

      public MarshallableEntry<K,V> get(int segment, Object key)
      Description copied from interface: SegmentedAdvancedLoadWriteStore
      Fetches an entry from the storage given a segment to optimize this lookup based on. If a MarshallableEntry needs to be created here, InitializationContext.getMarshallableEntryFactory() and InitializationContext.getByteBufferFactory() should be used.

      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().

      Parameters:
      segment - the segment that the key maps to
      key - the key of the entry to fetch
      Returns:
      the entry, or null if the entry does not exist

    • contains

      public boolean contains(int segment, 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().

      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

    • write

      public void write(int segment, MarshallableEntry<? extends K,? extends V> entry)
      Description copied from interface: SegmentedAdvancedLoadWriteStore
      Persists the entry to the storage with the given segment to optimize future lookups.

      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().

      Parameters:
      segment - the segment to persist this entry to
      entry - the entry to write to the store
      See Also:

    • delete

      public boolean delete(int segment, 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().

      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.

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

      Parameters:
      segments - the segments which should have their entries counted. Always non null.
      Returns:
      the count of entries in the given segments

    • size

      public int size()
      Description copied from interface: AdvancedCacheLoader
      Returns the number of elements in the store.

    • publishKeys

      public org.reactivestreams.Publisher<K> publishKeys(IntSet segments, 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().

      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

    • publishKeys

      public org.reactivestreams.Publisher<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

      Parameters:
      filter - a filter - null is treated as allowing all entries
      Returns:
      a publisher that will provide the keys from the store

    • entryPublisher

      public org.reactivestreams.Publisher<MarshallableEntry<K,V>> entryPublisher(IntSet segments, 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().

      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

    • entryPublisher

      public org.reactivestreams.Publisher<MarshallableEntry<K,V>> entryPublisher(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.

      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

    • clear

      public void clear()
      Description copied from interface: AdvancedCacheWriter
      Removes all the data from the storage.

    • purge

      public void purge(Executor executor, AdvancedCacheExpirationWriter.ExpirationPurgeListener<K,V> listener)
      Description copied from interface: SegmentedAdvancedLoadWriteStore
      Using the thread in the pool, removed all the expired data from the persistence storage. For each removed entry, the supplied listener is invoked. This should be preferred to AdvancedCacheWriter.purge(Executor, PurgeListener) since it allows for value and metadata to be provided which provides more accurate expiration when coordination is required.
      Parameters:
      executor - the executor to invoke the given command on
      listener - the listener that is notified for each expired entry

    • clear

      public void clear(IntSet segments)
      Description copied from interface: SegmentedAdvancedLoadWriteStore
      Removes all the data that maps to the given segments from the storage.

      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.

      Parameters:
      segments - data mapping to these segments are removed. Always non null.

    • deleteBatch

      public void deleteBatch(Iterable<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).
      Parameters:
      keys - an Iterable of entry Keys to be removed from the store.

    • bulkUpdate

      public CompletionStage<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).
      Parameters:
      publisher - a Publisher of MarshallableEntry instances

    • init

      public void init(InitializationContext ctx)
      Description copied from interface: CacheLoader
      Used to initialize a cache loader. Typically invoked by the PersistenceManager when setting up cache loaders.

    • start

      public void start()
      Description copied from interface: Lifecycle
      Invoked on component start

    • stop

      public void stop()
      Description copied from interface: Lifecycle
      Invoked on component stop

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

    • addSegments

      public void addSegments(IntSet segments)
      Description copied from interface: SegmentedAdvancedLoadWriteStore
      Invoked when a node becomes an owner of the given segments. Note this method is only invoked for non shared store implementations.

      This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not.

      Parameters:
      segments - segments to associate with this store

    • removeSegments

      public void removeSegments(IntSet segments)
      Description copied from interface: SegmentedAdvancedLoadWriteStore
      Invoked when a node loses ownership of a segment. The provided segments are the ones this node no longer owns. Note this method is only invoked for non shared store implementations.

      This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not. StoreConfiguration.segmented().

      Parameters:
      segments - segments that should no longer be associated with this store

    • forEach

      public void forEach(ObjIntConsumer<? super AdvancedLoadWriteStore> consumer)
      Method that allows user to directly invoke some method(s) on the underlying store. The segment that each store maps to is also provided as an argument to the consumer
      Parameters:
      consumer - callback for every store that is currently installed