worker.h

#pragma once

#include <functional>

#include "envoy/server/guarddog.h"
#include "envoy/server/overload_manager.h"

namespace Envoy {
namespace Server {

/**
 * Interface for a threaded connection handling worker. All routines are thread safe.
 */
class Worker {
public:
  virtual ~Worker() = default;

  /**
   * Completion called when a listener has been added on a worker and is listening for new
   * connections.
   * @param success supplies whether the addition was successful or not. FALSE can be returned
   *                when there is a race condition between bind() and listen().
   */
  using AddListenerCompletion = std::function<void(bool success)>;

  /**
   * Add a listener to the worker.
   * @param listener supplies the listener to add.
   * @param completion supplies the completion to call when the listener has been added (or not) on
   *                   the worker.
   */
  virtual void addListener(Network::ListenerConfig& listener,
                           AddListenerCompletion completion) PURE;

  /**
   * @return uint64_t the number of connections across all listeners that the worker owns.
   */
  virtual uint64_t numConnections() PURE;

  /**
   * Start the worker thread.
   * @param guard_dog supplies the guard dog to use for thread watching.
   */
  virtual void start(GuardDog& guard_dog) PURE;

  /**
   * Initialize stats for this worker's dispatcher, if available. The worker will output
   * thread-specific stats under the given scope.
   * @param scope the scope to contain the new per-dispatcher stats created here.
   * @param prefix the stats prefix to identify this dispatcher.
   */
  virtual void initializeStats(Stats::Scope& scope, const std::string& prefix) PURE;

  /**
   * Stop the worker thread.
   */
  virtual void stop() PURE;

  /**
   * Remove a listener from the worker.
   * @param listener supplies the listener to remove.
   * @param completion supplies the completion to be called when the listener has been removed.
   *        This completion is called on the worker thread. No locking is performed by the worker.
   */
  virtual void removeListener(Network::ListenerConfig& listener,
                              std::function<void()> completion) PURE;

  /**
   * Stop a listener from accepting new connections. This is used for server draining.
   * @param listener supplies the listener to stop.
   * @param completion supplies the completion to be called when the listener has stopped
   * accepting new connections. This completion is called on the worker thread. No locking is
   * performed by the worker.
   */
  virtual void stopListener(Network::ListenerConfig& listener,
                            std::function<void()> completion) PURE;

  virtual void updateListener(
      uint64_t listener_tag,
      std::function<bool(Network::ConnectionHandler::ActiveListener&)> listener_update_func,
      std::function<void(bool)> completion) PURE;
};

using WorkerPtr = std::unique_ptr<Worker>;

/**
 * Factory for creating workers.
 */
class WorkerFactory {
public:
  virtual ~WorkerFactory() = default;

  /**
   * @param overload_manager supplies the server's overload manager.
   * @param worker_name supplies the name of the worker, used for per-worker stats.
   * @return WorkerPtr a new worker.
   */
  virtual WorkerPtr createWorker(OverloadManager& overload_manager,
                                 const std::string& worker_name) PURE;
};

} // namespace Server
} // namespace Envoy