std::unique_ptr<ConnectionHandler> getHandler(Event::Dispatcher& dispatcher) {

  auto* factory = Config::Utility::getFactoryByName<ConnectionHandlerFactory>(

      "envoy.connection_handler.default");

  if (factory) {

    return factory->createConnectionHandler(dispatcher, absl::nullopt);

  }

}

    : init_manager_(init_manager), live_(false), options_(options),

      validation_context_(options_.allowUnknownStaticFields(),

                          !options.rejectUnknownDynamicFields(),

                          options.ignoreUnknownDynamicFields(), options.skipDeprecatedLogs()),

      time_source_(time_system), restarter_(restarter), start_time_(time(nullptr)),

      original_start_time_(start_time_), stats_store_(store), thread_local_(tls),

      random_generator_(std::move(random_generator)),

      api_(new Api::Impl(

          thread_factory, store, time_system, file_system, *random_generator_, bootstrap_,

          process_context ? ProcessContextOptRef(std::ref(*process_context)) : absl::nullopt,

          watermark_factory)),

      dispatcher_(api_->allocateDispatcher("main_thread")),

      access_log_manager_(options.fileFlushIntervalMsec(), options.fileFlushMinSizeKB(), *api_,

                          *dispatcher_, access_log_lock, store),

      handler_(getHandler(*dispatcher_)), worker_factory_(thread_local_, *api_, hooks),

      mutex_tracer_(options.mutexTracingEnabled() ? &Envoy::MutexTracerImpl::getOrCreateTracer()

                                                  : nullptr),

      grpc_context_(store.symbolTable()), http_context_(store.symbolTable()),

      router_context_(store.symbolTable()), process_context_(std::move(process_context)),

      hooks_(hooks), quic_stat_names_(store.symbolTable()), server_contexts_(*this),

      enable_reuse_port_default_(true), stats_flush_in_progress_(false) {

  Configuration::ServerFactoryContextInstance::initialize(&server_contexts_);

}

InstanceBase::~InstanceBase() {

  terminate();

  Configuration::ServerFactoryContextInstance::clear();

  file_logger_.reset();

  ENVOY_LOG(debug, "destroying listener manager");

  listener_manager_.reset();

  ENVOY_LOG(debug, "destroyed listener manager");

  dispatcher_->shutdown();

  ENVOY_LOG(debug, "shut down dispatcher");

}

Upstream::ClusterManager& InstanceBase::clusterManager() {

  ASSERT(config_.clusterManager() != nullptr);

  return *config_.clusterManager();

}

const Upstream::ClusterManager& InstanceBase::clusterManager() const {

  ASSERT(config_.clusterManager() != nullptr);

  return *config_.clusterManager();

}

void InstanceBase::drainListeners(OptRef<const Network::ExtraShutdownListenerOptions> options) {

  ENVOY_LOG(info, "closing and draining listeners");

  listener_manager_->stopListeners(ListenerManager::StopListenersType::All,

                                   options.has_value() ? *options

                                                       : Network::ExtraShutdownListenerOptions{});

  drain_manager_->startDrainSequence(Network::DrainDirection::All, [] {});

}

void InstanceBase::failHealthcheck(bool fail) {

  live_.store(!fail);

  server_stats_->live_.set(live_.load());

}

                                       TimeSource& time_source) {

  store.forEachSinkedCounter(

      [this](std::size_t size) {

        snapped_counters_.reserve(size);

        counters_.reserve(size);

      },

      [this](Stats::Counter& counter) {

        snapped_counters_.push_back(Stats::CounterSharedPtr(&counter));

        counters_.push_back({counter.latch(), counter});

      });

  store.forEachSinkedGauge(

      [this](std::size_t size) {

        snapped_gauges_.reserve(size);

        gauges_.reserve(size);

      },

      [this](Stats::Gauge& gauge) {

        snapped_gauges_.push_back(Stats::GaugeSharedPtr(&gauge));

        gauges_.push_back(gauge);

      });

  store.forEachSinkedHistogram(

      [this](std::size_t size) {

        snapped_histograms_.reserve(size);

        histograms_.reserve(size);

      },

      [this](Stats::ParentHistogram& histogram) {

        snapped_histograms_.push_back(Stats::ParentHistogramSharedPtr(&histogram));

        histograms_.push_back(histogram);

      });

  store.forEachSinkedTextReadout(

      [this](std::size_t size) {

        snapped_text_readouts_.reserve(size);

        text_readouts_.reserve(size);

      },

      [this](Stats::TextReadout& text_readout) {

        snapped_text_readouts_.push_back(Stats::TextReadoutSharedPtr(&text_readout));

        text_readouts_.push_back(text_readout);

      });

  Upstream::HostUtility::forEachHostMetric(

      cluster_manager,

      [this](Stats::PrimitiveCounterSnapshot&& metric) {

      [this](Stats::PrimitiveGaugeSnapshot&& metric) {

  snapshot_time_ = time_source.systemTime();

}

                                       Upstream::ClusterManager& cm, TimeSource& time_source) {

  MetricSnapshotImpl snapshot(store, cm, time_source);

  for (const auto& sink : sinks) {

    sink->flush(snapshot);

  }

}

void InstanceBase::flushStats() {

  if (stats_flush_in_progress_) {

    ENVOY_LOG(debug, "skipping stats flush as flush is already in progress");

    server_stats_->dropped_stat_flushes_.inc();

    return;

  }

  stats_flush_in_progress_ = true;

  ENVOY_LOG(debug, "flushing stats");

  if (initManager().state() == Init::Manager::State::Initialized) {

    stats_store_.mergeHistograms([this]() -> void { flushStatsInternal(); });

  } else {

    ENVOY_LOG(debug, "Envoy is not fully initialized, skipping histogram merge and flushing stats");

    flushStatsInternal();

  }

}

void InstanceBase::updateServerStats() {

  HotRestart::ServerStatsFromParent parent_stats = restarter_.mergeParentStatsIfAny(stats_store_);

  server_stats_->uptime_.set(time(nullptr) - original_start_time_);

  server_stats_->memory_allocated_.set(Memory::Stats::totalCurrentlyAllocated() +

                                       parent_stats.parent_memory_allocated_);

  server_stats_->memory_heap_size_.set(Memory::Stats::totalCurrentlyReserved());

  server_stats_->memory_physical_size_.set(Memory::Stats::totalPhysicalBytes());

  if (!options().hotRestartDisabled()) {

    server_stats_->parent_connections_.set(parent_stats.parent_connections_);

  }

  server_stats_->total_connections_.set(listener_manager_->numConnections() +

                                        parent_stats.parent_connections_);

  server_stats_->days_until_first_cert_expiring_.set(

      sslContextManager().daysUntilFirstCertExpires().value_or(0));

  auto secs_until_ocsp_response_expires =

      sslContextManager().secondsUntilFirstOcspResponseExpires();

  if (secs_until_ocsp_response_expires) {

    server_stats_->seconds_until_first_ocsp_response_expiring_.set(

        secs_until_ocsp_response_expires.value());

  }

  server_stats_->state_.set(

      enumToInt(Utility::serverState(initManager().state(), healthCheckFailed())));

  server_stats_->stats_recent_lookups_.set(

      stats_store_.symbolTable().getRecentLookups([](absl::string_view, uint64_t) {}));

}

void InstanceBase::flushStatsInternal() {

  updateServerStats();

  auto& stats_config = config_.statsConfig();

  InstanceUtil::flushMetricsToSinks(stats_config.sinks(), stats_store_, clusterManager(),

                                    timeSource());

  if (const auto evict_on_flush = stats_config.evictOnFlush(); evict_on_flush > 0) {

    stats_eviction_counter_ = (stats_eviction_counter_ + 1) % evict_on_flush;

    if (stats_eviction_counter_ == 0) {

      stats_store_.evictUnused();

    }

  }

  if (stat_flush_timer_ != nullptr) {

    stat_flush_timer_->enableTimer(stats_config.flushInterval());

  }

  stats_flush_in_progress_ = false;

}

bool InstanceBase::healthCheckFailed() { return !live_.load(); }

ProcessContextOptRef InstanceBase::processContext() {

  if (process_context_ == nullptr) {

    return absl::nullopt;

  }

  return *process_context_;

}

bool canBeRegisteredAsInlineHeader(const Http::LowerCaseString& header_name) {

  if (header_name == Http::Headers::get().SetCookie) {

    return false;

  }

  return true;

}

registerCustomInlineHeadersFromBootstrap(const envoy::config::bootstrap::v3::Bootstrap& bootstrap) {

  for (const auto& inline_header : bootstrap.inline_headers()) {

    const Http::LowerCaseString lower_case_name(inline_header.inline_header_name());

    if (!canBeRegisteredAsInlineHeader(lower_case_name)) {

      return absl::InvalidArgumentError(

          fmt::format("Header {} cannot be registered as an inline header.",

                      inline_header.inline_header_name()));

    }

    switch (inline_header.inline_header_type()) {

    case envoy::config::bootstrap::v3::CustomInlineHeader::REQUEST_HEADER:

      Http::CustomInlineHeaderRegistry::registerInlineHeader<

          Http::RequestHeaderMap::header_map_type>(lower_case_name);

      break;

    case envoy::config::bootstrap::v3::CustomInlineHeader::REQUEST_TRAILER:

      Http::CustomInlineHeaderRegistry::registerInlineHeader<

          Http::RequestTrailerMap::header_map_type>(lower_case_name);

      break;

    case envoy::config::bootstrap::v3::CustomInlineHeader::RESPONSE_HEADER:

      Http::CustomInlineHeaderRegistry::registerInlineHeader<

          Http::ResponseHeaderMap::header_map_type>(lower_case_name);

      break;

    case envoy::config::bootstrap::v3::CustomInlineHeader::RESPONSE_TRAILER:

      Http::CustomInlineHeaderRegistry::registerInlineHeader<

          Http::ResponseTrailerMap::header_map_type>(lower_case_name);

      break;

    }

  }

  return absl::OkStatus();

}

    ProtobufMessage::ValidationVisitor& validation_visitor, Api::Api& api) {

  const std::string& config_path = options.configPath();

  const std::string& config_yaml = options.configYaml();

  const envoy::config::bootstrap::v3::Bootstrap& config_proto = options.configProto();

  if (config_path.empty() && config_yaml.empty() && config_proto.ByteSizeLong() == 0) {

    return absl::InvalidArgumentError(

        "At least one of --config-path or --config-yaml or Options::configProto() "

        "should be non-empty");

  }

  if (!config_path.empty()) {

    RETURN_IF_NOT_OK(MessageUtil::loadFromFile(config_path, bootstrap, validation_visitor, api));

  }

  if (!config_yaml.empty()) {

    envoy::config::bootstrap::v3::Bootstrap bootstrap_override;

#ifdef ENVOY_ENABLE_YAML

    MessageUtil::loadFromYaml(config_yaml, bootstrap_override, validation_visitor);

    bootstrap.MergeFrom(bootstrap_override);

  }

  if (config_proto.ByteSizeLong() != 0) {

    bootstrap.MergeFrom(config_proto);

  }

  MessageUtil::validate(bootstrap, validation_visitor);

  return absl::OkStatus();

}

void InstanceUtil::raiseFileLimits() {

  if (!Runtime::runtimeFeatureEnabled("envoy.restart_features.raise_file_limits")) {

  struct rlimit rlim;

  if (const auto result = Api::OsSysCallsSingleton::get().getrlimit(RLIMIT_NOFILE, &rlim);

      result.return_value_ != 0) {

    ENVOY_LOG(warn, "Failed to read file descriptor limit, error {}.", errorDetails(result.errno_));

    return;

  }

  const auto old = rlim.rlim_cur;

  if (old == rlim.rlim_max) {

    return;

  }

  rlim.rlim_cur = rlim.rlim_max;

  if (const auto result = Api::OsSysCallsSingleton::get().setrlimit(RLIMIT_NOFILE, &rlim);

      result.return_value_ != 0) {

    ENVOY_LOG(warn, "Failed to raise file descriptor limit to maximum, error {}.",

              errorDetails(result.errno_));

    return;

  }

  ENVOY_LOG(info, "Raised file descriptor limits from {} to {}.", old, rlim.rlim_max);

}

                              ComponentFactory& component_factory) {

  std::function set_up_logger = [&] {

    TRY_ASSERT_MAIN_THREAD {

      file_logger_ = THROW_OR_RETURN_VALUE(

          Logger::FileSinkDelegate::create(options_.logPath(), access_log_manager_,

                                           Logger::Registry::getSink()),

          std::unique_ptr<Logger::FileSinkDelegate>);

    }

    END_TRY

    CATCH(const EnvoyException& e, {

      throw EnvoyException(

          fmt::format("Failed to open log-file '{}'. e.what(): {}", options_.logPath(), e.what()));

    });

  };

  TRY_ASSERT_MAIN_THREAD {

    if (!options_.logPath().empty()) {

      set_up_logger();

    }

    restarter_.initialize(*dispatcher_, *this);

    drain_manager_ = component_factory.createDrainManager(*this);

    THROW_IF_NOT_OK(initializeOrThrow(std::move(local_address), component_factory));

  }

  END_TRY

  MULTI_CATCH(

      const EnvoyException& e,

      {

        ENVOY_LOG(critical, "error `{}` initializing config '{} {} {}'", e.what(),

                  options_.configProto().DebugString(), options_.configYaml(),

                  options_.configPath());

        terminate();

        throw;

      },

      {

        ENVOY_LOG(critical, "error initializing due to unknown exception");

        terminate();

        throw;

      });

}

                                             ComponentFactory& component_factory) {

  ENVOY_LOG(info, "initializing epoch {} (base id={}, hot restart version={})",

            options_.restartEpoch(), restarter_.baseId(), restarter_.version());

  ENVOY_LOG(info, "statically linked extensions:");

  for (const auto& ext : Envoy::Registry::FactoryCategoryRegistry::registeredFactories()) {

    ENVOY_LOG(info, "  {}: {}", ext.first, absl::StrJoin(ext.second->registeredNames(), ", "));

  }

  thread_local_.registerThread(*dispatcher_, true);

  RETURN_IF_NOT_OK(InstanceUtil::loadBootstrapConfig(

      bootstrap_, options_, messageValidationContext().staticValidationVisitor(), *api_));

  bootstrap_config_update_time_ = time_source_.systemTime();

  if (bootstrap_.has_application_log_config()) {

    RETURN_IF_NOT_OK(

        Utility::assertExclusiveLogFormatMethod(options_, bootstrap_.application_log_config()));

    RETURN_IF_NOT_OK(Utility::maybeSetApplicationLogFormat(bootstrap_.application_log_config()));

  }

  if (!bootstrap_.header_prefix().empty()) {

    ThreadSafeSingleton<Http::PrefixValue>::get().setPrefix(bootstrap_.header_prefix().c_str());

  }

  RETURN_IF_NOT_OK(registerCustomInlineHeadersFromBootstrap(bootstrap_));

  ENVOY_LOG(info, "HTTP header map info:");

  for (const auto& info : Http::HeaderMapImplUtility::getAllHeaderMapImplInfo()) {

    ENVOY_LOG(info, "  {}: {} bytes: {}", info.name_, info.size_,

              absl::StrJoin(info.registered_headers_, ","));

  }

  regex_engine_ = createRegexEngine(

      bootstrap_, messageValidationContext().staticValidationVisitor(), serverFactoryContext());

  auto producer_or_error =

      Stats::TagProducerImpl::createTagProducer(bootstrap_.stats_config(), options_.statsTags());

  RETURN_IF_NOT_OK_REF(producer_or_error.status());

  stats_store_.setTagProducer(std::move(producer_or_error.value()));

  stats_store_.setStatsMatcher(std::make_unique<Stats::StatsMatcherImpl>(

      bootstrap_.stats_config(), stats_store_.symbolTable(), server_contexts_));

  stats_store_.setHistogramSettings(

      std::make_unique<Stats::HistogramSettingsImpl>(bootstrap_.stats_config(), server_contexts_));

  const std::string server_stats_prefix = "server.";

  const std::string server_compilation_settings_stats_prefix = "server.compilation_settings";

  server_stats_ = std::make_unique<ServerStats>(

      ServerStats{ALL_SERVER_STATS(POOL_COUNTER_PREFIX(stats_store_, server_stats_prefix),

                                   POOL_GAUGE_PREFIX(stats_store_, server_stats_prefix),

                                   POOL_HISTOGRAM_PREFIX(stats_store_, server_stats_prefix))});

  server_compilation_settings_stats_ =

      std::make_unique<CompilationSettings::ServerCompilationSettingsStats>(

          CompilationSettings::ServerCompilationSettingsStats{ALL_SERVER_COMPILATION_SETTINGS_STATS(

              POOL_COUNTER_PREFIX(stats_store_, server_compilation_settings_stats_prefix),

              POOL_GAUGE_PREFIX(stats_store_, server_compilation_settings_stats_prefix),

              POOL_HISTOGRAM_PREFIX(stats_store_, server_compilation_settings_stats_prefix))});

  validation_context_.setCounters(server_stats_->static_unknown_fields_,

                                  server_stats_->dynamic_unknown_fields_,

                                  server_stats_->wip_protos_);

  memory_allocator_manager_ =

      std::make_unique<Memory::AllocatorManager>(*api_, bootstrap_.memory_allocator_manager());

  initialization_timer_ = std::make_unique<Stats::HistogramCompletableTimespanImpl>(

      server_stats_->initialization_time_ms_, timeSource());

  server_stats_->concurrency_.set(options_.concurrency());

  if (!options().hotRestartDisabled()) {

    server_stats_->hot_restart_epoch_.set(options_.restartEpoch());

  }

  InstanceBase::failHealthcheck(false);

  uint64_t version_int;

  if (bootstrap_.stats_server_version_override().value() > 0) {

    version_int = bootstrap_.stats_server_version_override().value();

  } else {

    if (!StringUtil::atoull(VersionInfo::revision().substr(0, 6).c_str(), version_int, 16)) {

  }

  server_stats_->version_.set(version_int);

  if (VersionInfo::sslFipsCompliant()) {

  } else {

    server_compilation_settings_stats_->fips_mode_.set(0);

  }

  if (bootstrap_.node().user_agent_name().empty()) {

    bootstrap_.mutable_node()->set_user_agent_name("envoy");

  }

  if (!bootstrap_.node().user_agent_build_version().has_version()) {

    *bootstrap_.mutable_node()->mutable_user_agent_build_version() = VersionInfo::buildVersion();

  }

  for (const auto& ext : Envoy::Registry::FactoryCategoryRegistry::registeredFactories()) {

    auto registered_types = ext.second->registeredTypes();

    for (const auto& name : ext.second->allRegisteredNames()) {

      auto* extension = bootstrap_.mutable_node()->add_extensions();

      extension->set_name(std::string(name));

      extension->set_category(ext.first);

      auto const version = ext.second->getFactoryVersion(name);

      if (version) {

      extension->set_disabled(ext.second->isFactoryDisabled(name));

      auto it = registered_types.find(name);

      if (it != registered_types.end()) {

        std::sort(it->second.begin(), it->second.end());

        for (const auto& type_url : it->second) {

          extension->add_type_urls(type_url);

        }

      }

    }

  }

  local_info_ = std::make_unique<LocalInfo::LocalInfoImpl>(

      stats().symbolTable(), bootstrap_.node(), bootstrap_.node_context_params(), local_address,

      options_.serviceZone(), options_.serviceClusterName(), options_.serviceNodeName());

  absl::Status creation_status;

  Configuration::InitialImpl initial_config(bootstrap_, creation_status);

  RETURN_IF_NOT_OK(creation_status);

  const auto parent_admin_shutdown_response = restarter_.sendParentAdminShutdownRequest();

  if (parent_admin_shutdown_response.has_value()) {

  OptRef<Server::ConfigTracker> config_tracker;

#ifdef ENVOY_ADMIN_FUNCTIONALITY

  auto admin_impl = std::make_shared<AdminImpl>(initial_config.admin().profilePath(), *this,

                                                initial_config.admin().ignoreGlobalConnLimit());

  for (const auto& allowlisted_path : bootstrap_.admin().allow_paths()) {

    admin_impl->addAllowlistedPath(

        std::make_unique<Matchers::StringMatcherImpl>(allowlisted_path, server_contexts_));

  }

  admin_ = admin_impl;

  config_tracker = admin_->getConfigTracker();

#endif

  secret_manager_ = std::make_unique<Secret::SecretManagerImpl>(config_tracker);

  loadServerFlags(initial_config.flagsPath());

  auto overload_manager_or_error = createOverloadManager();

  RETURN_IF_NOT_OK(overload_manager_or_error.status());

  overload_manager_ = std::move(*overload_manager_or_error);

  null_overload_manager_ = createNullOverloadManager();

  maybeCreateHeapShrinker();

  for (const auto& bootstrap_extension : bootstrap_.bootstrap_extensions()) {

    auto& factory = Config::Utility::getAndCheckFactory<Configuration::BootstrapExtensionFactory>(

        bootstrap_extension);

    auto config = Config::Utility::translateAnyToFactoryConfig(

        bootstrap_extension.typed_config(), messageValidationContext().staticValidationVisitor(),

        factory);

    bootstrap_extensions_.push_back(

        factory.createBootstrapExtension(*config, serverFactoryContext()));

  }

  {

    FatalAction::FatalActionPtrList safe_actions;

    FatalAction::FatalActionPtrList unsafe_actions;

    for (const auto& action_config : bootstrap_.fatal_actions()) {

    Envoy::FatalErrorHandler::registerFatalActions(

        std::move(safe_actions), std::move(unsafe_actions), api_->threadFactory());

  }

  if (!bootstrap_.default_socket_interface().empty()) {

    auto& sock_name = bootstrap_.default_socket_interface();

    auto sock = const_cast<Network::SocketInterface*>(Network::socketInterface(sock_name));

    if (sock != nullptr) {

      Network::SocketInterfaceSingleton::clear();

      Network::SocketInterfaceSingleton::initialize(sock);

    }

  }

  ListenerManagerFactory* listener_manager_factory = nullptr;

  if (bootstrap_.has_listener_manager()) {

  } else {

    listener_manager_factory = &Config::Utility::getAndCheckFactoryByName<ListenerManagerFactory>(

        Config::ServerExtensionValues::get().DEFAULT_LISTENER);

  }

  listener_manager_ = listener_manager_factory->createListenerManager(

      *this, nullptr, worker_factory_, bootstrap_.enable_dispatcher_stats(), quic_stat_names_);

  stats_store_.initializeThreading(*dispatcher_, thread_local_);

  if (bootstrap_.enable_dispatcher_stats()) {

    dispatcher_->initializeStats(*stats_store_.rootScope(), "server.");

  }

  runtime_ = component_factory.createRuntime(*this, initial_config);

  validation_context_.setRuntime(runtime());

#ifndef WIN32

  InstanceUtil::raiseFileLimits();

#endif

  if (!runtime().snapshot().getBoolean("envoy.disallow_global_stats", false)) {

    assert_action_registration_ = Assert::addDebugAssertionFailureRecordAction(

        [this](const char*) { server_stats_->debug_assertion_failures_.inc(); });

    envoy_bug_action_registration_ = Assert::addEnvoyBugFailureRecordAction(

        [this](const char*) { server_stats_->envoy_bug_failures_.inc(); });

    envoy_notification_registration_ = Notification::addEnvoyNotificationRecordAction(

        [this](absl::string_view) { server_stats_->envoy_notifications_.inc(); });

  }

  if (initial_config.admin().address()) {

#ifdef ENVOY_ADMIN_FUNCTIONALITY

    RELEASE_ASSERT(admin_ != nullptr, "Admin instance should be created but actually not.");

    auto typed_admin = dynamic_cast<AdminImpl*>(admin_.get());

    RELEASE_ASSERT(typed_admin != nullptr, "Admin implementation is not an AdminImpl.");

    initial_config.initAdminAccessLog(bootstrap_, typed_admin->factoryContext());

    ENVOY_LOG(info, "Starting admin HTTP server at {}",

              initial_config.admin().address()->asString());

    admin_->startHttpListener(initial_config.admin().accessLogs(), initial_config.admin().address(),

                              initial_config.admin().socketOptions());

  } else {

    ENVOY_LOG(info, "No admin address given, so no admin HTTP server started.");

  }

  if (admin_) {

    config_tracker_entry_ = admin_->getConfigTracker().add(

        "bootstrap", [this](const Matchers::StringMatcher&) { return dumpBootstrapConfig(); });

  }

  if (initial_config.admin().address()) {

    admin_->addListenerToHandler(handler_.get());

  }

  ssl_context_manager_ =

      std::make_unique<Extensions::TransportSockets::Tls::ContextManagerImpl>(server_contexts_);

  http_server_properties_cache_manager_ =

      std::make_unique<Http::HttpServerPropertiesCacheManagerImpl>(

          serverFactoryContext(), messageValidationContext().staticValidationVisitor(),

          thread_local_);

  xds_manager_ = std::make_unique<Config::XdsManagerImpl>(*dispatcher_, *api_, stats_store_,

                                                          *local_info_, validation_context_, *this);

  cluster_manager_factory_ = std::make_unique<Upstream::ProdClusterManagerFactory>(

      serverFactoryContext(),

      [this]() -> Network::DnsResolverSharedPtr { return this->getOrCreateDnsResolver(); },

      quic_stat_names_);

  for (auto&& bootstrap_extension : bootstrap_extensions_) {

    bootstrap_extension->onWorkerThreadInitialized();

  }

  RETURN_IF_NOT_OK(config_.initialize(bootstrap_, *this, *cluster_manager_factory_));

  if (bootstrap_.dynamic_resources().has_lds_config() ||

      !bootstrap_.dynamic_resources().lds_resources_locator().empty()) {

    std::unique_ptr<xds::core::v3::ResourceLocator> lds_resources_locator;

    if (!bootstrap_.dynamic_resources().lds_resources_locator().empty()) {

      lds_resources_locator = std::make_unique<xds::core::v3::ResourceLocator>(

          THROW_OR_RETURN_VALUE(Config::XdsResourceIdentifier::decodeUrl(

                                    bootstrap_.dynamic_resources().lds_resources_locator()),

                                xds::core::v3::ResourceLocator));

    }

    listener_manager_->createLdsApi(bootstrap_.dynamic_resources().lds_config(),

                                    lds_resources_locator.get());

  }

  RETURN_IF_NOT_OK(runtime().initialize(clusterManager()));

  clusterManager().setPrimaryClustersInitializedCb(

      [this]() { onClusterManagerPrimaryInitializationComplete(); });

  auto& stats_config = config_.statsConfig();

  for (const Stats::SinkPtr& sink : stats_config.sinks()) {

    stats_store_.addSink(*sink);

  }

  if (!stats_config.flushOnAdmin()) {

    stat_flush_timer_ = dispatcher_->createTimer([this]() -> void { flushStats(); });

    stat_flush_timer_->enableTimer(stats_config.flushInterval());

  }

  for (auto&& bootstrap_extension : bootstrap_extensions_) {

    bootstrap_extension->onServerInitialized(*this);

  }

  main_thread_guard_dog_ = maybeCreateGuardDog("main_thread", config_.mainThreadWatchdogConfig());

  if (Runtime::runtimeFeatureEnabled("envoy.restart_features.worker_threads_watchdog_fix")) {

    worker_guard_dog_ = maybeCreateGuardDog("workers", config_.workerWatchdogConfig());

  } else {

    worker_guard_dog_ = maybeCreateGuardDog("workers", config_.mainThreadWatchdogConfig());

  }

  return absl::OkStatus();

}

void InstanceBase::onClusterManagerPrimaryInitializationComplete() {

  runtime().startRtdsSubscriptions([this]() { onRuntimeReady(); });

}

void InstanceBase::onRuntimeReady() {

  TRY_ASSERT_MAIN_THREAD {

    THROW_IF_NOT_OK(clusterManager().initializeSecondaryClusters(bootstrap_));

  }

  END_TRY

  CATCH(const EnvoyException& e, {

    ENVOY_LOG(warn, "Skipping initialization of secondary cluster: {}", e.what());

    shutdown();

  });

  if (bootstrap_.has_hds_config()) {

    const auto& hds_config = bootstrap_.hds_config();

    async_client_manager_ = std::make_unique<Grpc::AsyncClientManagerImpl>(

        bootstrap_.grpc_async_client_manager_config(), server_contexts_, grpc_context_.statNames());

    TRY_ASSERT_MAIN_THREAD {

      THROW_IF_NOT_OK(Config::Utility::checkTransportVersion(hds_config));

      auto factory_or_error = Config::Utility::factoryForGrpcApiConfigSource(

          *async_client_manager_, hds_config, *stats_store_.rootScope(), false, 0, false);

      THROW_IF_NOT_OK_REF(factory_or_error.status());

      hds_delegate_ = maybeCreateHdsDelegate(

          serverFactoryContext(), *stats_store_.rootScope(),

          THROW_OR_RETURN_VALUE(factory_or_error.value()->createUncachedRawAsyncClient(),

                                Grpc::RawAsyncClientPtr),

          stats_store_, *ssl_context_manager_);

    }

    END_TRY

    CATCH(const EnvoyException& e,

          { ENVOY_LOG(warn, "Skipping initialization of HDS cluster: {}", e.what()); });

    if (!hds_delegate_) {

      shutdown();

    }

  }

  if (runtime().snapshot().get(Runtime::Keys::GlobalMaxCxRuntimeKey)) {

    if (!options_.skipDeprecatedLogs()) {

      ENVOY_LOG(warn,

                "Usage of the deprecated runtime key {}, consider switching to "

                "`envoy.resource_monitors.global_downstream_max_connections` instead."

                "This runtime key will be removed in future.",

                Runtime::Keys::GlobalMaxCxRuntimeKey);

    }

  }

}

void InstanceBase::startWorkers() {

  THROW_IF_NOT_OK(

      listener_manager_->startWorkers(makeOptRefFromPtr(worker_guard_dog_.get()), [this]() {

        if (isShutdown()) {

          return;

        }

        initialization_timer_->complete();

        updateServerStats();

        workers_started_ = true;

        hooks_.onWorkersStarted();

        restarter_.drainParentListeners();

        drain_manager_->startParentShutdownSequence();

      }));

}

                                               Server::Configuration::Initial& config) {

#ifdef ENVOY_ENABLE_YAML

  ENVOY_LOG(info, "runtime: {}", MessageUtil::getYamlStringFromMessage(config.runtime()));

#endif

  absl::StatusOr<std::unique_ptr<Runtime::LoaderImpl>> loader = Runtime::LoaderImpl::create(

      server.dispatcher(), server.threadLocal(), config.runtime(), server.localInfo(),

      server.stats(), server.api().randomGenerator(),

      server.messageValidationContext().dynamicValidationVisitor(), server.api());

  THROW_IF_NOT_OK_REF(loader.status());

  return std::move(loader.value());

}

void InstanceBase::loadServerFlags(const absl::optional<std::string>& flags_path) {

  if (!flags_path) {

    return;

  }

    : init_watcher_("RunHelper", [&instance, post_init_cb]() {

        if (!instance.isShutdown()) {

          post_init_cb();

        }

      }) {

  if (options.signalHandlingEnabled()) {

    sigterm_ = dispatcher.listenForSignal(ENVOY_SIGTERM, [&instance]() {

      ENVOY_LOG(warn, "caught ENVOY_SIGTERM");

      instance.shutdown();

    });

#ifndef WIN32

    sigint_ = dispatcher.listenForSignal(SIGINT, [&instance]() {

      ENVOY_LOG(warn, "caught SIGINT");

      instance.shutdown();

    });

    sig_usr_1_ = dispatcher.listenForSignal(SIGUSR1, [&access_log_manager]() {

    sig_hup_ = dispatcher.listenForSignal(SIGHUP, []() {

#endif

  }

  overload_manager.start();

  null_overload_manager.start();

  if (!overload_manager.getThreadLocalOverloadState().isResourceMonitorEnabled(

          Server::OverloadProactiveResourceName::GlobalDownstreamMaxConnections)) {

    ENVOY_LOG(

        warn,

        "There is no configured limit to the number of allowed active downstream "

        "connections. Configure a "

        "limit in `envoy.resource_monitors.global_downstream_max_connections` resource monitor.");

  }

  cm.setInitializedCb([&instance, &init_manager, &xds_manager, this]() {

    if (instance.isShutdown()) {

      return;

    }

    const auto type_url = Config::getTypeUrl<envoy::config::route::v3::RouteConfiguration>();

    Config::ScopedResume resume_rds = xds_manager.pause(type_url);

    ENVOY_LOG(info, "all clusters initialized. initializing init manager");

    init_manager.initialize(init_watcher_);

  });

}

void InstanceBase::run() {

  const auto run_helper =

      RunHelper(*this, options_, *dispatcher_, xdsManager(), clusterManager(), access_log_manager_,

                init_manager_, overloadManager(), nullOverloadManager(), [this] {

                  notifyCallbacksForStage(Stage::PostInit);

                  startWorkers();

                });

  ENVOY_LOG(info, "starting main dispatch loop");

  WatchDogSharedPtr watchdog;

  if (main_thread_guard_dog_) {

    watchdog = main_thread_guard_dog_->createWatchDog(api_->threadFactory().currentThreadId(),

                                                      "main_thread", *dispatcher_);

  }

  main_dispatch_loop_started_.store(true);

  dispatcher_->post([this] { notifyCallbacksForStage(Stage::Startup); });

  dispatcher_->run(Event::Dispatcher::RunType::Block);

  ENVOY_LOG(info, "main dispatch loop exited");

  if (main_thread_guard_dog_) {

    main_thread_guard_dog_->stopWatching(watchdog);

  }

  watchdog.reset();

  terminate();

}

void InstanceBase::terminate() {

  if (terminated_) {

    return;

  }

  terminated_ = true;

  thread_local_.shutdownGlobalThreading();

  stats_store_.shutdownThreading();

  std::vector<std::string> muxes = {

      "envoy.config_mux.new_grpc_mux_factory", "envoy.config_mux.grpc_mux_factory",

      "envoy.config_mux.delta_grpc_mux_factory", "envoy.config_mux.sotw_grpc_mux_factory"};

  for (const auto& name : muxes) {

    auto* factory = Config::Utility::getFactoryByName<Config::MuxFactory>(name);

    if (factory) {

      factory->shutdownAll();

    }

  }

  if (overload_manager_) {

    overload_manager_->stop();

  }

  if (listener_manager_ != nullptr) {

    listener_manager_->stopWorkers();

  }

  if (stat_flush_timer_) {

    flushStats();

  }

  if (config_.clusterManager() != nullptr) {

    config_.clusterManager()->shutdown();

  }

  handler_.reset();

  thread_local_.shutdownThread();

  restarter_.shutdown();

  ENVOY_LOG(info, "exiting");

  ENVOY_FLUSH_LOG();

  FatalErrorHandler::clearFatalActionsOnTerminate();

}

Runtime::Loader& InstanceBase::runtime() { return *runtime_; }

void InstanceBase::shutdown() {

  ENVOY_LOG(info, "shutting down server instance");

  shutdown_ = true;

  restarter_.sendParentTerminateRequest();

  notifyCallbacksForStage(Stage::ShutdownExit, [this] { dispatcher_->exit(); });

}

                                                                  StageCallback callback) {

  auto& callbacks = stage_callbacks_[stage];

  return std::make_unique<LifecycleCallbackHandle<StageCallback>>(callbacks, callback);

}

InstanceBase::registerCallback(Stage stage, StageCallbackWithCompletion callback) {

  ASSERT(stage == Stage::ShutdownExit);

  auto& callbacks = stage_completable_callbacks_[stage];

  return std::make_unique<LifecycleCallbackHandle<StageCallbackWithCompletion>>(callbacks,

                                                                                callback);

}

void InstanceBase::notifyCallbacksForStage(Stage stage, std::function<void()> completion_cb) {

  ASSERT_IS_MAIN_OR_TEST_THREAD();

  const auto stage_it = stage_callbacks_.find(stage);

  if (stage_it != stage_callbacks_.end()) {

    LifecycleNotifierCallbacks& callbacks = stage_it->second;

    for (auto callback_it = callbacks.begin(); callback_it != callbacks.end();) {

      StageCallback callback = *callback_it;

      ++callback_it;

      callback();

    }

  }

  std::shared_ptr<void> cb_guard(

      new Cleanup([this, completion_cb]() { dispatcher_->post(completion_cb); }));

  if (workers_started_) {

    const auto it2 = stage_completable_callbacks_.find(stage);

    if (it2 != stage_completable_callbacks_.end()) {

      ENVOY_LOG(info, "Notifying {} callback(s) with completion.", it2->second.size());

      for (const StageCallbackWithCompletion& callback : it2->second) {

        callback([cb_guard] {});

      }

    }

  }

}

ProtobufTypes::MessagePtr InstanceBase::dumpBootstrapConfig() {

  auto config_dump = std::make_unique<envoy::admin::v3::BootstrapConfigDump>();

  config_dump->mutable_bootstrap()->MergeFrom(bootstrap_);

  TimestampUtil::systemClockToTimestamp(bootstrap_config_update_time_,

                                        *(config_dump->mutable_last_updated()));

  return config_dump;

}

Network::DnsResolverSharedPtr InstanceBase::getOrCreateDnsResolver() {

  if (!dns_resolver_) {

    envoy::config::core::v3::TypedExtensionConfig typed_dns_resolver_config;

    Network::DnsResolverFactory& dns_resolver_factory =

        Network::createDnsResolverFactoryFromProto(bootstrap_, typed_dns_resolver_config);

    dns_resolver_ = THROW_OR_RETURN_VALUE(

        dns_resolver_factory.createDnsResolver(dispatcher(), api(), typed_dns_resolver_config),

        Network::DnsResolverSharedPtr);

  }

  return dns_resolver_;

}

bool InstanceBase::enableReusePortDefault() { return enable_reuse_port_default_; }