Class MesosExecutorDriver

include/mesos/executor.hpp:212–264

Concrete implementation of an ExecutorDriver that connects an Executor with a Mesos slave. The MesosExecutorDriver is thread-safe. The driver is responsible for invoking the Executor callbacks as it communicates with the Mesos slave. Note that blocking on the MesosExecutorDriver (e.g., via MesosExecutorDriver::join) doesn't affect the executor callbacks in anyway because they are handled by a di

// See src/examples/test_executor.cpp for an example of using the
// MesosExecutorDriver.
class MesosExecutorDriver : public ExecutorDriver
{
public:
  // Creates a new driver that uses the specified Executor. Note, the
  // executor pointer must outlive the driver.
  //
  // Note that the other constructor overload that accepts `environment`
  // argument is preferable to this one in a multithreaded environment,
  // because the implementation of this one accesses global environment
  // which is unsafe due to a potential concurrent modification of the
  // environment by another thread.
  explicit MesosExecutorDriver(Executor* executor);

  // Creates a new driver that uses the specified `Executor` and environment
  // variables. Note, the executor pointer must outlive the driver.
  explicit MesosExecutorDriver(
      Executor* executor,
      const std::map<std::string, std::string>& environment);

  // This destructor will block indefinitely if
  // MesosExecutorDriver::start was invoked successfully (possibly via
  // MesosExecutorDriver::run) and MesosExecutorDriver::stop has not
  // been invoked.
  ~MesosExecutorDriver() override;

  // See ExecutorDriver for descriptions of these.
  Status start() override;
  Status stop() override;
  Status abort() override;
  Status join() override;
  Status run() override;
  Status sendStatusUpdate(const TaskStatus& status) override;
  Status sendFrameworkMessage(const std::string& data) override;

private:
  friend class internal::ExecutorProcess;

  Executor* executor;

  // Libprocess process for communicating with slave.
  internal::ExecutorProcess* process;

  // Mutex for enforcing serial execution of all non-callbacks.
  std::recursive_mutex mutex;

  // Latch for waiting until driver terminates.
  process::Latch* latch;

  // Current status of the driver.
  Status status;

  std::map<std::string, std::string> environment;
};

} // namespace mesos {