const Filter::NetworkFilterFactoriesList& factories) {

  for (const auto& filter_config_provider : factories) {

    auto config = filter_config_provider->config();

    if (!config.has_value()) {

      return false;

    }

    Network::FilterFactoryCb& factory = config.value();

    factory(filter_manager);

  }

  return filter_manager.initializeReadFilters();

}

                                          const Filter::ListenerFilterFactoriesList& factories) {

  for (const auto& filter_config_provider : factories) {

    auto config = filter_config_provider->config();

    if (!config.has_value()) {

      return false;

    }

    auto config_value = config.value();

    config_value(filter_manager);

  }

  return true;

}

    const std::vector<Network::UdpListenerFilterFactoryCb>& factories) {

  for (const Network::UdpListenerFilterFactoryCb& factory : factories) {

    factory(filter_manager, callbacks);

  }

}

    const Filter::QuicListenerFilterFactoriesList& factories) {

  for (const auto& filter_config_provider : factories) {

    auto config = filter_config_provider->config();

    if (!config.has_value()) {

      return false;

    }

    auto config_value = config.value();

    config_value(filter_manager);

  }

  return true;

}

    : deferred_stat_options_(bootstrap.deferred_stat_options()) {

  status = absl::OkStatus();

  if (bootstrap.has_stats_flush_interval() &&

      bootstrap.stats_flush_case() !=

          envoy::config::bootstrap::v3::Bootstrap::STATS_FLUSH_NOT_SET) {

    status = absl::InvalidArgumentError(

        "Only one of stats_flush_interval or stats_flush_on_admin should be set!");

    return;

  }

  flush_interval_ =

      std::chrono::milliseconds(PROTOBUF_GET_MS_OR_DEFAULT(bootstrap, stats_flush_interval, 5000));

  if (bootstrap.stats_flush_case() == envoy::config::bootstrap::v3::Bootstrap::kStatsFlushOnAdmin) {

    flush_on_admin_ = bootstrap.stats_flush_on_admin();

  }

  const auto evict_interval_ms = PROTOBUF_GET_MS_OR_DEFAULT(bootstrap, stats_eviction_interval, 0);

  if (evict_interval_ms % flush_interval_.count() != 0) {

    status = absl::InvalidArgumentError(

        "stats_eviction_interval must be a multiple of stats_flush_interval");

    return;

  }

  evict_on_flush_ = evict_interval_ms / flush_interval_.count();

}

                                  Upstream::ClusterManagerFactory& cluster_manager_factory) {

  initializeTracers(bootstrap.tracing(), server);

  absl::Status status = absl::OkStatus();

  stats_config_ = std::make_unique<StatsConfigImpl>(bootstrap, status);

  RETURN_IF_NOT_OK(status);

  const auto& secrets = bootstrap.static_resources().secrets();

  ENVOY_LOG(info, "loading {} static secret(s)", secrets.size());

  for (ssize_t i = 0; i < secrets.size(); i++) {

    ENVOY_LOG(debug, "static secret #{}: {}", i, secrets[i].name());

    RETURN_IF_NOT_OK(server.secretManager().addStaticSecret(secrets[i]));

  }

  ENVOY_LOG(info, "loading {} cluster(s)", bootstrap.static_resources().clusters().size());

  auto manager_or_error = cluster_manager_factory.clusterManagerFromProto(bootstrap);

  RETURN_IF_NOT_OK_REF(manager_or_error.status());

  cluster_manager_ = std::move(*manager_or_error);

  status = cluster_manager_->initialize(bootstrap);

  RETURN_IF_NOT_OK(status);

  const auto& listeners = bootstrap.static_resources().listeners();

  ENVOY_LOG(info, "loading {} listener(s)", listeners.size());

  for (ssize_t i = 0; i < listeners.size(); i++) {

    ENVOY_LOG(debug, "listener #{}:", i);

    absl::StatusOr<bool> update_or_error =

        server.listenerManager().addOrUpdateListener(listeners[i], "", false);

    RETURN_IF_NOT_OK_REF(update_or_error.status());

  }

  RETURN_IF_NOT_OK(initializeWatchdogs(bootstrap, server));

  return initializeStatsConfig(bootstrap, server);

}

                                Instance& server) {

  ENVOY_LOG(info, "loading stats configuration");

  for (const envoy::config::metrics::v3::StatsSink& sink_object : bootstrap.stats_sinks()) {

    auto& factory = Config::Utility::getAndCheckFactory<StatsSinkFactory>(sink_object);

    ProtobufTypes::MessagePtr message = Config::Utility::translateToFactoryConfig(

        sink_object, server.messageValidationContext().staticValidationVisitor(), factory);

    auto sink = factory.createStatsSink(*message, server.serverFactoryContext());

    RETURN_IF_NOT_OK_REF(sink.status());

    stats_config_->addSink(std::move(sink.value()));

  }

  return absl::OkStatus();

}

                                 Instance& server) {

  ENVOY_LOG(info, "loading tracing configuration");

  server.setDefaultTracingConfig(configuration);

  if (!configuration.has_http()) {

    return;

  }

  ENVOY_LOG(info, "  validating default server-wide tracing driver: {}",

            configuration.http().name());

  auto& factory = Config::Utility::getAndCheckFactory<TracerFactory>(configuration.http());

  ProtobufTypes::MessagePtr message = Config::Utility::translateToFactoryConfig(

      configuration.http(), server.messageValidationContext().staticValidationVisitor(), factory);

}

                                           Instance& server) {

  if (bootstrap.has_watchdog() && bootstrap.has_watchdogs()) {

    return absl::InvalidArgumentError("Only one of watchdog or watchdogs should be set!");

  }

  if (bootstrap.has_watchdog()) {

    main_thread_watchdog_ = std::make_unique<WatchdogImpl>(bootstrap.watchdog(), server);

    worker_watchdog_ = std::make_unique<WatchdogImpl>(bootstrap.watchdog(), server);

  } else {

    main_thread_watchdog_ =

        std::make_unique<WatchdogImpl>(bootstrap.watchdogs().main_thread_watchdog(), server);

    worker_watchdog_ =

        std::make_unique<WatchdogImpl>(bootstrap.watchdogs().worker_watchdog(), server);

  }

  return absl::OkStatus();

}

                           Instance& server) {

  miss_timeout_ =

      std::chrono::milliseconds(PROTOBUF_GET_MS_OR_DEFAULT(watchdog, miss_timeout, 200));

  megamiss_timeout_ =

      std::chrono::milliseconds(PROTOBUF_GET_MS_OR_DEFAULT(watchdog, megamiss_timeout, 1000));

  uint64_t kill_timeout = PROTOBUF_GET_MS_OR_DEFAULT(watchdog, kill_timeout, 0);

  const uint64_t max_kill_timeout_jitter =

      PROTOBUF_GET_MS_OR_DEFAULT(watchdog, max_kill_timeout_jitter, 0);

  if (kill_timeout > 0 && max_kill_timeout_jitter > 0) {

    kill_timeout += (server.api().randomGenerator().random() % max_kill_timeout_jitter) + 1;

  }

  kill_timeout_ = std::chrono::milliseconds(kill_timeout);

  multikill_timeout_ =

      std::chrono::milliseconds(PROTOBUF_GET_MS_OR_DEFAULT(watchdog, multikill_timeout, 0));

  multikill_threshold_ = PROTOBUF_PERCENT_TO_DOUBLE_OR_DEFAULT(watchdog, multikill_threshold, 0.0);

  actions_ = watchdog.actions();

}

                         absl::Status& creation_status) {

  creation_status = absl::OkStatus();

  const auto& admin = bootstrap.admin();

  admin_.profile_path_ =

      admin.profile_path().empty() ? "/var/log/envoy/envoy.prof" : admin.profile_path();

  if (admin.has_address()) {

    auto address_or_error = Network::Address::resolveProtoAddress(admin.address());

    if (!address_or_error.status().ok()) {

    admin_.address_ = std::move(address_or_error.value());

  }

  admin_.socket_options_ = std::make_shared<std::vector<Network::Socket::OptionConstSharedPtr>>();

  if (!admin.socket_options().empty()) {

    Network::Socket::appendOptions(

        admin_.socket_options_,

        Network::SocketOptionFactory::buildLiteralOptions(admin.socket_options()));

  }

  admin_.ignore_global_conn_limit_ = admin.ignore_global_conn_limit();

  if (!bootstrap.flags_path().empty()) {

    flags_path_ = bootstrap.flags_path();

  }

  if (bootstrap.has_layered_runtime()) {

    layered_runtime_.MergeFrom(bootstrap.layered_runtime());

    if (layered_runtime_.layers().empty()) {

      layered_runtime_.add_layers()->mutable_admin_layer();

    }

  }

}

                                     FactoryContext& factory_context) {

  const auto& admin = bootstrap.admin();

  for (const auto& access_log : admin.access_log()) {

    AccessLog::InstanceSharedPtr current_access_log =

        AccessLog::AccessLogFactory::fromProto(access_log, factory_context);

    admin_.access_logs_.emplace_back(current_access_log);

  }

  if (!admin.access_log_path().empty()) {

    envoy::extensions::access_loggers::file::v3::FileAccessLog config;

    config.mutable_format();

    config.set_path(admin.access_log_path());

    auto factory = Config::Utility::getFactoryByName<AccessLog::AccessLogInstanceFactory>(

        "envoy.file_access_log");

    admin_.access_logs_.emplace_back(factory->createAccessLogInstance(config, {}, factory_context));

  }

}