Grcov report - admin.h

1

#pragma once

2

3

#include <chrono>

4

#include <functional>

5

#include <list>

6

#include <string>

7

#include <utility>

8

#include <vector>

9

10

#include "envoy/http/filter.h"

11

#include "envoy/http/request_id_extension.h"

12

#include "envoy/network/filter.h"

13

#include "envoy/network/listen_socket.h"

14

#include "envoy/server/admin.h"

15

#include "envoy/server/instance.h"

16

#include "envoy/server/listener_manager.h"

17

#include "envoy/upstream/outlier_detection.h"

18

#include "envoy/upstream/resource_manager.h"

19

20

#include "source/common/common/assert.h"

21

#include "source/common/common/basic_resource_impl.h"

22

#include "source/common/common/empty_string.h"

23

#include "source/common/common/logger.h"

24

#include "source/common/common/macros.h"

25

#include "source/common/http/conn_manager_config.h"

26

#include "source/common/http/conn_manager_impl.h"

27

#include "source/common/http/date_provider_impl.h"

28

#include "source/common/http/default_server_string.h"

29

#include "source/common/http/http1/codec_stats.h"

30

#include "source/common/http/http2/codec_stats.h"

31

#include "source/common/http/request_id_extension_impl.h"

32

#include "source/common/http/utility.h"

33

#include "source/common/network/connection_balancer_impl.h"

34

#include "source/common/network/raw_buffer_socket.h"

35

#include "source/common/router/scoped_config_impl.h"

36

#include "source/common/stats/isolated_store_impl.h"

37

#include "source/extensions/filters/http/common/pass_through_filter.h"

38

#include "source/server/admin/admin_factory_context.h"

39

#include "source/server/admin/admin_filter.h"

40

#include "source/server/admin/clusters_handler.h"

41

#include "source/server/admin/config_dump_handler.h"

42

#include "source/server/admin/config_tracker_impl.h"

43

#include "source/server/admin/init_dump_handler.h"

44

#include "source/server/admin/listeners_handler.h"

45

#include "source/server/admin/logs_handler.h"

46

#include "source/server/admin/profiling_handler.h"

47

#include "source/server/admin/runtime_handler.h"

48

#include "source/server/admin/server_cmd_handler.h"

49

#include "source/server/admin/server_info_handler.h"

50

#include "source/server/admin/stats_handler.h"

51

#include "source/server/null_overload_manager.h"

52

53

#include "absl/strings/string_view.h"

54

55

namespace Envoy {

56

namespace Server {

57

58

class AdminInternalAddressConfig : public Http::InternalAddressConfig {

59

439

  bool isInternalAddress(const Network::Address::Instance&) const override { return false; }

60

};

61

62

/**

63

 * Implementation of Server::Admin.

64

*/

65

class AdminImpl : public Admin,

66

                  public Network::FilterChainManager,

67

                  public Network::FilterChainFactory,

68

                  public Http::FilterChainFactory,

69

                  public Http::ConnectionManagerConfig,

70

                  public std::enable_shared_from_this<AdminImpl>,

71

                  Logger::Loggable<Logger::Id::admin> {

72

public:

73

  AdminImpl(const std::string& profile_path, Server::Instance& server,

74

            bool ignore_global_conn_limit);

75

76

  Http::Code runCallback(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,

77

                         AdminStream& admin_stream);

78

22689

  const Network::Socket& socket() override { return *socket_; }

79

1

  Network::Socket& mutableSocket() { return *socket_; }

80

81

10633

  Configuration::FactoryContext& factoryContext() { return factory_context_; }

82

83

  const Matcher::MatchTreePtr<Http::HttpMatchingData>& forwardClientCertMatcher() const override;

84

85

  // Server::Admin

86

  // TODO(jsedgwick) These can be managed with a generic version of ConfigTracker.

87

  // Wins would be no manual removeHandler() and code reuse.

88

//

89

  // The prefix must start with "/" and contain at least one additional character.

90

  bool addHandler(const std::string& prefix, const std::string& help_text, HandlerCb callback,

91

                  bool removable, bool mutates_server_state,

92

                  const ParamDescriptorVec& params = {}) override;

93

  bool addStreamingHandler(const std::string& prefix, const std::string& help_text,

94

                           GenRequestFn callback, bool removable, bool mutates_server_state,

95

                           const ParamDescriptorVec& params = {}) override;

96

  bool removeHandler(const std::string& prefix) override;

97

  ConfigTracker& getConfigTracker() override;

98

99

  void startHttpListener(AccessLog::InstanceSharedPtrVector access_logs,

100

                         Network::Address::InstanceConstSharedPtr address,

101

                         Network::Socket::OptionsSharedPtr socket_options) override;

102

1

  uint32_t concurrency() const override { return server_.options().concurrency(); }

103

104

  // Network::FilterChainManager

105

  const Network::FilterChain* findFilterChain(const Network::ConnectionSocket&,

106

440

                                              const StreamInfo::StreamInfo&) const override {

107

440

    return admin_filter_chain_.get();

108

440

109

110

  // Network::FilterChainFactory

111

  bool

112

  createNetworkFilterChain(Network::Connection& connection,

113

                           const Filter::NetworkFilterFactoriesList& filter_factories) override;

114

440

  bool createListenerFilterChain(Network::ListenerFilterManager&) override { return true; }

115

  void createUdpListenerFilterChain(Network::UdpListenerFilterManager&,

116

                                    Network::UdpReadFilterCallbacks&) override {}

117

  bool createQuicListenerFilterChain(Network::QuicListenerFilterManager&) override { return true; }

118

119

  // Http::FilterChainFactory

120

  bool createFilterChain(Http::FilterChainFactoryCallbacks& callbacks) const override;

121

  bool createUpgradeFilterChain(absl::string_view, const Http::FilterChainFactory::UpgradeMap*,

122

                                Http::FilterChainFactoryCallbacks&) const override {

123

    return false;

124

125

126

  // Http::ConnectionManagerConfig

127

  const Http::RequestIDExtensionSharedPtr& requestIDExtension() override {

128

    return request_id_extension_;

129

130

439

  const AccessLog::InstanceSharedPtrVector& accessLogs() override { return access_logs_; }

131

44

  bool acceptTargetPath(absl::string_view path_name) const {

132

44

    return std::any_of(allowlisted_paths_.begin(), allowlisted_paths_.end(),

133

98

                       [path_name](const Matchers::StringMatcherPtr& matcher) {

134

98

                         return matcher->match(path_name);

135

98

});

136

44

137

  void addAllowlistedPath(Matchers::StringMatcherPtr matcher);

138

439

  bool flushAccessLogOnNewRequest() override { return flush_access_log_on_new_request_; }

139

  bool flushAccessLogOnTunnelSuccessfullyEstablished() const override { return false; }

140

439

  const absl::optional<std::chrono::milliseconds>& accessLogFlushInterval() override {

141

439

    return null_access_log_flush_interval_;

142

439

143

  Http::ServerConnectionPtr createCodec(Network::Connection& connection,

144

                                        const Buffer::Instance& data,

145

                                        Http::ServerConnectionCallbacks& callbacks,

146

                                        Server::OverloadManager& overload_manager) override;

147

439

  Http::DateProvider& dateProvider() override { return date_provider_; }

148

76

  std::chrono::milliseconds drainTimeout() const override { return std::chrono::milliseconds(100); }

149

439

  Http::FilterChainFactory& filterFactory() override { return *this; }

150

439

  bool generateRequestId() const override { return false; }

151

1

  bool preserveExternalRequestId() const override { return false; }

152

439

  bool alwaysSetRequestIdInResponse() const override { return false; }

153

440

  absl::optional<std::chrono::milliseconds> idleTimeout() const override { return idle_timeout_; }

154

1756

  bool isRoutable() const override { return false; }

155

440

  absl::optional<std::chrono::milliseconds> maxConnectionDuration() const override {

156

440

    return max_connection_duration_;

157

440

158

  bool http1SafeMaxConnectionDuration() const override { return false; }

159

439

  uint32_t maxRequestHeadersKb() const override { return max_request_headers_kb_; }

160

439

  uint32_t maxRequestHeadersCount() const override { return max_request_headers_count_; }

161

878

  std::chrono::milliseconds streamIdleTimeout() const override { return {}; }

162

878

  absl::optional<std::chrono::milliseconds> streamFlushTimeout() const override {

163

878

    return std::nullopt;

164

878

165

439

  std::chrono::milliseconds requestTimeout() const override { return {}; }

166

439

  std::chrono::milliseconds requestHeadersTimeout() const override { return {}; }

167

440

  std::chrono::milliseconds delayedCloseTimeout() const override { return {}; }

168

439

  absl::optional<std::chrono::milliseconds> maxStreamDuration() const override {

169

439

    return max_stream_duration_;

170

439

171

439

  Router::RouteConfigProvider* routeConfigProvider() override { return &route_config_provider_; }

172

1

  Config::ConfigProvider* scopedRouteConfigProvider() override {

173

1

    return &scoped_route_config_provider_;

174

1

175

  OptRef<const Router::ScopeKeyBuilder> scopeKeyBuilder() override { return scope_key_builder_; }

176

879

  const std::string& serverName() const override { return Http::DefaultServerString::get(); }

177

440

  const absl::optional<std::string>& schemeToSet() const override { return scheme_; }

178

440

  bool shouldSchemeMatchUpstream() const override { return scheme_match_upstream_; }

179

  HttpConnectionManagerProto::ServerHeaderTransformation

180

439

  serverHeaderTransformation() const override {

181

439

    return HttpConnectionManagerProto::OVERWRITE;

182

439

183

440

  Http::ConnectionManagerStats& stats() override { return stats_; }

184

62

  Http::ConnectionManagerTracingStats& tracingStats() override { return tracing_stats_; }

185

878

  bool useRemoteAddress() const override { return true; }

186

439

  const Http::InternalAddressConfig& internalAddressConfig() const override {

187

439

    return internal_address_config_;

188

439

189

439

  uint32_t xffNumTrustedHops() const override { return 0; }

190

439

  bool skipXffAppend() const override { return false; }

191

878

  const std::string& via() const override { return EMPTY_STRING; }

192

439

  Http::ForwardClientCertType forwardClientCert() const override {

193

439

    return Http::ForwardClientCertType::Sanitize;

194

439

195

500

  const std::vector<Http::ClientCertDetailsType>& setCurrentClientCertDetails() const override {

196

500

    return set_current_client_cert_details_;

197

500

198

  const Network::Address::Instance& localAddress() override;

199

439

  const absl::optional<std::string>& userAgent() override { return user_agent_; }

200

1

  Tracing::TracerSharedPtr tracer() override { return nullptr; }

201

878

  const Http::TracingConnectionManagerConfig* tracingConfig() override { return nullptr; }

202

440

  Http::ConnectionManagerListenerStats& listenerStats() override { return listener_->stats_; }

203

878

  bool proxy100Continue() const override { return false; }

204

1

  bool streamErrorOnInvalidHttpMessaging() const override { return false; }

205

1

  const Http::Http1Settings& http1Settings() const override { return http1_settings_; }

206

439

  bool shouldNormalizePath() const override { return true; }

207

439

  bool shouldMergeSlashes() const override { return true; }

208

439

  bool shouldStripTrailingHostDot() const override { return false; }

209

878

  Http::StripPortType stripPortType() const override { return Http::StripPortType::None; }

210

  envoy::config::core::v3::HttpProtocolOptions::HeadersWithUnderscoresAction

211

439

  headersWithUnderscoresAction() const override {

212

439

    return envoy::config::core::v3::HttpProtocolOptions::ALLOW;

213

439

214

439

  const LocalReply::LocalReply& localReply() const override { return *local_reply_; }

215

  envoy::extensions::filters::network::http_connection_manager::v3::HttpConnectionManager::

216

      PathWithEscapedSlashesAction

217

440

      pathWithEscapedSlashesAction() const override {

218

440

    return envoy::extensions::filters::network::http_connection_manager::v3::HttpConnectionManager::

219

440

        KEEP_UNCHANGED;

220

440

221

  const std::vector<Http::OriginalIPDetectionSharedPtr>&

222

1

  originalIpDetectionExtensions() const override {

223

1

    return detection_extensions_;

224

1

225

439

  const std::vector<Http::EarlyHeaderMutationPtr>& earlyHeaderMutationExtensions() const override {

226

439

    return early_header_mutations_;

227

439

228

  Http::Code request(absl::string_view path_and_query, absl::string_view method,

229

                     Http::ResponseHeaderMap& response_headers, std::string& body) override;

230

  void closeSocket() override;

231

  void addListenerToHandler(Network::ConnectionHandler* handler) override;

232

233

439

  uint32_t maxRequestsPerConnection() const override { return 0; }

234

879

  const HttpConnectionManagerProto::ProxyStatusConfig* proxyStatusConfig() const override {

235

879

    return proxy_status_config_.get();

236

879

237

  Http::ServerHeaderValidatorPtr

238

440

  makeHeaderValidator([[maybe_unused]] Http::Protocol protocol) override {

239

#ifdef ENVOY_ENABLE_UHV

240

    ENVOY_BUG(header_validator_factory_ != nullptr,

241

              "Admin HCM config can not have null UHV factory.");

242

    return header_validator_factory_ ? header_validator_factory_->createServerHeaderValidator(

243

                                           protocol, getHeaderValidatorStats(protocol))

244

                                     : nullptr;

245

#else

246

440

    return nullptr;

247

440

#endif

248

440

249

  bool appendLocalOverload() const override { return false; }

250

878

  bool appendXForwardedPort() const override { return false; }

251

440

  bool addProxyProtocolConnectionState() const override { return true; }

252

439

  const absl::flat_hash_set<uint32_t>& httpsDestinationPorts() const override {

253

439

    return https_destination_ports_;

254

439

255

439

  const absl::flat_hash_set<uint32_t>& httpDestinationPorts() const override {

256

439

    return http_destination_ports_;

257

439

258

259

private:

260

  friend class AdminTestingPeer;

261

262

#ifdef ENVOY_ENABLE_UHV

263

  ::Envoy::Http::HeaderValidatorStats& getHeaderValidatorStats(Http::Protocol protocol);

264

#endif

265

266

  RequestPtr makeRequest(AdminStream& admin_stream) const override;

267

268

/**

269

   * Creates a UrlHandler structure from a non-chunked callback.

270

*/

271

  UrlHandler makeHandler(const std::string& prefix, const std::string& help_text,

272

                         HandlerCb callback, bool removable, bool mutates_state,

273

                         const ParamDescriptorVec& params = {});

274

275

/**

276

   * Creates a URL prefix bound to chunked handler. Handler is expected to

277

   * supply a method makeRequest(AdminStream&).

278

279

   * @param prefix the prefix to register

280

   * @param help_text a help text ot display in a table in the admin home page

281

   * @param handler the Handler object for the admin subsystem, supplying makeContext().

282

   * @param removeable indicates whether the handler can be removed after being added

283

   * @param mutates_state indicates whether the handler will mutate state and therefore

284

   *                      must be accessed via HTTP POST rather than GET.

285

   * @return the UrlHandler.

286

*/

287

  template <class Handler>

288

  UrlHandler makeStreamingHandler(const std::string& prefix, const std::string& help_text,

289

                                  Handler& handler, bool removable, bool mutates_state) {

290

    return {prefix, help_text,

291

            [&handler](AdminStream& admin_stream) -> Admin::RequestPtr {

292

              return handler.makeRequest(admin_stream);

293

},

294

            removable, mutates_state};

295

296

297

/**

298

   * Implementation of RouteConfigProvider that returns a static null route config.

299

*/

300

  struct NullRouteConfigProvider : public Router::RouteConfigProvider {

301

    NullRouteConfigProvider(TimeSource& time_source);

302

303

    // Router::RouteConfigProvider

304

1

    Rds::ConfigConstSharedPtr config() const override { return config_; }

305

1

    const absl::optional<ConfigInfo>& configInfo() const override { return config_info_; }

306

1

    SystemTime lastUpdated() const override { return time_source_.systemTime(); }

307

1

    absl::Status onConfigUpdate() override { return absl::OkStatus(); }

308

439

    Router::ConfigConstSharedPtr configCast() const override { return config_; }

309

    void requestVirtualHostsUpdate(const std::string&, Event::Dispatcher&,

310

                                   std::weak_ptr<Http::RouteConfigUpdatedCallback>) override {}

311

312

    Router::ConfigConstSharedPtr config_;

313

    absl::optional<ConfigInfo> config_info_;

314

    TimeSource& time_source_;

315

};

316

317

/**

318

   * Implementation of ScopedRouteConfigProvider that returns a null scoped route config.

319

*/

320

  struct NullScopedRouteConfigProvider : public Config::ConfigProvider {

321

    NullScopedRouteConfigProvider(TimeSource& time_source)

322

10736

        : config_(std::make_shared<const Router::NullScopedConfigImpl>()),

323

10736

          time_source_(time_source) {}

324

325

10736

    ~NullScopedRouteConfigProvider() override = default;

326

327

    // Config::ConfigProvider

328

1

    SystemTime lastUpdated() const override { return time_source_.systemTime(); }

329

1

    ConfigConstSharedPtr getConfig() const override { return config_; }

330

1

    ApiType apiType() const override { return ApiType::Full; }

331

1

    ConfigProtoVector getConfigProtos() const override { return {}; }

332

333

    Router::ScopedConfigConstSharedPtr config_;

334

    TimeSource& time_source_;

335

};

336

337

/**

338

   * Implementation of ScopeKeyBuilder that returns a null scope key.

339

*/

340

  struct NullScopeKeyBuilder : public Router::ScopeKeyBuilder {

341

10735

    NullScopeKeyBuilder() = default;

342

10735

    ~NullScopeKeyBuilder() override = default;

343

344

    Router::ScopeKeyPtr computeScopeKey(const Http::HeaderMap&) const override { return nullptr; };

345

};

346

347

  std::vector<const UrlHandler*> sortedHandlers() const;

348

  envoy::admin::v3::ServerInfo::State serverState();

349

350

/**

351

   * URL handlers.

352

*/

353

  Http::Code handlerAdminHome(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,

354

                              AdminStream&);

355

356

  Http::Code handlerHelp(Http::ResponseHeaderMap& response_headers, Buffer::Instance& response,

357

                         AdminStream&);

358

  void getHelp(Buffer::Instance& response) const;

359

360

  class AdminListenSocketFactory : public Network::ListenSocketFactory {

361

  public:

362

10697

    AdminListenSocketFactory(Network::SocketSharedPtr socket) : socket_(socket) {}

363

364

    // Network::ListenSocketFactory

365

10633

    Network::Socket::Type socketType() const override { return socket_->socketType(); }

366

10633

    const Network::Address::InstanceConstSharedPtr& localAddress() const override {

367

10633

      return socket_->connectionInfoProvider().localAddress();

368

10633

369

10633

    Network::SocketSharedPtr getListenSocket(uint32_t) override {

370

      // This is only supposed to be called once.

371

10633

      RELEASE_ASSERT(!socket_create_, "AdminListener's socket shouldn't be shared.");

372

10633

      socket_create_ = true;

373

10633

      return socket_;

374

10633

375

1

    Network::ListenSocketFactoryPtr clone() const override { return nullptr; }

376

1

    void closeAllSockets() override {}

377

1

    absl::Status doFinalPreWorkerInit() override { return absl::OkStatus(); }

378

379

  private:

380

    Network::SocketSharedPtr socket_;

381

    bool socket_create_{false};

382

};

383

384

  class AdminListener : public Network::ListenerConfig {

385

  public:

386

    AdminListener(AdminImpl& parent, Stats::Scope& listener_scope)

387

10697

        : parent_(parent), name_("admin"), scope_(listener_scope),

388

10697

          stats_(Http::ConnectionManagerImpl::generateListenerStats("http.admin.", scope_)),

389

10697

          init_manager_(nullptr), ignore_global_conn_limit_(parent.ignore_global_conn_limit_) {}

390

391

    // Network::ListenerConfig

392

440

    Network::FilterChainManager& filterChainManager() override { return parent_; }

393

880

    Network::FilterChainFactory& filterChainFactory() override { return parent_; }

394

21266

    std::vector<Network::ListenSocketFactoryPtr>& listenSocketFactories() override {

395

21266

      return parent_.socket_factories_;

396

21266

397

10633

    bool bindToPort() const override { return true; }

398

440

    bool handOffRestoredDestinationConnections() const override { return false; }

399

440

    uint32_t perConnectionBufferLimitBytes() const override { return 0; }

400

440

    std::chrono::milliseconds perConnectionBufferHighWatermarkTimeout() const override {

401

440

      return std::chrono::milliseconds::zero();

402

440

403

10633

    std::chrono::milliseconds listenerFiltersTimeout() const override { return {}; }

404

10633

    bool continueOnListenerFiltersTimeout() const override { return false; }

405

170128

    Stats::Scope& listenerScope() override { return scope_; }

406

21266

    uint64_t listenerTag() const override { return 0; }

407

1

    const std::string& name() const override { return name_; }

408

441

    const Network::ListenerInfoConstSharedPtr& listenerInfo() const override {

409

441

      return parent_.listener_info_;

410

441

411

1

    Network::UdpListenerConfigOptRef udpListenerConfig() override { return {}; }

412

10633

    Network::InternalListenerConfigOptRef internalListenerConfig() override { return {}; }

413

10633

    Network::ConnectionBalancer& connectionBalancer(const Network::Address::Instance&) override {

414

10633

      return connection_balancer_;

415

10633

416

1320

    ResourceLimit& openConnections() override { return open_connections_; }

417

440

    const AccessLog::InstanceSharedPtrVector& accessLogs() const override {

418

440

      return empty_access_logs_;

419

440

420

1

    uint32_t tcpBacklogSize() const override { return ENVOY_TCP_BACKLOG_SIZE; }

421

10633

    uint32_t maxConnectionsToAcceptPerSocketEvent() const override {

422

10633

      return Network::DefaultMaxConnectionsToAcceptPerSocketEvent;

423

10633

424

    Init::Manager& initManager() override { return *init_manager_; }

425

10633

    bool ignoreGlobalConnLimit() const override { return ignore_global_conn_limit_; }

426

31899

    bool shouldBypassOverloadManager() const override { return true; }

427

428

    AdminImpl& parent_;

429

    const std::string name_;

430

    Stats::Scope& scope_;

431

    Http::ConnectionManagerListenerStats stats_;

432

    Network::NopConnectionBalancerImpl connection_balancer_;

433

    BasicResourceLimitImpl open_connections_;

434

435

  private:

436

    const AccessLog::InstanceSharedPtrVector empty_access_logs_;

437

    std::unique_ptr<Init::Manager> init_manager_;

438

    const bool ignore_global_conn_limit_;

439

};

440

  using AdminListenerPtr = std::unique_ptr<AdminListener>;

441

442

  class AdminFilterChain : public Network::FilterChain {

443

  public:

444

    // We can't use the default constructor because transport_socket_factory_ doesn't have a

445

    // default constructor.

446

10735

    AdminFilterChain() {} // NOLINT(modernize-use-equals-default)

447

448

    // Network::FilterChain

449

440

    const Network::DownstreamTransportSocketFactory& transportSocketFactory() const override {

450

440

      return transport_socket_factory_;

451

440

452

453

440

    std::chrono::milliseconds transportSocketConnectTimeout() const override {

454

440

      return std::chrono::milliseconds::zero();

455

440

456

457

440

    const Filter::NetworkFilterFactoriesList& networkFilterFactories() const override {

458

440

      return empty_network_filter_factory_;

459

440

460

461

    absl::string_view name() const override { return "admin"; }

462

463

    bool addedViaApi() const override { return false; }

464

465

440

    const Network::FilterChainInfoSharedPtr& filterChainInfo() const override {

466

440

      return filter_chain_info_;

467

440

468

469

  private:

470

    const Network::RawBufferSocketFactory transport_socket_factory_;

471

    const Filter::NetworkFilterFactoriesList empty_network_filter_factory_;

472

    const Network::FilterChainInfoSharedPtr filter_chain_info_;

473

};

474

475

  Server::Instance& server_;

476

  const Network::ListenerInfoConstSharedPtr listener_info_;

477

  AdminFactoryContext factory_context_;

478

  Http::RequestIDExtensionSharedPtr request_id_extension_;

479

  AccessLog::InstanceSharedPtrVector access_logs_;

480

  std::vector<Matchers::StringMatcherPtr> allowlisted_paths_;

481

  Matcher::MatchTreePtr<Http::HttpMatchingData> forward_client_cert_matcher_;

482

  const bool flush_access_log_on_new_request_ = false;

483

  const absl::optional<std::chrono::milliseconds> null_access_log_flush_interval_;

484

  const std::string profile_path_;

485

  Http::ConnectionManagerStats stats_;

486

  NullOverloadManager null_overload_manager_;

487

  // Note: this is here to essentially blackhole the tracing stats since they aren't used in the

488

  // Admin case.

489

  Stats::IsolatedStoreImpl no_op_store_;

490

  Http::ConnectionManagerTracingStats tracing_stats_;

491

  NullRouteConfigProvider route_config_provider_;

492

  NullScopedRouteConfigProvider scoped_route_config_provider_;

493

  NullScopeKeyBuilder scope_key_builder_;

494

  Server::ClustersHandler clusters_handler_;

495

  Server::ConfigDumpHandler config_dump_handler_;

496

  Server::InitDumpHandler init_dump_handler_;

497

  Server::StatsHandler stats_handler_;

498

  Server::LogsHandler logs_handler_;

499

  Server::ProfilingHandler profiling_handler_;

500

  Server::TcmallocProfilingHandler tcmalloc_profiling_handler_;

501

  Server::RuntimeHandler runtime_handler_;

502

  Server::ListenersHandler listeners_handler_;

503

  Server::ServerCmdHandler server_cmd_handler_;

504

  Server::ServerInfoHandler server_info_handler_;

505

  std::list<UrlHandler> handlers_;

506

  const uint32_t max_request_headers_kb_{Http::DEFAULT_MAX_REQUEST_HEADERS_KB};

507

  const uint32_t max_request_headers_count_{Http::DEFAULT_MAX_HEADERS_COUNT};

508

  absl::optional<std::chrono::milliseconds> idle_timeout_;

509

  absl::optional<std::chrono::milliseconds> max_connection_duration_;

510

  absl::optional<std::chrono::milliseconds> max_stream_duration_;

511

  absl::optional<std::string> user_agent_;

512

  Http::SlowDateProviderImpl date_provider_;

513

  std::vector<Http::ClientCertDetailsType> set_current_client_cert_details_;

514

  Http::Http1Settings http1_settings_;

515

  Http::Http1::CodecStats::AtomicPtr http1_codec_stats_;

516

  Http::Http2::CodecStats::AtomicPtr http2_codec_stats_;

517

  ConfigTrackerImpl config_tracker_;

518

  const Network::FilterChainSharedPtr admin_filter_chain_;

519

  Network::SocketSharedPtr socket_;

520

  std::vector<Network::ListenSocketFactoryPtr> socket_factories_;

521

  AdminListenerPtr listener_;

522

  const AdminInternalAddressConfig internal_address_config_;

523

  const LocalReply::LocalReplyPtr local_reply_;

524

  const std::vector<Http::OriginalIPDetectionSharedPtr> detection_extensions_;

525

  const std::vector<Http::EarlyHeaderMutationPtr> early_header_mutations_;

526

  const absl::optional<std::string> scheme_;

527

  const bool scheme_match_upstream_ = false;

528

  const bool ignore_global_conn_limit_;

529

  std::unique_ptr<HttpConnectionManagerProto::ProxyStatusConfig> proxy_status_config_;

530

  const Http::HeaderValidatorFactoryPtr header_validator_factory_;

531

  const absl::flat_hash_set<uint32_t> https_destination_ports_;

532

  const absl::flat_hash_set<uint32_t> http_destination_ports_;

533

};

534

535

} // namespace Server

536

} // namespace Envoy