[router] Add SRDS configUpdate impl

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",
@@ -176,6 +170,7 @@ envoy_cc_library(
     deps = [
         ":scoped_config_lib",
         "//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/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(
@@ -104,13 +98,32 @@ ScopeKeyBuilderImpl::computeScopeKey(const Http::HeaderMap& headers) const {
   return std::make_unique<ScopeKey>(std::move(key));
 }
 
-void ThreadLocalScopedConfigImpl::addOrUpdateRoutingScope(const ScopedRouteInfoConstSharedPtr&) {}
+void ThreadLocalScopedConfigImpl::addOrUpdateRoutingScope(
+    const ScopedRouteInfoConstSharedPtr& scoped_route_info) {
+  scoped_route_info_by_name_.try_emplace(scoped_route_info->scopeName(), scoped_route_info);
+  scoped_route_info_by_key_.try_emplace(scoped_route_info->scopeKey().hash(), scoped_route_info);
+}
 
-void ThreadLocalScopedConfigImpl::removeRoutingScope(const std::string&) {}
+void ThreadLocalScopedConfigImpl::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
-ThreadLocalScopedConfigImpl::getRouteConfig(const Http::HeaderMap&) const {
-  return std::make_shared<const NullConfigImpl>();
+ThreadLocalScopedConfigImpl::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,45 @@ 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::shared_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;
+      }
+    }
+  }
+  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::shared_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 +200,11 @@ class ThreadLocalScopedConfigImpl : public ScopedConfig, public ThreadLocal::Thr
   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, const ScopedRouteInfoConstSharedPtr> scoped_route_info_by_name_;
+  // Hash by ScopeKey hash to lookup in constant time.
+  absl::flat_hash_map<uint64_t, const ScopedRouteInfoConstSharedPtr> scoped_route_info_by_key_;
 };
 
 /**