Module org.elasticsearch.server
Package org.elasticsearch.cluster

Class SimpleBatchedAckListenerTaskExecutor<Task extends ClusterStateTaskListener>

java.lang.Object
org.elasticsearch.cluster.SimpleBatchedAckListenerTaskExecutor<Task>
All Implemented Interfaces:
ClusterStateTaskExecutor<Task>
public abstract class SimpleBatchedAckListenerTaskExecutor<Task extends ClusterStateTaskListener> extends Object implements ClusterStateTaskExecutor<Task>
A basic batch executor implementation for tasks that can listen for acks themselves by providing a ClusterStateAckListener. The tasks in the batch are executed iteratively, producing a cluster state after each task. This allows executing the tasks in the batch as a series of executions, each taking an input cluster state and producing a new cluster state that serves as the input of the next task in the batch.

  • Constructor Details

    • SimpleBatchedAckListenerTaskExecutor

      public SimpleBatchedAckListenerTaskExecutor()

  • Method Details

    • executeTask

      public abstract Tuple<ClusterState,ClusterStateAckListener> executeTask(Task task, ClusterState clusterState) throws Exception
      Executes the provided task from the batch.
      Parameters:
      task - The task to be executed.
      clusterState - The cluster state on which the task should be executed.
      Returns:
      A tuple consisting of the resulting cluster state after executing this task, and a ClusterStateAckListener. The listener is completed if the publication succeeds and the nodes ack the state update. The returned cluster state serves as the cluster state on which the next task in the batch will run.
      Throws:
      Exception

    • afterBatchExecution

      public ClusterState afterBatchExecution(ClusterState clusterState, boolean clusterStateChanged)
      Called once all tasks in the batch have finished execution. It should return a cluster state that reflects the execution of all the tasks.
      Parameters:
      clusterState - The cluster state resulting from the execution of all the tasks.
      clusterStateChanged - Whether clusterState is different from the cluster state before executing the tasks in the batch.
      Returns:
      The resulting cluster state after executing all the tasks.

    • clusterStatePublished

      public final void clusterStatePublished(ClusterState newClusterState)
      Description copied from interface: ClusterStateTaskExecutor
      Callback invoked after new cluster state is published. Note that this method is not invoked if the cluster state was not updated. Note that this method will be executed using system context.
      Specified by:
      clusterStatePublished in interface ClusterStateTaskExecutor<Task extends ClusterStateTaskListener>
      Parameters:
      newClusterState - The new state which was published.

    • clusterStatePublished

      public void clusterStatePublished()
      Called after the new cluster state is published. Note that this method is not invoked if the cluster state was not updated.

    • execute

      public final ClusterState execute(ClusterStateTaskExecutor.BatchExecutionContext<Task> batchExecutionContext) throws Exception
      Description copied from interface: ClusterStateTaskExecutor
      Update the cluster state based on the current state and the given tasks. Return batchExecutionContext.initialState() to avoid publishing any update.

      If this method throws an exception then the cluster state is unchanged and every task's ClusterStateTaskListener.onFailure(java.lang.Exception) method is called.

      A common implementation pattern is to iterate through the tasks, constructing a new and updated ClusterState for each one. This works ok but beware that constructing a whole new ClusterState can be somewhat expensive, and there may sometimes be surprisingly many tasks to process in the batch. If it's possible to accumulate the effects of the tasks at a lower level then you should do that instead.

      Returning batchExecutionContext.initialState() is an important and useful optimisation in most cases, but note that this fast-path exposes APIs to the risk of stale reads in the vicinity of a master failover: a node N that handles such a no-op task batch does not verify with its peers that it's still the master, and if it's not the master then another node M may already have become master and updated the state in a way that would be inconsistent with the response that N sends back to clients.

      Specified by:
      execute in interface ClusterStateTaskExecutor<Task extends ClusterStateTaskListener>
      Returns:
      The resulting cluster state after executing all the tasks. If batchExecutionContext.initialState() is returned then no update is published.
      Throws:
      Exception