config: plumb v2 bootstrap file to cluster manager instantiation.

bazel/repositories.bzl

@@ -110,7 +110,7 @@ def envoy_api_deps(skip_targets):
         remote = REPO_LOCATIONS["envoy_api"],
         commit = "0b35f3efc31621953bc2eb7458d01d8eab984394",
     )
-    bind_targets = ["address", "base", "cds", "eds", "health_check", "protocol", "tls_context"]
+    bind_targets = ["address", "base", "bootstrap", "cds", "eds", "health_check", "protocol", "tls_context"]
     for t in bind_targets:
         native.bind(
             name = "envoy_" + t,

include/envoy/server/options.h

@@ -64,6 +64,14 @@ class Options {
    */
   virtual const std::string& configPath() PURE;
 
+  /**
+   * @return const std::string& the path to the v2 bootstrap file.
+   * TODO(htuch): We can eventually consolidate configPath()/bootstrapPath(), but today
+   * the config fetched from bootstrapPath() acts as an overlay to the config fetched from
+   * configPath() during v2 API bringup.
+   */
+  virtual const std::string& bootstrapPath() PURE;
+
   /**
    * @return const std::string& the admin address output file.
    */

include/envoy/upstream/BUILD

@@ -11,7 +11,10 @@ envoy_package()
 envoy_cc_library(
     name = "cluster_manager_interface",
     hdrs = ["cluster_manager.h"],
-    external_deps = ["envoy_cds"],
+    external_deps = [
+        "envoy_bootstrap",
+        "envoy_cds",
+    ],
     deps = [
         ":load_balancer_interface",
         ":thread_local_cluster_interface",

include/envoy/upstream/cluster_manager.h

@@ -16,6 +16,7 @@
 #include "envoy/upstream/thread_local_cluster.h"
 #include "envoy/upstream/upstream.h"
 
+#include "api/bootstrap.pb.h"
 #include "api/cds.pb.h"
 
 namespace Envoy {
@@ -148,13 +149,14 @@ class ClusterManagerFactory {
 
   /**
    * Allocate a cluster manager from configuration JSON.
+   * TODO(htuch): Once bootstrap is sufficiently capable, switch to a translation from the JSON v1
+   * cluster manager config -> v2 proto and drop the config parameter.
    */
-  virtual ClusterManagerPtr clusterManagerFromJson(const Json::Object& config, Stats::Store& stats,
-                                                   ThreadLocal::Instance& tls,
-                                                   Runtime::Loader& runtime,
-                                                   Runtime::RandomGenerator& random,
-                                                   const LocalInfo::LocalInfo& local_info,
-                                                   AccessLog::AccessLogManager& log_manager) PURE;
+  virtual ClusterManagerPtr
+  clusterManagerFromJson(const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap,
+                         Stats::Store& stats, ThreadLocal::Instance& tls, Runtime::Loader& runtime,
+                         Runtime::RandomGenerator& random, const LocalInfo::LocalInfo& local_info,
+                         AccessLog::AccessLogManager& log_manager) PURE;
 
   /**
    * Allocate an HTTP connection pool.

source/common/config/BUILD

@@ -49,8 +49,8 @@ envoy_cc_library(
         "//include/envoy/filesystem:filesystem_interface",
         "//source/common/common:logger_lib",
         "//source/common/config:utility_lib",
-        "//source/common/filesystem:filesystem_lib",
         "//source/common/protobuf",
+        "//source/common/protobuf:utility_lib",
     ],
 )
 

source/common/config/filesystem_subscription_impl.h

@@ -7,8 +7,8 @@
 #include "common/common/logger.h"
 #include "common/common/macros.h"
 #include "common/config/utility.h"
-#include "common/filesystem/filesystem_impl.h"
 #include "common/protobuf/protobuf.h"
+#include "common/protobuf/utility.h"
 
 #include "api/base.pb.h"
 
@@ -53,17 +53,8 @@ class FilesystemSubscriptionImpl : public Config::Subscription<ResourceType>,
     stats_.update_attempt_.inc();
     bool config_update_available = false;
     try {
-      const std::string json = Filesystem::fileReadToEnd(path_);
       envoy::api::v2::DiscoveryResponse message;
-      const auto status =
-          Protobuf::util::JsonStringToMessage(ProtobufTypes::ToString(json), &message);
-      if (!status.ok()) {
-        callbacks_->onConfigUpdateFailed(nullptr);
-        ENVOY_LOG(warn, "Filesystem config JSON conversion error: {}",
-                  ProtobufTypes::FromString(status.ToString()));
-        stats_.update_failure_.inc();
-        return;
-      }
+      MessageUtil::loadFromFile(path_, message);
       const auto typed_resources = Config::Utility::getTypedResources<ResourceType>(message);
       config_update_available = true;
       callbacks_->onConfigUpdate(typed_resources);

source/common/protobuf/BUILD

@@ -22,5 +22,6 @@ envoy_cc_library(
     deps = [
         ":protobuf",
         "//source/common/common:utility_lib",
+        "//source/common/filesystem:filesystem_lib",
     ],
 )

source/common/protobuf/utility.cc

@@ -1,5 +1,7 @@
 #include "common/protobuf/utility.h"
 
+#include "common/filesystem/filesystem_impl.h"
+
 #include "spdlog/spdlog.h"
 
 namespace Envoy {
@@ -9,4 +11,12 @@ MissingFieldException::MissingFieldException(const std::string& field_name,
     : EnvoyException(fmt::format("Field '{}' is missing in: {}", field_name,
                                  ProtobufTypes::FromString(message.DebugString()))) {}
 
+void MessageUtil::loadFromFile(const std::string& path, Protobuf::Message& message) {
+  const std::string json = Filesystem::fileReadToEnd(path);
+  const auto status = Protobuf::util::JsonStringToMessage(ProtobufTypes::ToString(json), &message);
+  if (!status.ok()) {
+    throw EnvoyException("Unable to parse JSON as proto: " + json);
+  }
+}
+
 } // namespace Envoy

source/common/protobuf/utility.h

@@ -50,6 +50,8 @@ class MessageUtil {
   static std::size_t hash(const Protobuf::Message& message) {
     return std::hash<std::string>{}(message.SerializeAsString());
   }
+
+  static void loadFromFile(const std::string& path, Protobuf::Message& message);
 };
 
 } // namespace Envoy

source/common/upstream/cluster_manager_impl.cc

@@ -154,15 +154,18 @@ void ClusterManagerInitHelper::setInitializedCb(std::function<void()> callback)
   }
 }
 
-ClusterManagerImpl::ClusterManagerImpl(const Json::Object& config, ClusterManagerFactory& factory,
-                                       Stats::Store& stats, ThreadLocal::SlotAllocator& tls,
-                                       Runtime::Loader& runtime, Runtime::RandomGenerator& random,
+ClusterManagerImpl::ClusterManagerImpl(const Json::Object& config,
+                                       const envoy::api::v2::Bootstrap& bootstrap,
+                                       ClusterManagerFactory& factory, Stats::Store& stats,
+                                       ThreadLocal::SlotAllocator& tls, Runtime::Loader& runtime,
+                                       Runtime::RandomGenerator& random,
                                        const LocalInfo::LocalInfo& local_info,
                                        AccessLog::AccessLogManager& log_manager)
     : factory_(factory), runtime_(runtime), stats_(stats), tls_(tls.allocateSlot()),
       random_(random), local_info_(local_info), cm_stats_(generateStats(stats)) {
 
   config.validateSchema(Json::Schema::CLUSTER_MANAGER_SCHEMA);
+  UNREFERENCED_PARAMETER(bootstrap);
 
   if (config.hasObject("outlier_detection")) {
     std::string event_log_file_path =
@@ -576,11 +579,11 @@ ClusterManagerImpl::ThreadLocalClusterManagerImpl::ClusterEntry::connPool(
 }
 
 ClusterManagerPtr ProdClusterManagerFactory::clusterManagerFromJson(
-    const Json::Object& config, Stats::Store& stats, ThreadLocal::Instance& tls,
-    Runtime::Loader& runtime, Runtime::RandomGenerator& random,
+    const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap, Stats::Store& stats,
+    ThreadLocal::Instance& tls, Runtime::Loader& runtime, Runtime::RandomGenerator& random,
     const LocalInfo::LocalInfo& local_info, AccessLog::AccessLogManager& log_manager) {
-  return ClusterManagerPtr{
-      new ClusterManagerImpl(config, *this, stats, tls, runtime, random, local_info, log_manager)};
+  return ClusterManagerPtr{new ClusterManagerImpl(config, bootstrap, *this, stats, tls, runtime,
+                                                  random, local_info, log_manager)};
 }
 
 Http::ConnectionPool::InstancePtr

source/common/upstream/cluster_manager_impl.h

@@ -39,11 +39,11 @@ class ProdClusterManagerFactory : public ClusterManagerFactory {
         local_info_(local_info) {}
 
   // Upstream::ClusterManagerFactory
-  ClusterManagerPtr clusterManagerFromJson(const Json::Object& config, Stats::Store& stats,
-                                           ThreadLocal::Instance& tls, Runtime::Loader& runtime,
-                                           Runtime::RandomGenerator& random,
-                                           const LocalInfo::LocalInfo& local_info,
-                                           AccessLog::AccessLogManager& log_manager) override;
+  ClusterManagerPtr
+  clusterManagerFromJson(const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap,
+                         Stats::Store& stats, ThreadLocal::Instance& tls, Runtime::Loader& runtime,
+                         Runtime::RandomGenerator& random, const LocalInfo::LocalInfo& local_info,
+                         AccessLog::AccessLogManager& log_manager) override;
   Http::ConnectionPool::InstancePtr allocateConnPool(Event::Dispatcher& dispatcher,
                                                      HostConstSharedPtr host,
                                                      ResourcePriority priority) override;
@@ -119,8 +119,9 @@ struct ClusterManagerStats {
  */
 class ClusterManagerImpl : public ClusterManager, Logger::Loggable<Logger::Id::upstream> {
 public:
-  ClusterManagerImpl(const Json::Object& config, ClusterManagerFactory& factory,
-                     Stats::Store& stats, ThreadLocal::SlotAllocator& tls, Runtime::Loader& runtime,
+  ClusterManagerImpl(const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap,
+                     ClusterManagerFactory& factory, Stats::Store& stats,
+                     ThreadLocal::SlotAllocator& tls, Runtime::Loader& runtime,
                      Runtime::RandomGenerator& random, const LocalInfo::LocalInfo& local_info,
                      AccessLog::AccessLogManager& log_manager);
 

source/server/BUILD

@@ -20,6 +20,7 @@ envoy_cc_library(
     name = "configuration_lib",
     srcs = ["configuration_impl.cc"],
     hdrs = ["configuration_impl.h"],
+    external_deps = ["envoy_bootstrap"],
     deps = [
         ":lds_api_lib",
         "//include/envoy/http:filter_interface",
@@ -156,6 +157,7 @@ envoy_cc_library(
     name = "server_lib",
     srcs = ["server.cc"],
     hdrs = ["server.h"],
+    external_deps = ["envoy_bootstrap"],
     deps = [
         ":configuration_lib",
         ":connection_handler_lib",
@@ -181,6 +183,7 @@ envoy_cc_library(
         "//source/common/common:utility_lib",
         "//source/common/common:version_lib",
         "//source/common/memory:stats_lib",
+        "//source/common/protobuf:utility_lib",
         "//source/common/runtime:runtime_lib",
         "//source/common/stats:statsd_lib",
         "//source/common/upstream:cluster_manager_lib",

source/server/config_validation/BUILD

@@ -63,6 +63,7 @@ envoy_cc_library(
     name = "server_lib",
     srcs = ["server.cc"],
     hdrs = ["server.h"],
+    external_deps = ["envoy_bootstrap"],
     deps = [
         ":api_lib",
         ":cluster_manager_lib",
@@ -74,6 +75,7 @@ envoy_cc_library(
         "//include/envoy/tracing:http_tracer_interface",
         "//source/common/access_log:access_log_manager_lib",
         "//source/common/common:assert_lib",
+        "//source/common/protobuf:utility_lib",
         "//source/common/runtime:runtime_lib",
         "//source/common/ssl:context_lib",
         "//source/common/stats:stats_lib",

source/server/config_validation/cluster_manager.cc

@@ -12,11 +12,11 @@ ValidationClusterManagerFactory::ValidationClusterManagerFactory(
                                 primary_dispatcher, local_info) {}
 
 ClusterManagerPtr ValidationClusterManagerFactory::clusterManagerFromJson(
-    const Json::Object& config, Stats::Store& stats, ThreadLocal::Instance& tls,
-    Runtime::Loader& runtime, Runtime::RandomGenerator& random,
+    const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap, Stats::Store& stats,
+    ThreadLocal::Instance& tls, Runtime::Loader& runtime, Runtime::RandomGenerator& random,
     const LocalInfo::LocalInfo& local_info, AccessLog::AccessLogManager& log_manager) {
-  return ClusterManagerPtr{new ValidationClusterManager(config, *this, stats, tls, runtime, random,
-                                                        local_info, log_manager)};
+  return ClusterManagerPtr{new ValidationClusterManager(config, bootstrap, *this, stats, tls,
+                                                        runtime, random, local_info, log_manager)};
 }
 
 CdsApiPtr ValidationClusterManagerFactory::createCds(const Json::Object& config,
@@ -29,10 +29,12 @@ CdsApiPtr ValidationClusterManagerFactory::createCds(const Json::Object& config,
 }
 
 ValidationClusterManager::ValidationClusterManager(
-    const Json::Object& config, ClusterManagerFactory& factory, Stats::Store& stats,
-    ThreadLocal::Instance& tls, Runtime::Loader& runtime, Runtime::RandomGenerator& random,
+    const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap,
+    ClusterManagerFactory& factory, Stats::Store& stats, ThreadLocal::Instance& tls,
+    Runtime::Loader& runtime, Runtime::RandomGenerator& random,
     const LocalInfo::LocalInfo& local_info, AccessLog::AccessLogManager& log_manager)
-    : ClusterManagerImpl(config, factory, stats, tls, runtime, random, local_info, log_manager) {}
+    : ClusterManagerImpl(config, bootstrap, factory, stats, tls, runtime, random, local_info,
+                         log_manager) {}
 
 Http::ConnectionPool::Instance*
 ValidationClusterManager::httpConnPoolForCluster(const std::string&, ResourcePriority,

source/server/config_validation/cluster_manager.h

@@ -22,11 +22,11 @@ class ValidationClusterManagerFactory : public ProdClusterManagerFactory {
                                   Event::Dispatcher& primary_dispatcher,
                                   const LocalInfo::LocalInfo& local_info);
 
-  ClusterManagerPtr clusterManagerFromJson(const Json::Object& config, Stats::Store& stats,
-                                           ThreadLocal::Instance& tls, Runtime::Loader& runtime,
-                                           Runtime::RandomGenerator& random,
-                                           const LocalInfo::LocalInfo& local_info,
-                                           AccessLog::AccessLogManager& log_manager) override;
+  ClusterManagerPtr
+  clusterManagerFromJson(const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap,
+                         Stats::Store& stats, ThreadLocal::Instance& tls, Runtime::Loader& runtime,
+                         Runtime::RandomGenerator& random, const LocalInfo::LocalInfo& local_info,
+                         AccessLog::AccessLogManager& log_manager) override;
 
   // Delegates to ProdClusterManagerFactory::createCds, but discards the result and returns nullptr
   // unconditionally.
@@ -39,10 +39,10 @@ class ValidationClusterManagerFactory : public ProdClusterManagerFactory {
  */
 class ValidationClusterManager : public ClusterManagerImpl {
 public:
-  ValidationClusterManager(const Json::Object& config, ClusterManagerFactory& factory,
-                           Stats::Store& stats, ThreadLocal::Instance& tls,
-                           Runtime::Loader& runtime, Runtime::RandomGenerator& random,
-                           const LocalInfo::LocalInfo& local_info,
+  ValidationClusterManager(const Json::Object& config, const envoy::api::v2::Bootstrap& bootstrap,
+                           ClusterManagerFactory& factory, Stats::Store& stats,
+                           ThreadLocal::Instance& tls, Runtime::Loader& runtime,
+                           Runtime::RandomGenerator& random, const LocalInfo::LocalInfo& local_info,
                            AccessLog::AccessLogManager& log_manager);
 
   Http::ConnectionPool::Instance* httpConnPoolForCluster(const std::string&, ResourcePriority,

source/server/config_validation/server.cc

@@ -1,7 +1,11 @@
 #include "server/config_validation/server.h"
 
+#include "common/protobuf/utility.h"
+
 #include "server/configuration_impl.h"
 
+#include "api/bootstrap.pb.h"
+
 namespace Envoy {
 namespace Server {
 
@@ -50,6 +54,11 @@ void ValidationInstance::initialize(Options& options, ComponentFactory& componen
   // If we get all the way through that stripped-down initialization flow, to the point where we'd
   // be ready to serve, then the config has passed validation.
   Json::ObjectSharedPtr config_json = Json::Factory::loadFromFile(options.configPath());
+  envoy::api::v2::Bootstrap bootstrap;
+  if (!options.bootstrapPath().empty()) {
+    MessageUtil::loadFromFile(options.bootstrapPath(), bootstrap);
+  }
+
   Configuration::InitialImpl initial_config(*config_json);
   thread_local_.registerThread(*dispatcher_, true);
   runtime_loader_ = component_factory.createRuntime(*this, initial_config);
@@ -60,7 +69,7 @@ void ValidationInstance::initialize(Options& options, ComponentFactory& componen
 
   Configuration::MainImpl* main_config = new Configuration::MainImpl();
   config_.reset(main_config);
-  main_config->initialize(*config_json, *this, *cluster_manager_factory_);
+  main_config->initialize(*config_json, bootstrap, *this, *cluster_manager_factory_);
 
   clusterManager().setInitializedCb(
       [this]() -> void { init_manager_.initialize([]() -> void {}); });

source/server/configuration_impl.cc

@@ -33,11 +33,12 @@ bool FilterChainUtility::buildFilterChain(Network::FilterManager& filter_manager
   return filter_manager.initializeReadFilters();
 }
 
-void MainImpl::initialize(const Json::Object& json, Instance& server,
+void MainImpl::initialize(const Json::Object& json, const envoy::api::v2::Bootstrap& bootstrap,
+                          Instance& server,
                           Upstream::ClusterManagerFactory& cluster_manager_factory) {
   cluster_manager_ = cluster_manager_factory.clusterManagerFromJson(
-      *json.getObject("cluster_manager"), server.stats(), server.threadLocal(), server.runtime(),
-      server.random(), server.localInfo(), server.accessLogManager());
+      *json.getObject("cluster_manager"), bootstrap, server.stats(), server.threadLocal(),
+      server.runtime(), server.random(), server.localInfo(), server.accessLogManager());
 
   std::vector<Json::ObjectSharedPtr> listeners = json.getObjectArray("listeners");
   ENVOY_LOG(info, "loading {} listener(s)", listeners.size());

source/server/configuration_impl.h

@@ -22,6 +22,8 @@
 
 #include "server/lds_api.h"
 
+#include "api/bootstrap.pb.h"
+
 namespace Envoy {
 namespace Server {
 namespace Configuration {
@@ -106,11 +108,12 @@ class MainImpl : Logger::Loggable<Logger::Id::config>, public Main {
    * will call through the server into the config to get the cluster manager so the config object
    * must be created already.
    * @param json supplies the configuration JSON.
+   * @param bootstrap v2 bootstrap proto.
    * @param server supplies the owning server.
    * @param cluster_manager_factory supplies the cluster manager creation factory.
    */
-  void initialize(const Json::Object& json, Instance& server,
-                  Upstream::ClusterManagerFactory& cluster_manager_factory);
+  void initialize(const Json::Object& json, const envoy::api::v2::Bootstrap& bootstrap,
+                  Instance& server, Upstream::ClusterManagerFactory& cluster_manager_factory);
 
   // Server::Configuration::Main
   Upstream::ClusterManager& clusterManager() override { return *cluster_manager_; }