Method CREATE_JOB

include/process/windows/jobobject.hpp:84–126

} // namespace internal {

inline Subprocess::ParentHook Subprocess::ParentHook::CREATE_JOB() {
  return Subprocess::ParentHook([](pid_t pid) -> Try<Nothing> {
    // NOTE: There are two very important parts to this hook. First, Windows
    // does not have a process hierarchy in the same sense that Unix does, so
    // in order to be able to kill a task, we have to put it in a job object.
    // Then, when we terminate the job object, it will terminate all the
    // processes in the task (including any processes that were subsequently
    // created by any process in this task). Second, the lifetime of the job
    // object is greater than the lifetime of the processes it contains. Thus
    // the job object handle is explicitly owned by the global job object
    // manager process.
    Try<std::wstring> name = os::name_job(pid);
    if (name.isError()) {
      return Error(name.error());
    }

    // This creates a named job object in the Windows kernel.
    // This handle must remain in scope (and open) until
    // a running process is assigned to it.
    Try<SharedHandle> handle = os::create_job(name.get());
    if (handle.isError()) {
      return Error(handle.error());
    }

    // This actually assigns the process `pid` to the job object.
    Try<Nothing> result = os::assign_job(handle.get(), pid);
    if (result.isError()) {
      return Error(result.error());
    }

    // Save the handle to the job object to ensure the object remains
    // open for the entire lifetime of the agent process, and is closed
    // when the process is reaped.
    dispatch(
      process::internal::job_object_manager,
      &process::internal::JobObjectManager::manage,
      pid,
      name.get(),
      handle.get());

    return Nothing();
  });
}

} // namespace process {