grpc 1.30.2 → 1.31.0.pre1

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

@@ -30,6 +30,7 @@
 
 #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"
@@ -46,12 +47,74 @@ class XdsApi {
   static const char* kEdsTypeUrl;
 
   struct RdsUpdate {
+    // TODO(donnadionne): When we can use absl::variant<>, consider using that
+    // for: PathMatcher, HeaderMatcher, cluster_name and weighted_clusters
     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.
+      // 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;
@@ -60,14 +123,16 @@ class XdsApi {
         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 (service == other.service && method == other.method &&
+        return (matchers == other.matchers &&
                 cluster_name == other.cluster_name &&
                 weighted_clusters == other.weighted_clusters);
       }
+      std::string ToString() const;
     };
 
     std::vector<RdsRoute> routes;
@@ -75,6 +140,7 @@ class XdsApi {
     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
@@ -269,7 +335,6 @@ class XdsApi {
  private:
   XdsClient* client_;
   TraceFlag* tracer_;
-  const bool xds_routing_enabled_;
   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

@@ -23,12 +23,11 @@
 #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"
@@ -98,11 +97,9 @@ std::unique_ptr 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 +151,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);
@@ -194,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]);
   }
@@ -210,10 +203,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,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]);
   }

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

@@ -30,7 +30,6 @@
 #include <grpc/byte_buffer_reader.h>
 #include <grpc/grpc.h>
 #include <grpc/support/alloc.h>
-#include <grpc/support/string_util.h>
 #include <grpc/support/time.h>
 
 #include "src/core/ext/filters/client_channel/client_channel.h"
@@ -180,13 +179,11 @@ class XdsClient::ChannelState::AdsCallState
     void OnTimerLocked(grpc_error* error) {
       if (error == GRPC_ERROR_NONE && timer_pending_) {
         timer_pending_ = false;
-        char* msg;
-        gpr_asprintf(
-            &msg,
-            "timeout obtaining resource {type=%s name=%s} from xds server",
-            type_url_.c_str(), name_.c_str());
-        grpc_error* watcher_error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(msg);
-        gpr_free(msg);
+        grpc_error* watcher_error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+            absl::StrFormat(
+                "timeout obtaining resource {type=%s name=%s} from xds server",
+                type_url_, name_)
+                .c_str());
         if (GRPC_TRACE_FLAG_ENABLED(grpc_xds_client_trace)) {
           gpr_log(GPR_INFO, "[xds_client %p] %s", ads_calld_->xds_client(),
                   grpc_error_string(watcher_error));
@@ -894,14 +891,12 @@ void XdsClient::ChannelState::AdsCallState::AcceptLdsUpdate(
                  ? lds_update->route_config_name.c_str()
                  : "<inlined>"));
     if (lds_update->rds_update.has_value()) {
-      gpr_log(GPR_INFO, "  RouteConfiguration contains %" PRIuPTR " routes",
+      gpr_log(GPR_INFO, "RouteConfiguration contains %" PRIuPTR " routes",
               lds_update->rds_update.value().routes.size());
-      for (const auto& route : lds_update->rds_update.value().routes) {
-        gpr_log(GPR_INFO,
-                "  route: { service=\"%s\", "
-                "method=\"%s\" }, cluster=\"%s\" }",
-                route.service.c_str(), route.method.c_str(),
-                route.cluster_name.c_str());
+      for (size_t i = 0; i < lds_update->rds_update.value().routes.size();
+           ++i) {
+        gpr_log(GPR_INFO, "Route %" PRIuPTR ":\n%s", i,
+                lds_update->rds_update.value().routes[i].ToString().c_str());
       }
     }
   }
@@ -959,12 +954,9 @@ void XdsClient::ChannelState::AdsCallState::AcceptRdsUpdate(
             "[xds_client %p] RDS update received;  RouteConfiguration contains "
             "%" PRIuPTR " routes",
             this, rds_update.value().routes.size());
-    for (const auto& route : rds_update.value().routes) {
-      gpr_log(GPR_INFO,
-              "  route: { service=\"%s\", "
-              "method=\"%s\" }, cluster=\"%s\" }",
-              route.service.c_str(), route.method.c_str(),
-              route.cluster_name.c_str());
+    for (size_t i = 0; i < rds_update.value().routes.size(); ++i) {
+      gpr_log(GPR_INFO, "Route %" PRIuPTR ":\n%s", i,
+              rds_update.value().routes[i].ToString().c_str());
     }
   }
   auto& rds_state = state_map_[XdsApi::kRdsTypeUrl];
@@ -1097,8 +1089,8 @@ void XdsClient::ChannelState::AdsCallState::AcceptEdsUpdate(
                   "[xds_client %p] Priority %" PRIuPTR ", locality %" PRIuPTR
                   " %s has weight %d, contains %" PRIuPTR " server addresses",
                   xds_client(), priority, locality_count,
-                  locality.name->AsHumanReadableString(), locality.lb_weight,
-                  locality.serverlist.size());
+                  locality.name->AsHumanReadableString().c_str(),
+                  locality.lb_weight, locality.serverlist.size());
           for (size_t i = 0; i < locality.serverlist.size(); ++i) {
             std::string ipport = grpc_sockaddr_to_string(
                 &locality.serverlist[i].address(), false);
@@ -1106,7 +1098,8 @@ void XdsClient::ChannelState::AdsCallState::AcceptEdsUpdate(
                     "[xds_client %p] Priority %" PRIuPTR ", locality %" PRIuPTR
                     " %s, server address %" PRIuPTR ": %s",
                     xds_client(), priority, locality_count,
-                    locality.name->AsHumanReadableString(), i, ipport.c_str());
+                    locality.name->AsHumanReadableString().c_str(), i,
+                    ipport.c_str());
           }
           ++locality_count;
         }
@@ -2024,17 +2017,103 @@ std::string CreateServiceConfigActionCluster(const std::string& cluster_name) {
 }
 
 std::string CreateServiceConfigRoute(const std::string& action_name,
-                                     const std::string& service,
-                                     const std::string& method) {
+                                     const XdsApi::RdsUpdate::RdsRoute& route) {
+  std::vector<std::string> headers;
+  for (const auto& header : route.matchers.header_matchers) {
+    std::string header_matcher;
+    switch (header.type) {
+      case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
+          HeaderMatcherType::EXACT:
+        header_matcher = absl::StrFormat("             \"exact_match\": \"%s\"",
+                                         header.string_matcher);
+        break;
+      case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
+          HeaderMatcherType::REGEX:
+        header_matcher = absl::StrFormat("             \"regex_match\": \"%s\"",
+                                         header.regex_match->pattern());
+        break;
+      case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
+          HeaderMatcherType::RANGE:
+        header_matcher = absl::StrFormat(
+            "             \"range_match\":{\n"
+            "              \"start\":%d,\n"
+            "              \"end\":%d\n"
+            "             }",
+            header.range_start, header.range_end);
+        break;
+      case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
+          HeaderMatcherType::PRESENT:
+        header_matcher =
+            absl::StrFormat("             \"present_match\": %s",
+                            header.present_match ? "true" : "false");
+        break;
+      case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
+          HeaderMatcherType::PREFIX:
+        header_matcher = absl::StrFormat(
+            "             \"prefix_match\": \"%s\"", header.string_matcher);
+        break;
+      case XdsApi::RdsUpdate::RdsRoute::Matchers::HeaderMatcher::
+          HeaderMatcherType::SUFFIX:
+        header_matcher = absl::StrFormat(
+            "             \"suffix_match\": \"%s\"", header.string_matcher);
+        break;
+      default:
+        break;
+    }
+    std::vector<std::string> header_parts;
+    header_parts.push_back(
+        absl::StrFormat("           { \n"
+                        "             \"name\": \"%s\",\n",
+                        header.name));
+    header_parts.push_back(header_matcher);
+    if (header.invert_match) {
+      header_parts.push_back(
+          absl::StrFormat(",\n"
+                          "             \"invert_match\": true"));
+    }
+    header_parts.push_back(
+        absl::StrFormat("\n"
+                        "           }"));
+    headers.push_back(absl::StrJoin(header_parts, ""));
+  }
+  std::vector<std::string> headers_service_config;
+  if (!headers.empty()) {
+    headers_service_config.push_back("\"headers\":[\n");
+    headers_service_config.push_back(absl::StrJoin(headers, ","));
+    headers_service_config.push_back("           ],\n");
+  }
+  std::string path_match_str;
+  switch (route.matchers.path_matcher.type) {
+    case XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::PathMatcherType::
+        PREFIX:
+      path_match_str = absl::StrFormat(
+          "\"prefix\": \"%s\",\n", route.matchers.path_matcher.string_matcher);
+      break;
+    case XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::PathMatcherType::
+        PATH:
+      path_match_str = absl::StrFormat(
+          "\"path\": \"%s\",\n", route.matchers.path_matcher.string_matcher);
+      break;
+    case XdsApi::RdsUpdate::RdsRoute::Matchers::PathMatcher::PathMatcherType::
+        REGEX:
+      path_match_str =
+          absl::StrFormat("\"regex\": \"%s\",\n",
+                          route.matchers.path_matcher.regex_matcher->pattern());
+      break;
+  }
   return absl::StrFormat(
       "      { \n"
-      "         \"methodName\": {\n"
-      "           \"service\": \"%s\",\n"
-      "           \"method\": \"%s\"\n"
-      "        },\n"
-      "        \"action\": \"%s\"\n"
+      "           %s"
+      "           %s"
+      "           %s"
+      "           \"action\": \"%s\"\n"
       "      }",
-      service, method, action_name);
+      path_match_str, absl::StrJoin(headers_service_config, ""),
+      route.matchers.fraction_per_million.has_value()
+          ? absl::StrFormat("\"match_fraction\":%d,\n",
+                            route.matchers.fraction_per_million.value())
+          : "",
+      action_name);
 }
 
 // Create the service config for one weighted cluster.
@@ -2216,7 +2295,7 @@ grpc_error* XdsClient::CreateServiceConfig(
         absl::StrFormat("%s:%s",
                         route.weighted_clusters.empty() ? "cds" : "weighted",
                         action_name),
-        route.service, route.method));
+        route));
   }
   std::vector<std::string> config_parts;
   config_parts.push_back(

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

@@ -22,11 +22,12 @@
 #include <grpc/support/port_platform.h>
 
 #include <map>
+#include <string>
 
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_format.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/support/string_util.h>
-
 #include "src/core/lib/gprpp/atomic.h"
 #include "src/core/lib/gprpp/memory.h"
 #include "src/core/lib/gprpp/ref_counted.h"
@@ -79,21 +80,20 @@ class XdsLocalityName : public RefCounted {
   const std::string& zone() const { return zone_; }
   const std::string& sub_zone() const { return sub_zone_; }
 
-  const char* AsHumanReadableString() {
-    if (human_readable_string_ == nullptr) {
-      char* tmp;
-      gpr_asprintf(&tmp, "{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
-                   region_.c_str(), zone_.c_str(), sub_zone_.c_str());
-      human_readable_string_.reset(tmp);
+  const std::string& AsHumanReadableString() {
+    if (human_readable_string_.empty()) {
+      human_readable_string_ =
+          absl::StrFormat("{region=\"%s\", zone=\"%s\", sub_zone=\"%s\"}",
+                          region_, zone_, sub_zone_);
     }
-    return human_readable_string_.get();
+    return human_readable_string_;
   }
 
  private:
   std::string region_;
   std::string zone_;
   std::string sub_zone_;
-  UniquePtr<char> human_readable_string_;
+  std::string human_readable_string_;
 };
 
 // Drop stats for an xds cluster.

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -23,12 +23,12 @@
 #include <string>
 #include <vector>
 
+#include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 #include "absl/strings/str_join.h"
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
-#include <grpc/support/string_util.h>
 
 #include "src/core/ext/filters/http/client/http_client_filter.h"
 #include "src/core/lib/gpr/string.h"
@@ -121,8 +121,8 @@ static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
     } else {
       char* val = grpc_dump_slice(GRPC_MDVALUE(b->idx.named.status->md),
                                   GPR_DUMP_ASCII);
-      char* msg;
-      gpr_asprintf(&msg, "Received http2 header with status: %s", val);
+      std::string msg =
+          absl::StrCat("Received http2 header with status: ", val);
       grpc_error* e = grpc_error_set_str(
           grpc_error_set_int(
               grpc_error_set_str(
@@ -131,9 +131,9 @@ static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
                   GRPC_ERROR_STR_VALUE, grpc_slice_from_copied_string(val)),
               GRPC_ERROR_INT_GRPC_STATUS,
               grpc_http2_status_to_grpc_status(atoi(val))),
-          GRPC_ERROR_STR_GRPC_MESSAGE, grpc_slice_from_copied_string(msg));
+          GRPC_ERROR_STR_GRPC_MESSAGE,
+          grpc_slice_from_cpp_string(std::move(msg)));
       gpr_free(val);
-      gpr_free(msg);
       return e;
     }
   }