Class SingletonCacheWriter

  • All Implemented Interfaces:
    org.infinispan.commons.api.Lifecycle, CacheWriter
    Direct Known Subclasses:

    public class SingletonCacheWriter
    extends DelegatingCacheWriter
    this writer will be removed in 10.0. If it is desirable that all nodes don't write to the underlying store then a shared store should be used instead, as this only performs store writes at a key's primary owner.
    SingletonStore is a delegating cache store used for situations when only one instance should interact with the underlying store. The coordinator of the cluster will be responsible for the underlying CacheStore.

    SingletonStore is a simply facade to a real CacheStore implementation. It always delegates reads to the real CacheStore.

    Writes are delegated only if this SingletonStore is currently the coordinator. This avoids having all stores in a cluster writing the same data to the same underlying store. Although not incorrect (e.g. a DB will just discard additional INSERTs for the same key, and throw an exception), this will avoid a lot of redundant work.

    Whenever the current coordinator dies (or leaves), the second in line will take over. That SingletonStore will then pass writes through to its underlying CacheStore. Optionally, when a new coordinator takes over the Singleton, it can push the in-memory state to the cache cacheStore, within a time constraint.

    Mircea Markus
    • Field Detail

      • executor

        protected final ExecutorService executor
        Executor service used to submit tasks to push in-memory state.
      • active

        protected volatile boolean active
        Whether the the current cache is the coordinator and therefore SingletonStore is active. Being active means delegating calls to the underlying cache loader.
    • Method Detail

      • start

        public void start()
        Description copied from interface: org.infinispan.commons.api.Lifecycle
        Invoked on component start
        Specified by:
        start in interface org.infinispan.commons.api.Lifecycle
        start in class DelegatingCacheWriter
      • stop

        public void stop()
        Description copied from interface: org.infinispan.commons.api.Lifecycle
        Invoked on component stop
        Specified by:
        stop in interface org.infinispan.commons.api.Lifecycle
        stop in class DelegatingCacheWriter
      • createPushStateTask

        protected Callable<?> createPushStateTask()
      • pushState

        protected void pushState​(Cache<?,​?> cache)
                          throws Exception
        Pushes the state of a specific cache by reading the cache's data and putting in the cache store.
      • awaitForPushToFinish

        protected void awaitForPushToFinish​(Future<?> future,
                                            long timeout,
                                            TimeUnit unit)
        Method that waits for the in-memory to cache loader state to finish. This method's called in case a push state is already in progress and we need to wait for it to finish.
      • activeStatusChanged

        protected void activeStatusChanged​(boolean newActiveState)
                                    throws SingletonCacheWriter.PushStateException
        Method called when the cache either becomes the coordinator or stops being the coordinator. If it becomes the coordinator, it can optionally start the in-memory state transfer to the underlying cache store.