grpc 1.30.2 → 1.32.0

data/src/core/ext/{filters/client_channel/xds → xds}/xds_api.h

@@ -16,8 +16,8 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_API_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_API_H
+#ifndef GRPC_CORE_EXT_XDS_XDS_API_H
+#define GRPC_CORE_EXT_XDS_XDS_API_H
 
 #include <grpc/support/port_platform.h>
 
@@ -27,12 +27,13 @@
 
 #include "absl/container/inlined_vector.h"
 #include "absl/types/optional.h"
+#include "re2/re2.h"
 
 #include <grpc/slice_buffer.h>
 
 #include "src/core/ext/filters/client_channel/server_address.h"
-#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
+#include "src/core/ext/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_client_stats.h"
 
 namespace grpc_core {
 
@@ -45,36 +46,109 @@ class XdsApi {
   static const char* kCdsTypeUrl;
   static const char* kEdsTypeUrl;
 
-  struct RdsUpdate {
-    struct RdsRoute {
-      std::string service;
-      std::string method;
-      // TODO(donnadionne): When we can use absl::variant<>, consider using that
-      // here, to enforce the fact that only one of cluster_name and
-      // weighted_clusters can be set.
-      std::string cluster_name;
-      struct ClusterWeight {
-        std::string name;
-        uint32_t weight;
+  // TODO(donnadionne): When we can use absl::variant<>, consider using that
+  // for: PathMatcher, HeaderMatcher, cluster_name and weighted_clusters
+  struct Route {
+    // Matchers for this route.
+    struct Matchers {
+      struct PathMatcher {
+        enum class PathMatcherType {
+          PATH,    // path stored in string_matcher field
+          PREFIX,  // prefix stored in string_matcher field
+          REGEX,   // regex stored in regex_matcher field
+        };
+        PathMatcherType type;
+        std::string string_matcher;
+        std::unique_ptr<RE2> regex_matcher;
+
+        PathMatcher() = default;
+        PathMatcher(const PathMatcher& other);
+        PathMatcher& operator=(const PathMatcher& other);
+        bool operator==(const PathMatcher& other) const;
+        std::string ToString() const;
+      };
 
-        bool operator==(const ClusterWeight& other) const {
-          return (name == other.name && weight == other.weight);
-        }
+      struct HeaderMatcher {
+        enum class HeaderMatcherType {
+          EXACT,    // value stored in string_matcher field
+          REGEX,    // uses regex_match field
+          RANGE,    // uses range_start and range_end fields
+          PRESENT,  // uses present_match field
+          PREFIX,   // prefix stored in string_matcher field
+          SUFFIX,   // suffix stored in string_matcher field
+        };
+        std::string name;
+        HeaderMatcherType type;
+        int64_t range_start;
+        int64_t range_end;
+        std::string string_matcher;
+        std::unique_ptr<RE2> regex_match;
+        bool present_match;
+        // invert_match field may or may not exisit, so initialize it to
+        // false.
+        bool invert_match = false;
+
+        HeaderMatcher() = default;
+        HeaderMatcher(const HeaderMatcher& other);
+        HeaderMatcher& operator=(const HeaderMatcher& other);
+        bool operator==(const HeaderMatcher& other) const;
+        std::string ToString() const;
       };
-      std::vector<ClusterWeight> weighted_clusters;
 
-      bool operator==(const RdsRoute& other) const {
-        return (service == other.service && method == other.method &&
-                cluster_name == other.cluster_name &&
-                weighted_clusters == other.weighted_clusters);
+      PathMatcher path_matcher;
+      std::vector<HeaderMatcher> header_matchers;
+      absl::optional<uint32_t> fraction_per_million;
+
+      bool operator==(const Matchers& other) const {
+        return (path_matcher == other.path_matcher &&
+                header_matchers == other.header_matchers &&
+                fraction_per_million == other.fraction_per_million);
       }
+      std::string ToString() const;
     };
 
-    std::vector<RdsRoute> routes;
+    Matchers matchers;
+
+    // Action for this route.
+    // TODO(roth): When we can use absl::variant<>, consider using that
+    // here, to enforce the fact that only one of the two fields can be set.
+    std::string cluster_name;
+    struct ClusterWeight {
+      std::string name;
+      uint32_t weight;
+      bool operator==(const ClusterWeight& other) const {
+        return (name == other.name && weight == other.weight);
+      }
+      std::string ToString() const;
+    };
+    std::vector<ClusterWeight> weighted_clusters;
+
+    bool operator==(const Route& other) const {
+      return (matchers == other.matchers &&
+              cluster_name == other.cluster_name &&
+              weighted_clusters == other.weighted_clusters);
+    }
+    std::string ToString() const;
+  };
+
+  struct RdsUpdate {
+    struct VirtualHost {
+      std::vector<std::string> domains;
+      std::vector<Route> routes;
+
+      bool operator==(const VirtualHost& other) const {
+        return domains == other.domains && routes == other.routes;
+      }
+    };
+
+    std::vector<VirtualHost> virtual_hosts;
 
     bool operator==(const RdsUpdate& other) const {
-      return routes == other.routes;
+      return virtual_hosts == other.virtual_hosts;
     }
+    std::string ToString() const;
+    const VirtualHost* FindVirtualHostForDomain(
+        const std::string& domain) const;
   };
 
   // TODO(roth): When we can use absl::variant<>, consider using that
@@ -82,8 +156,8 @@ class XdsApi {
   struct LdsUpdate {
     // The name to use in the RDS request.
     std::string route_config_name;
-    // The name to use in the CDS request. Present if the LDS response has it
-    // inlined.
+    // The RouteConfiguration to use for this listener.
+    // Present only if it is inlined in the LDS response.
     absl::optional<RdsUpdate> rds_update;
 
     bool operator==(const LdsUpdate& other) const {
@@ -228,7 +302,7 @@ class XdsApi {
       std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
       ClusterLoadReport>;
 
-  XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node);
+  XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap* bootstrap);
 
   // Creates an ADS request.
   // Takes ownership of \a error.
@@ -238,19 +312,25 @@ class XdsApi {
                               const std::string& nonce, grpc_error* error,
                               bool populate_node);
 
-  // Parses the ADS response and outputs the validated update for either CDS or
-  // EDS. If the response can't be parsed at the top level, \a type_url will
-  // point to an empty string; otherwise, it will point to the received data.
-  grpc_error* ParseAdsResponse(
+  // Parses an ADS response.
+  // If the response can't be parsed at the top level, the resulting
+  // type_url will be empty.
+  struct AdsParseResult {
+    grpc_error* parse_error = GRPC_ERROR_NONE;
+    std::string version;
+    std::string nonce;
+    std::string type_url;
+    absl::optional<LdsUpdate> lds_update;
+    absl::optional<RdsUpdate> rds_update;
+    CdsUpdateMap cds_update_map;
+    EdsUpdateMap eds_update_map;
+  };
+  AdsParseResult ParseAdsResponse(
       const grpc_slice& encoded_response,
       const std::string& expected_server_name,
       const std::set<absl::string_view>& expected_route_configuration_names,
       const std::set<absl::string_view>& expected_cluster_names,
-      const std::set<absl::string_view>& expected_eds_service_names,
-      absl::optional<LdsUpdate>* lds_update,
-      absl::optional<RdsUpdate>* rds_update, CdsUpdateMap* cds_update_map,
-      EdsUpdateMap* eds_update_map, std::string* version, std::string* nonce,
-      std::string* type_url);
+      const std::set<absl::string_view>& expected_eds_service_names);
 
   // Creates an LRS request querying \a server_name.
   grpc_slice CreateLrsInitialRequest(const std::string& server_name);
@@ -269,12 +349,12 @@ class XdsApi {
  private:
   XdsClient* client_;
   TraceFlag* tracer_;
-  const bool xds_routing_enabled_;
-  const XdsBootstrap::Node* node_;
+  const bool use_v3_;
+  const XdsBootstrap* bootstrap_;  // Do not own.
   const std::string build_version_;
   const std::string user_agent_name_;
 };
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_API_H */
+#endif /* GRPC_CORE_EXT_XDS_XDS_API_H */

data/src/core/ext/{filters/client_channel/xds → xds}/xds_bootstrap.cc

@@ -16,19 +16,18 @@
 
 #include <grpc/support/port_platform.h>
 
-#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_bootstrap.h"
 
 #include <vector>
 
 #include <errno.h>
 #include <stdlib.h>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/string_util.h>
-
 #include "src/core/lib/gpr/env.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/load_file.h"
@@ -36,6 +35,10 @@
 
 namespace grpc_core {
 
+bool XdsBootstrap::XdsServer::ShouldUseV3() const {
+  return server_features.find("xds_v3") != server_features.end();
+}
+
 namespace {
 
 std::string BootstrapString(const XdsBootstrap& bootstrap) {
@@ -66,7 +69,13 @@ std::string BootstrapString(const XdsBootstrap& bootstrap) {
     parts.push_back(absl::StrFormat("      {type=\"%s\", config=%s},\n",
                                     creds.type, creds.config.Dump()));
   }
-  parts.push_back("    ]\n  }\n]");
+  parts.push_back("    ],\n");
+  if (!bootstrap.server().server_features.empty()) {
+    parts.push_back(absl::StrCat(
+        "    server_features=[",
+        absl::StrJoin(bootstrap.server().server_features, ", "), "],\n"));
+  }
+  parts.push_back("  }\n]");
   return absl::StrJoin(parts, "");
 }
 
@@ -98,11 +107,9 @@ std::unique_ptr<XdsBootstrap> XdsBootstrap::ReadFromFile(XdsClient* client,
   Json json = Json::Parse(contents_str_view, error);
   grpc_slice_unref_internal(contents);
   if (*error != GRPC_ERROR_NONE) {
-    char* msg;
-    gpr_asprintf(&msg, "Failed to parse bootstrap file %s", path.get());
-    grpc_error* error_out =
-        GRPC_ERROR_CREATE_REFERENCING_FROM_COPIED_STRING(msg, error, 1);
-    gpr_free(msg);
+    grpc_error* error_out = GRPC_ERROR_CREATE_REFERENCING_FROM_COPIED_STRING(
+        absl::StrCat("Failed to parse bootstrap file ", path.get()).c_str(),
+        error, 1);
     GRPC_ERROR_UNREF(*error);
     *error = error_out;
     return nullptr;
@@ -154,10 +161,8 @@ grpc_error* XdsBootstrap::ParseXdsServerList(Json* json) {
   for (size_t i = 0; i < json->mutable_array()->size(); ++i) {
     Json& child = json->mutable_array()->at(i);
     if (child.type() != Json::Type::OBJECT) {
-      char* msg;
-      gpr_asprintf(&msg, "array element %" PRIuPTR " is not an object", i);
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-      gpr_free(msg);
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("array element ", i, " is not an object").c_str()));
     } else {
       grpc_error* parse_error = ParseXdsServer(&child, i);
       if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
@@ -191,13 +196,21 @@ grpc_error* XdsBootstrap::ParseXdsServer(Json* json, size_t idx) {
       if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
     }
   }
+  it = json->mutable_object()->find("server_features");
+  if (it != json->mutable_object()->end()) {
+    if (it->second.type() != Json::Type::ARRAY) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "\"server_features\" field is not an array"));
+    } else {
+      grpc_error* parse_error = ParseServerFeaturesArray(&it->second, &server);
+      if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
+    }
+  }
   // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
   // string is not static in this case.
   if (error_list.empty()) return GRPC_ERROR_NONE;
-  char* msg;
-  gpr_asprintf(&msg, "errors parsing index %" PRIuPTR, idx);
-  grpc_error* error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-  gpr_free(msg);
+  grpc_error* error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+      absl::StrCat("errors parsing index ", idx).c_str());
   for (size_t i = 0; i < error_list.size(); ++i) {
     error = grpc_error_add_child(error, error_list[i]);
   }
@@ -210,10 +223,8 @@ grpc_error* XdsBootstrap::ParseChannelCredsArray(Json* json,
   for (size_t i = 0; i < json->mutable_array()->size(); ++i) {
     Json& child = json->mutable_array()->at(i);
     if (child.type() != Json::Type::OBJECT) {
-      char* msg;
-      gpr_asprintf(&msg, "array element %" PRIuPTR " is not an object", i);
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg));
-      gpr_free(msg);
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("array element ", i, " is not an object").c_str()));
     } else {
       grpc_error* parse_error = ParseChannelCreds(&child, i, server);
       if (parse_error != GRPC_ERROR_NONE) error_list.push_back(parse_error);
@@ -252,16 +263,36 @@ grpc_error* XdsBootstrap::ParseChannelCreds(Json* json, size_t idx,
   // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
   // string is not static in this case.
   if (error_list.empty()) return GRPC_ERROR_NONE;
-  char* msg;
-  gpr_asprintf(&msg, "errors parsing index %" PRIuPTR, idx);
-  grpc_error* error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-  gpr_free(msg);
+  grpc_error* error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+      absl::StrCat("errors parsing index ", idx).c_str());
   for (size_t i = 0; i < error_list.size(); ++i) {
     error = grpc_error_add_child(error, error_list[i]);
   }
   return error;
 }
 
+grpc_error* XdsBootstrap::ParseServerFeaturesArray(Json* json,
+                                                   XdsServer* server) {
+  std::vector<grpc_error*> error_list;
+  for (size_t i = 0; i < json->mutable_array()->size(); ++i) {
+    Json& child = json->mutable_array()->at(i);
+    if (child.type() == Json::Type::STRING &&
+        child.string_value() == "xds_v3") {
+      // TODO(roth): Remove env var check once we do interop testing and
+      // are sure that the v3 code actually works.
+      grpc_core::UniquePtr<char> enable_str(
+          gpr_getenv("GRPC_XDS_EXPERIMENTAL_V3_SUPPORT"));
+      bool enabled = false;
+      if (gpr_parse_bool_value(enable_str.get(), &enabled) && enabled) {
+        server->server_features.insert(
+            std::move(*child.mutable_string_value()));
+      }
+    }
+  }
+  return GRPC_ERROR_CREATE_FROM_VECTOR(
+      "errors parsing \"server_features\" array", &error_list);
+}
+
 grpc_error* XdsBootstrap::ParseNode(Json* json) {
   std::vector<grpc_error*> error_list;
   node_ = absl::make_unique<Node>();

data/src/core/ext/{filters/client_channel/xds → xds}/xds_bootstrap.h

@@ -14,12 +14,13 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_BOOTSTRAP_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_BOOTSTRAP_H
+#ifndef GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H
+#define GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H
 
 #include <grpc/support/port_platform.h>
 
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
@@ -55,6 +56,9 @@ class XdsBootstrap {
   struct XdsServer {
     std::string server_uri;
     absl::InlinedVector<ChannelCreds, 1> channel_creds;
+    std::set<std::string> server_features;
+
+    bool ShouldUseV3() const;
   };
 
   // If *error is not GRPC_ERROR_NONE after returning, then there was an
@@ -76,6 +80,7 @@ class XdsBootstrap {
   grpc_error* ParseXdsServer(Json* json, size_t idx);
   grpc_error* ParseChannelCredsArray(Json* json, XdsServer* server);
   grpc_error* ParseChannelCreds(Json* json, size_t idx, XdsServer* server);
+  grpc_error* ParseServerFeaturesArray(Json* json, XdsServer* server);
   grpc_error* ParseNode(Json* json);
   grpc_error* ParseLocality(Json* json);
 
@@ -85,4 +90,4 @@ class XdsBootstrap {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_BOOTSTRAP_H */
+#endif /* GRPC_CORE_EXT_XDS_XDS_BOOTSTRAP_H */

data/src/core/ext/{filters/client_channel/xds → xds}/xds_channel.h

@@ -16,14 +16,14 @@
  *
  */
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CHANNEL_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CHANNEL_H
+#ifndef GRPC_CORE_EXT_XDS_XDS_CHANNEL_H
+#define GRPC_CORE_EXT_XDS_XDS_CHANNEL_H
 
 #include <grpc/support/port_platform.h>
 
 #include <grpc/impl/codegen/grpc_types.h>
 
-#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
+#include "src/core/ext/xds/xds_bootstrap.h"
 #include "src/core/lib/iomgr/error.h"
 
 namespace grpc_core {
@@ -42,5 +42,5 @@ grpc_channel* CreateXdsChannel(const XdsBootstrap& bootstrap,
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CHANNEL_H \
+#endif /* GRPC_CORE_EXT_XDS_XDS_CHANNEL_H \
         */

data/src/core/ext/{filters/client_channel/xds → xds}/xds_channel_args.h

@@ -14,8 +14,8 @@
 // limitations under the License.
 //
 
-#ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CHANNEL_ARGS_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CHANNEL_ARGS_H
+#ifndef GRPC_CORE_EXT_XDS_XDS_CHANNEL_ARGS_H
+#define GRPC_CORE_EXT_XDS_XDS_CHANNEL_ARGS_H
 
 // Boolean channel arg indicating whether the target is an xds server.
 #define GRPC_ARG_ADDRESS_IS_XDS_SERVER "grpc.address_is_xds_server"
@@ -23,4 +23,4 @@
 // Pointer channel arg containing a ref to the XdsClient object.
 #define GRPC_ARG_XDS_CLIENT "grpc.xds_client"
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CHANNEL_ARGS_H */
+#endif /* GRPC_CORE_EXT_XDS_XDS_CHANNEL_ARGS_H */