Java Code Examples for org.apache.mesos.Protos#TaskState

public void killTask(TaskID taskId) {
    synchronized (lock) {
        TaskExecutorHolder taskExecutorHolder = pendingTasks.remove(taskId);
        if (taskExecutorHolder == null) {
            logger.warn(slaveId + " is not running task " + taskId); // don't throw, treat it as no-op
            return;
        }
        Protos.TaskState taskState = taskExecutorHolder.getState();
        if (taskState == Protos.TaskState.TASK_FINISHED || taskState == Protos.TaskState.TASK_FAILED || taskState == Protos.TaskState.TASK_KILLED) {
            taskUpdates.onNext(Protos.TaskStatus.newBuilder()
                    .setTaskId(taskId)
                    .setState(Protos.TaskState.TASK_LOST)
                    .setMessage("Task already terminated: " + taskState)
                    .build()
            );
            return;
        }

        taskExecutorHolder.transitionTo(Protos.TaskState.TASK_KILLED);

        releaseResourcesAndReOffer(taskExecutorHolder);
    }
}
 

private void onFinish(SingularityExecutorTask task, Protos.TaskState taskState) {
  processKiller.cancelDestroyFuture(task.getTaskId());

  tasks.remove(task.getTaskId());
  processRunningTasks.remove(task.getTaskId());
  processBuildingTasks.remove(task.getTaskId());

  task.cleanup(taskState);

  ListeningExecutorService executorService = taskToShellCommandPool.remove(
    task.getTaskId()
  );

  if (executorService != null) {
    executorService.shutdownNow();
    try {
      executorService.awaitTermination(5, TimeUnit.MILLISECONDS);
    } catch (InterruptedException e) {
      LOG.warn("Awaiting shutdown of shell executor service", e);
    }
  }

  logging.stopTaskLogger(task.getTaskId(), task.getLogbackLog());

  checkIdleExecutorShutdown(task.getDriver());
}
 

private boolean taskHasReusableExecutor(Protos.TaskInfo taskInfo) {
  Optional<Protos.TaskStatus> taskStatus = stateStore.fetchStatus(taskInfo.getName());
  if (!taskStatus.isPresent() || FailureUtils.isPermanentlyFailed(taskInfo)) {
    return false;
  }

  Protos.TaskState state = taskStatus.get().getState();
  switch (state) {
    case TASK_STAGING:
    case TASK_STARTING:
    case TASK_RUNNING:
      return true;
    default:
      return false;
  }
}
 

static TaskStatus.TaskState fromMesosTaskState(Protos.TaskState mesosTaskState) {
    switch (mesosTaskState) {
        case TASK_STAGING:
            return TaskStatus.TaskState.Launched;
        case TASK_STARTING:
            return TaskStatus.TaskState.StartInitiated;
        case TASK_RUNNING:
            return TaskStatus.TaskState.Started;
        case TASK_KILLING:
            return TaskStatus.TaskState.KillInitiated;
        case TASK_FINISHED:
        case TASK_FAILED:
        case TASK_ERROR:
        case TASK_LOST:
        case TASK_KILLED:
            return TaskStatus.TaskState.Finished;
    }
    throw new IllegalArgumentException("Unknown Mesos task state found: " + mesosTaskState);
}
 

@NotNull
static Protos.TaskStatus taskStatus(
    @NotNull final Protos.ExecutorID executorId,
    @NotNull final Protos.TaskID taskId,
    @NotNull final Protos.TaskState state,
    @NotNull final CassandraFrameworkProtos.SlaveStatusDetails details
) {
    return Protos.TaskStatus.newBuilder()
        .setExecutorId(executorId)
        .setTaskId(taskId)
        .setState(state)
        .setSource(Protos.TaskStatus.Source.SOURCE_EXECUTOR)
        .setData(ByteString.copyFrom(details.toByteArray()))
        .build();
}
 

private void sendStatusUpdate(
  SingularityExecutorTask task,
  Protos.TaskState taskState,
  String message
) {
  executorUtils.sendStatusUpdate(
    task.getDriver(),
    TaskID.newBuilder().setValue(task.getTaskId()).build(),
    taskState,
    message,
    task.getLog()
  );
}
 

ContainerStateRule(long delayInStateMs,
                   Action action,
                   Optional<Protos.TaskState> mesosTerminalState,
                   Optional<Protos.TaskStatus.Reason> mesosReasonCode,
                   Optional<String> reasonMessage) {
    this.delayInStateMs = delayInStateMs;
    this.action = action;
    this.mesosTerminalState = mesosTerminalState;
    this.mesosReasonCode = mesosReasonCode;
    this.reasonMessage = reasonMessage;
}
 

@Override
public RepairStatus createStatus(
        Protos.TaskState state,
        Optional<String> message) {

    Protos.TaskStatus.Builder builder = getStatusBuilder();
    if (message.isPresent()) {
        builder.setMessage(message.get());
    }

    return RepairStatus.create(builder
            .setData(CassandraData.createRepairStatusData().getBytes())
            .setState(state)
            .build());
}
 

@Override
public RestoreSnapshotStatus createStatus(
        Protos.TaskState state,
        Optional<String> message) {

    Protos.TaskStatus.Builder builder = getStatusBuilder();
    if (message.isPresent()) {
        builder.setMessage(message.get());
    }

    return RestoreSnapshotStatus.create(builder
            .setData(CassandraData.createRestoreSnapshotStatusData().getBytes())
            .setState(state)
            .build());
}
 

@SuppressFBWarnings("DM_EXIT")
public void sendStatusUpdate(
  ExecutorDriver driver,
  Protos.TaskID taskID,
  Protos.TaskState taskState,
  String message,
  Logger logger
) {
  logger.info("Sending status update \"{}\" ({})", message, taskState.name());

  message =
    message.substring(
      0,
      Math.min(configuration.getMaxTaskMessageLength(), message.length())
    );

  try {
    final Protos.TaskStatus.Builder builder = Protos
      .TaskStatus.newBuilder()
      .setTaskId(taskID)
      .setState(taskState)
      .setMessage(message);

    driver.sendStatusUpdate(builder.build());
  } catch (Throwable t) {
    try {
      logger.error("Exception while sending status updates, exiting", t);
    } finally {
      System.exit(4);
    }
  }
}
 

public static Protos.TaskStatus generateStatus(
        Protos.TaskID taskID,
        Protos.TaskState taskState) {
    return Protos.TaskStatus.newBuilder()
            .setTaskId(taskID)
            .setState(taskState)
            .build();
}
 

public void finishTask(
  final SingularityExecutorTask task,
  Protos.TaskState taskState,
  String message,
  Optional<String> errorMsg,
  Object... errorObjects
) {
  try {
    if (errorMsg.isPresent()) {
      task.getLog().error(errorMsg.get(), errorObjects);
    }
  } finally {
    try {
      sendStatusUpdate(task, taskState, message);

      onFinish(task, taskState);
    } catch (Throwable t) {
      logAndExit(
        3,
        "Failed while finishing task {} (state {})",
        task.getTaskId(),
        taskState,
        t
      );
    }
  }
}
 

@Override
public DownloadSnapshotTask update(Protos.TaskState state) {
    return new DownloadSnapshotTask(getBuilder().setData(
        getData().withState(state).getBytes()).build());
}
 

private static Protos.TaskStatus newTaskStatus(final Protos.TaskID taskID, final Protos.TaskState taskState) {
  return Protos.TaskStatus.newBuilder()
      .setTaskId(taskID)
      .setState(taskState)
      .build();
}
 

public CassandraData withState(final Protos.TaskState state) {
    return new CassandraData(
        getBuilder()
            .setState(state.ordinal())
            .build());
}
 

public static Protos.TaskStatus newTaskStatus(final Protos.TaskInfo taskInfo, final Protos.TaskState taskState) {
    return newTaskStatus(taskInfo.getTaskId(), taskState);
}
 

public Protos.TaskState getState() {
    return state;
}
 

private void sendStatus(ExecutorDriver driver,
                        Protos.TaskState state, String message) {
    Protos.TaskStatus status =
        task.createStatus(state, Optional.of(message)).getTaskStatus();
    driver.sendStatusUpdate(status);
}
 

public static SendTaskStatus.Builder taskStatus(String taskName, Protos.TaskState taskState) {
  return new SendTaskStatus.Builder(taskName, taskState);
}
 

/**
 * Gets the state.
 *
 * @return The state of the task associated with the status.
 */
public Protos.TaskState getState() {
    return status.getState();
}