Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <functional>
       4             : #include <memory>
       5             : 
       6             : #include "envoy/api/api.h"
       7             : #include "envoy/network/connection_handler.h"
       8             : #include "envoy/server/guarddog.h"
       9             : #include "envoy/server/listener_manager.h"
      10             : #include "envoy/server/worker.h"
      11             : #include "envoy/thread_local/thread_local.h"
      12             : 
      13             : #include "source/common/common/logger.h"
      14             : #include "source/server/listener_hooks.h"
      15             : 
      16             : namespace Envoy {
      17             : namespace Server {
      18             : 
      19             : // Captures a set of stat names for the workers.
      20             : struct WorkerStatNames {
      21             :   explicit WorkerStatNames(Stats::SymbolTable& symbol_table)
      22             :       : pool_(symbol_table),
      23         135 :         reset_high_memory_stream_(pool_.add(OverloadActionStatsNames::get().ResetStreamsCount)) {}
      24             : 
      25             :   Stats::StatNamePool pool_;
      26             :   Stats::StatName reset_high_memory_stream_;
      27             : };
      28             : 
      29             : class ProdWorkerFactory : public WorkerFactory, Logger::Loggable<Logger::Id::main> {
      30             : public:
      31             :   ProdWorkerFactory(ThreadLocal::Instance& tls, Api::Api& api, ListenerHooks& hooks)
      32         135 :       : tls_(tls), api_(api), stat_names_(api.rootScope().symbolTable()), hooks_(hooks) {}
      33             : 
      34             :   // Server::WorkerFactory
      35             :   WorkerPtr createWorker(uint32_t index, OverloadManager& overload_manager,
      36             :                          const std::string& worker_name) override;
      37             : 
      38             : private:
      39             :   ThreadLocal::Instance& tls_;
      40             :   Api::Api& api_;
      41             :   WorkerStatNames stat_names_;
      42             :   ListenerHooks& hooks_;
      43             : };
      44             : 
      45             : /**
      46             :  * A server threaded worker that wraps up a worker thread, event loop, etc.
      47             :  */
      48             : class WorkerImpl : public Worker, Logger::Loggable<Logger::Id::main> {
      49             : public:
      50             :   WorkerImpl(ThreadLocal::Instance& tls, ListenerHooks& hooks, Event::DispatcherPtr&& dispatcher,
      51             :              Network::ConnectionHandlerPtr handler, OverloadManager& overload_manager,
      52             :              Api::Api& api, WorkerStatNames& stat_names);
      53             : 
      54             :   // Server::Worker
      55             :   void addListener(absl::optional<uint64_t> overridden_listener, Network::ListenerConfig& listener,
      56             :                    AddListenerCompletion completion, Runtime::Loader& loader,
      57             :                    Random::RandomGenerator& random) override;
      58             :   uint64_t numConnections() const override;
      59             : 
      60             :   void removeListener(Network::ListenerConfig& listener, std::function<void()> completion) override;
      61             :   void removeFilterChains(uint64_t listener_tag,
      62             :                           const std::list<const Network::FilterChain*>& filter_chains,
      63             :                           std::function<void()> completion) override;
      64             :   void start(OptRef<GuardDog> guard_dog, const std::function<void()>& cb) override;
      65             :   void initializeStats(Stats::Scope& scope) override;
      66             :   void stop() override;
      67             :   void stopListener(Network::ListenerConfig& listener,
      68             :                     const Network::ExtraShutdownListenerOptions& options,
      69             :                     std::function<void()> completion) override;
      70             : 
      71             : private:
      72             :   void threadRoutine(OptRef<GuardDog> guard_dog, const std::function<void()>& cb);
      73             :   void stopAcceptingConnectionsCb(OverloadActionState state);
      74             :   void rejectIncomingConnectionsCb(OverloadActionState state);
      75             :   void resetStreamsUsingExcessiveMemory(OverloadActionState state);
      76             : 
      77             :   ThreadLocal::Instance& tls_;
      78             :   ListenerHooks& hooks_;
      79             :   Event::DispatcherPtr dispatcher_;
      80             :   Network::ConnectionHandlerPtr handler_;
      81             :   Api::Api& api_;
      82             :   Stats::Counter& reset_streams_counter_;
      83             :   Thread::ThreadPtr thread_;
      84             :   WatchDogSharedPtr watch_dog_;
      85             : };
      86             : 
      87             : } // namespace Server
      88             : } // namespace Envoy