Method resume

3rdparty/libprocess/src/process.cpp:2924–3083

void ProcessManager::resume(ProcessBase* process)
{
  __process__ = process;

  VLOG(3) << "Resuming " << process->pid << " at " << Clock::now();

  bool manage = process->manage;
  bool terminate = false;
  bool blocked = false;

  ProcessBase::State state = process->state.load();

  CHECK(state == ProcessBase::State::BOTTOM ||
        state == ProcessBase::State::READY);

  if (state == ProcessBase::State::BOTTOM) {
    // In the event that the process throws an exception,
    // we will abort the program.
    //
    // TODO(bmahler): Consider providing recovery mechanisms.
    try {
      process->initialize();
    } catch (const std::exception& e) {
      LOG(FATAL) << "Aborting libprocess: '" << process->pid << "'"
                 << " threw exception during initialization: " << e.what();
    } catch (...) {
      LOG(FATAL) << "Aborting libprocess: '" << process->pid << "'"
                 << " threw exception during initialization: unknown";
    }

    state = ProcessBase::State::READY;
    process->state.store(state);
  }

  // We must hold a reference to the process because it's possible
  // that another worker races ahead and deletes the process after
  // we set the state to BLOCKED (see the comment below).
  ProcessReference reference = process->reference;

  while (!terminate && !blocked) {
    Event* event = nullptr;

    // NOTE: the event queue requires only a _single_ consumer at a
    // time ... this is where we act as that single consumer (and down
    // in `ProcessManager::cleanup` which we call from here).

    if (!process->events->consumer.empty()) {
      event = process->events->consumer.dequeue();
    } else {
      // We now transition the process to BLOCKED. It's possible that
      // events get enqueued while we're still in the READY state.
      // If this happens, the process would not have been enqueued
      // into the run queue and we need to continue processing the
      // events!
      //
      // However, when checking for such events, we need to be
      // careful not to process the events if they were enqueued
      // *after* we transitioned to BLOCKED. In this case, the