[router] Add SRDS configUpdate impl

include/envoy/router/route_config_provider_manager.h

@@ -33,10 +33,13 @@ class RouteConfigProviderManager {
    * @param rds supplies the proto configuration of an RDS-configured RouteConfigProvider.
    * @param factory_context is the context to use for the route config provider.
    * @param stat_prefix supplies the stat_prefix to use for the provider stats.
+   * @param init_manager the Init::Manager used to coordinate initialization of a the underlying RDS
+   * subscription.
    */
   virtual RouteConfigProviderPtr createRdsRouteConfigProvider(
       const envoy::config::filter::network::http_connection_manager::v2::Rds& rds,
-      Server::Configuration::FactoryContext& factory_context, const std::string& stat_prefix) PURE;
+      Server::Configuration::FactoryContext& factory_context, const std::string& stat_prefix,
+      Init::Manager& init_manager) PURE;
 
   /**
    * Get a RouteConfigSharedPtr for a statically defined route. Ownership is as described for

source/common/router/BUILD

@@ -146,22 +146,16 @@ envoy_cc_library(
     ],
 )
 
-envoy_cc_library(
-    name = "scoped_config_manager_lib",
-    srcs = ["scoped_config_manager.cc"],
-    hdrs = ["scoped_config_manager.h"],
-    deps = [
-        "@envoy_api//envoy/api/v2:srds_cc",
-    ],
-)
-
 envoy_cc_library(
     name = "scoped_config_lib",
     srcs = ["scoped_config_impl.cc"],
     hdrs = ["scoped_config_impl.h"],
+    external_deps = [
+        "abseil_str_format",
+    ],
     deps = [
         ":config_lib",
-        ":scoped_config_manager_lib",
+        "//include/envoy/router:rds_interface",
         "//include/envoy/router:scopes_interface",
         "//include/envoy/thread_local:thread_local_interface",
         "@envoy_api//envoy/api/v2:srds_cc",
@@ -177,10 +171,13 @@ envoy_cc_library(
         ":scoped_config_lib",
         "//include/envoy/config:config_provider_interface",
         "//include/envoy/config:subscription_interface",
+        "//include/envoy/router:route_config_provider_manager_interface",
         "//include/envoy/stats:stats_interface",
         "//source/common/common:assert_lib",
         "//source/common/common:minimal_logger_lib",
         "//source/common/config:config_provider_lib",
+        "//source/common/init:manager_lib",
+        "//source/common/init:watcher_lib",
         "@envoy_api//envoy/admin/v2alpha:config_dump_cc",
         "@envoy_api//envoy/api/v2:srds_cc",
     ],

source/common/router/rds_impl.cc

@@ -30,8 +30,8 @@ RouteConfigProviderPtr RouteConfigProviderUtil::create(
     return route_config_provider_manager.createStaticRouteConfigProvider(config.route_config(),
                                                                          factory_context);
   case envoy::config::filter::network::http_connection_manager::v2::HttpConnectionManager::kRds:
-    return route_config_provider_manager.createRdsRouteConfigProvider(config.rds(), factory_context,
-                                                                      stat_prefix);
+    return route_config_provider_manager.createRdsRouteConfigProvider(
+        config.rds(), factory_context, stat_prefix, factory_context.initManager());
   default:
     NOT_REACHED_GCOVR_EXCL_LINE;
   }
@@ -208,8 +208,8 @@ RouteConfigProviderManagerImpl::RouteConfigProviderManagerImpl(Server::Admin& ad
 
 Router::RouteConfigProviderPtr RouteConfigProviderManagerImpl::createRdsRouteConfigProvider(
     const envoy::config::filter::network::http_connection_manager::v2::Rds& rds,
-    Server::Configuration::FactoryContext& factory_context, const std::string& stat_prefix) {
-
+    Server::Configuration::FactoryContext& factory_context, const std::string& stat_prefix,
+    Init::Manager& init_manager) {
   // RdsRouteConfigSubscriptions are unique based on their serialized RDS config.
   const uint64_t manager_identifier = MessageUtil::hash(rds);
 
@@ -222,9 +222,7 @@ Router::RouteConfigProviderPtr RouteConfigProviderManagerImpl::createRdsRouteCon
     // of simplicity.
     subscription.reset(new RdsRouteConfigSubscription(rds, manager_identifier, factory_context,
                                                       stat_prefix, *this));
-
-    factory_context.initManager().add(subscription->init_target_);
-
+    init_manager.add(subscription->init_target_);
     route_config_subscriptions_.insert({manager_identifier, subscription});
   } else {
     // Because the RouteConfigProviderManager's weak_ptrs only get cleaned up

source/common/router/rds_impl.h

@@ -195,8 +195,8 @@ class RouteConfigProviderManagerImpl : public RouteConfigProviderManager,
   // RouteConfigProviderManager
   RouteConfigProviderPtr createRdsRouteConfigProvider(
       const envoy::config::filter::network::http_connection_manager::v2::Rds& rds,
-      Server::Configuration::FactoryContext& factory_context,
-      const std::string& stat_prefix) override;
+      Server::Configuration::FactoryContext& factory_context, const std::string& stat_prefix,
+      Init::Manager& init_manager) override;
 
   RouteConfigProviderPtr
   createStaticRouteConfigProvider(const envoy::api::v2::RouteConfiguration& route_config,

source/common/router/scoped_config_impl.cc

@@ -10,13 +10,7 @@ bool ScopeKey::operator==(const ScopeKey& other) const {
     // An empty key equals to nothing, "NULL" != "NULL".
     return false;
   }
-  return std::equal(fragments_.begin(), fragments_.end(), other.fragments_.begin(),
-                    other.fragments_.end(),
-                    [](const std::unique_ptr<ScopeKeyFragmentBase>& left,
-                       const std::unique_ptr<ScopeKeyFragmentBase>& right) -> bool {
-                      // Both should be non-NULL now.
-                      return *left == *right;
-                    });
+  return this->hash() == other.hash();
 }
 
 HeaderValueExtractorImpl::HeaderValueExtractorImpl(
@@ -76,6 +70,27 @@ HeaderValueExtractorImpl::computeFragment(const Http::HeaderMap& headers) const
   return nullptr;
 }
 
+ScopedRouteInfo::ScopedRouteInfo(envoy::api::v2::ScopedRouteConfiguration&& config_proto,
+                                 std::unique_ptr<RouteConfigProvider>&& route_provider)
+    : config_proto_(std::move(config_proto)), route_provider_(std::move(route_provider)) {
+  ASSERT(route_provider_ != nullptr, "ScopedRouteInfo expects a valid RouteConfigProvider.");
+  ASSERT(!route_provider_->configInfo().has_value() ||
+             route_provider_->config()->name() == config_proto_.route_configuration_name(),
+         fmt::format("RouteConfigProvider's name '{}' doesn't match route_configuration_name '{}'.",
+                     route_provider_->config()->name(), config_proto_.route_configuration_name()));
+  // TODO(stevenzzzz): Maybe worth a KeyBuilder abstraction when there are more than one type of
+  // Fragment.
+  for (const auto& fragment : config_proto_.key().fragments()) {
+    switch (fragment.type_case()) {
+    case envoy::api::v2::ScopedRouteConfiguration::Key::Fragment::kStringKey:
+      scope_key_.addFragment(std::make_unique<StringKeyFragment>(fragment.string_key()));
+      break;
+    default:
+      NOT_REACHED_GCOVR_EXCL_LINE;
+    }
+  }
+}
+
 ScopeKeyBuilderImpl::ScopeKeyBuilderImpl(ScopedRoutes::ScopeKeyBuilder&& config)
     : ScopeKeyBuilderBase(std::move(config)) {
   for (const auto& fragment_builder : config_.fragments()) {
@@ -104,12 +119,36 @@ ScopeKeyBuilderImpl::computeScopeKey(const Http::HeaderMap& headers) const {
   return std::make_unique<ScopeKey>(std::move(key));
 }
 
-void ScopedConfigImpl::addOrUpdateRoutingScope(const ScopedRouteInfoConstSharedPtr&) {}
+void ScopedConfigImpl::addOrUpdateRoutingScope(
+    const ScopedRouteInfoConstSharedPtr& scoped_route_info) {
+  const auto iter = scoped_route_info_by_name_.find(scoped_route_info->scopeName());
+  if (iter != scoped_route_info_by_name_.end()) {
+    scoped_route_info_by_key_.erase(iter->second->scopeKey().hash());
+  }
+  scoped_route_info_by_name_[scoped_route_info->scopeName()] = scoped_route_info;
+  scoped_route_info_by_key_[scoped_route_info->scopeKey().hash()] = scoped_route_info;
+}
 
-void ScopedConfigImpl::removeRoutingScope(const std::string&) {}
+void ScopedConfigImpl::removeRoutingScope(const std::string& scope_name) {
+  const auto iter = scoped_route_info_by_name_.find(scope_name);
+  if (iter != scoped_route_info_by_name_.end()) {
+    ASSERT(scoped_route_info_by_key_.count(iter->second->scopeKey().hash()) == 1);
+    scoped_route_info_by_key_.erase(iter->second->scopeKey().hash());
+    scoped_route_info_by_name_.erase(iter);
+  }
+}
 
-Router::ConfigConstSharedPtr ScopedConfigImpl::getRouteConfig(const Http::HeaderMap&) const {
-  return std::make_shared<const NullConfigImpl>();
+Router::ConfigConstSharedPtr
+ScopedConfigImpl::getRouteConfig(const Http::HeaderMap& headers) const {
+  std::unique_ptr<ScopeKey> scope_key = scope_key_builder_.computeScopeKey(headers);
+  if (scope_key == nullptr) {
+    return nullptr;
+  }
+  auto iter = scoped_route_info_by_key_.find(scope_key->hash());
+  if (iter != scoped_route_info_by_key_.end()) {
+    return iter->second->routeConfig();
+  }
+  return nullptr;
 }
 
 } // namespace Router

source/common/router/scoped_config_impl.h

@@ -4,13 +4,17 @@
 
 #include "envoy/api/v2/srds.pb.h"
 #include "envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.pb.h"
+#include "envoy/router/rds.h"
 #include "envoy/router/router.h"
 #include "envoy/router/scopes.h"
 #include "envoy/thread_local/thread_local.h"
 
+#include "common/common/hash.h"
 #include "common/protobuf/utility.h"
 #include "common/router/config_impl.h"
-#include "common/router/scoped_config_manager.h"
+
+#include "absl/numeric/int128.h"
+#include "absl/strings/str_format.h"
 
 namespace Envoy {
 namespace Router {
@@ -26,15 +30,14 @@ class ScopeKeyFragmentBase {
 
   bool operator==(const ScopeKeyFragmentBase& other) const {
     if (typeid(*this) == typeid(other)) {
-      return equals(other);
+      return hash() == other.hash();
     }
     return false;
   }
   virtual ~ScopeKeyFragmentBase() = default;
 
-private:
-  // Returns true if the two fragments equal else false.
-  virtual bool equals(const ScopeKeyFragmentBase&) const PURE;
+  // Hash of the fragment.
+  virtual uint64_t hash() const PURE;
 };
 
 /**
@@ -52,28 +55,36 @@ class ScopeKey {
   // Caller should guarantee the fragment is not nullptr.
   void addFragment(std::unique_ptr<ScopeKeyFragmentBase>&& fragment) {
     ASSERT(fragment != nullptr, "null fragment not allowed in ScopeKey.");
+    updateHash(*fragment);
     fragments_.emplace_back(std::move(fragment));
   }
 
+  uint64_t hash() const { return hash_; }
   bool operator!=(const ScopeKey& other) const;
-
   bool operator==(const ScopeKey& other) const;
 
 private:
+  // Update the key's hash with the new fragment hash.
+  void updateHash(const ScopeKeyFragmentBase& fragment) {
+    absl::uint128 buffer = absl::MakeUint128(hash_, fragment.hash());
+    hash_ = HashUtil::xxHash64(absl::string_view(reinterpret_cast<char*>(&buffer), 16));
+  }
+
+  uint64_t hash_{0};
   std::vector<std::unique_ptr<ScopeKeyFragmentBase>> fragments_;
 };
 
 // String fragment.
 class StringKeyFragment : public ScopeKeyFragmentBase {
 public:
-  explicit StringKeyFragment(absl::string_view value) : value_(value) {}
+  explicit StringKeyFragment(absl::string_view value)
+      : value_(value), hash_(HashUtil::xxHash64(value_)) {}
 
-private:
-  bool equals(const ScopeKeyFragmentBase& other) const override {
-    return value_ == static_cast<const StringKeyFragment&>(other).value_;
-  }
+  uint64_t hash() const override { return hash_; }
 
+private:
   const std::string value_;
+  const uint64_t hash_;
 };
 
 /**
@@ -132,9 +143,27 @@ class ScopeKeyBuilderImpl : public ScopeKeyBuilderBase {
   std::vector<std::unique_ptr<FragmentBuilderBase>> fragment_builders_;
 };
 
+// ScopedRouteConfiguration and corresponding RouteConfigProvider.
+class ScopedRouteInfo {
+public:
+  ScopedRouteInfo(envoy::api::v2::ScopedRouteConfiguration&& config_proto,
+                  std::unique_ptr<RouteConfigProvider>&& route_provider);
+
+  Router::ConfigConstSharedPtr routeConfig() const { return route_provider_->config(); }
+  const ScopeKey& scopeKey() const { return scope_key_; }
+  const envoy::api::v2::ScopedRouteConfiguration& configProto() const { return config_proto_; }
+  const std::string& scopeName() const { return config_proto_.name(); }
+
+private:
+  const envoy::api::v2::ScopedRouteConfiguration config_proto_;
+  ScopeKey scope_key_;
+  std::unique_ptr<RouteConfigProvider> route_provider_;
+};
+using ScopedRouteInfoConstSharedPtr = std::shared_ptr<const ScopedRouteInfo>;
+// Ordered map for consistent config dumping.
+using ScopedRouteMap = std::map<std::string, ScopedRouteInfoConstSharedPtr>;
+
 /**
- * TODO(AndresGuedez): implement scoped routing logic.
- *
  * Each Envoy worker is assigned an instance of this type. When config updates are received,
  * addOrUpdateRoutingScope() and removeRoutingScope() are called to update the set of scoped routes.
  *
@@ -153,8 +182,11 @@ class ScopedConfigImpl : public ScopedConfig {
   Router::ConfigConstSharedPtr getRouteConfig(const Http::HeaderMap& headers) const override;
 
 private:
-  const envoy::config::filter::network::http_connection_manager::v2::ScopedRoutes::ScopeKeyBuilder
-      scope_key_builder_;
+  ScopeKeyBuilderImpl scope_key_builder_;
+  // From scope name to cached ScopedRouteInfo.
+  absl::flat_hash_map<std::string, ScopedRouteInfoConstSharedPtr> scoped_route_info_by_name_;
+  // Hash by ScopeKey hash to lookup in constant time.
+  absl::flat_hash_map<uint64_t, ScopedRouteInfoConstSharedPtr> scoped_route_info_by_key_;
 };
 
 /**