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

Class SimpleBatchedExecutor<Task extends ClusterStateTaskListener,TaskResult>

java.lang.Object
org.elasticsearch.cluster.SimpleBatchedExecutor<Task,TaskResult>
All Implemented Interfaces:
ClusterStateTaskExecutor<Task>
Direct Known Subclasses:
ReservedStateUpdateTaskExecutor
public abstract class SimpleBatchedExecutor<Task extends ClusterStateTaskListener,TaskResult> extends Object implements ClusterStateTaskExecutor<Task>
A basic implementation for batch executors that simply need to execute the tasks in the batch iteratively. Executing each task in the batch produces a cluster state and a result of type TaskResult. 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

    • SimpleBatchedExecutor

      public SimpleBatchedExecutor()

  • Method Details

    • executeTask

      public abstract Tuple<ClusterState,TaskResult> 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 the result of the task execution. The returned cluster state serves as the cluster state on which the next task in the batch will run. The returned task result is provided to the taskSucceeded(Task, TaskResult) implementation.
      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.

    • taskSucceeded

      public abstract void taskSucceeded(Task task, TaskResult taskResult)
      Called if executing a task in the batch finished successfully, and before the execution of the next task in the batch.
      Parameters:
      task - The task that successfully finished execution.
      taskResult - The result returned from the successful execution of the task.

    • 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