config: Scoped RDS (PR 1/4): Introduce {static,dynamic} config provider framework

include/envoy/config/BUILD

@@ -33,3 +33,23 @@ envoy_cc_library(
         "//source/common/protobuf",
     ],
 )
+
+envoy_cc_library(
+    name = "config_provider_interface",
+    hdrs = ["config_provider.h"],
+    external_deps = ["abseil_optional"],
+    deps = [
+        "//include/envoy/common:time_interface",
+        "//source/common/protobuf",
+    ],
+)
+
+envoy_cc_library(
+    name = "config_provider_manager_interface",
+    hdrs = ["config_provider_manager.h"],
+    deps = [
+        ":config_provider_interface",
+        "//include/envoy/server:filter_config_interface",
+        "//source/common/protobuf",
+    ],
+)

include/envoy/config/config_provider.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include <memory>
+
+#include "envoy/common/time.h"
+
+#include "common/protobuf/protobuf.h"
+
+#include "absl/types/optional.h"
+
+namespace Envoy {
+namespace Config {
+
+/**
+ * A provider for configuration obtained ether statically or dynamically via xDS APIs.
+ */
+class ConfigProvider {
+public:
+  /**
+   * The "implementation" of the configuration.
+   * Use config() to obtain a typed object that corresponds to the specific configuration
+   * represented by this abstract type.
+   */
+  class Config {
+  public:
+    virtual ~Config() {}
+  };
+  using ConfigConstSharedPtr = std::shared_ptr<const Config>;
+
+  /**
+   * Stores the config proto as well as the associated version.
+   */
+  template <typename P> struct ConfigInfo {
+    const P& config_;
+
+    std::string version_;
+  };
+
+  virtual ~ConfigProvider() {}
+
+  /**
+   * Returns a ConfigInfo associated with the provider.
+   * @return absl::optional<ConfigInfo<P>> an optional ConfigInfo; the value is set when a config is
+   *         available.
+   */
+  template <typename P> absl::optional<ConfigInfo<P>> configInfo() {
+    static_assert(std::is_base_of<Protobuf::Message, P>::value,
+                  "Proto type must derive from Protobuf::Message");
+
+    const auto* config_proto = dynamic_cast<const P*>(getConfigProto());
+    if (!config_proto) {
+      return {};
+    }
+    return ConfigInfo<P>{*config_proto, getConfigVersion()};
+  }
+
+  /**
+   * Returns the Config corresponding to the provider.
+   * @return std::shared_ptr<const C> a shared pointer to the Config.
+   */
+  template <typename C> std::shared_ptr<const C> config() {
+    static_assert(std::is_base_of<Config, C>::value,
+                  "Config type must derive from ConfigProvider::Config");
+
+    return std::dynamic_pointer_cast<const C>(getConfig());
+  }
+
+  /**
+   * Returns the timestamp associated with the last update to the Config.
+   * @return SystemTime the timestamp corresponding to the last config update.
+   */
+  virtual SystemTime lastUpdated() const PURE;
+
+protected:
+  /**
+   * Returns the config proto associated with the provider.
+   * @return Protobuf::Message* the config proto corresponding to the Config instantiated by the
+   *         provider.
+   */
+  virtual const Protobuf::Message* getConfigProto() const PURE;
+
+  /**
+   * Returns the config version associated with the provider.
+   * @return std::string the config version.
+   */
+  virtual std::string getConfigVersion() const PURE;
+
+  /**
+   * Returns the config implementation associated with the provider.
+   * @return ConfigConstSharedPtr the config as the base type.
+   */
+  virtual ConfigConstSharedPtr getConfig() const PURE;
+};
+
+using ConfigProviderPtr = std::unique_ptr<ConfigProvider>;
+
+} // namespace Config
+} // namespace Envoy

include/envoy/config/config_provider_manager.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <string>
+
+#include "envoy/config/config_provider.h"
+#include "envoy/server/filter_config.h"
+
+#include "common/protobuf/protobuf.h"
+
+namespace Envoy {
+namespace Config {
+
+/**
+ * A ConfigProvider manager which instantiates static and dynamic (xDS) providers.
+ *
+ * ConfigProvider objects are owned by the caller of the
+ * createXdsConfigProvider()/createStaticConfigProvider() functions. The ConfigProviderManager holds
+ * raw pointers to those objects.
+ */
+class ConfigProviderManager {
+public:
+  virtual ~ConfigProviderManager() {}
+
+  /**
+   * Returns a dynamic ConfigProvider which receives configuration via an xDS API.
+   * A shared ownership model is used, such that the underlying subscription, config proto
+   * and Config are shared amongst all providers relying on the same config source.
+   * @param config_source_proto supplies the proto containing the xDS API configuration.
+   * @param factory_context is the context to use for the provider.
+   * @param stat_prefix supplies the prefix to use for statistics.
+   * @return ConfigProviderPtr a newly allocated dynamic config provider which shares underlying
+   *                           data structures with other dynamic providers configured with the same
+   *                           API source.
+   */
+  virtual ConfigProviderPtr
+  createXdsConfigProvider(const Protobuf::Message& config_source_proto,
+                          Server::Configuration::FactoryContext& factory_context,
+                          const std::string& stat_prefix) PURE;
+
+  /**
+   * Returns a ConfigProvider associated with a statically specified configuration.
+   * @param config_proto supplies the configuration proto.
+   * @param factory_context is the context to use for the provider.
+   * @return ConfigProviderPtr a newly allocated static config provider.
+   */
+  virtual ConfigProviderPtr
+  createStaticConfigProvider(const Protobuf::Message& config_proto,
+                             Server::Configuration::FactoryContext& factory_context) PURE;
+};
+
+} // namespace Config
+} // namespace Envoy

source/common/config/BUILD

@@ -366,3 +366,20 @@ envoy_cc_library(
         "//source/common/singleton:const_singleton",
     ],
 )
+
+envoy_cc_library(
+    name = "config_provider_lib",
+    srcs = ["config_provider_impl.cc"],
+    hdrs = ["config_provider_impl.h"],
+    deps = [
+        ":utility_lib",
+        "//include/envoy/config:config_provider_interface",
+        "//include/envoy/config:config_provider_manager_interface",
+        "//include/envoy/init:init_interface",
+        "//include/envoy/server:admin_interface",
+        "//include/envoy/server:config_tracker_interface",
+        "//include/envoy/singleton:instance_interface",
+        "//include/envoy/thread_local:thread_local_interface",
+        "//source/common/protobuf",
+    ],
+)

source/common/config/config_provider_impl.cc

@@ -0,0 +1,64 @@
+#include "common/config/config_provider_impl.h"
+
+namespace Envoy {
+namespace Config {
+
+StaticConfigProviderImpl::StaticConfigProviderImpl(
+    Server::Configuration::FactoryContext& factory_context,
+    ConfigProviderManagerImpl& config_provider_manager)
+    : last_updated_(factory_context.timeSource().systemTime()),
+      config_provider_manager_(config_provider_manager) {
+  config_provider_manager_.static_config_providers_.insert(this);
+}
+
+StaticConfigProviderImpl::~StaticConfigProviderImpl() {
+  config_provider_manager_.static_config_providers_.erase(this);
+}
+
+ConfigSubscriptionInstance::~ConfigSubscriptionInstance() {
+  runInitializeCallbackIfAny();
+  config_provider_manager_.unbindSubscription(manager_identifier_);
+}
+
+void ConfigSubscriptionInstance::runInitializeCallbackIfAny() {
+  if (initialize_callback_) {
+    initialize_callback_();
+    initialize_callback_ = nullptr;
+  }
+}
+
+bool ConfigSubscriptionInstance::checkAndApplyConfig(const Protobuf::Message& config_proto,
+                                                     const std::string& config_name,
+                                                     const std::string& version_info) {
+  const uint64_t new_hash = MessageUtil::hash(config_proto);
+  if (config_info_ && config_info_.value().last_config_hash_ == new_hash) {
+    return false;
+  }
+
+  config_info_ = {new_hash, version_info};
+  ENVOY_LOG(debug, "{}: loading new configuration: config_name={} hash={}", name_, config_name,
+            new_hash);
+
+  ASSERT(!dynamic_config_providers_.empty());
+  ConfigProvider::ConfigConstSharedPtr new_config;
+  for (auto* provider : dynamic_config_providers_) {
+    if (new_config == nullptr) {
+      new_config = provider->onConfigProtoUpdate(config_proto);
+    }
+    provider->onConfigUpdate(new_config);
+  }
+
+  return true;
+}
+
+ConfigProviderManagerImpl::ConfigProviderManagerImpl(Server::Admin& admin,
+                                                     const std::string& config_name) {
+  config_tracker_entry_ =
+      admin.getConfigTracker().add(config_name, [this] { return dumpConfigs(); });
+  // ConfigTracker keys must be unique. We are asserting that no one has stolen the key
+  // from us, since the returned entry will be nullptr if the key already exists.
+  RELEASE_ASSERT(config_tracker_entry_, "");
+}
+
+} // namespace Config
+} // namespace Envoy