Class ExtensibleConfigurableCacheFactory.Manager

java.lang.Object
com.tangosol.util.Base
com.tangosol.net.AbstractBackingMapManager
com.tangosol.net.ExtensibleConfigurableCacheFactory.Manager
All Implemented Interfaces:
com.tangosol.internal.net.security.StorageAccessAuthorizerPolicyResolver, BackingMapManager
Direct Known Subclasses:
TopicBackingMapManager, TransactionalScheme.Manager
Enclosing class:
ExtensibleConfigurableCacheFactory
public static class ExtensibleConfigurableCacheFactory.Manager extends AbstractBackingMapManager implements com.tangosol.internal.net.security.StorageAccessAuthorizerPolicyResolver
The Manager class uses builders to create the required backing maps and provides client access to those maps.

This class also implements methods to create/release backup maps as needed by PartitionedCache.Storage$BackingManager.

Since:
Coherence 12.1.2
Author:
gg 2003.05.26, pfm 2012.12.19

  • Constructor Details

  • Method Details

    • init

      public void init(BackingMapManagerContext context)
      Called by a CacheService to indicate to this manager that the manager is being associated with the CacheService. This method is called once immediately upon the startup of the CacheService, before any NamedCache objects are created by the CacheService.

      Important note: BackingMapManager cannot be associated with more then one instance of a CacheService. However, in a situation when a CacheService automatically restarts, it is possible that this manager instance is re-used by a newly created (restarted) CacheService calling this method once again providing a new context.

      Important note: BackingMapManager cannot be associated with more than one instance of a CacheService. However, in a situation when a CacheService automatically restarts, it is possible that this manager instance is re-used by a newly created (restarted) CacheService calling this method once again providing a new context.

      Specified by:
      init in interface BackingMapManager
      Overrides:
      init in class AbstractBackingMapManager
      Parameters:
      context - the BackingMapManagerContext object for this BackingMapManager

    • instantiateBackingMap

      public Map instantiateBackingMap(String sName)
      Instantiate a [thread safe] Map that should be used by a CacheService to store cached values for a NamedCache with the specified name.

      If the contents of the Map can be modified by anything other than the CacheService itself (e.g. if the Map automatically expires its entries periodically or size-limits its contents), then the returned object must implement the ObservableMap interface.

      Specified by:
      instantiateBackingMap in interface BackingMapManager
      Parameters:
      sName - the name of the NamedCache for which this backing map is being created
      Returns:
      an object implementing the Map interface that will provide backing storage for the specified cache name

    • instantiatePartitionedBackingMap

      protected Map instantiatePartitionedBackingMap(MapBuilder bldrMap, ParameterResolver resolver, MapBuilder.Dependencies dependencies, CachingScheme scheme)
      Instantiate a partitioned backing map (an instance of ObservableSplittingBackingMap) using ExtensibleConfigurableCacheFactory.PartitionedBackingMapManager. If the provided scheme is an instance of ReadWriteBackingMapScheme, the internal scheme's map builder is used to build the backing map.
      Parameters:
      bldrMap - the MapBuilder for partitions
      resolver - the ParameterizedBuilder
      dependencies - the ExtensibleConfigurableCacheFactory.Dependencies for MapBuilders
      scheme - the CachingScheme of the requested cache
      Returns:
      partitioned backing map that will provide backing storage for the specified cache

    • instantiatePartitionedBackingMap

      protected Map instantiatePartitionedBackingMap(MapBuilder bldrMap, ParameterResolver resolver, MapBuilder.Dependencies dependencies, CachingScheme scheme, BiFunction<ExtensibleConfigurableCacheFactory.PartitionedBackingMapManager, String, ObservableSplittingBackingCache> fn)
      Instantiate a partitioned backing map (an instance of ObservableSplittingBackingMap) using ExtensibleConfigurableCacheFactory.PartitionedBackingMapManager. If the provided scheme is an instance of ReadWriteBackingMapScheme, the internal scheme's map builder is used to build the backing map.
      Parameters:
      bldrMap - the MapBuilder for partitions
      resolver - the ParameterizedBuilder
      dependencies - the ExtensibleConfigurableCacheFactory.Dependencies for MapBuilders
      scheme - the CachingScheme of the requested cache
      fn - a function to create an ObservableSplittingBackingCache
      Returns:
      partitioned backing map that will provide backing storage for the specified cache

    • isBackingMapPersistent

      public boolean isBackingMapPersistent(String sName)
      Determine if the contents of the Map that is used by a CacheService to store cached values for a NamedCache with the specified name should be persisted.
      Specified by:
      isBackingMapPersistent in interface BackingMapManager
      Parameters:
      sName - the name of the NamedCache
      Returns:
      true if the CacheService should persist the backing storage of the specified NamedCache

    • isBackingMapSlidingExpiry

      public boolean isBackingMapSlidingExpiry(String sName)
      Determine if the Map that is used by a CacheService to store cached values for a NamedCache with specified name enables the sliding expiry - the expiry delay being extended by the read operations.
      Specified by:
      isBackingMapSlidingExpiry in interface BackingMapManager
      Parameters:
      sName - the name of the NamedCache
      Returns:
      true if the backing map of the specified NamedCache enables the sliding expiry

    • mayWriteOnRead

      public boolean mayWriteOnRead(String sName)
      Determine if a read operation against the backing map for the specified NamedCache may write cache state as part of servicing the read.

      The default implementation is conservative because custom managers may hide read-through, expiry-refresh, or other read-side mutation behavior. Implementations that can prove their read path is non-mutating should override this method and return false.

      Specified by:
      mayWriteOnRead in interface BackingMapManager
      Parameters:
      sName - the name of the NamedCache
      Returns:
      true if a read operation may write cache state

    • mayWriteOnRead

      protected boolean mayWriteOnRead(CachingScheme scheme)
      Return true iff reads against the specified caching scheme may write cache state.
      Parameters:
      scheme - the caching scheme
      Returns:
      true iff reads against the specified scheme may write

    • getStorageAccessAuthorizer

      public StorageAccessAuthorizer getStorageAccessAuthorizer(String sName)
      Determine the StorageAccessAuthorizer that is used by a CacheService to secure access to the NamedCache with the specified name.
      Specified by:
      getStorageAccessAuthorizer in interface BackingMapManager
      Parameters:
      sName - the name of the NamedCache
      Returns:
      the StorageAccessAuthorizer or null if the authorizer is not configured

    • isSubjectProofRequired

      public boolean isSubjectProofRequired(String sName)
      Description copied from interface: com.tangosol.internal.net.security.StorageAccessAuthorizerPolicyResolver
      Return true iff the cache's configured operational storage authorizer requires subject proof.
      Specified by:
      isSubjectProofRequired in interface com.tangosol.internal.net.security.StorageAccessAuthorizerPolicyResolver
      Parameters:
      sName - the cache name
      Returns:
      true iff subject proof is required

    • getStorageAccessAuthorizer

      protected StorageAccessAuthorizer getStorageAccessAuthorizer(String sName, boolean fAllowNull)
      Determine the configured storage access authorizer.
      Parameters:
      sName - the cache name
      fAllowNull - true to return null when no authorizer is configured
      Returns:
      the configured storage access authorizer, or null

    • getStorageAccessAuthorizerBuilder

      protected ParameterizedBuilder<StorageAccessAuthorizer> getStorageAccessAuthorizerBuilder(String sName, boolean fAllowNull)
      Return the storage access authorizer builder for the specified cache.
      Parameters:
      sName - the cache name
      fAllowNull - true to return null when no authorizer is configured
      Returns:
      the storage access authorizer builder, or null

    • getReadLocator

      public BiFunction<Ownership, PartitionedService, Member> getReadLocator(String sName)
      Description copied from interface: BackingMapManager
      Return a function that when called will return a member given the current partition owners and service, or null if the service should target the primary. This function is called by the respective service to target read requests at the relevant member, and can be specific to a cache.

      An implementation can return any member in the ownership chain, inferring a tolerance to stale reads when a backup (non-primary) is targeted. This may be possible as the primary (or other backups) process future changes while the member that performed the read (and was chosen by the returned function) has not.

      There are several benefits in targeting backups for reads including balancing load and latency. For example, the latter can be achieved by targeting the read to a backup that resides on the same machine, rack or site. The default implementation allows this to be chosen via configuration.

      Specified by:
      getReadLocator in interface BackingMapManager
      Parameters:
      sName - the name of the NamedCache
      Returns:
      a function that when called will return a member given the current partition owners and service, or null if the service should target the primary

    • releaseBackingMap

      public void releaseBackingMap(String sName, Map map)
      Release the specified Map that was created using the BackingMapManager.instantiateBackingMap(String) method. This method is invoked by the CacheService when the CacheService no longer requires the specified Map object.
      Specified by:
      releaseBackingMap in interface BackingMapManager
      Overrides:
      releaseBackingMap in class AbstractBackingMapManager
      Parameters:
      sName - the name of the NamedCache for which the specified Map object has acted as the backing map
      map - the Map object that is being released

    • instantiateBackupMap

      public Map instantiateBackupMap(String sName)
      Instantiate a [thread safe] Map that should be used by a CacheService to store cached values for a NamedCache with the specified name.
      Parameters:
      sName - the name of the NamedCache for which this map is being created
      Returns:
      an object implementing the Map interface that will provide backing storage for the specified cache name

    • releaseBackupMap

      public void releaseBackupMap(String sName, Map map, Map mapListeners)
      Release the specified Map that was created using the instantiateBackupMap(String) method. This method is invoked by the CacheService when the CacheService no longer requires the specified Map object.
      Parameters:
      sName - the cache name
      map - the Map object that is being released
      mapListeners - the map of listeners for the map

    • isBackupPartitioned

      public boolean isBackupPartitioned(String sName)
      Return true if the backup map should be partitioned.
      Parameters:
      sName - the cache name
      Returns:
      true if the backup map should be partitioned

    • getCacheFactory

      public ExtensibleConfigurableCacheFactory getCacheFactory()
      Obtain the "container" ConfigurableCacheFactory that created this manager and which this manager is bound to.
      Specified by:
      getCacheFactory in interface BackingMapManager
      Returns:
      the ConfigurableCacheFactory that created this manager

    • getResolver

      protected ParameterResolver getResolver(String sName)
      Return the ParameterResolver for the given cache.
      Parameters:
      sName - the cache name
      Returns:
      the ParameterResolver

    • getScopedResolver

      protected ScopedParameterResolver getScopedResolver(String sName)
      Return the ScopedParameterResolver for the given cache. A scoped resolver is needed so that a sub-class (like TransactionScheme.Manager) can add a parameter to the resolver.
      Parameters:
      sName - the cache name
      Returns:
      the ScopedParameterResolver

    • getBackingMap

      public Map getBackingMap(String sName)
      Get the backing Map associated with a given cache.
      Parameters:
      sName - the cache name
      Returns:
      a Map associated with the specified name

    • setBackingMap

      protected void setBackingMap(String sName, Map map)
      Associate the specified backing Map with a given name.
      Parameters:
      sName - the cache name
      map - the backing map associated with the specified name

    • findDistributedScheme

      protected DistributedScheme findDistributedScheme(String sName)
      Return the DistributedScheme for a given cache name.
      Parameters:
      sName - the cache name
      Returns:
      the DistributedScheme or null

    • findCachingScheme

      protected CachingScheme findCachingScheme(String sName)
      Return the CachingScheme for a given cache name. If the caching scheme is a near cache then return the back scheme.
      Parameters:
      sName - the cache name
      Returns:
      the CachingScheme or null