TaskStatus createTaskStatus( TaskStatus status, const id::UUID& uuid, double timestamp, const Option<TaskState>& state, const Option<string>& message, const Option<TaskStatus::Source>& source, const Option<TaskStatus::Reason>& reason, const Option<string>& data, const Option<bool>& healthy, const Option<CheckStatusInfo>& checkStatus, const Option<Labels>& labels, const Option<ContainerStatus>& containerStatus, const Option<TimeInfo>& unreachableTime) { status.set_uuid(uuid.toBytes()); status.set_timestamp(timestamp); if (state.isSome()) { status.set_state(state.get()); } if (message.isSome()) { status.set_message(message.get()); } if (source.isSome()) { status.set_source(source.get()); } if (reason.isSome()) { status.set_reason(reason.get()); } if (data.isSome()) { status.set_data(data.get()); } if (healthy.isSome()) { status.set_healthy(healthy.get()); } if (checkStatus.isSome()) { status.mutable_check_status()->CopyFrom(checkStatus.get()); } if (labels.isSome()) { status.mutable_labels()->CopyFrom(labels.get()); } if (containerStatus.isSome()) { status.mutable_container_status()->CopyFrom(containerStatus.get()); } if (unreachableTime.isSome()) { status.mutable_unreachable_time()->CopyFrom(unreachableTime.get()); } return status; }
void update(const TaskInfo& task, const TaskState& state) { UUID uuid = UUID::random(); TaskStatus status; status.mutable_task_id()->CopyFrom(task.task_id()); status.mutable_executor_id()->CopyFrom(executorId); status.set_state(state); status.set_source(TaskStatus::SOURCE_EXECUTOR); status.set_timestamp(process::Clock::now().secs()); status.set_uuid(uuid.toBytes()); Call call; call.mutable_framework_id()->CopyFrom(frameworkId); call.mutable_executor_id()->CopyFrom(executorId); call.set_type(Call::UPDATE); call.mutable_update()->mutable_status()->CopyFrom(status); // Capture the status update. updates[uuid] = call.update(); mesos->send(call); }
TaskStatus createTaskStatus( const TaskID& taskId, const TaskState& state, const id::UUID& uuid, double timestamp) { TaskStatus status; status.set_uuid(uuid.toBytes()); status.set_timestamp(timestamp); status.mutable_task_id()->CopyFrom(taskId); status.set_state(state); return status; }
StatusUpdate createStatusUpdate( const FrameworkID& frameworkId, const Option<SlaveID>& slaveId, const TaskID& taskId, const TaskState& state, const TaskStatus::Source& source, const Option<UUID>& uuid, const string& message = "", const Option<TaskStatus::Reason>& reason = None(), const Option<ExecutorID>& executorId = None(), const Option<bool>& healthy = None()) { StatusUpdate update; update.set_timestamp(process::Clock::now().secs()); update.mutable_framework_id()->MergeFrom(frameworkId); if (slaveId.isSome()) { update.mutable_slave_id()->MergeFrom(slaveId.get()); } if (executorId.isSome()) { update.mutable_executor_id()->MergeFrom(executorId.get()); } TaskStatus* status = update.mutable_status(); status->mutable_task_id()->MergeFrom(taskId); if (slaveId.isSome()) { status->mutable_slave_id()->MergeFrom(slaveId.get()); } status->set_state(state); status->set_source(source); status->set_message(message); status->set_timestamp(update.timestamp()); if (uuid.isSome()) { update.set_uuid(uuid.get().toBytes()); status->set_uuid(uuid.get().toBytes()); } else { // Note that in 0.22.x, the StatusUpdate.uuid was required // even though the scheduler driver ignores it for master // and scheduler driver generated updates. So we continue // to "set" it here so that updates coming from a 0.23.x // master can be parsed by a 0.22.x scheduler driver. // // TODO(bmahler): In 0.24.x, leave the uuid unset. update.set_uuid(""); } if (reason.isSome()) { status->set_reason(reason.get()); } if (healthy.isSome()) { status->set_healthy(healthy.get()); } return update; }