grpc 1.72.0 → 1.73.0

data/src/core/config/core_configuration.h

@@ -16,6 +16,7 @@
 #define GRPC_SRC_CORE_CONFIG_CORE_CONFIGURATION_H
 
 #include <grpc/support/port_platform.h>
+#include <sys/stat.h>
 
 #include <atomic>
 
@@ -30,6 +31,8 @@
 #include "src/core/load_balancing/lb_policy_registry.h"
 #include "src/core/resolver/resolver_registry.h"
 #include "src/core/service_config/service_config_parser.h"
+#include "src/core/transport/endpoint_transport.h"
+#include "src/core/util/debug_location.h"
 
 namespace grpc_core {
 
@@ -40,6 +43,27 @@ class GRPC_DLL CoreConfiguration {
   CoreConfiguration(const CoreConfiguration&) = delete;
   CoreConfiguration& operator=(const CoreConfiguration&) = delete;
 
+  // BulderScope is used to indicate whether a builder is persistent - these
+  // are builders that are used every time the configuration is built, or
+  // ephemeral - each time the configuration is built these are thrown away.
+  //
+  // Considerations for choosing persistent vs ephemeral:
+  // - For testing we want ephemeral builders, so the next test can throw away
+  //   configuration.
+  // - For adapting gRPC to different environments we typically want persistent
+  //   builders.
+  //   - However, if the adaption should run only once per process, then
+  //     ephemeral is better.
+  //
+  // Builders are instantiated in scope order - persistent first, ephemeral
+  // second.
+  enum class BuilderScope {
+    kPersistent,
+    kEphemeral,
+    // Must be last, do not use as a scope.
+    kCount,
+  };
+
   // Builder is passed to plugins, etc... at initialization time to collect
   // their configuration and assemble the published CoreConfiguration.
   class Builder {
@@ -78,6 +102,10 @@ class GRPC_DLL CoreConfiguration {
       return &certificate_provider_registry_;
     }
 
+    EndpointTransportRegistry::Builder* endpoint_transport_registry() {
+      return &endpoint_transport_registry_;
+    }
+
    private:
     friend class CoreConfiguration;
 
@@ -90,6 +118,7 @@ class GRPC_DLL CoreConfiguration {
     LoadBalancingPolicyRegistry::Builder lb_policy_registry_;
     ProxyMapperRegistry::Builder proxy_mapper_registry_;
     CertificateProviderRegistry::Builder certificate_provider_registry_;
+    EndpointTransportRegistry::Builder endpoint_transport_registry_;
 
     Builder();
     CoreConfiguration* Build();
@@ -99,6 +128,7 @@ class GRPC_DLL CoreConfiguration {
   struct RegisteredBuilder {
     absl::AnyInvocable<void(Builder*)> builder;
     RegisteredBuilder* next;
+    SourceLocation whence;
   };
 
   // Temporarily replaces core configuration with what is built from the
@@ -121,8 +151,10 @@ class GRPC_DLL CoreConfiguration {
       // Backup current core configuration and replace/reset.
       config_restore_ =
           CoreConfiguration::config_.exchange(p, std::memory_order_acquire);
-      builders_restore_ = CoreConfiguration::builders_.exchange(
-          nullptr, std::memory_order_acquire);
+      builders_restore_ =
+          CoreConfiguration::builders_[static_cast<size_t>(
+                                           BuilderScope::kEphemeral)]
+              .exchange(nullptr, std::memory_order_acquire);
     }
 
     ~WithSubstituteBuilder() {
@@ -130,8 +162,10 @@ class GRPC_DLL CoreConfiguration {
       Reset();
       CHECK(CoreConfiguration::config_.exchange(
                 config_restore_, std::memory_order_acquire) == nullptr);
-      CHECK(CoreConfiguration::builders_.exchange(
-                builders_restore_, std::memory_order_acquire) == nullptr);
+      CHECK(CoreConfiguration::builders_[static_cast<size_t>(
+                                             BuilderScope::kEphemeral)]
+                .exchange(builders_restore_, std::memory_order_acquire) ==
+            nullptr);
     }
 
    private:
@@ -153,13 +187,34 @@ class GRPC_DLL CoreConfiguration {
   // Attach a registration function globally.
   // Each registration function is called *in addition to*
   // BuildCoreConfiguration for the default core configuration.
-  static void RegisterBuilder(absl::AnyInvocable<void(Builder*)> builder);
+  static void RegisterBuilder(BuilderScope scope,
+                              absl::AnyInvocable<void(Builder*)> builder,
+                              SourceLocation whence);
+
+  static void RegisterPersistentBuilder(
+      absl::AnyInvocable<void(Builder*)> builder, SourceLocation whence = {}) {
+    RegisterBuilder(BuilderScope::kPersistent, std::move(builder), whence);
+  }
+
+  static void RegisterEphemeralBuilder(
+      absl::AnyInvocable<void(Builder*)> builder, SourceLocation whence = {}) {
+    RegisterBuilder(BuilderScope::kEphemeral, std::move(builder), whence);
+  }
 
   // Drop the core configuration. Users must ensure no other threads are
   // accessing the configuration.
-  // Clears any dynamically registered builders.
+  // Clears any dynamically registered ephemeral builders.
   static void Reset();
 
+  // Reset, but also reset persistent builders. This is not recommended, but
+  // is useful for tests that assume exactly the default open source
+  // configuration when running in other environments.
+  //
+  // TODO(ctiller, roth, yashkt): Remove the need for this method, and then
+  // move the legacy plugin registration mechanism to be a persistent builder.
+  static void
+  ResetEverythingIncludingPersistentBuildersAbsolutelyNotRecommended();
+
   // Helper for tests: Reset the configuration, build a special one, run some
   // code, and then reset the configuration again.
   // Templatized to be sure no codegen in normal builds.
@@ -206,6 +261,10 @@ class GRPC_DLL CoreConfiguration {
     return certificate_provider_registry_;
   }
 
+  const EndpointTransportRegistry& endpoint_transport_registry() const {
+    return endpoint_transport_registry_;
+  }
+
   static void SetDefaultBuilder(void (*builder)(CoreConfiguration::Builder*)) {
     default_builder_ = builder;
   }
@@ -219,8 +278,13 @@ class GRPC_DLL CoreConfiguration {
 
   // The configuration
   static std::atomic<CoreConfiguration*> config_;
+  // Has a configuration *ever* been produced - we verify this is false for
+  // persistent builders so that we can prove consistency build to build for
+  // these.
+  static std::atomic<bool> has_config_ever_been_produced_;
   // Extra registered builders
-  static std::atomic<RegisteredBuilder*> builders_;
+  static std::atomic<RegisteredBuilder*>
+      builders_[static_cast<size_t>(BuilderScope::kCount)];
   // Default builder
   static void (*default_builder_)(CoreConfiguration::Builder*);
 
@@ -233,8 +297,26 @@ class GRPC_DLL CoreConfiguration {
   LoadBalancingPolicyRegistry lb_policy_registry_;
   ProxyMapperRegistry proxy_mapper_registry_;
   CertificateProviderRegistry certificate_provider_registry_;
+  EndpointTransportRegistry endpoint_transport_registry_;
 };
 
+template <typename Sink>
+void AbslStringify(Sink& sink, CoreConfiguration::BuilderScope scope) {
+  switch (scope) {
+    case CoreConfiguration::BuilderScope::kPersistent:
+      sink.Append("Persistent");
+      break;
+    case CoreConfiguration::BuilderScope::kEphemeral:
+      sink.Append("Ephemeral");
+      break;
+    case CoreConfiguration::BuilderScope::kCount:
+      sink.Append("Count(");
+      sink.Append(std::to_string(static_cast<size_t>(scope)));
+      sink.Append(")");
+      break;
+  }
+}
+
 extern void BuildCoreConfiguration(CoreConfiguration::Builder* builder);
 
 }  // namespace grpc_core

data/src/core/credentials/call/external/aws_request_signer.cc

@@ -151,8 +151,9 @@ std::map<std::string, std::string> AwsRequestSigner::GetSignedRequestHeaders() {
   canonical_request_vector.emplace_back(query);
   canonical_request_vector.emplace_back("\n");
   // 4. CanonicalHeaders
+  std::string authority = url_.authority();
   if (request_headers_.empty()) {
-    request_headers_.insert({"host", url_.authority()});
+    request_headers_.insert({"host", authority});
     if (!token_.empty()) {
       request_headers_.insert({"x-amz-security-token", token_});
     }
@@ -198,7 +199,7 @@ std::map<std::string, std::string> AwsRequestSigner::GetSignedRequestHeaders() {
   string_to_sign_vector.emplace_back("\n");
   // 3. CredentialScope
   std::pair<absl::string_view, absl::string_view> host_parts =
-      absl::StrSplit(url_.authority(), absl::MaxSplits('.', 1));
+      absl::StrSplit(authority, absl::MaxSplits('.', 1));
   std::string service_name(host_parts.first);
   std::string credential_scope = absl::StrFormat(
       "%s/%s/%s/aws4_request", request_date_short, region_, service_name);

data/src/core/credentials/call/external/url_external_account_credentials.cc

@@ -146,8 +146,8 @@ UrlExternalAccountCredentials::RetrieveSubjectToken(
     Timestamp deadline,
     absl::AnyInvocable<void(absl::StatusOr<std::string>)> on_done) {
   auto url_for_request =
-      URI::Create(url_.scheme(), url_.authority(), url_full_path_,
-                  {} /* query params */, "" /* fragment */);
+      URI::Create(url_.scheme(), url_.user_info(), url_.host_port(),
+                  url_full_path_, {} /* query params */, "" /* fragment */);
   if (!url_for_request.ok()) {
     return MakeOrphanable<NoOpFetchBody>(
         event_engine(), std::move(on_done),

data/src/core/credentials/call/gcp_service_account_identity/gcp_service_account_identity_credentials.cc

@@ -180,7 +180,7 @@ GcpServiceAccountIdentityCallCredentials::StartHttpRequest(
   // channel. This would allow us to cancel an authentication query when under
   // extreme memory pressure.
   auto uri = URI::Create(
-      "http", "metadata.google.internal.",
+      "http", /*user_info=*/"", "metadata.google.internal.",
       "/computeMetadata/v1/instance/service-accounts/default/identity",
       {{"audience", audience_}}, /*fragment=*/"");
   CHECK_OK(uri);  // params are hardcoded

data/src/core/credentials/call/jwt/jwt_verifier.cc

@@ -756,8 +756,8 @@ static void on_openid_config_retrieved(void* user_data,
   // TODO(ctiller): Carry the resource_quota in ctx and share it with the host
   // channel. This would allow us to cancel an authentication query when under
   // extreme memory pressure.
-  uri = grpc_core::URI::Create("https", host, path, {} /* query params /*/,
-                               "" /* fragment */);
+  uri = grpc_core::URI::Create("https", /*user_info=*/"", host, path,
+                               {} /* query params /*/, "" /* fragment */);
   if (!uri.ok()) {
     goto error;
   }
@@ -886,8 +886,8 @@ static void retrieve_key_and_verify(verifier_cb_ctx* ctx) {
   // TODO(ctiller): Carry the resource_quota in ctx and share it with the host
   // channel. This would allow us to cancel an authentication query when under
   // extreme memory pressure.
-  uri = grpc_core::URI::Create("https", host, path, {} /* query params */,
-                               "" /* fragment */);
+  uri = grpc_core::URI::Create("https", /*user_info=*/"", host, path,
+                               {} /* query params */, "" /* fragment */);
   if (!uri.ok()) {
     goto error;
   }

data/src/core/credentials/call/oauth2/oauth2_credentials.cc

@@ -314,7 +314,8 @@ class grpc_compute_engine_token_fetcher_credentials
     // TODO(ctiller): Carry the memory quota in ctx and share it with the host
     // channel. This would allow us to cancel an authentication query when under
     // extreme memory pressure.
-    auto uri = grpc_core::URI::Create("http", GRPC_COMPUTE_ENGINE_METADATA_HOST,
+    auto uri = grpc_core::URI::Create("http", /*user_info=*/"",
+                                      GRPC_COMPUTE_ENGINE_METADATA_HOST,
                                       GRPC_COMPUTE_ENGINE_METADATA_TOKEN_PATH,
                                       {} /* query params */, "" /* fragment */);
     CHECK(uri.ok());  // params are hardcoded
@@ -372,7 +373,8 @@ grpc_google_refresh_token_credentials::StartHttpRequest(
   // TODO(ctiller): Carry the memory quota in ctx and share it with the host
   // channel. This would allow us to cancel an authentication query when under
   // extreme memory pressure.
-  auto uri = grpc_core::URI::Create("https", GRPC_GOOGLE_OAUTH2_SERVICE_HOST,
+  auto uri = grpc_core::URI::Create("https", /*user_info=*/"",
+                                    GRPC_GOOGLE_OAUTH2_SERVICE_HOST,
                                     GRPC_GOOGLE_OAUTH2_SERVICE_TOKEN_PATH,
                                     {} /* query params */, "" /* fragment */);
   CHECK(uri.ok());  // params are hardcoded

data/src/core/credentials/transport/alts/alts_security_connector.cc

@@ -102,10 +102,11 @@ class grpc_alts_channel_security_connector final
         static_cast<const grpc_alts_credentials*>(channel_creds());
     const size_t user_specified_max_frame_size =
         std::max(0, args.GetInt(GRPC_ARG_TSI_MAX_FRAME_SIZE).value_or(0));
-    CHECK(alts_tsi_handshaker_create(creds->options(), target_name_,
-                                     creds->handshaker_service_url(), true,
-                                     interested_parties, &handshaker,
-                                     user_specified_max_frame_size) == TSI_OK);
+    CHECK(alts_tsi_handshaker_create(
+              creds->options(), target_name_, creds->handshaker_service_url(),
+              true, interested_parties, &handshaker,
+              user_specified_max_frame_size,
+              args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS)) == TSI_OK);
     handshake_manager->Add(
         grpc_core::SecurityHandshakerCreate(handshaker, this, args));
   }
@@ -155,10 +156,10 @@ class grpc_alts_server_security_connector final
         static_cast<const grpc_alts_server_credentials*>(server_creds());
     size_t user_specified_max_frame_size =
         std::max(0, args.GetInt(GRPC_ARG_TSI_MAX_FRAME_SIZE).value_or(0));
-    CHECK(alts_tsi_handshaker_create(creds->options(), nullptr,
-                                     creds->handshaker_service_url(), false,
-                                     interested_parties, &handshaker,
-                                     user_specified_max_frame_size) == TSI_OK);
+    CHECK(alts_tsi_handshaker_create(
+              creds->options(), nullptr, creds->handshaker_service_url(), false,
+              interested_parties, &handshaker, user_specified_max_frame_size,
+              args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS)) == TSI_OK);
     handshake_manager->Add(
         grpc_core::SecurityHandshakerCreate(handshaker, this, args));
   }

data/src/core/credentials/transport/google_default/google_default_credentials.cc

@@ -217,9 +217,9 @@ static int is_metadata_server_reachable() {
   detector.is_done = 0;
   detector.success = 0;
   memset(&request, 0, sizeof(grpc_http_request));
-  auto uri =
-      grpc_core::URI::Create("http", GRPC_COMPUTE_ENGINE_DETECTION_HOST, "/",
-                             {} /* query params */, "" /* fragment */);
+  auto uri = grpc_core::URI::Create("http", /*user_info=*/"",
+                                    GRPC_COMPUTE_ENGINE_DETECTION_HOST, "/",
+                                    {} /* query params */, "" /* fragment */);
   CHECK(uri.ok());  // params are hardcoded
   auto http_request = grpc_core::HttpRequest::Get(
       std::move(*uri), nullptr /* channel args */, &detector.pollent, &request,

data/src/core/credentials/transport/ssl/ssl_credentials.cc

@@ -278,8 +278,8 @@ grpc_ssl_server_credentials::~grpc_ssl_server_credentials() {
 }
 grpc_core::RefCountedPtr<grpc_server_security_connector>
 grpc_ssl_server_credentials::create_security_connector(
-    const grpc_core::ChannelArgs& /* args */) {
-  return grpc_ssl_server_security_connector_create(this->Ref());
+    const grpc_core::ChannelArgs& args) {
+  return grpc_ssl_server_security_connector_create(this->Ref(), args);
 }
 
 grpc_core::UniqueTypeName grpc_ssl_server_credentials::Type() {

data/src/core/credentials/transport/ssl/ssl_security_connector.cc

@@ -108,7 +108,8 @@ class grpc_ssl_channel_security_connector final
         overridden_target_name_.empty() ? target_name_.c_str()
                                         : overridden_target_name_.c_str(),
         /*network_bio_buf_size=*/0,
-        /*ssl_bio_buf_size=*/0, &tsi_hs);
+        /*ssl_bio_buf_size=*/0,
+        args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS), &tsi_hs);
     if (result != TSI_OK) {
       LOG(ERROR) << "Handshaker creation failed with error "
                  << tsi_result_to_string(result);
@@ -198,7 +199,24 @@ class grpc_ssl_server_security_connector
     return server_handshaker_factory_;
   }
 
-  grpc_security_status InitializeHandshakerFactory() {
+  // Helper method to initialize the handshaker factory for all handshaker on
+  // the server side.
+  // - alpn_preferred_protocol_raw_list: an optional string that represents the
+  // comma-separated ordered list of preferred protocols for alpn negotiation on
+  // this server.
+  //
+  // For the server handshaker, override the preferred protocols given
+  // by the channel args on the handshaker factory creation. Do this for all
+  // handshake that a server may produce because it is unlikely that a server
+  // handshaker would change protocol list per handshake.
+  //
+  // OpenSSL's provided method to override the selection of the handshaker
+  // protocols for alpn is only available per context base which makes it
+  // thread-unsafe. The introduction of a lock in the server callback may make
+  // the alternative thread-safe, however it will introduce too much contention
+  // which in turn will affect performance.
+  grpc_security_status InitializeHandshakerFactory(
+      std::optional<std::string> alpn_preferred_protocol_raw_list) {
     if (has_cert_config_fetcher()) {
       // Load initial credentials from certificate_config_fetcher:
       if (!try_fetch_ssl_server_credentials()) {
@@ -209,8 +227,17 @@ class grpc_ssl_server_security_connector
       auto* server_credentials =
           static_cast<const grpc_ssl_server_credentials*>(server_creds());
       size_t num_alpn_protocols = 0;
-      const char** alpn_protocol_strings =
-          grpc_fill_alpn_protocol_strings(&num_alpn_protocols);
+      const char** alpn_protocol_strings = nullptr;
+      if (alpn_preferred_protocol_raw_list.has_value()) {
+#if TSI_OPENSSL_ALPN_SUPPORT
+        alpn_protocol_strings = ParseAlpnStringIntoArray(
+            alpn_preferred_protocol_raw_list.value(), &num_alpn_protocols);
+#endif  // TSI_OPENSSL_ALPN_SUPPORT
+      }
+      if (alpn_protocol_strings == nullptr) {
+        alpn_protocol_strings =
+            grpc_fill_alpn_protocol_strings(&num_alpn_protocols);
+      }
       tsi_ssl_server_handshaker_options options;
       options.pem_key_cert_pairs =
           server_credentials->config().pem_key_cert_pairs;
@@ -277,9 +304,10 @@ class grpc_ssl_server_security_connector
   }
 
  private:
-  // Attempts to fetch the server certificate config if a callback is available.
-  // Current certificate config will continue to be used if the callback returns
-  // an error. Returns true if new credentials were successfully loaded.
+  // Attempts to fetch the server certificate config if a callback is
+  // available. Current certificate config will continue to be used if the
+  // callback returns an error. Returns true if new credentials were
+  // successfully loaded.
   bool try_fetch_ssl_server_credentials() {
     grpc_ssl_server_certificate_config* certificate_config = nullptr;
     bool status;
@@ -307,8 +335,8 @@ class grpc_ssl_server_security_connector
     return status;
   }
 
-  // Attempts to replace the server_handshaker_factory with a new factory using
-  // the provided grpc_ssl_server_certificate_config. Should new factory
+  // Attempts to replace the server_handshaker_factory with a new factory
+  // using the provided grpc_ssl_server_certificate_config. Should new factory
   // creation fail, the existing factory will not be replaced. Returns true on
   // success (new factory created).
   bool try_replace_server_handshaker_factory(
@@ -390,12 +418,14 @@ grpc_ssl_channel_security_connector_create(
 
 grpc_core::RefCountedPtr<grpc_server_security_connector>
 grpc_ssl_server_security_connector_create(
-    grpc_core::RefCountedPtr<grpc_server_credentials> server_credentials) {
+    grpc_core::RefCountedPtr<grpc_server_credentials> server_credentials,
+    const grpc_core::ChannelArgs& args) {
   CHECK(server_credentials != nullptr);
   grpc_core::RefCountedPtr<grpc_ssl_server_security_connector> c =
       grpc_core::MakeRefCounted<grpc_ssl_server_security_connector>(
           std::move(server_credentials));
-  const grpc_security_status retval = c->InitializeHandshakerFactory();
+  const grpc_security_status retval = c->InitializeHandshakerFactory(
+      args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS));
   if (retval != GRPC_SECURITY_OK) {
     return nullptr;
   }

data/src/core/credentials/transport/ssl/ssl_security_connector.h

@@ -76,6 +76,7 @@ struct grpc_ssl_server_config {
 //
 grpc_core::RefCountedPtr<grpc_server_security_connector>
 grpc_ssl_server_security_connector_create(
-    grpc_core::RefCountedPtr<grpc_server_credentials> server_credentials);
+    grpc_core::RefCountedPtr<grpc_server_credentials> server_credentials,
+    const grpc_core::ChannelArgs& args);
 
 #endif  // GRPC_SRC_CORE_CREDENTIALS_TRANSPORT_SSL_SSL_SECURITY_CONNECTOR_H

data/src/core/credentials/transport/tls/ssl_utils.cc

@@ -200,6 +200,24 @@ const char** grpc_fill_alpn_protocol_strings(size_t* num_alpn_protocols) {
   return alpn_protocol_strings;
 }
 
+const char** ParseAlpnStringIntoArray(absl::string_view preferred_protocols_raw,
+                                      size_t* num_alpn_protocols) {
+  CHECK_NE(num_alpn_protocols, nullptr);
+  std::vector<std::string> preferred_protocols;
+  preferred_protocols =
+      absl::StrSplit(preferred_protocols_raw, ',', absl::SkipWhitespace());
+  *num_alpn_protocols = preferred_protocols.size();
+  const char** alpn_protocol_strings = nullptr;
+  if (*num_alpn_protocols != 0) {
+    alpn_protocol_strings = static_cast<const char**>(
+        gpr_malloc(sizeof(const char*) * (*num_alpn_protocols)));
+    for (size_t i = 0; i < *num_alpn_protocols; i++) {
+      alpn_protocol_strings[i] = gpr_strdup(preferred_protocols[i].c_str());
+    }
+  }
+  return alpn_protocol_strings;
+}
+
 int grpc_ssl_host_matches_name(const tsi_peer* peer,
                                absl::string_view peer_name) {
   absl::string_view allocated_name;

data/src/core/credentials/transport/tls/ssl_utils.h

@@ -77,6 +77,11 @@ tsi_tls_version grpc_get_tsi_tls_version(grpc_tls_version tls_version);
 // Return an array of strings containing alpn protocols.
 const char** grpc_fill_alpn_protocol_strings(size_t* num_alpn_protocols);
 
+// Parse a list of comma-separated protocol names into a const char** struct
+// that can be injected into the handshaker factory options.
+const char** ParseAlpnStringIntoArray(absl::string_view preferred_protocols,
+                                      size_t* num_alpn_protocols);
+
 // Initialize TSI SSL server/client handshaker factory.
 grpc_security_status grpc_ssl_tsi_client_handshaker_factory_init(
     tsi_ssl_pem_key_cert_pair* key_cert_pair, const char* pem_root_certs,

data/src/core/credentials/transport/tls/tls_security_connector.cc

@@ -347,7 +347,8 @@ void TlsChannelSecurityConnector::add_handshakers(
         overridden_target_name_.empty() ? target_name_.c_str()
                                         : overridden_target_name_.c_str(),
         /*network_bio_buf_size=*/0,
-        /*ssl_bio_buf_size=*/0, &tsi_hs);
+        /*ssl_bio_buf_size=*/0,
+        args.GetOwnedString(GRPC_ARG_TRANSPORT_PROTOCOLS), &tsi_hs);
     if (result != TSI_OK) {
       LOG(ERROR) << "Handshaker creation failed with error "
                  << tsi_result_to_string(result);

data/src/core/ext/filters/channel_idle/legacy_channel_idle_filter.cc

@@ -50,6 +50,7 @@
 #include "src/core/util/no_destruct.h"
 #include "src/core/util/orphanable.h"
 #include "src/core/util/per_cpu.h"
+#include "src/core/util/shared_bit_gen.h"
 #include "src/core/util/status_helper.h"
 #include "src/core/util/sync.h"
 
@@ -107,9 +108,11 @@ struct LegacyMaxAgeFilter::Config {
         return absl::Uniform(bit_gen, min, max);
       }
     };
-    static NoDestruct<PerCpu<BitGen>> bit_gen(PerCpuOptions().SetMaxShards(8));
-    const double multiplier = bit_gen->this_cpu().MakeUniformDouble(
-        1.0 - kMaxConnectionAgeJitter, 1.0 + kMaxConnectionAgeJitter);
+    const double multiplier = []() {
+      SharedBitGen g;
+      return absl::Uniform(g, 1.0 - kMaxConnectionAgeJitter,
+                           1.0 + kMaxConnectionAgeJitter);
+    }();
     // GRPC_MILLIS_INF_FUTURE - 0.5 converts the value to float, so that result
     // will not be cast to int implicitly before the comparison.
     return Config{args_max_age * multiplier, args_max_idle * multiplier,

data/src/core/ext/filters/http/message_compress/compression_filter.h

@@ -91,6 +91,20 @@ class ChannelCompression {
       bool is_client, MessageHandle message, DecompressArgs args,
       CallTracerInterface* call_tracer) const;
 
+  Json::Object ToJsonObject() const {
+    Json::Object object;
+    if (max_recv_size_.has_value()) {
+      object["maxRecvSize"] = Json::FromNumber(*max_recv_size_);
+    }
+    object["defaultCompressionAlgorithm"] = Json::FromString(
+        CompressionAlgorithmAsString(default_compression_algorithm_));
+    object["enabledCompressionAlgorithms"] = Json::FromString(
+        std::string(enabled_compression_algorithms_.ToString()));
+    object["enableCompression"] = Json::FromBool(enable_compression_);
+    object["enableDecompression"] = Json::FromBool(enable_decompression_);
+    return object;
+  }
+
  private:
   // Max receive message length, if set.
   std::optional<uint32_t> max_recv_size_;
@@ -106,7 +120,8 @@ class ChannelCompression {
 };
 
 class ClientCompressionFilter final
-    : public ImplementChannelFilter<ClientCompressionFilter> {
+    : public ImplementChannelFilter<ClientCompressionFilter>,
+      public channelz::DataSource {
  public:
   static const grpc_channel_filter kFilter;
 
@@ -116,7 +131,14 @@ class ClientCompressionFilter final
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
   explicit ClientCompressionFilter(const ChannelArgs& args)
-      : compression_engine_(args) {}
+      : channelz::DataSource(args.GetObjectRef<channelz::BaseNode>()),
+        compression_engine_(args) {}
+  ~ClientCompressionFilter() override { ResetDataSource(); }
+
+  void AddData(channelz::DataSink& sink) override {
+    sink.AddAdditionalInfo("clientCompressionFilter",
+                           compression_engine_.ToJsonObject());
+  }
 
   // Construct a promise for one call.
   class Call {
@@ -148,7 +170,8 @@ class ClientCompressionFilter final
 };
 
 class ServerCompressionFilter final
-    : public ImplementChannelFilter<ServerCompressionFilter> {
+    : public ImplementChannelFilter<ServerCompressionFilter>,
+      public channelz::DataSource {
  public:
   static const grpc_channel_filter kFilter;
 
@@ -158,7 +181,14 @@ class ServerCompressionFilter final
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
   explicit ServerCompressionFilter(const ChannelArgs& args)
-      : compression_engine_(args) {}
+      : channelz::DataSource(args.GetObjectRef<channelz::BaseNode>()),
+        compression_engine_(args) {}
+  ~ServerCompressionFilter() override { ResetDataSource(); }
+
+  void AddData(channelz::DataSink& sink) override {
+    sink.AddAdditionalInfo("serverCompressionFilter",
+                           compression_engine_.ToJsonObject());
+  }
 
   // Construct a promise for one call.
   class Call {

data/src/core/ext/filters/http/server/http_server_filter.cc

@@ -153,7 +153,7 @@ void HttpServerFilter::Call::OnServerTrailingMetadata(ServerMetadata& md) {
 absl::StatusOr<std::unique_ptr<HttpServerFilter>> HttpServerFilter::Create(
     const ChannelArgs& args, ChannelFilter::Args) {
   return std::make_unique<HttpServerFilter>(
-      args.GetBool(GRPC_ARG_SURFACE_USER_AGENT).value_or(true),
+      args, args.GetBool(GRPC_ARG_SURFACE_USER_AGENT).value_or(true),
       args.GetBool(
               GRPC_ARG_DO_NOT_USE_UNLESS_YOU_HAVE_PERMISSION_FROM_GRPC_TEAM_ALLOW_BROKEN_PUT_REQUESTS)
           .value_or(false));

data/src/core/ext/filters/http/server/http_server_filter.h

@@ -31,7 +31,8 @@
 namespace grpc_core {
 
 // Processes metadata on the server side for HTTP2 transports
-class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
+class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter>,
+                         public channelz::DataSource {
  public:
   static const grpc_channel_filter kFilter;
 
@@ -40,9 +41,19 @@ class HttpServerFilter : public ImplementChannelFilter<HttpServerFilter> {
   static absl::StatusOr<std::unique_ptr<HttpServerFilter>> Create(
       const ChannelArgs& args, ChannelFilter::Args filter_args);
 
-  HttpServerFilter(bool surface_user_agent, bool allow_put_requests)
-      : surface_user_agent_(surface_user_agent),
+  HttpServerFilter(const ChannelArgs& args, bool surface_user_agent,
+                   bool allow_put_requests)
+      : channelz::DataSource(args.GetObjectRef<channelz::BaseNode>()),
+        surface_user_agent_(surface_user_agent),
         allow_put_requests_(allow_put_requests) {}
+  ~HttpServerFilter() override { ResetDataSource(); }
+
+  void AddData(channelz::DataSink& sink) override {
+    Json::Object object;
+    object["surfaceUserAgent"] = Json::FromBool(surface_user_agent_);
+    object["allowPutRequests"] = Json::FromBool(allow_put_requests_);
+    sink.AddAdditionalInfo("httpServerFilter", object);
+  }
 
   class Call {
    public: