grpc 1.43.1 → 1.44.0.pre2

data/src/core/lib/address_utils/parse_address.cc

@@ -37,6 +37,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
 #include "src/core/lib/iomgr/grpc_if_nametoindex.h"
@@ -318,3 +319,22 @@ uint16_t grpc_strhtons(const char* port) {
   }
   return htons(static_cast<unsigned short>(atoi(port)));
 }
+
+grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
+                                          const char* addr, int port) {
+  memset(out, 0, sizeof(grpc_resolved_address));
+  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
+  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
+  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
+    addr6->sin6_family = GRPC_AF_INET6;
+    out->len = sizeof(grpc_sockaddr_in6);
+  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
+    addr4->sin_family = GRPC_AF_INET;
+    out->len = sizeof(grpc_sockaddr_in);
+  } else {
+    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
+        absl::StrCat("Failed to parse address:", addr));
+  }
+  grpc_sockaddr_set_port(out, port);
+  return GRPC_ERROR_NONE;
+}

data/src/core/lib/address_utils/parse_address.h

@@ -61,6 +61,11 @@ bool grpc_parse_ipv6_hostport(absl::string_view hostport,
 /* Converts named or numeric port to a uint16 suitable for use in a sockaddr. */
 uint16_t grpc_strhtons(const char* port);
 
+// Newer form of grpc_string_to_sockaddr which returns an error instead of
+// crashing if \a addr is not IPv6/IPv6
+grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
+                                          const char* addr, int port);
+
 namespace grpc_core {
 
 /** Populate \a resolved_addr to be a unix socket at |path| */

data/src/core/lib/address_utils/sockaddr_utils.cc

@@ -29,16 +29,42 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
 
-#include <grpc/event_engine/event_engine.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
 #include "src/core/lib/gpr/string.h"
 #include "src/core/lib/gprpp/host_port.h"
-#include "src/core/lib/iomgr/event_engine/resolved_address_internal.h"
 #include "src/core/lib/iomgr/sockaddr.h"
 #include "src/core/lib/iomgr/socket_utils.h"
-#include "src/core/lib/iomgr/unix_sockets_posix.h"
+
+#ifdef GRPC_HAVE_UNIX_SOCKET
+#include <sys/un.h>
+#endif
+
+#ifdef GRPC_HAVE_UNIX_SOCKET
+static std::string grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* resolved_addr) {
+  const grpc_sockaddr* addr =
+      reinterpret_cast<const grpc_sockaddr*>(resolved_addr->addr);
+  if (addr->sa_family != AF_UNIX) {
+    return "";
+  }
+  const auto* unix_addr = reinterpret_cast<const struct sockaddr_un*>(addr);
+  if (unix_addr->sun_path[0] == '\0' && unix_addr->sun_path[1] != '\0') {
+    return absl::StrCat(
+        "unix-abstract:",
+        absl::string_view(
+            unix_addr->sun_path + 1,
+            resolved_addr->len - sizeof(unix_addr->sun_family) - 1));
+  }
+  return absl::StrCat("unix:", unix_addr->sun_path);
+}
+#else
+static std::string grpc_sockaddr_to_uri_unix_if_possible(
+    const grpc_resolved_address* /* addr */) {
+  return "";
+}
+#endif
 
 static const uint8_t kV4MappedPrefix[] = {0, 0, 0, 0, 0,    0,
                                           0, 0, 0, 0, 0xff, 0xff};
@@ -200,25 +226,6 @@ std::string grpc_sockaddr_to_string(const grpc_resolved_address* resolved_addr,
   return out;
 }
 
-grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
-                                          const char* addr, int port) {
-  memset(out, 0, sizeof(grpc_resolved_address));
-  grpc_sockaddr_in6* addr6 = reinterpret_cast<grpc_sockaddr_in6*>(out->addr);
-  grpc_sockaddr_in* addr4 = reinterpret_cast<grpc_sockaddr_in*>(out->addr);
-  if (grpc_inet_pton(GRPC_AF_INET6, addr, &addr6->sin6_addr) == 1) {
-    addr6->sin6_family = GRPC_AF_INET6;
-    out->len = sizeof(grpc_sockaddr_in6);
-  } else if (grpc_inet_pton(GRPC_AF_INET, addr, &addr4->sin_addr) == 1) {
-    addr4->sin_family = GRPC_AF_INET;
-    out->len = sizeof(grpc_sockaddr_in);
-  } else {
-    return GRPC_ERROR_CREATE_FROM_CPP_STRING(
-        absl::StrCat("Failed to parse address:", addr));
-  }
-  grpc_sockaddr_set_port(out, port);
-  return GRPC_ERROR_NONE;
-}
-
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* resolved_addr) {
   if (resolved_addr->len == 0) return "";
   grpc_resolved_address addr_normalized;
@@ -269,10 +276,11 @@ int grpc_sockaddr_get_port(const grpc_resolved_address* resolved_addr) {
     case GRPC_AF_INET6:
       return grpc_ntohs(
           (reinterpret_cast<const grpc_sockaddr_in6*>(addr))->sin6_port);
+#ifdef GRPC_HAVE_UNIX_SOCKET
+    case AF_UNIX:
+      return 1;
+#endif
     default:
-      if (grpc_is_unix_socket(resolved_addr)) {
-        return 1;
-      }
       gpr_log(GPR_ERROR, "Unknown socket family %d in grpc_sockaddr_get_port",
               addr->sa_family);
       return 0;
@@ -399,14 +407,3 @@ bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
   }
   return false;
 }
-
-namespace grpc_event_engine {
-namespace experimental {
-
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr) {
-  auto gra = CreateGRPCResolvedAddress(addr);
-  return grpc_sockaddr_to_uri(&gra);
-}
-
-}  // namespace experimental
-}  // namespace grpc_event_engine

data/src/core/lib/address_utils/sockaddr_utils.h

@@ -23,9 +23,7 @@
 
 #include <string>
 
-#include <grpc/event_engine/event_engine.h>
-
-#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/iomgr/resolved_address.h"
 
 /* Returns true if addr is an IPv4-mapped IPv6 address within the
    ::ffff:0.0.0.0/96 range, or false otherwise.
@@ -68,11 +66,6 @@ int grpc_sockaddr_set_port(grpc_resolved_address* addr, int port);
 std::string grpc_sockaddr_to_string(const grpc_resolved_address* addr,
                                     bool normalize) GRPC_MUST_USE_RESULT;
 
-// Newer form of grpc_string_to_sockaddr which returns an error instead of
-// crashing if \a addr is not IPv6/IPv6
-grpc_error_handle grpc_string_to_sockaddr(grpc_resolved_address* out,
-                                          const char* addr, int port);
-
 /* Returns the URI string corresponding to \a addr */
 std::string grpc_sockaddr_to_uri(const grpc_resolved_address* addr);
 
@@ -99,12 +92,4 @@ bool grpc_sockaddr_match_subnet(const grpc_resolved_address* address,
                                 const grpc_resolved_address* subnet_address,
                                 uint32_t mask_bits);
 
-namespace grpc_event_engine {
-namespace experimental {
-
-std::string ResolvedAddressToURI(const EventEngine::ResolvedAddress& addr);
-
-}  // namespace experimental
-}  // namespace grpc_event_engine
-
 #endif /* GRPC_CORE_LIB_ADDRESS_UTILS_SOCKADDR_UTILS_H */

data/src/core/lib/backoff/backoff.cc

@@ -26,31 +26,7 @@
 
 namespace grpc_core {
 
-namespace {
-
-/* Generate a random number between 0 and 1. We roll our own RNG because seeding
- * rand() modifies a global variable we have no control over. */
-double generate_uniform_random_number(uint32_t* rng_state) {
-  constexpr uint32_t two_raise_31 = uint32_t(1) << 31;
-  *rng_state = (1103515245 * *rng_state + 12345) % two_raise_31;
-  return *rng_state / static_cast<double>(two_raise_31);
-}
-
-double generate_uniform_random_number_between(uint32_t* rng_state, double a,
-                                              double b) {
-  if (a == b) return a;
-  if (a > b) std::swap(a, b);  // make sure a < b
-  const double range = b - a;
-  return a + generate_uniform_random_number(rng_state) * range;
-}
-
-}  // namespace
-
-BackOff::BackOff(const Options& options)
-    : options_(options),
-      rng_state_(static_cast<uint32_t>(gpr_now(GPR_CLOCK_REALTIME).tv_nsec)) {
-  Reset();
-}
+BackOff::BackOff(const Options& options) : options_(options) { Reset(); }
 
 grpc_millis BackOff::NextAttemptTime() {
   if (initial_) {
@@ -60,9 +36,9 @@ grpc_millis BackOff::NextAttemptTime() {
   current_backoff_ = static_cast<grpc_millis>(
       std::min(current_backoff_ * options_.multiplier(),
                static_cast<double>(options_.max_backoff())));
-  const double jitter = generate_uniform_random_number_between(
-      &rng_state_, -options_.jitter() * current_backoff_,
-      options_.jitter() * current_backoff_);
+  const double jitter =
+      absl::Uniform(rand_gen_, -options_.jitter() * current_backoff_,
+                    options_.jitter() * current_backoff_);
   const grpc_millis next_timeout =
       static_cast<grpc_millis>(current_backoff_ + jitter);
   return next_timeout + ExecCtx::Get()->Now();
@@ -73,6 +49,4 @@ void BackOff::Reset() {
   initial_ = true;
 }
 
-void BackOff::SetRandomSeed(uint32_t seed) { rng_state_ = seed; }
-
 }  // namespace grpc_core

data/src/core/lib/backoff/backoff.h

@@ -21,6 +21,8 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/random/random.h"
+
 #include "src/core/lib/iomgr/exec_ctx.h"
 
 namespace grpc_core {
@@ -41,8 +43,6 @@ class BackOff {
   /// will be the time of the second attempt (rather than the Nth).
   void Reset();
 
-  void SetRandomSeed(unsigned int seed);
-
   class Options {
    public:
     Options& set_initial_backoff(grpc_millis initial_backoff) {
@@ -79,7 +79,7 @@ class BackOff {
 
  private:
   const Options options_;
-  uint32_t rng_state_;
+  absl::BitGen rand_gen_;
   bool initial_;
   /// current delay before retries
   grpc_millis current_backoff_;

data/src/core/lib/channel/channel_args.cc

@@ -30,7 +30,6 @@
 #include "absl/strings/str_join.h"
 
 #include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>

data/src/core/lib/channel/channel_stack.cc

@@ -29,6 +29,7 @@
 #include "src/core/lib/gpr/alloc.h"
 
 grpc_core::TraceFlag grpc_trace_channel(false, "channel");
+grpc_core::TraceFlag grpc_trace_channel_stack(false, "channel_stack");
 
 /* Memory layouts.
 
@@ -105,6 +106,13 @@ grpc_error_handle grpc_channel_stack_init(
     const grpc_channel_filter** filters, size_t filter_count,
     const grpc_channel_args* channel_args, grpc_transport* optional_transport,
     const char* name, grpc_channel_stack* stack) {
+  if (grpc_trace_channel_stack.enabled()) {
+    gpr_log(GPR_INFO, "CHANNEL_STACK: init %s", name);
+    for (size_t i = 0; i < filter_count; i++) {
+      gpr_log(GPR_INFO, "CHANNEL_STACK:   filter %s", filters[i]->name);
+    }
+  }
+
   size_t call_size =
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(sizeof(grpc_call_stack)) +
       GPR_ROUND_UP_TO_ALIGNMENT_SIZE(filter_count * sizeof(grpc_call_element));

data/src/core/lib/channel/channel_stack.h

@@ -54,9 +54,9 @@
 
 #include "src/core/lib/debug/trace.h"
 #include "src/core/lib/gpr/time_precise.h"
-#include "src/core/lib/gprpp/arena.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/transport/transport.h"
 
 typedef struct grpc_channel_element grpc_channel_element;

data/src/core/lib/channel/channel_stack_builder.cc

@@ -51,7 +51,8 @@ struct grpc_channel_stack_builder_iterator {
   filter_node* node;
 };
 
-grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
+grpc_channel_stack_builder* grpc_channel_stack_builder_create(
+    const char* name) {
   grpc_channel_stack_builder* b =
       grpc_core::Zalloc<grpc_channel_stack_builder>();
   b->begin.filter = nullptr;
@@ -60,6 +61,7 @@ grpc_channel_stack_builder* grpc_channel_stack_builder_create(void) {
   b->begin.prev = &b->end;
   b->end.next = &b->begin;
   b->end.prev = &b->begin;
+  b->name = name;
   return b;
 }
 
@@ -69,9 +71,9 @@ void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
   b->target = gpr_strdup(target);
 }
 
-const char* grpc_channel_stack_builder_get_target(
+std::string grpc_channel_stack_builder_get_target(
     grpc_channel_stack_builder* b) {
-  return b->target;
+  return b->target == nullptr ? std::string("unknown") : std::string(b->target);
 }
 
 static grpc_channel_stack_builder_iterator* create_iterator_at_filter_node(
@@ -143,12 +145,6 @@ grpc_channel_stack_builder_iterator* grpc_channel_stack_builder_iterator_find(
 bool grpc_channel_stack_builder_move_prev(
     grpc_channel_stack_builder_iterator* iterator);
 
-void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
-                                         const char* name) {
-  GPR_ASSERT(builder->name == nullptr);
-  builder->name = name;
-}
-
 void grpc_channel_stack_builder_set_channel_arguments(
     grpc_channel_stack_builder* builder, const grpc_channel_args* args) {
   if (builder->args != nullptr) {

data/src/core/lib/channel/channel_stack_builder.h

@@ -32,18 +32,15 @@ typedef struct grpc_channel_stack_builder grpc_channel_stack_builder;
 typedef struct grpc_channel_stack_builder_iterator
     grpc_channel_stack_builder_iterator;
 
-/// Create a new channel stack builder
-grpc_channel_stack_builder* grpc_channel_stack_builder_create(void);
-
-/// Assign a name to the channel stack: \a name must be statically allocated
-void grpc_channel_stack_builder_set_name(grpc_channel_stack_builder* builder,
-                                         const char* name);
+/// Create a new channel stack builder.
+/// \a name must be statically allocated.
+grpc_channel_stack_builder* grpc_channel_stack_builder_create(const char* name);
 
 /// Set the target uri
 void grpc_channel_stack_builder_set_target(grpc_channel_stack_builder* b,
                                            const char* target);
 
-const char* grpc_channel_stack_builder_get_target(
+std::string grpc_channel_stack_builder_get_target(
     grpc_channel_stack_builder* b);
 
 /// Attach \a transport to the builder (does not take ownership)

data/src/core/lib/channel/channelz.cc

@@ -34,6 +34,7 @@
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/address_utils/parse_address.h"
 #include "src/core/lib/address_utils/sockaddr_utils.h"
 #include "src/core/lib/channel/channelz_registry.h"
 #include "src/core/lib/channel/status_util.h"

data/src/core/lib/compression/compression.cc

@@ -23,89 +23,47 @@
 
 #include <grpc/compression.h>
 
-#include "src/core/lib/compression/algorithm_metadata.h"
 #include "src/core/lib/compression/compression_internal.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/slice/slice_utils.h"
 #include "src/core/lib/surface/api_trace.h"
-#include "src/core/lib/transport/static_metadata.h"
 
-int grpc_compression_algorithm_is_message(
-    grpc_compression_algorithm algorithm) {
-  return (algorithm >= GRPC_COMPRESS_DEFLATE && algorithm <= GRPC_COMPRESS_GZIP)
-             ? 1
-             : 0;
+int grpc_compression_algorithm_is_message(grpc_compression_algorithm) {
+  return 1;
 }
 
-int grpc_compression_algorithm_is_stream(grpc_compression_algorithm algorithm) {
-  return (algorithm == GRPC_COMPRESS_STREAM_GZIP) ? 1 : 0;
+int grpc_compression_algorithm_is_stream(grpc_compression_algorithm) {
+  return 0;
 }
 
 int grpc_compression_algorithm_parse(grpc_slice name,
                                      grpc_compression_algorithm* algorithm) {
-  if (grpc_slice_eq_static_interned(name, GRPC_MDSTR_IDENTITY)) {
-    *algorithm = GRPC_COMPRESS_NONE;
-    return 1;
-  } else if (grpc_slice_eq_static_interned(name, GRPC_MDSTR_DEFLATE)) {
-    *algorithm = GRPC_COMPRESS_DEFLATE;
+  absl::optional<grpc_compression_algorithm> alg =
+      grpc_core::ParseCompressionAlgorithm(
+          grpc_core::StringViewFromSlice(name));
+  if (alg.has_value()) {
+    *algorithm = alg.value();
     return 1;
-  } else if (grpc_slice_eq_static_interned(name, GRPC_MDSTR_GZIP)) {
-    *algorithm = GRPC_COMPRESS_GZIP;
-    return 1;
-  } else if (grpc_slice_eq_static_interned(name,
-                                           GRPC_MDSTR_STREAM_SLASH_GZIP)) {
-    *algorithm = GRPC_COMPRESS_STREAM_GZIP;
-    return 1;
-  } else {
-    return 0;
   }
+  return 0;
 }
 
 int grpc_compression_algorithm_name(grpc_compression_algorithm algorithm,
                                     const char** name) {
   GRPC_API_TRACE("grpc_compression_algorithm_name(algorithm=%d, name=%p)", 2,
                  ((int)algorithm, name));
-  switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
-      *name = "identity";
-      return 1;
-    case GRPC_COMPRESS_DEFLATE:
-      *name = "deflate";
-      return 1;
-    case GRPC_COMPRESS_GZIP:
-      *name = "gzip";
-      return 1;
-    case GRPC_COMPRESS_STREAM_GZIP:
-      *name = "stream/gzip";
-      return 1;
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
-      return 0;
+  const char* result = grpc_core::CompressionAlgorithmAsString(algorithm);
+  if (result != nullptr) {
+    *name = result;
+    return 1;
   }
   return 0;
 }
 
 grpc_compression_algorithm grpc_compression_algorithm_for_level(
     grpc_compression_level level, uint32_t accepted_encodings) {
-  grpc_compression_algorithm algo;
-  if (level == GRPC_COMPRESS_LEVEL_NONE) {
-    return GRPC_COMPRESS_NONE;
-  } else if (level <= GRPC_COMPRESS_LEVEL_HIGH) {
-    // TODO(mxyan): Design algorithm to select from all algorithms, including
-    // stream compression algorithm
-    if (!grpc_compression_algorithm_from_message_stream_compression_algorithm(
-            &algo,
-            grpc_message_compression_algorithm_for_level(
-                level,
-                grpc_compression_bitset_to_message_bitset(accepted_encodings)),
-            static_cast<grpc_stream_compression_algorithm>(0))) {
-      gpr_log(GPR_ERROR, "Parse compression level error");
-      return GRPC_COMPRESS_NONE;
-    }
-    return algo;
-  } else {
-    gpr_log(GPR_ERROR, "Unknown compression level: %d", level);
-    return GRPC_COMPRESS_NONE;
-  }
+  return grpc_core::CompressionAlgorithmSet::FromUint32(accepted_encodings)
+      .CompressionAlgorithmForLevel(level);
 }
 
 void grpc_compression_options_init(grpc_compression_options* opts) {
@@ -127,57 +85,7 @@ void grpc_compression_options_disable_algorithm(
 int grpc_compression_options_is_algorithm_enabled(
     const grpc_compression_options* opts,
     grpc_compression_algorithm algorithm) {
-  return grpc_compression_options_is_algorithm_enabled_internal(opts,
-                                                                algorithm);
-}
-
-grpc_slice grpc_compression_algorithm_slice(
-    grpc_compression_algorithm algorithm) {
-  switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
-      return GRPC_MDSTR_IDENTITY;
-    case GRPC_COMPRESS_DEFLATE:
-      return GRPC_MDSTR_DEFLATE;
-    case GRPC_COMPRESS_GZIP:
-      return GRPC_MDSTR_GZIP;
-    case GRPC_COMPRESS_STREAM_GZIP:
-      return GRPC_MDSTR_STREAM_SLASH_GZIP;
-    case GRPC_COMPRESS_ALGORITHMS_COUNT:
-      return grpc_empty_slice();
-  }
-  return grpc_empty_slice();
-}
-
-grpc_compression_algorithm grpc_compression_algorithm_from_slice(
-    const grpc_slice& str) {
-  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_IDENTITY)) {
-    return GRPC_COMPRESS_NONE;
-  }
-  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_DEFLATE)) {
-    return GRPC_COMPRESS_DEFLATE;
-  }
-  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_GZIP)) {
-    return GRPC_COMPRESS_GZIP;
-  }
-  if (grpc_slice_eq_static_interned(str, GRPC_MDSTR_STREAM_SLASH_GZIP)) {
-    return GRPC_COMPRESS_STREAM_GZIP;
-  }
-  return GRPC_COMPRESS_ALGORITHMS_COUNT;
-}
-
-grpc_mdelem grpc_compression_encoding_mdelem(
-    grpc_compression_algorithm algorithm) {
-  switch (algorithm) {
-    case GRPC_COMPRESS_NONE:
-      return GRPC_MDELEM_GRPC_ENCODING_IDENTITY;
-    case GRPC_COMPRESS_DEFLATE:
-      return GRPC_MDELEM_GRPC_ENCODING_DEFLATE;
-    case GRPC_COMPRESS_GZIP:
-      return GRPC_MDELEM_GRPC_ENCODING_GZIP;
-    case GRPC_COMPRESS_STREAM_GZIP:
-      return GRPC_MDELEM_GRPC_ENCODING_GZIP;
-    default:
-      break;
-  }
-  return GRPC_MDNULL;
+  return grpc_core::CompressionAlgorithmSet::FromUint32(
+             opts->enabled_algorithms_bitset)
+      .IsSet(algorithm);
 }