C++ process::Future类代码示例

bool await(const process::Future<T>& future, const Duration& duration)
{
  if (!process::Clock::paused()) {
    return future.await(duration);
  }

  // If the clock is paused, no new timers will expire.
  // Future::await(duration) may hang forever because it depends on
  // a timer to expire after 'duration'. We instead ensure all
  // expired timers are flushed and check if the future is satisfied.
  Stopwatch stopwatch;
  stopwatch.start();

  // Settle to make sure all expired timers are executed (not
  // necessarily finished, see below).
  process::Clock::settle();

  while (future.isPending() && stopwatch.elapsed() < duration) {
    // Synchronous operations and asynchronous process::Process
    // operations should finish when the above 'settle()' returns.
    // Other types of async operations such as io::write() may not.
    // Therefore we wait the specified duration for it to complete.
    // Note that nothing prevents the operations to schedule more
    // timeouts for some time in the future. These timeouts will
    // never be executed due to the paused process::Clock. In this
    // case we return after the stopwatch (system clock) runs out.
    os::sleep(Milliseconds(10));
  }

  return !future.isPending();
}

inline ::testing::AssertionResult AwaitAssertResponseBodyEq(
    const char* expectedExpr,
    const char* actualExpr,
    const char* durationExpr,
    const std::string& expected,
    const process::Future<process::http::Response>& actual,
    const Duration& duration)
{
  const ::testing::AssertionResult result =
    AwaitAssertReady(actualExpr, durationExpr, actual, duration);

  if (result) {
    if (expected == actual.get().body) {
      return ::testing::AssertionSuccess();
    } else {
      return ::testing::AssertionFailure()
        << "Value of: (" << actualExpr << ").get().body\n"
        << "  Actual: " << ::testing::PrintToString(actual.get().body) << "\n"
        << "Expected: " << expectedExpr << "\n"
        << "Which is: " << ::testing::PrintToString(expected);
    }
  }

  return result;
}

Future<Nothing> _destroy(
    const ContainerID& containerId,
    process::Future<bool> destroyed)
{
  if (destroyed.isFailed()) {
    LOG(ERROR) << "Failed to destroy freezer cgroup for '"
               << containerId << "': " << destroyed.failure();
    return Failure("Failed to destroy launcher: " + destroyed.failure());
  }
  return Nothing();
}

Future<Nothing> _destroy(
    const ContainerID& containerId,
    const process::Future<Nothing>& destroyed)
{
  if (!destroyed.isReady()) {
    return Failure("Failed to destroy launcher: " +
                   (destroyed.isFailed() ? destroyed.failure() : "discarded"));
  }

  return Nothing();
}

Option<Error> _check_failed(const process::Future<T>& f)
{
  if (f.isPending()) {
    return Some("is PENDING");
  } else if (f.isReady()) {
    return Some("is READY");
  } else if (f.isDiscarded()) {
    return Some("is DISCARDED");
  } else {
    CHECK(f.isFailed());
    return None();
  }
}

Option<Error> _check_discarded(const process::Future<T>& f)
{
  if (f.isPending()) {
    return Error("is PENDING");
  } else if (f.isReady()) {
    return Error("is READY");
  } else if (f.isFailed()) {
    return Error("is FAILED: " + f.failure());
  } else {
    CHECK(f.isDiscarded());
    return None();
  }
}

inline ::testing::AssertionResult AwaitAssertResponseHeaderEq(
    const char* expectedExpr,
    const char* keyExpr,
    const char* actualExpr,
    const char* durationExpr,
    const std::string& expected,
    const std::string& key,
    const process::Future<process::http::Response>& actual,
    const Duration& duration)
{
  const ::testing::AssertionResult result =
    AwaitAssertReady(actualExpr, durationExpr, actual, duration);

  if (result) {
    const Option<std::string> value = actual.get().headers.get(key);
    if (value.isNone()) {
      return ::testing::AssertionFailure()
        << "Response does not contain header '" << key << "'";
    } else if (expected == value.get()) {
      return ::testing::AssertionSuccess();
    } else {
      return ::testing::AssertionFailure()
        << "Value of: (" << actualExpr << ").get().headers[" << keyExpr << "]\n"
        << "  Actual: " << ::testing::PrintToString(value.get()) << "\n"
        << "Expected: " << expectedExpr << "\n"
        << "Which is: " << ::testing::PrintToString(expected);
    }
  }

  return result;
}

::testing::AssertionResult AwaitAssertAbandoned(
    const char* expr,
    const char*, // Unused string representation of 'duration'.
    const process::Future<T>& actual,
    const Duration& duration)
{
  process::Owned<process::Latch> latch(new process::Latch());

  actual.onAny([=]() { latch->trigger(); });
  actual.onAbandoned([=]() { latch->trigger(); });

  if (!latch->await(duration)) {
    return ::testing::AssertionFailure()
      << "Failed to wait " << duration << " for " << expr;
  } else if (actual.isDiscarded()) {
    return ::testing::AssertionFailure()
      << expr << " was discarded";
  } else if (actual.isReady()) {
    return ::testing::AssertionFailure()
      << expr << " is ready (" << ::testing::PrintToString(actual.get()) << ")";
  } else if (actual.isFailed()) {
    return ::testing::AssertionFailure()
      << "(" << expr << ").failure(): " << actual.failure();
  }

  CHECK_ABANDONED(actual);

  return ::testing::AssertionSuccess();
}

::testing::AssertionResult AwaitAssertDiscarded(
    const char* expr,
    const char*, // Unused string representation of 'duration'.
    const process::Future<T>& actual,
    const Duration& duration)
{
  if (!process::internal::await(actual, duration)) {
    return ::testing::AssertionFailure()
      << "Failed to wait " << duration << " for " << expr;
  } else if (actual.isFailed()) {
    return ::testing::AssertionFailure()
      << "(" << expr << ").failure(): " << actual.failure();
  } else if (actual.isReady()) {
    return ::testing::AssertionFailure()
      << expr << " is ready (" << ::testing::PrintToString(actual.get()) << ")";
  }

  return ::testing::AssertionSuccess();
}

inline ::testing::AssertionResult AwaitAssertTermSigNe(
    const char* expectedExpr,
    const char* actualExpr,
    const char* durationExpr,
    const int expected,
    const process::Future<Option<int>>& actual,
    const Duration& duration)
{
  const ::testing::AssertionResult result =
    AwaitAssertSignaled(actualExpr, durationExpr, actual, duration);

  if (result) {
    CHECK_READY(actual);
    CHECK_SOME(actual.get());
    return AssertTermSigNe(
        expectedExpr,
        strings::join("(", actualExpr, ")->get()").c_str(),
        expected,
        actual->get());
  }

  return result;
}

inline ::testing::AssertionResult AwaitAssertSignaled(
    const char* actualExpr,
    const char* durationExpr,
    const process::Future<Option<int>>& actual,
    const Duration& duration)
{
  const ::testing::AssertionResult result =
    AwaitAssertReady(actualExpr, durationExpr, actual, duration);

  if (result) {
    CHECK_READY(actual);
    if (actual->isNone()) {
      return ::testing::AssertionFailure()
        << "(" << actualExpr << ")->isNone() is true";
    }

    return AssertSignaled(
        strings::join("(", actualExpr, ")->get()").c_str(),
        actual->get());
  }

  return result;
}