Method _waitContainer

src/slave/http.cpp:3547–3640

template <authorization::Action action>
Future<Response> Http::_waitContainer(
    const ContainerID& containerId,
    ContentType acceptType,
    const Owned<ObjectApprovers>& approvers,
    const bool deprecated) const
{
  // Attempt to get the executor associated with this ContainerID.
  // We only expect to get the executor when waiting upon a nested container
  // under a container launched via a scheduler. In other cases, we are
  // waiting on a standalone container (possibly nested).
  Executor* executor = slave->getExecutor(containerId);
  if (executor == nullptr) {
    if (!approvers->approved<action>(containerId)) {
      return Forbidden();
    }
  } else {
    Framework* framework = slave->getFramework(executor->frameworkId);
    CHECK_NOTNULL(framework);

    if (!approvers->approved<action>(
            executor->info, framework->info, containerId)) {
      return Forbidden();
    }
  }

  return slave->containerizer->wait(containerId)
    .then([=](const Option<ContainerTermination>& termination) -> Response {
      if (termination.isNone()) {
        return NotFound(
            "Container " + stringify(containerId) + " cannot be found");
      }

      mesos::agent::Response response;

      // The response object depends on which API was originally used
      // to make this call.
      if (deprecated) {
        response.set_type(mesos::agent::Response::WAIT_NESTED_CONTAINER);

        mesos::agent::Response::WaitNestedContainer* waitNestedContainer =
          response.mutable_wait_nested_container();

        if (termination->has_status()) {
          waitNestedContainer->set_exit_status(termination->status());
        }

        if (termination->has_state()) {
          waitNestedContainer->set_state(termination->state());
        }

        if (termination->has_reason()) {
          waitNestedContainer->set_reason(termination->reason());
        }

        if (!termination->limited_resources().empty()) {
          waitNestedContainer->mutable_limitation()->mutable_resources()
            ->CopyFrom(termination->limited_resources());
        }