Package com.tangosol.coherence.config.scheme

Class ReadWriteBackingMapScheme

java.lang.Object
com.tangosol.coherence.config.scheme.AbstractScheme
com.tangosol.coherence.config.scheme.AbstractServiceScheme
com.tangosol.coherence.config.scheme.AbstractCachingScheme
com.tangosol.coherence.config.scheme.AbstractLocalCachingScheme<ReadWriteBackingMap>
com.tangosol.coherence.config.scheme.ReadWriteBackingMapScheme
All Implemented Interfaces:
BackingMapManagerBuilder, BuilderCustomization<ReadWriteBackingMap>, MapBuilder, NamedCacheBuilder, ServiceBuilder, CachingScheme, ObservableCachingScheme, Scheme, ServiceScheme
public class ReadWriteBackingMapScheme extends AbstractLocalCachingScheme<ReadWriteBackingMap>
The RemoteCacheScheme is responsible for creating a fully configured ReadWriteBackingMap. The setters are annotated so that CODI can automatically configure the builder After the builder is configured, the realize method can be called to create either a custom ReadWriteBackingMap or the internal Coherence ReadWriteBackingMap.
Since:
Coherence 12.1.2
Author:
pfm 2011.11.30

  • Constructor Details

    • ReadWriteBackingMapScheme

      public ReadWriteBackingMapScheme()

  • Method Details

    • realizeMap

      public ReadWriteBackingMap realizeMap(ParameterResolver resolver, MapBuilder.Dependencies dependencies)
      Realize a Map based on the state of the MapBuilder, resolvable parameters and provided MapBuilder.Dependencies.
      Specified by:
      realizeMap in interface MapBuilder
      Overrides:
      realizeMap in class AbstractCachingScheme
      Parameters:
      resolver - the ParameterResolver
      dependencies - the MapBuilder.Dependencies for realizing the Map
      Returns:
      a Map

    • establishMapListeners

      public void establishMapListeners(Map map, ParameterResolver resolver, MapBuilder.Dependencies dependencies)
      Establishes an appropriate MapListener (provided by the ObservableCachingScheme.getListenerBuilder()) on the ObservableMap that was produced by the ObservableCachingScheme.

      This method will automatically inject the following types and named values into realized classes that have been annotated with @Injectable.

      1. BackingMapManagerContext (optionally named "manager-context")
      2. ConfigurableCacheFactory
      3. Cache Name (as a String.class named "cache-name")
      4. Context ClassLoader (optionally named "class-loader")
      5. ResourceRegistry
      6. CacheConfig
      7. together with any other resource, named or otherwise, available in the ResourceRegistry provided by the ConfigurableCacheFactory.
      Specified by:
      establishMapListeners in interface ObservableCachingScheme
      Overrides:
      establishMapListeners in class AbstractCachingScheme
      Parameters:
      map - an ObservableMap to which to add a MapListener (if the map is not observable, no listeners are added)
      resolver - the ParameterResolver to use for resolving builder parameters
      dependencies - the MapBuilder dependencies from which to obtain builder information
      See Also:

    • getCacheStoreScheme

      public CacheStoreScheme getCacheStoreScheme()
      Return the CacheStoreScheme used to create a CacheStore or CacheLoader.
      Returns:
      the builder

    • setCacheStoreScheme

      @Injectable("cachestore-scheme") public void setCacheStoreScheme(CacheStoreScheme bldr)
      Set the CacheStoreScheme builder.
      Parameters:
      bldr - the builder

    • getCacheStoreTimeout

      public Millis getCacheStoreTimeout(ParameterResolver resolver)
      Return the timeout interval to use for CacheStore read and write operations. If a CacheStore operation times out, the executing thread is interrupted and may ultimately lead to the termination of the cache service. Timeouts of asynchronous CacheStore operations (for example, refresh-ahead, write-behind) do not result in service termination.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the timeout

    • setCacheStoreTimeout

      @Injectable("cachestore-timeout") public void setCacheStoreTimeout(Expression<Millis> expr)
      Set the timeout interval to use for CacheStore/CacheLoader read and write operations.
      Parameters:
      expr - the timeout interval expression

    • getInternalScheme

      public CachingScheme getInternalScheme()
      Return the scheme which the specifies the map used to cache entries.
      Returns:
      the scheme for the internal map

    • setInternalScheme

      @Injectable("internal-cache-scheme") public void setInternalScheme(CachingScheme scheme)
      Set the internal scheme.
      Parameters:
      scheme - the internal scheme

    • getInternalMap

      public ObservableMap getInternalMap()
      Return the internal map which is set by the backing map manager when the partitioned flag is true. Otherwise the map will be null.
      Returns:
      the internal map

    • setInternalMap

      public void setInternalMap(ObservableMap map)
      Set the internal map.
      Parameters:
      map - the internal map

    • getMissCacheScheme

      public LocalScheme getMissCacheScheme()
      Return the Scheme for the cache used to maintain information on cache misses. The miss-cache is used track keys which were not found in the cache store. The knowledge that a key is not in the cache store allows some operations to perform faster, as they can avoid querying the potentially slow cache store. A size-limited scheme may be used to control how many misses are cached. If unspecified no cache-miss data is maintained.
      Returns:
      the miss cache scheme

    • setMissCacheScheme

      @Injectable("miss-cache-scheme") public void setMissCacheScheme(LocalScheme scheme)
      Set the miss cache Scheme.
      Parameters:
      scheme - the miss cache scheme

    • isReadOnly

      public boolean isReadOnly(ParameterResolver resolver)
      Returns true if the cache is read only. A read-only cache loads data from cache store for read operations and does not perform any writing to the cache store when the cache is updated.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      true if the cache is read only

    • setReadOnly

      @Injectable public void setReadOnly(Expression<Boolean> expr)
      Set the read-only flag.
      Parameters:
      expr - true if the cache is read-only

    • getRefreshAheadFactor

      public double getRefreshAheadFactor(ParameterResolver resolver)
      Return refresh-ahead-factor used to calculate the "soft-expiration" time for cache entries. Soft-expiration is the point in time before the actual expiration after which any access request for an entry schedules an asynchronous load request for the entry. This attribute is only applicable if the internal cache is a LocalCache, with a non-zero expiry delay. The value is expressed as a percentage of the internal LocalCache expiration interval. If zero, refresh-ahead scheduling is disabled. If 1.0, then any get operation immediately triggers an asynchronous reload. Legal values are nonnegative doubles less than or equal to 1.0.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the refresh-ahead factor

    • setRefreshAheadFactor

      @Injectable public void setRefreshAheadFactor(Expression<Double> expr)
      Set the refresh ahead factor.
      Parameters:
      expr - the refresh ahead factor

    • isRollbackCacheStoreFailures

      public boolean isRollbackCacheStoreFailures(ParameterResolver resolver)
      Return true if exceptions caught during synchronous cachestore operations are rethrown to the calling thread (possibly over the network to a remote member). Legal values are true or false. If the value of this element is false, an exception caught during a synchronous cachestore operation is logged locally and the internal cache is updated. If the value is true, the exception is rethrown to the calling thread and the internal cache is not changed. If the operation was called within a transactional context, this would have the effect of rolling back the current transaction.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the rollback cachestore failures flag

    • setRollbackCacheStoreFailures

      @Injectable("rollback-cachestore-failures") public void setRollbackCacheStoreFailures(Expression<Boolean> expr)
      Set the flag to indicate that cache store failures should be rolled back.
      Parameters:
      expr - true if failures should be rolled back

    • getWriteBatchFactor

      public double getWriteBatchFactor(ParameterResolver resolver)
      Return the write-batch-factor element is used to calculate the "soft-ripe" time for write-behind queue entries. A queue entry is considered to be "ripe" for a write operation if it has been in the write-behind queue for no less than the write-delay interval. The "soft-ripe" time is the point in time before the actual ripe time after which an entry is included in a batched asynchronous write operation to the CacheStore (along with all other ripe and soft-ripe entries).
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the write batch factor

    • setWriteBatchFactor

      @Injectable public void setWriteBatchFactor(Expression<Double> expr)
      Set the write batch factor.
      Parameters:
      expr - the write batch factor

    • getWriteDelay

      public Seconds getWriteDelay(ParameterResolver resolver)
      Return the time interval to defer asynchronous writes to the cache store for a write-behind queue. If zero, synchronous writes to the cache store (without queuing) take place, otherwise the writes are asynchronous and deferred by specified time interval after the last update to the value in the cache.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the write behind delay

    • setWriteDelay

      @Injectable public void setWriteDelay(Expression<Seconds> expr)
      Set the write behind delay.
      Parameters:
      expr - the write behind delay

    • getWriteDelaySeconds

      public int getWriteDelaySeconds(ParameterResolver resolver)
      Return the write behind delay in seconds.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the write behind delay in seconds

    • setWriteDelaySeconds

      @Injectable public void setWriteDelaySeconds(Expression<Integer> expr)
      Set the write behind delay seconds.
      Parameters:
      expr - the write behind delay in seconds

    • getWriteMaxBatchSize

      public int getWriteMaxBatchSize(ParameterResolver resolver)
      Return the maximum number of entries to write in a single storeAll operation. Valid values are positive integers or zero. The default value is 128 entries. This value has no effect if write behind is disabled.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the write maximum batch size

    • setWriteMaxBatchSize

      @Injectable public void setWriteMaxBatchSize(Expression<Integer> expr)
      Set the write max batch size.
      Parameters:
      expr - the write max batch size

    • getWriteRequeueThreshold

      public int getWriteRequeueThreshold(ParameterResolver resolver)
      Return the size of the write-behind queue at which additional actions could be taken. If zero, write-behind re-queuing is disabled. Otherwise, this value controls the frequency of the corresponding log messages. For example, a value of 100 produces a log message every time the size of the write queue is a multiple of 100. Legal values are positive integers or zero.
      Parameters:
      resolver - the ParameterResolver
      Returns:
      the write re-queue threshold

    • setWriteRequeueThreshold

      @Injectable public void setWriteRequeueThreshold(Expression<Integer> expr)
      Set the size of the write-behind queue at which additional actions could be taken.
      Parameters:
      expr - the write re-queue threshold

    • instantiateReadWriteBackingMap

      protected ReadWriteBackingMap instantiateReadWriteBackingMap(BackingMapManagerContext context, ObservableMap mapInternal, Map mapMisses, CacheLoader store, boolean fReadOnly, int cWriteBehindSeconds, double dflRefreshAheadFactor)
      Construct a ReadWriteBackingMap using the specified parameters.

      This method exposes a corresponding ReadWriteBackingMap constructor and is provided for the express purpose of allowing its override.

      Parameters:
      context - the context provided by the CacheService which is using this backing map
      mapInternal - the ObservableMap used to store the data internally in this backing map
      mapMisses - the Map used to cache CacheStore misses (optional)
      store - the object responsible for the persistence of the cached data (optional)
      fReadOnly - pass true is the specified loader is in fact a CacheStore that needs to be used only for read operations; changes to the cache will not be persisted
      cWriteBehindSeconds - number of seconds to write if there is a CacheStore; zero disables write-behind caching, which (combined with !fReadOnly) implies write-through
      dflRefreshAheadFactor - the interval before an entry expiration time (expressed as a percentage of the internal cache expiration interval) during which an asynchronous load request for the entry will be scheduled; zero disables refresh-ahead; only applicable when the mapInternal parameter is an instance of ConfigurableCacheMap
      Returns:
      the instantiated ReadWriteBackingMap

    • instantiateReadWriteBackingMap

      protected ReadWriteBackingMap instantiateReadWriteBackingMap(BackingMapManagerContext context, ObservableMap mapInternal, Map mapMisses, BinaryEntryStore storeBinary, boolean fReadOnly, int cWriteBehindSeconds, double dflRefreshAheadFactor)
      Construct a ReadWriteBackingMap using the specified parameters.

      This method exposes a corresponding ReadWriteBackingMap constructor and is provided for the express purpose of allowing its override.

      Parameters:
      context - the context provided by the CacheService which is using this backing map
      mapInternal - the ObservableMap used to store the data internally in this backing map
      mapMisses - the Map used to cache CacheStore misses (optional)
      storeBinary - the BinaryEntryStore responsible for the persistence of the cached data (optional)
      fReadOnly - pass true is the specified loader is in fact a CacheStore that needs to be used only for read operations; changes to the cache will not be persisted
      cWriteBehindSeconds - number of seconds to write if there is a CacheStore; zero disables write-behind caching, which (combined with !fReadOnly) implies write-through
      dflRefreshAheadFactor - the interval before an entry expiration time (expressed as a percentage of the internal cache expiration interval) during which an asynchronous load request for the entry will be scheduled; zero disables refresh-ahead; only applicable when the mapInternal parameter is an instance of ConfigurableCacheMap
      Returns:
      the instantiated ReadWriteBackingMap

    • instantiateReadWriteBackingMap

      protected ReadWriteBackingMap instantiateReadWriteBackingMap(BackingMapManagerContext context, ObservableMap mapInternal, Map mapMisses, NonBlockingEntryStore storeBinary, boolean fReadOnly, int cWriteBehindSeconds, double dflRefreshAheadFactor)
      Construct a ReadWriteBackingMap using the specified parameters.

      This method exposes a corresponding ReadWriteBackingMap constructor and is provided for the express purpose of allowing its override.

      Parameters:
      context - the context provided by the CacheService which is using this backing map
      mapInternal - the ObservableMap used to store the data internally in this backing map
      mapMisses - the Map used to cache CacheStore misses (optional)
      storeBinary - the NonBlockingEntryStore responsible for the persistence of the cached data (optional)
      fReadOnly - pass true is the specified loader is in fact a CacheStore that needs to be used only for read operations; changes to the cache will not be persisted
      cWriteBehindSeconds - number of seconds to write if there is a CacheStore; zero disables write-behind caching, which (combined with !fReadOnly) implies write-through
      dflRefreshAheadFactor - the interval before an entry expiration time (expressed as a percentage of the internal cache expiration interval) during which an asynchronous load request for the entry will be scheduled; zero disables refresh-ahead; only applicable when the mapInternal parameter is an instance of ConfigurableCacheMap
      Returns:
      the instantiated ReadWriteBackingMap

    • instantiateReadWriteSplittingBackingMap

      protected ReadWriteSplittingBackingMap instantiateReadWriteSplittingBackingMap(BackingMapManagerContext context, PartitionAwareBackingMap mapInternal, Map mapMisses, CacheLoader store, boolean fReadOnly, int cWriteBehindSeconds, double dflRefreshAheadFactor)
      Construct a ReadWriteSplittingBackingMap using the specified parameters.

      This method exposes a corresponding ReadWriteSplittingBackingMap constructor and is provided for the express purpose of allowing its override.

      Parameters:
      context - the context provided by the CacheService which is using this backing map
      mapInternal - the ObservableMap used to store the data internally in this backing map
      mapMisses - the Map used to cache CacheStore misses (optional)
      store - the object responsible for the persistence of the cached data (optional)
      fReadOnly - pass true is the specified loader is in fact a CacheStore that needs to be used only for read operations; changes to the cache will not be persisted
      cWriteBehindSeconds - number of seconds to write if there is a CacheStore; zero disables write-behind caching, which (combined with !fReadOnly) implies write-through
      dflRefreshAheadFactor - the interval before an entry expiration time (expressed as a percentage of the internal cache expiration interval) during which an asynchronous load request for the entry will be scheduled; zero disables refresh-ahead; only applicable when the mapInternal parameter is an instance of ConfigurableCacheMap
      Returns:
      the instantiated ReadWriteSplittingBackingMap

    • instantiateReadWriteSplittingBackingMap

      protected ReadWriteSplittingBackingMap instantiateReadWriteSplittingBackingMap(BackingMapManagerContext context, PartitionAwareBackingMap mapInternal, Map mapMisses, BinaryEntryStore storeBinary, boolean fReadOnly, int cWriteBehindSeconds, double dflRefreshAheadFactor)
      Construct a ReadWriteSplittingBackingMap using the specified parameters.

      This method exposes a corresponding ReadWriteSplittingBackingMap constructor and is provided for the express purpose of allowing its override.

      Parameters:
      context - the context provided by the CacheService which is using this backing map
      mapInternal - the ObservableMap used to store the data internally in this backing map
      mapMisses - the Map used to cache CacheStore misses (optional)
      storeBinary - the BinaryEntryStore responsible for the persistence of the cached data (optional)
      fReadOnly - pass true is the specified loader is in fact a CacheStore that needs to be used only for read operations; changes to the cache will not be persisted
      cWriteBehindSeconds - number of seconds to write if there is a CacheStore; zero disables write-behind caching, which (combined with !fReadOnly) implies write-through
      dflRefreshAheadFactor - the interval before an entry expiration time (expressed as a percentage of the internal cache expiration interval) during which an asynchronous load request for the entry will be scheduled; zero disables refresh-ahead; only applicable when the mapInternal parameter is an instance of ConfigurableCacheMap
      Returns:
      the instantiated ReadWriteSplittingBackingMap

    • instantiateReadWriteSplittingBackingMap

      protected ReadWriteSplittingBackingMap instantiateReadWriteSplittingBackingMap(BackingMapManagerContext context, PartitionAwareBackingMap mapInternal, Map mapMisses, NonBlockingEntryStore storeBinary, boolean fReadOnly, int cWriteBehindSeconds, double dflRefreshAheadFactor)
      Construct a ReadWriteSplittingBackingMap using the specified parameters.

      This method exposes a corresponding ReadWriteSplittingBackingMap constructor and is provided for the express purpose of allowing its override.

      Parameters:
      context - the context provided by the CacheService which is using this backing map
      mapInternal - the ObservableMap used to store the data internally in this backing map
      mapMisses - the Map used to cache CacheStore misses (optional)
      storeBinary - the NonBlockingEntryStore responsible for the persistence of the cached data (optional)
      fReadOnly - pass true is the specified loader is in fact a CacheStore that needs to be used only for read operations; changes to the cache will not be persisted
      cWriteBehindSeconds - number of seconds to write if there is a CacheStore; zero disables write-behind caching, which (combined with !fReadOnly) implies write-through
      dflRefreshAheadFactor - the interval before an entry expiration time (expressed as a percentage of the internal cache expiration interval) during which an asynchronous load request for the entry will be scheduled; zero disables refresh-ahead; only applicable when the mapInternal parameter is an instance of ConfigurableCacheMap
      Returns:
      the instantiated ReadWriteSplittingBackingMap

    • validate

      protected void validate(ParameterResolver resolver)
      Validate the properties.
      Overrides:
      validate in class AbstractCachingScheme
      Parameters:
      resolver - the ParameterResolver needed to resolve expressions