Line data    Source code

       1             : #pragma once
       2             : 
       3             : #include <chrono>
       4             : #include <cstdint>
       5             : #include <string>
       6             : 
       7             : #include "envoy/common/exception.h"
       8             : #include "envoy/config/bootstrap/v3/bootstrap.pb.h"
       9             : #include "envoy/registry/registry.h"
      10             : #include "envoy/server/options.h"
      11             : 
      12             : #include "source/common/common/logger.h"
      13             : #include "source/common/config/well_known_names.h"
      14             : 
      15             : #include "spdlog/spdlog.h"
      16             : 
      17             : namespace Envoy {
      18             : 
      19             : /**
      20             :  * Implementation of Server::Options without command line parsing.
      21             :  */
      22             : class OptionsImplBase : public Server::Options, protected Logger::Loggable<Logger::Id::config> {
      23             : public:
      24             :   /**
      25             :    * Parameters are hot_restart_enabled
      26             :    */
      27             :   using HotRestartVersionCb = std::function<std::string(bool)>;
      28             : 
      29             :   // Constructor for mobile
      30         167 :   OptionsImplBase() = default;
      31             : 
      32             :   // Setters for option fields. These are not part of the Options interface.
      33           0 :   void setBaseId(uint64_t base_id) { base_id_ = base_id; };
      34           0 :   void setUseDynamicBaseId(bool use_dynamic_base_id) { use_dynamic_base_id_ = use_dynamic_base_id; }
      35           0 :   void setBaseIdPath(const std::string& base_id_path) { base_id_path_ = base_id_path; }
      36          98 :   void setConcurrency(uint32_t concurrency) { concurrency_ = concurrency; }
      37          98 :   void setConfigPath(const std::string& config_path) { config_path_ = config_path; }
      38           0 :   void setConfigProto(const envoy::config::bootstrap::v3::Bootstrap& config_proto) {
      39           0 :     *config_proto_ = config_proto;
      40           0 :   }
      41           0 :   void setConfigProto(std::unique_ptr<envoy::config::bootstrap::v3::Bootstrap>&& config_proto) {
      42           0 :     config_proto_ = std::move(config_proto);
      43           0 :   }
      44          98 :   void setConfigYaml(const std::string& config_yaml) { config_yaml_ = config_yaml; }
      45           0 :   void setAdminAddressPath(const std::string& admin_address_path) {
      46           0 :     admin_address_path_ = admin_address_path;
      47           0 :   }
      48          98 :   void setLocalAddressIpVersion(Network::Address::IpVersion local_address_ip_version) {
      49          98 :     local_address_ip_version_ = local_address_ip_version;
      50          98 :   }
      51          98 :   void setDrainTime(std::chrono::seconds drain_time) { drain_time_ = drain_time; }
      52          98 :   void setParentShutdownTime(std::chrono::seconds parent_shutdown_time) {
      53          98 :     parent_shutdown_time_ = parent_shutdown_time;
      54          98 :   }
      55          98 :   void setDrainStrategy(Server::DrainStrategy drain_strategy) { drain_strategy_ = drain_strategy; }
      56          98 :   void setLogLevel(spdlog::level::level_enum log_level) { log_level_ = log_level; }
      57             :   absl::Status setLogLevel(absl::string_view log_level);
      58           0 :   void setLogFormat(const std::string& log_format) {
      59           0 :     log_format_ = log_format;
      60           0 :     log_format_set_ = true;
      61           0 :   }
      62           0 :   void setLogPath(const std::string& log_path) { log_path_ = log_path; }
      63           0 :   void setRestartEpoch(uint64_t restart_epoch) { restart_epoch_ = restart_epoch; }
      64           0 :   void setMode(Server::Mode mode) { mode_ = mode; }
      65          98 :   void setFileFlushIntervalMsec(std::chrono::milliseconds file_flush_interval_msec) {
      66          98 :     file_flush_interval_msec_ = file_flush_interval_msec;
      67          98 :   }
      68          98 :   void setServiceClusterName(const std::string& service_cluster) {
      69          98 :     service_cluster_ = service_cluster;
      70          98 :   }
      71          98 :   void setServiceNodeName(const std::string& service_node) { service_node_ = service_node; }
      72          98 :   void setServiceZone(const std::string& service_zone) { service_zone_ = service_zone; }
      73          98 :   void setHotRestartDisabled(bool hot_restart_disabled) {
      74          98 :     hot_restart_disabled_ = hot_restart_disabled;
      75          98 :   }
      76           0 :   void setSignalHandling(bool signal_handling_enabled) {
      77           0 :     signal_handling_enabled_ = signal_handling_enabled;
      78           0 :   }
      79           0 :   void setCpusetThreads(bool cpuset_threads_enabled) { cpuset_threads_ = cpuset_threads_enabled; }
      80          98 :   void setAllowUnknownFields(bool allow_unknown_static_fields) {
      81          98 :     allow_unknown_static_fields_ = allow_unknown_static_fields;
      82          98 :   }
      83          98 :   void setRejectUnknownFieldsDynamic(bool reject_unknown_dynamic_fields) {
      84          98 :     reject_unknown_dynamic_fields_ = reject_unknown_dynamic_fields;
      85          98 :   }
      86          98 :   void setIgnoreUnknownFieldsDynamic(bool ignore_unknown_dynamic_fields) {
      87          98 :     ignore_unknown_dynamic_fields_ = ignore_unknown_dynamic_fields;
      88          98 :   }
      89             : 
      90           0 :   void setSocketPath(const std::string& socket_path) { socket_path_ = socket_path; }
      91             : 
      92           0 :   void setSocketMode(mode_t socket_mode) { socket_mode_ = socket_mode; }
      93             : 
      94           0 :   void setStatsTags(const Stats::TagVector& stats_tags) { stats_tags_ = stats_tags; }
      95             : 
      96             :   // Server::Options
      97           0 :   uint64_t baseId() const override { return base_id_; }
      98           0 :   bool useDynamicBaseId() const override { return use_dynamic_base_id_; }
      99           0 :   const std::string& baseIdPath() const override { return base_id_path_; }
     100         766 :   uint32_t concurrency() const override { return concurrency_; }
     101          98 :   const std::string& configPath() const override { return config_path_; }
     102          98 :   const envoy::config::bootstrap::v3::Bootstrap& configProto() const override {
     103          98 :     return *config_proto_;
     104          98 :   }
     105          98 :   const std::string& configYaml() const override { return config_yaml_; }
     106          98 :   bool allowUnknownStaticFields() const override { return allow_unknown_static_fields_; }
     107          98 :   bool rejectUnknownDynamicFields() const override { return reject_unknown_dynamic_fields_; }
     108          98 :   bool ignoreUnknownDynamicFields() const override { return ignore_unknown_dynamic_fields_; }
     109          98 :   const std::string& adminAddressPath() const override { return admin_address_path_; }
     110           0 :   Network::Address::IpVersion localAddressIpVersion() const override {
     111           0 :     return local_address_ip_version_;
     112           0 :   }
     113          14 :   std::chrono::seconds drainTime() const override { return drain_time_; }
     114           0 :   std::chrono::seconds parentShutdownTime() const override { return parent_shutdown_time_; }
     115          10 :   Server::DrainStrategy drainStrategy() const override { return drain_strategy_; }
     116             : 
     117         167 :   spdlog::level::level_enum logLevel() const override { return log_level_; }
     118             :   const std::vector<std::pair<std::string, spdlog::level::level_enum>>&
     119           0 :   componentLogLevels() const override {
     120           0 :     return component_log_levels_;
     121           0 :   }
     122          69 :   const std::string& logFormat() const override { return log_format_; }
     123           0 :   bool logFormatSet() const override { return log_format_set_; }
     124           0 :   bool logFormatEscaped() const override { return log_format_escaped_; }
     125           0 :   bool enableFineGrainLogging() const override { return enable_fine_grain_logging_; }
     126          98 :   const std::string& logPath() const override { return log_path_; }
     127          98 :   uint64_t restartEpoch() const override { return restart_epoch_; }
     128           0 :   Server::Mode mode() const override { return mode_; }
     129          98 :   std::chrono::milliseconds fileFlushIntervalMsec() const override {
     130          98 :     return file_flush_interval_msec_;
     131          98 :   }
     132          98 :   const std::string& serviceClusterName() const override { return service_cluster_; }
     133          98 :   const std::string& serviceNodeName() const override { return service_node_; }
     134          98 :   const std::string& serviceZone() const override { return service_zone_; }
     135          94 :   bool hotRestartDisabled() const override { return hot_restart_disabled_; }
     136          98 :   bool signalHandlingEnabled() const override { return signal_handling_enabled_; }
     137          98 :   bool mutexTracingEnabled() const override { return mutex_tracing_enabled_; }
     138           0 :   bool coreDumpEnabled() const override { return core_dump_enabled_; }
     139          98 :   const Stats::TagVector& statsTags() const override { return stats_tags_; }
     140           0 :   bool cpusetThreadsEnabled() const override { return cpuset_threads_; }
     141           0 :   const std::vector<std::string>& disabledExtensions() const override {
     142           0 :     return disabled_extensions_;
     143           0 :   }
     144             :   uint32_t count() const;
     145           0 :   const std::string& socketPath() const override { return socket_path_; }
     146           0 :   mode_t socketMode() const override { return socket_mode_; }
     147             :   // implemented by OptionsImpl
     148           0 :   Server::CommandLineOptionsPtr toCommandLineOptions() const override { return nullptr; }
     149             : 
     150             :   /**
     151             :    * disableExtensions parses the given set of extension names of
     152             :    * the form $CATEGORY/$NAME, and disables the corresponding extension
     153             :    * factories.
     154             :    */
     155             :   static void disableExtensions(const std::vector<std::string>&);
     156             : 
     157             :   /**
     158             :    * Parses and validates the provided log_level, returning the corresponding
     159             :    * spdlog::level::level_enum or an error status if the provided string is not a valid spdlog
     160             :    * string.
     161             :    */
     162             :   static absl::StatusOr<spdlog::level::level_enum>
     163             :   parseAndValidateLogLevel(absl::string_view log_level);
     164             : 
     165             : private:
     166             :   friend class OptionsImpl;
     167             : 
     168             :   uint64_t base_id_{0};
     169             :   bool use_dynamic_base_id_{false};
     170             :   std::string base_id_path_;
     171             :   uint32_t concurrency_{1};
     172             :   std::string config_path_;
     173             :   std::unique_ptr<envoy::config::bootstrap::v3::Bootstrap> config_proto_{
     174             :       new envoy::config::bootstrap::v3::Bootstrap()};
     175             :   std::string config_yaml_;
     176             :   bool allow_unknown_static_fields_{false};
     177             :   bool reject_unknown_dynamic_fields_{false};
     178             :   bool ignore_unknown_dynamic_fields_{false};
     179             :   std::string admin_address_path_;
     180             :   Network::Address::IpVersion local_address_ip_version_{Network::Address::IpVersion::v4};
     181             :   spdlog::level::level_enum log_level_{spdlog::level::info};
     182             :   std::vector<std::pair<std::string, spdlog::level::level_enum>> component_log_levels_;
     183             :   std::string component_log_level_str_;
     184             :   std::string log_format_{Logger::Logger::DEFAULT_LOG_FORMAT};
     185             :   bool log_format_set_{false};
     186             :   bool log_format_escaped_{false};
     187             :   std::string log_path_;
     188             :   uint64_t restart_epoch_{0};
     189             :   std::string service_cluster_;
     190             :   std::string service_node_;
     191             :   std::string service_zone_;
     192             :   std::chrono::milliseconds file_flush_interval_msec_{10000};
     193             :   std::chrono::seconds drain_time_{600};
     194             :   std::chrono::seconds parent_shutdown_time_{900};
     195             :   Server::DrainStrategy drain_strategy_{Server::DrainStrategy::Gradual};
     196             :   Server::Mode mode_{Server::Mode::Serve};
     197             :   bool hot_restart_disabled_{false};
     198             :   bool signal_handling_enabled_{true};
     199             :   bool mutex_tracing_enabled_{false};
     200             :   bool core_dump_enabled_{false};
     201             :   bool cpuset_threads_{false};
     202             :   std::vector<std::string> disabled_extensions_;
     203             :   Stats::TagVector stats_tags_;
     204             :   uint32_t count_{0};
     205             : 
     206             :   // Initialization added here to avoid integration_admin_test failure caused by uninitialized
     207             :   // enable_fine_grain_logging_.
     208             :   bool enable_fine_grain_logging_ = false;
     209             :   std::string socket_path_{"@envoy_domain_socket"};
     210             :   mode_t socket_mode_{0};
     211             : };
     212             : 
     213             : } // namespace Envoy