router: scoped rds (2c): implement scoped rds API

api/envoy/admin/v2alpha/BUILD

@@ -10,6 +10,7 @@ api_proto_library_internal(
         "//envoy/api/v2:cds",
         "//envoy/api/v2:lds",
         "//envoy/api/v2:rds",
+        "//envoy/api/v2:srds",
         "//envoy/config/bootstrap/v2:bootstrap",
     ],
 )

api/envoy/admin/v2alpha/config_dump.proto

@@ -9,6 +9,7 @@ option java_package = "io.envoyproxy.envoy.admin.v2alpha";
 import "envoy/api/v2/cds.proto";
 import "envoy/api/v2/lds.proto";
 import "envoy/api/v2/rds.proto";
+import "envoy/api/v2/srds.proto";
 import "envoy/config/bootstrap/v2/bootstrap.proto";
 
 import "google/protobuf/any.proto";
@@ -178,3 +179,43 @@ message RoutesConfigDump {
   // The dynamically loaded route configs.
   repeated DynamicRouteConfig dynamic_route_configs = 3 [(gogoproto.nullable) = false];
 }
+
+// Envoy's scoped RDS implementation fills this message with all currently loaded route
+// configuration scopes (defined via ScopedRouteConfigurationsSet protos). This message lists both
+// the scopes defined inline with the higher order object (i.e., the HttpConnectionManager) and the
+// dynamically obtained scopes via the SRDS API.
+message ScopedRoutesConfigDump {
+  message InlineScopedRouteConfigs {
+    // The name assigned to the scoped route configurations.
+    string name = 1;
+
+    // The scoped route configurations.
+    repeated envoy.api.v2.ScopedRouteConfiguration scoped_route_configs = 2;
+
+    // The timestamp when the scoped route config set was last updated.
+    google.protobuf.Timestamp last_updated = 3;
+  }
+
+  message DynamicScopedRouteConfigs {
+    // The name assigned to the scoped route configurations.
+    string name = 1;
+
+    // This is the per-resource version information. This version is currently taken from the
+    // :ref:`version_info <envoy_api_field_DiscoveryResponse.version_info>` field at the time that
+    // the scoped routes configuration was loaded.
+    string version_info = 2;
+
+    // The scoped route configurations.
+    repeated envoy.api.v2.ScopedRouteConfiguration scoped_route_configs = 3;
+
+    // The timestamp when the scoped route config set was last updated.
+    google.protobuf.Timestamp last_updated = 4;
+  }
+
+  // The statically loaded scoped route configs.
+  repeated InlineScopedRouteConfigs inline_scoped_route_configs = 1 [(gogoproto.nullable) = false];
+
+  // The dynamically loaded scoped route configs.
+  repeated DynamicScopedRouteConfigs dynamic_scoped_route_configs = 2
+      [(gogoproto.nullable) = false];
+}

include/envoy/config/config_provider_manager.h

@@ -81,7 +81,7 @@ class ConfigProviderManager {
    * @return ConfigProviderPtr a newly allocated static config provider.
    */
   virtual ConfigProviderPtr
-  createStaticConfigProvider(std::vector<std::unique_ptr<const Protobuf::Message>>&& config_protos,
+  createStaticConfigProvider(ProtobufTypes::ConstMessagePtrVector&& config_protos,
                              Server::Configuration::FactoryContext& factory_context,
                              const OptionalArg& optarg) {
     UNREFERENCED_PARAMETER(config_protos);

include/envoy/router/BUILD

@@ -61,6 +61,16 @@ envoy_cc_library(
     ],
 )
 
+envoy_cc_library(
+    name = "scopes_interface",
+    hdrs = ["scopes.h"],
+    deps = [
+        ":router_interface",
+        "//include/envoy/config:config_provider_interface",
+        "//include/envoy/http:header_map_interface",
+    ],
+)
+
 envoy_cc_library(
     name = "router_ratelimit_interface",
     hdrs = ["router_ratelimit.h"],

include/envoy/router/scopes.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <memory>
+
+#include "envoy/config/config_provider.h"
+#include "envoy/router/router.h"
+
+namespace Envoy {
+namespace Router {
+
+/**
+ * The scoped routing configuration.
+ */
+class ScopedConfig : public Envoy::Config::ConfigProvider::Config {
+public:
+  ~ScopedConfig() override = default;
+
+  /**
+   * Based on the incoming HTTP request headers, returns the configuration to use for selecting a
+   * target route.
+   * @param headers the request headers to match the scoped routing configuration against.
+   * @return ConfigConstSharedPtr the router's Config matching the request headers.
+   */
+  virtual ConfigConstSharedPtr getRouterConfig(const Http::HeaderMap& headers) const PURE;
+};
+
+using ScopedConfigConstSharedPtr = std::shared_ptr<const ScopedConfig>;
+
+} // namespace Router
+} // namespace Envoy

source/common/config/resources.h

@@ -18,6 +18,8 @@ class TypeUrlValues {
   const std::string Secret{"type.googleapis.com/envoy.api.v2.auth.Secret"};
   const std::string RouteConfiguration{"type.googleapis.com/envoy.api.v2.RouteConfiguration"};
   const std::string VirtualHost{"type.googleapis.com/envoy.api.v2.route.VirtualHost"};
+  const std::string ScopedRouteConfiguration{
+      "type.googleapis.com/envoy.api.v2.ScopedRouteConfiguration"};
 };
 
 typedef ConstSingleton<TypeUrlValues> TypeUrl;

source/common/protobuf/protobuf.h

@@ -45,6 +45,7 @@ namespace ProtobufWkt = google::protobuf;
 namespace ProtobufTypes {
 
 typedef std::unique_ptr<Protobuf::Message> MessagePtr;
+typedef std::vector<std::unique_ptr<const Protobuf::Message>> ConstMessagePtrVector;
 
 typedef int64_t Int64;
 

source/common/router/BUILD

@@ -136,6 +136,46 @@ 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"],
+    deps = [
+        ":config_lib",
+        ":scoped_config_manager_lib",
+        "//include/envoy/router:scopes_interface",
+        "//include/envoy/thread_local:thread_local_interface",
+        "@envoy_api//envoy/api/v2:srds_cc",
+        "@envoy_api//envoy/config/filter/network/http_connection_manager/v2:http_connection_manager_cc",
+    ],
+)
+
+envoy_cc_library(
+    name = "scoped_rds_lib",
+    srcs = ["scoped_rds.cc"],
+    hdrs = ["scoped_rds.h"],
+    deps = [
+        ":scoped_config_lib",
+        "//include/envoy/config:subscription_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/config:subscription_factory_lib",
+        "@envoy_api//envoy/admin/v2alpha:config_dump_cc",
+        "@envoy_api//envoy/api/v2:srds_cc",
+    ],
+)
+
 envoy_cc_library(
     name = "retry_state_lib",
     srcs = ["retry_state_impl.cc"],

source/common/router/scoped_config_impl.cc

@@ -0,0 +1,16 @@
+#include "common/router/scoped_config_impl.h"
+
+namespace Envoy {
+namespace Router {
+
+void ThreadLocalScopedConfigImpl::addOrUpdateRoutingScope(const ScopedRouteInfoConstSharedPtr&) {}
+
+void ThreadLocalScopedConfigImpl::removeRoutingScope(const std::string&) {}
+
+Router::ConfigConstSharedPtr
+ThreadLocalScopedConfigImpl::getRouterConfig(const Http::HeaderMap&) const {
+  return std::make_shared<const NullConfigImpl>();
+}
+
+} // namespace Router
+} // namespace Envoy

source/common/router/scoped_config_impl.h

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "envoy/api/v2/srds.pb.h"
+#include "envoy/config/filter/network/http_connection_manager/v2/http_connection_manager.pb.h"
+#include "envoy/router/router.h"
+#include "envoy/router/scopes.h"
+#include "envoy/thread_local/thread_local.h"
+
+#include "common/router/config_impl.h"
+#include "common/router/scoped_config_manager.h"
+
+namespace Envoy {
+namespace Router {
+
+/**
+ * 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.
+ *
+ * ConnectionManagerImpl::refreshCachedRoute() will call getRouterConfig() to obtain the
+ * Router::ConfigConstSharedPtr to use for route selection.
+ */
+class ThreadLocalScopedConfigImpl : public ScopedConfig, public ThreadLocal::ThreadLocalObject {
+public:
+  ThreadLocalScopedConfigImpl(
+      envoy::config::filter::network::http_connection_manager::v2::ScopedRoutes::ScopeKeyBuilder
+          scope_key_builder)
+      : scope_key_builder_(std::move(scope_key_builder)) {}
+
+  ~ThreadLocalScopedConfigImpl() override = default;
+
+  void addOrUpdateRoutingScope(const ScopedRouteInfoConstSharedPtr& scoped_route_info);
+  void removeRoutingScope(const std::string& scope_name);
+
+  // Envoy::Router::ScopedConfig
+  Router::ConfigConstSharedPtr getRouterConfig(const Http::HeaderMap& headers) const override;
+
+private:
+  const envoy::config::filter::network::http_connection_manager::v2::ScopedRoutes::ScopeKeyBuilder
+      scope_key_builder_;
+};
+
+/**
+ * A NULL implementation of the scoped routing configuration.
+ */
+class NullScopedConfigImpl : public ScopedConfig {
+public:
+  Router::ConfigConstSharedPtr getRouterConfig(const Http::HeaderMap&) const override {
+    return std::make_shared<const NullConfigImpl>();
+  }
+};
+
+} // namespace Router
+} // namespace Envoy

source/common/router/scoped_config_manager.cc

@@ -0,0 +1,22 @@
+#include "common/router/scoped_config_manager.h"
+
+#include "envoy/common/exception.h"
+
+#include "common/common/fmt.h"
+
+namespace Envoy {
+namespace Router {
+
+ScopedRouteInfoConstSharedPtr ScopedConfigManager::addOrUpdateRoutingScope(
+    const envoy::api::v2::ScopedRouteConfiguration& config_proto, const std::string&) {
+  auto scoped_route_info = std::make_shared<const ScopedRouteInfo>(config_proto);
+  scoped_route_map_[config_proto.name()] = scoped_route_info;
+  return scoped_route_info;
+}
+
+bool ScopedConfigManager::removeRoutingScope(const std::string& name) {
+  return scoped_route_map_.erase(name) == 0;
+}
+
+} // namespace Router
+} // namespace Envoy

source/common/router/scoped_config_manager.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "envoy/api/v2/srds.pb.h"
+
+namespace Envoy {
+namespace Router {
+
+// The internal representation of the configuration distributed via the ScopedRouteConfiguration
+// proto.
+class ScopedRouteInfo {
+public:
+  ScopedRouteInfo(const envoy::api::v2::ScopedRouteConfiguration& config_proto)
+      : config_proto_(config_proto) {}
+
+  // TODO(AndresGuedez): Add the necessary APIs required for the scoped routing logic.
+
+  const envoy::api::v2::ScopedRouteConfiguration config_proto_;
+};
+using ScopedRouteInfoConstSharedPtr = std::shared_ptr<const ScopedRouteInfo>;
+
+// A manager for routing configuration scopes.
+// An instance of the manager is owned by each ScopedRdsConfigSubscription. When config updates are
+// received (on the main thread), the manager is called to track changes to the set of scoped route
+// configurations and build <ScopedRouteInfo>s as needed.
+class ScopedConfigManager {
+public:
+  // Ordered map for consistent config dumping.
+  using ScopedRouteMap = std::map<std::string, ScopedRouteInfoConstSharedPtr>;
+
+  // Adds/updates a routing scope specified via the Scoped RDS API. This scope will be added to the
+  // set of scopes matched against the scope keys built for each HTTP request.
+  ScopedRouteInfoConstSharedPtr
+  addOrUpdateRoutingScope(const envoy::api::v2::ScopedRouteConfiguration& scoped_route_config,
+                          const std::string& version_info);
+
+  // Removes a routing scope from the set of scopes matched against each HTTP request.
+  bool removeRoutingScope(const std::string& scope_name);
+
+  const ScopedRouteMap& scopedRouteMap() const { return scoped_route_map_; }
+
+private:
+  ScopedRouteMap scoped_route_map_;
+};
+
+} // namespace Router
+} // namespace Envoy