void statusUpdate(SchedulerDriver* driver, const TaskStatus& status)
{
if (!flags.long_running) {
if (status.state() == TASK_FAILED &&
status.reason() == TaskStatus::REASON_CONTAINER_LIMITATION_MEMORY) {
// NOTE: We expect TASK_FAILED when this scheduler is launched by the
// balloon_framework_test.sh shell script. The abort here ensures the
// script considers the test result as "PASS".
driver->abort();
} else if (status.state() == TASK_FAILED ||
status.state() == TASK_FINISHED ||
status.state() == TASK_KILLED ||
status.state() == TASK_LOST ||
status.state() == TASK_ERROR) {
driver->stop();
}
}
if (stringify(tasksLaunched - 1) != status.task_id().value()) {
// We might receive messages from older tasks. Ignore them.
LOG(INFO) << "Ignoring status update from older task "
<< status.task_id();
return;
}
switch (status.state()) {
case TASK_FINISHED:
taskActive = false;
++metrics.tasks_finished;
break;
case TASK_FAILED:
taskActive = false;
if (status.reason() == TaskStatus::REASON_CONTAINER_LIMITATION_MEMORY) {
++metrics.tasks_oomed;
break;
}
// NOTE: Fetching the executor (e.g. `--executor_uri`) may fail
// occasionally if the URI is rate limited. This case is common
// enough that it makes sense to track this failure metric separately.
if (status.reason() == TaskStatus::REASON_CONTAINER_LAUNCH_FAILED) {
++metrics.launch_failures;
break;
}
case TASK_KILLED:
case TASK_LOST:
case TASK_ERROR:
taskActive = false;
++metrics.abnormal_terminations;
break;
default:
break;
}
}
bool operator == (const TaskStatus& left, const TaskStatus& right)
{
return left.task_id() == right.task_id() &&
left.state() == right.state() &&
left.data() == right.data() &&
left.message() == right.message() &&
left.slave_id() == right.slave_id() &&
left.timestamp() == right.timestamp() &&
left.executor_id() == right.executor_id() &&
left.healthy() == right.healthy() &&
left.source() == right.source() &&
left.reason() == right.reason() &&
left.uuid() == right.uuid();
}
void update(const TaskStatus& status)
{
CHECK_EQ(SUBSCRIBED, state);
LOG(INFO)
<< "Task " << status.task_id().value()
<< " is in state " << TaskState_Name(status.state())
<< (status.has_message() ? " with message: " + status.message() : "");
if (status.has_uuid()) {
Call call;
call.set_type(Call::ACKNOWLEDGE);
CHECK(framework.has_id());
call.mutable_framework_id()->CopyFrom(framework.id());
Call::Acknowledge* acknowledge = call.mutable_acknowledge();
acknowledge->mutable_agent_id()->CopyFrom(status.agent_id());
acknowledge->mutable_task_id()->CopyFrom(status.task_id());
acknowledge->set_uuid(status.uuid());
mesos->send(call);
}
if (status.state() == TaskState::TASK_KILLED ||
status.state() == TaskState::TASK_LOST ||
status.state() == TaskState::TASK_FAILED ||
status.state() == TaskState::TASK_ERROR) {
// Launch on an invalid offer should not be
// counted as abnormal termination.
if (status.reason() != TaskStatus::REASON_INVALID_OFFERS) {
++metrics.abnormal_terminations;
}
}
}
virtual void statusUpdate(SchedulerDriver* driver, const TaskStatus& status)
{
std::cout << "Task in state " << status.state() << std::endl;
std::cout << "Source: " << status.source() << std::endl;
std::cout << "Reason: " << status.reason() << std::endl;
if (status.has_message()) {
std::cout << "Message: " << status.message() << std::endl;
}
if (protobuf::isTerminalState(status.state())) {
// NOTE: We expect TASK_FAILED here. The abort here ensures the shell
// script invoking this test, considers the test result as 'PASS'.
if (status.state() == TASK_FAILED) {
driver->abort();
} else {
driver->stop();
}
}
}
void statusUpdate(SchedulerDriver* driver, const TaskStatus& status)
{
if (stringify(tasksLaunched - 1) != status.task_id().value()) {
// We might receive messages from older tasks. Ignore them.
LOG(INFO) << "Ignoring status update from older task "
<< status.task_id();
return;
}
switch (status.state()) {
case TASK_FINISHED:
if (flags.run_once) {
driver->stop();
break;
}
taskActive = false;
++metrics.tasks_finished;
break;
case TASK_FAILED:
if (flags.run_once) {
driver->abort();
break;
}
taskActive = false;
if (status.reason() == TaskStatus::REASON_CONTAINER_LIMITATION_DISK) {
++metrics.tasks_disk_full;
// Increment abnormal_termination metric counter in case the task
// wasn't supposed to consume beyond its disk quota but still got
// terminated because of disk overuse.
if (flags.disk_use_limit >= DISK_PER_TASK) {
++metrics.abnormal_terminations;
}
break;
}
++metrics.abnormal_terminations;
break;
case TASK_KILLED:
case TASK_LOST:
case TASK_ERROR:
case TASK_DROPPED:
case TASK_UNREACHABLE:
case TASK_GONE:
case TASK_GONE_BY_OPERATOR:
if (flags.run_once) {
driver->abort();
}
taskActive = false;
++metrics.abnormal_terminations;
break;
case TASK_STARTING:
case TASK_RUNNING:
case TASK_STAGING:
case TASK_KILLING:
case TASK_UNKNOWN:
break;
}
}
