io.druid.indexing.overlord

Class RemoteTaskRunner

java.lang.Object

io.druid.indexing.overlord.RemoteTaskRunner

All Implemented Interfaces:

TaskRunner, WorkerTaskRunner, TaskLogStreamer

public class RemoteTaskRunner
extends Object
implements WorkerTaskRunner, TaskLogStreamer

The RemoteTaskRunner's primary responsibility is to assign tasks to worker nodes. The RemoteTaskRunner uses Zookeeper to keep track of which workers are running which tasks. Tasks are assigned by creating ephemeral nodes in ZK that workers must remove. Workers announce the statuses of the tasks they are running. Once a task completes, it is up to the RTR to remove the task status and run any necessary cleanup. The RemoteTaskRunner is event driven and updates state according to ephemeral node changes in ZK.

The RemoteTaskRunner will assign tasks to a node until the node hits capacity. At that point, task assignment will fail. The RemoteTaskRunner depends on another component to create additional worker resources.

If a worker node becomes inexplicably disconnected from Zk, the RemoteTaskRunner will fail any tasks associated with the worker after waiting for RemoteTaskRunnerConfig.taskCleanupTimeout for the worker to show up.

The RemoteTaskRunner uses ZK for job management and assignment and http for IPC messages.

Constructor Summary

Constructors

Constructor and Description

RemoteTaskRunner(com.fasterxml.jackson.databind.ObjectMapper jsonMapper, RemoteTaskRunnerConfig config, IndexerZkConfig indexerZkConfig, org.apache.curator.framework.CuratorFramework cf, PathChildrenCacheFactory.Builder pathChildrenCacheFactory, com.metamx.http.client.HttpClient httpClient, com.google.common.base.Supplier<WorkerBehaviorConfig> workerConfigRef, ScheduledExecutorService cleanupExec, ResourceManagementStrategy<WorkerTaskRunner> resourceManagement)

Method Summary

Modifier and Type	Method and Description
void	cleanBlackListedNode(ZkWorker zkWorker, long currentTimeStamp)
ZkWorker	findWorkerRunningTask(String taskId)
protected List<String>	getAssignedTasks(Worker worker)
Collection<ImmutableWorkerInfo>	getBlackListedWorkers()
RemoteTaskRunnerConfig	getConfig()
Collection<RemoteTaskRunnerWorkItem>	getKnownTasks()
Collection<Worker>	getLazyWorkers() Return a list of workers who can be reaped by autoscaling
Collection<Task>	getPendingTaskPayloads()
Collection<RemoteTaskRunnerWorkItem>	getPendingTasks()
Collection<RemoteTaskRunnerWorkItem>	getRunningTasks()
com.google.common.base.Optional<ScalingStats>	getScalingStats() Some runners are able to scale up and down their capacity in a dynamic manner.
static Collection<Worker>	getWorkerFromZK(Collection<ZkWorker> workers)
Collection<ImmutableWorkerInfo>	getWorkers() List of known workers who can accept tasks
boolean	isWorkerRunningTask(Worker worker, String taskId)
Collection<Worker>	markWorkersLazy(com.google.common.base.Predicate<ImmutableWorkerInfo> isLazyWorker, int maxWorkers) Check which workers can be marked as lazy
void	registerListener(TaskRunnerListener listener, Executor executor) Register a listener with this task runner.
List<Pair<Task,com.google.common.util.concurrent.ListenableFuture<TaskStatus>>>	restore() Some task runners can restart previously-running tasks after being bounced.
com.google.common.util.concurrent.ListenableFuture<TaskStatus>	run(Task task) A task will be run only if there is no current knowledge in the RemoteTaskRunner of the task.
void	shutdown(String taskId) Finds the worker running the task and forwards the shutdown signal to the worker.
void	start() Start the state of the runner
void	stop() Stop this task runner.
com.google.common.base.Optional<com.google.common.io.ByteSource>	streamTaskLog(String taskId, long offset) Stream log for a task.
void	unregisterListener(String listenerId)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

RemoteTaskRunner

public RemoteTaskRunner(com.fasterxml.jackson.databind.ObjectMapper jsonMapper,
                        RemoteTaskRunnerConfig config,
                        IndexerZkConfig indexerZkConfig,
                        org.apache.curator.framework.CuratorFramework cf,
                        PathChildrenCacheFactory.Builder pathChildrenCacheFactory,
                        com.metamx.http.client.HttpClient httpClient,
                        com.google.common.base.Supplier<WorkerBehaviorConfig> workerConfigRef,
                        ScheduledExecutorService cleanupExec,
                        ResourceManagementStrategy<WorkerTaskRunner> resourceManagement)

Method Detail

start

public void start()

Description copied from interface: TaskRunner

Start the state of the runner

Specified by:

start in interface TaskRunner

stop

public void stop()

Description copied from interface: TaskRunner

Stop this task runner. This may block until currently-running tasks can be gracefully stopped. After calling stopping, "run" will not accept further tasks.

Specified by:

stop in interface TaskRunner

restore

public List<Pair<Task,com.google.common.util.concurrent.ListenableFuture<TaskStatus>>> restore()

Description copied from interface: TaskRunner

Some task runners can restart previously-running tasks after being bounced. This method does that, and returns the list of tasks (and status futures).

Specified by:

restore in interface TaskRunner

registerListener

public void registerListener(TaskRunnerListener listener,
                             Executor executor)

Description copied from interface: TaskRunner

Register a listener with this task runner. On registration, the listener will get events corresponding to the current state of known tasks. Listener notifications are submitted to the executor in the order they occur, but it is up to the executor to decide when to actually run the notifications. If your listeners will not block, feel free to use a same-thread executor. Listeners that may block should use a separate executor, generally a single-threaded one with a fifo queue so the order of notifications is retained.

Specified by:

registerListener in interface TaskRunner

Parameters:

listener - the listener

executor - executor to run callbacks in

unregisterListener

public void unregisterListener(String listenerId)

Specified by:

unregisterListener in interface TaskRunner

getWorkers

public Collection<ImmutableWorkerInfo> getWorkers()

Description copied from interface: WorkerTaskRunner

List of known workers who can accept tasks

Specified by:

getWorkers in interface WorkerTaskRunner

Returns:

A list of workers who can accept tasks for running

getRunningTasks

public Collection<RemoteTaskRunnerWorkItem> getRunningTasks()

Specified by:

getRunningTasks in interface TaskRunner

getPendingTasks

public Collection<RemoteTaskRunnerWorkItem> getPendingTasks()

Specified by:

getPendingTasks in interface TaskRunner

getPendingTaskPayloads

public Collection<Task> getPendingTaskPayloads()

Specified by:

getPendingTaskPayloads in interface WorkerTaskRunner

getConfig

public RemoteTaskRunnerConfig getConfig()

Specified by:

getConfig in interface WorkerTaskRunner

getKnownTasks

public Collection<RemoteTaskRunnerWorkItem> getKnownTasks()

Specified by:

getKnownTasks in interface TaskRunner

getScalingStats

public com.google.common.base.Optional<ScalingStats> getScalingStats()

Description copied from interface: TaskRunner

Some runners are able to scale up and down their capacity in a dynamic manner. This returns stats on those activities

Specified by:

getScalingStats in interface TaskRunner

Returns:

ScalingStats if the runner has an underlying resource which can scale, Optional.absent() otherwise

findWorkerRunningTask

public ZkWorker findWorkerRunningTask(String taskId)

isWorkerRunningTask

public boolean isWorkerRunningTask(Worker worker,
                                   String taskId)

run

public com.google.common.util.concurrent.ListenableFuture<TaskStatus> run(Task task)

A task will be run only if there is no current knowledge in the RemoteTaskRunner of the task.

Specified by:

run in interface TaskRunner

Parameters:

task - task to run

Returns:

task status, eventually

shutdown

public void shutdown(String taskId)

Finds the worker running the task and forwards the shutdown signal to the worker.

Specified by:

shutdown in interface TaskRunner

Parameters:

taskId - - task id to shutdown

streamTaskLog

public com.google.common.base.Optional<com.google.common.io.ByteSource> streamTaskLog(String taskId,
                                                                                      long offset)

Description copied from interface: TaskLogStreamer

Stream log for a task.

Specified by:

streamTaskLog in interface TaskLogStreamer

offset - If zero, stream the entire log. If positive, attempt to read from this position onwards. If negative, attempt to read this many bytes from the end of the file (like tail -n).

Returns:

input supplier for this log, if available from this provider

cleanBlackListedNode

public void cleanBlackListedNode(ZkWorker zkWorker,
                                 long currentTimeStamp)

markWorkersLazy

public Collection<Worker> markWorkersLazy(com.google.common.base.Predicate<ImmutableWorkerInfo> isLazyWorker,
                                          int maxWorkers)

Description copied from interface: WorkerTaskRunner

Check which workers can be marked as lazy

Specified by:

markWorkersLazy in interface WorkerTaskRunner

Returns:

getAssignedTasks

protected List<String> getAssignedTasks(Worker worker)
                                 throws Exception

Throws:

Exception

getLazyWorkers

public Collection<Worker> getLazyWorkers()

Description copied from interface: WorkerTaskRunner

Return a list of workers who can be reaped by autoscaling

Specified by:

getLazyWorkers in interface WorkerTaskRunner

Returns:

Workers which can be reaped by autoscaling

getWorkerFromZK

public static Collection<Worker> getWorkerFromZK(Collection<ZkWorker> workers)

getBlackListedWorkers

public Collection<ImmutableWorkerInfo> getBlackListedWorkers()