grpc 1.28.0.pre2 → 1.31.0.pre1

data/src/core/ext/filters/client_channel/xds/xds_api.h

@@ -25,15 +25,20 @@
 
 #include <set>
 
+#include "absl/container/inlined_vector.h"
+#include "absl/types/optional.h"
+
 #include <grpc/slice_buffer.h>
 
+#include "re2/re2.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/lib/gprpp/optional.h"
 
 namespace grpc_core {
 
+class XdsClient;
+
 class XdsApi {
  public:
   static const char* kLdsTypeUrl;
@@ -42,16 +47,115 @@ class XdsApi {
   static const char* kEdsTypeUrl;
 
   struct RdsUpdate {
-    // The name to use in the CDS request.
-    std::string cluster_name;
+    // TODO(donnadionne): When we can use absl::variant<>, consider using that
+    // for: PathMatcher, HeaderMatcher, cluster_name and weighted_clusters
+    struct RdsRoute {
+      // 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;
+          bool operator==(const PathMatcher& other) const {
+            if (type != other.type) return false;
+            if (type == PathMatcherType::REGEX) {
+              // Should never be null.
+              if (regex_matcher == nullptr || other.regex_matcher == nullptr) {
+                return false;
+              }
+              return regex_matcher->pattern() == other.regex_matcher->pattern();
+            }
+            return string_matcher == other.string_matcher;
+          }
+          std::string ToString() const;
+        };
+        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;
+          bool operator==(const HeaderMatcher& other) const {
+            return (name == other.name && type == other.type &&
+                    range_start == other.range_start &&
+                    range_end == other.range_end &&
+                    string_matcher == other.string_matcher &&
+                    present_match == other.present_match &&
+                    invert_match == other.invert_match);
+          }
+          std::string ToString() const;
+        };
+        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;
+      };
+      Matchers matchers;
+      // Action for this route.
+      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 RdsRoute& other) const {
+        return (matchers == other.matchers &&
+                cluster_name == other.cluster_name &&
+                weighted_clusters == other.weighted_clusters);
+      }
+      std::string ToString() const;
+    };
+
+    std::vector<RdsRoute> routes;
+
+    bool operator==(const RdsUpdate& other) const {
+      return routes == other.routes;
+    }
+    std::string ToString() const;
   };
 
+  // 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.
   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.
-    Optional<RdsUpdate> rds_update;
+    absl::optional<RdsUpdate> rds_update;
+
+    bool operator==(const LdsUpdate& other) const {
+      return route_config_name == other.route_config_name &&
+             rds_update == other.rds_update;
+    }
   };
 
   using LdsUpdateMap = std::map<std::string /*server_name*/, LdsUpdate>;
@@ -66,7 +170,7 @@ class XdsApi {
     // If not set, load reporting will be disabled.
     // If set to the empty string, will use the same server we obtained the CDS
     // data from.
-    Optional<std::string> lrs_load_reporting_server_name;
+    absl::optional<std::string> lrs_load_reporting_server_name;
   };
 
   using CdsUpdateMap = std::map<std::string /*cluster_name*/, CdsUpdate>;
@@ -126,7 +230,7 @@ class XdsApi {
     }
 
    private:
-    InlinedVector<LocalityMap, 2> priorities_;
+    absl::InlinedVector<LocalityMap, 2> priorities_;
   };
 
   // There are two phases of accessing this class's content:
@@ -145,11 +249,12 @@ class XdsApi {
       const uint32_t parts_per_million;
     };
 
-    using DropCategoryList = InlinedVector<DropCategory, 2>;
+    using DropCategoryList = absl::InlinedVector<DropCategory, 2>;
 
     void AddCategory(std::string name, uint32_t parts_per_million) {
       drop_category_list_.emplace_back(
           DropCategory{std::move(name), parts_per_million});
+      if (parts_per_million == 1000000) drop_all_ = true;
     }
 
     // The only method invoked from the data plane combiner.
@@ -159,6 +264,8 @@ class XdsApi {
       return drop_category_list_;
     }
 
+    bool drop_all() const { return drop_all_; }
+
     bool operator==(const DropConfig& other) const {
       return drop_category_list_ == other.drop_category_list_;
     }
@@ -166,19 +273,19 @@ class XdsApi {
 
    private:
     DropCategoryList drop_category_list_;
+    bool drop_all_ = false;
   };
 
   struct EdsUpdate {
     PriorityListUpdate priority_list_update;
     RefCountedPtr<DropConfig> drop_config;
-    bool drop_all = false;
   };
 
   using EdsUpdateMap = std::map<std::string /*eds_service_name*/, EdsUpdate>;
 
   struct ClusterLoadReport {
     XdsClusterDropStats::DroppedRequestsMap dropped_requests;
-    std::map<XdsLocalityName*, XdsClusterLocalityStats::Snapshot,
+    std::map<RefCountedPtr<XdsLocalityName>, XdsClusterLocalityStats::Snapshot,
              XdsLocalityName::Less>
         locality_stats;
     grpc_millis load_report_interval;
@@ -187,38 +294,12 @@ class XdsApi {
       std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
       ClusterLoadReport>;
 
-  explicit XdsApi(const XdsBootstrap::Node* node);
-
-  // Creates a request to nack an unsupported resource type.
-  // Takes ownership of \a error.
-  grpc_slice CreateUnsupportedTypeNackRequest(const std::string& type_url,
-                                              const std::string& nonce,
-                                              grpc_error* error);
-
-  // Creates an LDS request querying \a server_name.
-  // Takes ownership of \a error.
-  grpc_slice CreateLdsRequest(const std::string& server_name,
-                              const std::string& version,
-                              const std::string& nonce, grpc_error* error,
-                              bool populate_node);
-
-  // Creates an RDS request querying \a route_config_name.
-  // Takes ownership of \a error.
-  grpc_slice CreateRdsRequest(const std::string& route_config_name,
-                              const std::string& version,
-                              const std::string& nonce, grpc_error* error,
-                              bool populate_node);
-
-  // Creates a CDS request querying \a cluster_names.
-  // Takes ownership of \a error.
-  grpc_slice CreateCdsRequest(const std::set<StringView>& cluster_names,
-                              const std::string& version,
-                              const std::string& nonce, grpc_error* error,
-                              bool populate_node);
+  XdsApi(XdsClient* client, TraceFlag* tracer, const XdsBootstrap::Node* node);
 
-  // Creates an EDS request querying \a eds_service_names.
+  // Creates an ADS request.
   // Takes ownership of \a error.
-  grpc_slice CreateEdsRequest(const std::set<StringView>& eds_service_names,
+  grpc_slice CreateAdsRequest(const std::string& type_url,
+                              const std::set<absl::string_view>& resource_names,
                               const std::string& version,
                               const std::string& nonce, grpc_error* error,
                               bool populate_node);
@@ -229,11 +310,13 @@ class XdsApi {
   grpc_error* ParseAdsResponse(
       const grpc_slice& encoded_response,
       const std::string& expected_server_name,
-      const std::string& expected_route_config_name,
-      const std::set<StringView>& expected_eds_service_names,
-      LdsUpdate* lds_update, 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_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);
 
   // Creates an LRS request querying \a server_name.
   grpc_slice CreateLrsInitialRequest(const std::string& server_name);
@@ -245,10 +328,13 @@ class XdsApi {
   // load_reporting_interval for client-side load reporting. If there is any
   // error, the output config is invalid.
   grpc_error* ParseLrsResponse(const grpc_slice& encoded_response,
+                               bool* send_all_clusters,
                                std::set<std::string>* cluster_names,
                                grpc_millis* load_reporting_interval);
 
  private:
+  XdsClient* client_;
+  TraceFlag* tracer_;
   const XdsBootstrap::Node* node_;
   const std::string build_version_;
   const std::string user_agent_name_;

data/src/core/ext/filters/client_channel/xds/xds_bootstrap.cc

@@ -18,31 +18,100 @@
 
 #include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
 
+#include <vector>
+
 #include <errno.h>
 #include <stdlib.h>
 
-#include <grpc/support/string_util.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 "src/core/lib/gpr/env.h"
+#include "src/core/lib/gpr/string.h"
 #include "src/core/lib/iomgr/load_file.h"
 #include "src/core/lib/slice/slice_internal.h"
 
 namespace grpc_core {
 
-std::unique_ptr<XdsBootstrap> XdsBootstrap::ReadFromFile(grpc_error** error) {
+namespace {
+
+std::string BootstrapString(const XdsBootstrap& bootstrap) {
+  std::vector<std::string> parts;
+  if (bootstrap.node() != nullptr) {
+    parts.push_back(absl::StrFormat(
+        "node={\n"
+        "  id=\"%s\",\n"
+        "  cluster=\"%s\",\n"
+        "  locality={\n"
+        "    region=\"%s\",\n"
+        "    zone=\"%s\",\n"
+        "    subzone=\"%s\"\n"
+        "  },\n"
+        "  metadata=%s,\n"
+        "},\n",
+        bootstrap.node()->id, bootstrap.node()->cluster,
+        bootstrap.node()->locality_region, bootstrap.node()->locality_zone,
+        bootstrap.node()->locality_subzone, bootstrap.node()->metadata.Dump()));
+  }
+  parts.push_back(
+      absl::StrFormat("servers=[\n"
+                      "  {\n"
+                      "    uri=\"%s\",\n"
+                      "    creds=[\n",
+                      bootstrap.server().server_uri));
+  for (const auto& creds : bootstrap.server().channel_creds) {
+    parts.push_back(absl::StrFormat("      {type=\"%s\", config=%s},\n",
+                                    creds.type, creds.config.Dump()));
+  }
+  parts.push_back("    ]\n  }\n]");
+  return absl::StrJoin(parts, "");
+}
+
+}  // namespace
+
+std::unique_ptr<XdsBootstrap> XdsBootstrap::ReadFromFile(XdsClient* client,
+                                                         TraceFlag* tracer,
+                                                         grpc_error** error) {
   grpc_core::UniquePtr<char> path(gpr_getenv("GRPC_XDS_BOOTSTRAP"));
   if (path == nullptr) {
     *error = GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "GRPC_XDS_BOOTSTRAP env var not set");
+        "Environment variable GRPC_XDS_BOOTSTRAP not defined");
     return nullptr;
   }
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer)) {
+    gpr_log(GPR_INFO,
+            "[xds_client %p] Got bootstrap file location from "
+            "GRPC_XDS_BOOTSTRAP environment variable: %s",
+            client, path.get());
+  }
   grpc_slice contents;
   *error = grpc_load_file(path.get(), /*add_null_terminator=*/true, &contents);
   if (*error != GRPC_ERROR_NONE) return nullptr;
-  Json json = Json::Parse(StringViewFromSlice(contents), error);
+  absl::string_view contents_str_view = StringViewFromSlice(contents);
+  if (GRPC_TRACE_FLAG_ENABLED(*tracer)) {
+    gpr_log(GPR_DEBUG, "[xds_client %p] Bootstrap file contents: %s", client,
+            std::string(contents_str_view).c_str());
+  }
+  Json json = Json::Parse(contents_str_view, error);
   grpc_slice_unref_internal(contents);
-  if (*error != GRPC_ERROR_NONE) return nullptr;
-  return absl::make_unique<XdsBootstrap>(std::move(json), error);
+  if (*error != GRPC_ERROR_NONE) {
+    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;
+  }
+  std::unique_ptr<XdsBootstrap> result =
+      absl::make_unique<XdsBootstrap>(std::move(json), error);
+  if (*error == GRPC_ERROR_NONE && GRPC_TRACE_FLAG_ENABLED(*tracer)) {
+    gpr_log(GPR_INFO,
+            "[xds_client %p] Bootstrap config for creating xds client:\n%s",
+            client, BootstrapString(*result).c_str());
+  }
+  return result;
 }
 
 XdsBootstrap::XdsBootstrap(Json json, grpc_error** error) {
@@ -51,7 +120,7 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error** error) {
         "malformed JSON in bootstrap file");
     return;
   }
-  InlinedVector<grpc_error*, 1> error_list;
+  std::vector<grpc_error*> error_list;
   auto it = json.mutable_object()->find("xds_servers");
   if (it == json.mutable_object()->end()) {
     error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -78,14 +147,12 @@ XdsBootstrap::XdsBootstrap(Json json, grpc_error** error) {
 }
 
 grpc_error* XdsBootstrap::ParseXdsServerList(Json* json) {
-  InlinedVector<grpc_error*, 1> error_list;
+  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::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);
@@ -96,7 +163,7 @@ grpc_error* XdsBootstrap::ParseXdsServerList(Json* json) {
 }
 
 grpc_error* XdsBootstrap::ParseXdsServer(Json* json, size_t idx) {
-  InlinedVector<grpc_error*, 1> error_list;
+  std::vector<grpc_error*> error_list;
   servers_.emplace_back();
   XdsServer& server = servers_[servers_.size() - 1];
   auto it = json->mutable_object()->find("server_uri");
@@ -122,10 +189,8 @@ grpc_error* XdsBootstrap::ParseXdsServer(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]);
   }
@@ -134,14 +199,12 @@ grpc_error* XdsBootstrap::ParseXdsServer(Json* json, size_t idx) {
 
 grpc_error* XdsBootstrap::ParseChannelCredsArray(Json* json,
                                                  XdsServer* server) {
-  InlinedVector<grpc_error*, 1> error_list;
+  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::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);
@@ -153,7 +216,7 @@ grpc_error* XdsBootstrap::ParseChannelCredsArray(Json* json,
 
 grpc_error* XdsBootstrap::ParseChannelCreds(Json* json, size_t idx,
                                             XdsServer* server) {
-  InlinedVector<grpc_error*, 1> error_list;
+  std::vector<grpc_error*> error_list;
   ChannelCreds channel_creds;
   auto it = json->mutable_object()->find("type");
   if (it == json->mutable_object()->end()) {
@@ -180,10 +243,8 @@ 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]);
   }
@@ -191,7 +252,7 @@ grpc_error* XdsBootstrap::ParseChannelCreds(Json* json, size_t idx,
 }
 
 grpc_error* XdsBootstrap::ParseNode(Json* json) {
-  InlinedVector<grpc_error*, 1> error_list;
+  std::vector<grpc_error*> error_list;
   node_ = absl::make_unique<Node>();
   auto it = json->mutable_object()->find("id");
   if (it != json->mutable_object()->end()) {
@@ -235,7 +296,7 @@ grpc_error* XdsBootstrap::ParseNode(Json* json) {
 }
 
 grpc_error* XdsBootstrap::ParseLocality(Json* json) {
-  InlinedVector<grpc_error*, 1> error_list;
+  std::vector<grpc_error*> error_list;
   auto it = json->mutable_object()->find("region");
   if (it != json->mutable_object()->end()) {
     if (it->second.type() != Json::Type::STRING) {