grpc 1.58.0 → 1.60.0

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

@@ -62,6 +62,8 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/load_balancing/lb_policy.h"
+#include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/resolver/resolver.h"
 #include "src/core/lib/resource_quota/arena.h"
 #include "src/core/lib/service_config/service_config.h"
@@ -102,10 +104,12 @@ namespace grpc_core {
 
 class ClientChannel {
  public:
-  static const grpc_channel_filter kFilterVtable;
+  static const grpc_channel_filter kFilterVtableWithPromises;
+  static const grpc_channel_filter kFilterVtableWithoutPromises;
 
   class LoadBalancedCall;
   class FilterBasedLoadBalancedCall;
+  class PromiseBasedLoadBalancedCall;
 
   // Flag that this object gets stored in channel args as a raw pointer.
   struct RawPointerChannelArgTag {};
@@ -115,6 +119,10 @@ class ClientChannel {
   // is not a client channel.
   static ClientChannel* GetFromChannel(Channel* channel);
 
+  static ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      grpc_channel_element* elem, CallArgs call_args,
+      NextPromiseFactory next_promise_factory);
+
   grpc_connectivity_state CheckConnectivityState(bool try_to_connect);
 
   // Starts a one-time connectivity state watch.  When the channel's state
@@ -164,6 +172,10 @@ class ClientChannel {
       grpc_closure* on_call_destruction_complete,
       absl::AnyInvocable<void()> on_commit, bool is_transparent_retry);
 
+  ArenaPromise<ServerMetadataHandle> CreateLoadBalancedCallPromise(
+      CallArgs call_args, absl::AnyInvocable<void()> on_commit,
+      bool is_transparent_retry);
+
   // Exposed for testing only.
   static ChannelArgs MakeSubchannelArgs(
       const ChannelArgs& channel_args, const ChannelArgs& address_args,
@@ -173,6 +185,7 @@ class ClientChannel {
  private:
   class CallData;
   class FilterBasedCallData;
+  class PromiseBasedCallData;
   class ResolverResultHandler;
   class SubchannelWrapper;
   class ClientChannelControlHelper;
@@ -315,8 +328,10 @@ class ClientChannel {
   mutable Mutex lb_mu_;
   RefCountedPtr<LoadBalancingPolicy::SubchannelPicker> picker_
       ABSL_GUARDED_BY(lb_mu_);
-  absl::flat_hash_set<LoadBalancedCall*> lb_queued_calls_
-      ABSL_GUARDED_BY(lb_mu_);
+  absl::flat_hash_set<RefCountedPtr<LoadBalancedCall>,
+                      RefCountedPtrHash<LoadBalancedCall>,
+                      RefCountedPtrEq<LoadBalancedCall>>
+      lb_queued_calls_ ABSL_GUARDED_BY(lb_mu_);
 
   //
   // Fields used in the control plane.  Guarded by work_serializer.
@@ -377,7 +392,7 @@ class ClientChannel::LoadBalancedCall
                    bool is_transparent_retry);
   ~LoadBalancedCall() override;
 
-  void Orphan() override;
+  void Orphan() override { Unref(); }
 
   // Called by channel when removing a call from the list of queued calls.
   void RemoveCallFromLbQueuedCallsLocked()
@@ -392,9 +407,8 @@ class ClientChannel::LoadBalancedCall
   ClientChannel* chand() const { return chand_; }
   ClientCallTracer::CallAttemptTracer* call_attempt_tracer() const {
     return static_cast<ClientCallTracer::CallAttemptTracer*>(
-        call_context()[GRPC_CONTEXT_CALL_TRACER].value);
+        call_context_[GRPC_CONTEXT_CALL_TRACER].value);
   }
-  gpr_cycle_counter lb_call_start_time() const { return lb_call_start_time_; }
   ConnectedSubchannel* connected_subchannel() const {
     return connected_subchannel_.get();
   }
@@ -425,14 +439,17 @@ class ClientChannel::LoadBalancedCall
                             grpc_transport_stream_stats* transport_stream_stats,
                             absl::string_view peer_address);
 
+  void RecordLatency();
+
+  grpc_call_context_element* call_context() const { return call_context_; }
+
  private:
   class LbCallState;
   class Metadata;
   class BackendMetricAccessor;
 
   virtual Arena* arena() const = 0;
-  virtual grpc_call_context_element* call_context() const = 0;
-  virtual grpc_polling_entity* pollent() const = 0;
+  virtual grpc_polling_entity* pollent() = 0;
   virtual grpc_metadata_batch* send_initial_metadata() const = 0;
 
   // Helper function for performing an LB pick with a specified picker.
@@ -445,7 +462,7 @@ class ClientChannel::LoadBalancedCall
 
   // Called when adding the call to the LB queue.
   virtual void OnAddToQueueLocked()
-      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannel::lb_mu_) {}
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannel::lb_mu_) = 0;
 
   ClientChannel* chand_;
 
@@ -457,6 +474,7 @@ class ClientChannel::LoadBalancedCall
   const BackendMetricData* backend_metric_data_ = nullptr;
   std::unique_ptr<LoadBalancingPolicy::SubchannelCallTrackerInterface>
       lb_subchannel_call_tracker_;
+  grpc_call_context_element* const call_context_;
 };
 
 class ClientChannel::FilterBasedLoadBalancedCall
@@ -493,10 +511,7 @@ class ClientChannel::FilterBasedLoadBalancedCall
   using LoadBalancedCall::Commit;
 
   Arena* arena() const override { return arena_; }
-  grpc_call_context_element* call_context() const override {
-    return call_context_;
-  }
-  grpc_polling_entity* pollent() const override { return pollent_; }
+  grpc_polling_entity* pollent() override { return pollent_; }
   grpc_metadata_batch* send_initial_metadata() const override {
     return pending_batches_[0]
         ->payload->send_initial_metadata.send_initial_metadata;
@@ -552,7 +567,6 @@ class ClientChannel::FilterBasedLoadBalancedCall
   // context.  This will save per-call memory overhead.
   Timestamp deadline_;
   Arena* arena_;
-  grpc_call_context_element* call_context_;
   grpc_call_stack* owning_call_;
   CallCombiner* call_combiner_;
   grpc_polling_entity* pollent_;
@@ -590,6 +604,33 @@ class ClientChannel::FilterBasedLoadBalancedCall
   grpc_transport_stream_op_batch* pending_batches_[MAX_PENDING_BATCHES] = {};
 };
 
+class ClientChannel::PromiseBasedLoadBalancedCall
+    : public ClientChannel::LoadBalancedCall {
+ public:
+  PromiseBasedLoadBalancedCall(ClientChannel* chand,
+                               absl::AnyInvocable<void()> on_commit,
+                               bool is_transparent_retry);
+
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, OrphanablePtr<PromiseBasedLoadBalancedCall> lb_call);
+
+ private:
+  Arena* arena() const override;
+  grpc_polling_entity* pollent() override { return &pollent_; }
+  grpc_metadata_batch* send_initial_metadata() const override;
+
+  void RetryPickLocked() override;
+
+  void OnAddToQueueLocked() override
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(&ClientChannel::lb_mu_);
+
+  grpc_polling_entity pollent_;
+  ClientMetadataHandle client_initial_metadata_;
+  Waker waker_;
+  bool was_queued_ = false;
+  Slice peer_string_;
+};
+
 }  // namespace grpc_core
 
 #endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_CLIENT_CHANNEL_H

data/src/core/ext/filters/client_channel/client_channel_plugin.cc

@@ -18,25 +18,38 @@
 
 #include <grpc/support/port_platform.h>
 
+#include "absl/types/optional.h"
+
+#include <grpc/impl/channel_arg_names.h>
+
 #include "src/core/ext/filters/client_channel/client_channel.h"
 #include "src/core/ext/filters/client_channel/client_channel_service_config.h"
 #include "src/core/ext/filters/client_channel/retry_service_config.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
+#include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 
 namespace grpc_core {
 
+namespace {
+bool IsEverythingBelowClientChannelPromiseSafe(const ChannelArgs& args) {
+  return !args.GetBool(GRPC_ARG_ENABLE_RETRIES).value_or(true);
+}
+}  // namespace
+
 void BuildClientChannelConfiguration(CoreConfiguration::Builder* builder) {
   internal::ClientChannelServiceConfigParser::Register(builder);
   internal::RetryServiceConfigParser::Register(builder);
-  builder->channel_init()->RegisterStage(
-      GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](ChannelStackBuilder* builder) {
-        builder->AppendFilter(&ClientChannel::kFilterVtable);
-        return true;
-      });
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_CHANNEL,
+                       &ClientChannel::kFilterVtableWithPromises)
+      .If(IsEverythingBelowClientChannelPromiseSafe)
+      .Terminal();
+  builder->channel_init()
+      ->RegisterFilter(GRPC_CLIENT_CHANNEL,
+                       &ClientChannel::kFilterVtableWithoutPromises)
+      .IfNot(IsEverythingBelowClientChannelPromiseSafe)
+      .Terminal();
 }
 
 }  // namespace grpc_core

data/src/core/ext/filters/client_channel/connector.h

@@ -29,7 +29,6 @@
 #include "src/core/lib/iomgr/iomgr_fwd.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/transport/transport.h"
-#include "src/core/lib/transport/transport_fwd.h"
 
 namespace grpc_core {
 
@@ -51,7 +50,7 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
 
   struct Result {
     // The connected transport.
-    grpc_transport* transport = nullptr;
+    Transport* transport = nullptr;
     // Channel args to be passed to filters.
     ChannelArgs channel_args;
     // Channelz socket node of the connected transport, if any.
@@ -59,7 +58,7 @@ class SubchannelConnector : public InternallyRefCounted<SubchannelConnector> {
 
     void Reset() {
       if (transport != nullptr) {
-        grpc_transport_destroy(transport);
+        transport->Orphan();
         transport = nullptr;
       }
       channel_args = ChannelArgs();

data/src/core/ext/filters/client_channel/dynamic_filters.cc

@@ -21,7 +21,6 @@
 #include <stddef.h>
 
 #include <new>
-#include <string>
 #include <utility>
 
 #include "absl/status/statusor.h"

data/src/core/ext/filters/client_channel/dynamic_filters.h

@@ -99,6 +99,8 @@ class DynamicFilters : public RefCounted<DynamicFilters> {
 
   RefCountedPtr<Call> CreateCall(Call::Args args, grpc_error_handle* error);
 
+  grpc_channel_stack* channel_stack() const { return channel_stack_.get(); }
+
  private:
   RefCountedPtr<grpc_channel_stack> channel_stack_;
 };

data/src/core/ext/filters/client_channel/http_proxy_mapper.cc

@@ -0,0 +1,305 @@
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/client_channel/http_proxy_mapper.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+#include "absl/types/optional.h"
+
+#include <grpc/impl/channel_arg_names.h>
+#include <grpc/support/alloc.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/address_utils/parse_address.h"
+#include "src/core/lib/address_utils/sockaddr_utils.h"
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/gpr/string.h"
+#include "src/core/lib/gprpp/env.h"
+#include "src/core/lib/gprpp/host_port.h"
+#include "src/core/lib/gprpp/memory.h"
+#include "src/core/lib/iomgr/resolve_address.h"
+#include "src/core/lib/slice/b64.h"
+#include "src/core/lib/transport/http_connect_handshaker.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+namespace grpc_core {
+namespace {
+
+bool ServerInCIDRRange(const grpc_resolved_address& server_address,
+                       absl::string_view cidr_range) {
+  std::pair<absl::string_view, absl::string_view> possible_cidr =
+      absl::StrSplit(cidr_range, absl::MaxSplits('/', 1), absl::SkipEmpty());
+  if (possible_cidr.first.empty() || possible_cidr.second.empty()) {
+    return false;
+  }
+  auto proxy_address = StringToSockaddr(possible_cidr.first, 0);
+  if (!proxy_address.ok()) {
+    return false;
+  }
+  uint32_t mask_bits = 0;
+  if (absl::SimpleAtoi(possible_cidr.second, &mask_bits)) {
+    grpc_sockaddr_mask_bits(&*proxy_address, mask_bits);
+    return grpc_sockaddr_match_subnet(&server_address, &*proxy_address,
+                                      mask_bits);
+  }
+  return false;
+}
+
+bool ExactMatchOrSubdomain(absl::string_view host_name,
+                           absl::string_view host_name_or_domain) {
+  return absl::EndsWithIgnoreCase(host_name, host_name_or_domain);
+}
+
+// Parses the list of host names, addresses or subnet masks and returns true if
+// the target address or host matches any value.
+bool AddressIncluded(
+    const absl::optional<grpc_resolved_address>& target_address,
+    absl::string_view host_name, absl::string_view addresses_and_subnets) {
+  for (absl::string_view entry :
+       absl::StrSplit(addresses_and_subnets, ',', absl::SkipEmpty())) {
+    absl::string_view sanitized_entry = absl::StripAsciiWhitespace(entry);
+    if (ExactMatchOrSubdomain(host_name, sanitized_entry) ||
+        (target_address.has_value() &&
+         ServerInCIDRRange(*target_address, sanitized_entry))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+///
+/// Parses the 'https_proxy' env var (fallback on 'http_proxy') and returns the
+/// proxy hostname to resolve or nullopt on error. Also sets 'user_cred' to user
+/// credentials if present in the 'http_proxy' env var, otherwise leaves it
+/// unchanged.
+///
+absl::optional<std::string> GetHttpProxyServer(
+    const ChannelArgs& args, absl::optional<std::string>* user_cred) {
+  GPR_ASSERT(user_cred != nullptr);
+  absl::StatusOr<URI> uri;
+  // We check the following places to determine the HTTP proxy to use, stopping
+  // at the first one that is set:
+  // 1. GRPC_ARG_HTTP_PROXY channel arg
+  // 2. grpc_proxy environment variable
+  // 3. https_proxy environment variable
+  // 4. http_proxy environment variable
+  // If none of the above are set, then no HTTP proxy will be used.
+  //
+  absl::optional<std::string> uri_str =
+      args.GetOwnedString(GRPC_ARG_HTTP_PROXY);
+  if (!uri_str.has_value()) uri_str = GetEnv("grpc_proxy");
+  if (!uri_str.has_value()) uri_str = GetEnv("https_proxy");
+  if (!uri_str.has_value()) uri_str = GetEnv("http_proxy");
+  if (!uri_str.has_value()) return absl::nullopt;
+  // an empty value means "don't use proxy"
+  if (uri_str->empty()) return absl::nullopt;
+  uri = URI::Parse(*uri_str);
+  if (!uri.ok() || uri->authority().empty()) {
+    gpr_log(GPR_ERROR, "cannot parse value of 'http_proxy' env var. Error: %s",
+            uri.status().ToString().c_str());
+    return absl::nullopt;
+  }
+  if (uri->scheme() != "http") {
+    gpr_log(GPR_ERROR, "'%s' scheme not supported in proxy URI",
+            uri->scheme().c_str());
+    return absl::nullopt;
+  }
+  // Split on '@' to separate user credentials from host
+  char** authority_strs = nullptr;
+  size_t authority_nstrs;
+  gpr_string_split(uri->authority().c_str(), "@", &authority_strs,
+                   &authority_nstrs);
+  GPR_ASSERT(authority_nstrs != 0);  // should have at least 1 string
+  absl::optional<std::string> proxy_name;
+  if (authority_nstrs == 1) {
+    // User cred not present in authority
+    proxy_name = authority_strs[0];
+  } else if (authority_nstrs == 2) {
+    // User cred found
+    *user_cred = authority_strs[0];
+    proxy_name = authority_strs[1];
+    gpr_log(GPR_DEBUG, "userinfo found in proxy URI");
+  } else {
+    // Bad authority
+    proxy_name = absl::nullopt;
+  }
+  for (size_t i = 0; i < authority_nstrs; i++) {
+    gpr_free(authority_strs[i]);
+  }
+  gpr_free(authority_strs);
+  return proxy_name;
+}
+
+// Adds the default port if target does not contain a port.
+std::string MaybeAddDefaultPort(absl::string_view target) {
+  absl::string_view host;
+  absl::string_view port;
+  SplitHostPort(target, &host, &port);
+  if (port.empty()) {
+    return JoinHostPort(host, kDefaultSecurePortInt);
+  }
+  return std::string(target);
+}
+
+absl::optional<std::string> GetChannelArgOrEnvVarValue(
+    const ChannelArgs& args, absl::string_view channel_arg,
+    const char* env_var) {
+  auto arg_value = args.GetOwnedString(channel_arg);
+  if (arg_value.has_value()) {
+    return arg_value;
+  }
+  return GetEnv(env_var);
+}
+
+absl::optional<grpc_resolved_address> GetAddressProxyServer(
+    const ChannelArgs& args) {
+  auto address_value = GetChannelArgOrEnvVarValue(
+      args, GRPC_ARG_ADDRESS_HTTP_PROXY, HttpProxyMapper::kAddressProxyEnvVar);
+  if (!address_value.has_value()) {
+    return absl::nullopt;
+  }
+  auto address = StringToSockaddr(*address_value);
+  if (!address.ok()) {
+    gpr_log(GPR_ERROR, "cannot parse value of '%s' env var. Error: %s",
+            HttpProxyMapper::kAddressProxyEnvVar,
+            address.status().ToString().c_str());
+    return absl::nullopt;
+  }
+  return *address;
+}
+
+}  // namespace
+
+absl::optional<std::string> HttpProxyMapper::MapName(
+    absl::string_view server_uri, ChannelArgs* args) {
+  if (!args->GetBool(GRPC_ARG_ENABLE_HTTP_PROXY).value_or(true)) {
+    return absl::nullopt;
+  }
+  absl::optional<std::string> user_cred;
+  auto name_to_resolve = GetHttpProxyServer(*args, &user_cred);
+  if (!name_to_resolve.has_value()) return name_to_resolve;
+  absl::StatusOr<URI> uri = URI::Parse(server_uri);
+  if (!uri.ok() || uri->path().empty()) {
+    gpr_log(GPR_ERROR,
+            "'http_proxy' environment variable set, but cannot "
+            "parse server URI '%s' -- not using proxy. Error: %s",
+            std::string(server_uri).c_str(), uri.status().ToString().c_str());
+    return absl::nullopt;
+  }
+  if (uri->scheme() == "unix") {
+    gpr_log(GPR_INFO, "not using proxy for Unix domain socket '%s'",
+            std::string(server_uri).c_str());
+    return absl::nullopt;
+  }
+  if (uri->scheme() == "vsock") {
+    gpr_log(GPR_INFO, "not using proxy for VSock '%s'",
+            std::string(server_uri).c_str());
+    return absl::nullopt;
+  }
+  // Prefer using 'no_grpc_proxy'. Fallback on 'no_proxy' if it is not set.
+  auto no_proxy_str = GetEnv("no_grpc_proxy");
+  if (!no_proxy_str.has_value()) {
+    no_proxy_str = GetEnv("no_proxy");
+  }
+  if (no_proxy_str.has_value()) {
+    std::string server_host;
+    std::string server_port;
+    if (!SplitHostPort(absl::StripPrefix(uri->path(), "/"), &server_host,
+                       &server_port)) {
+      gpr_log(GPR_INFO,
+              "unable to split host and port, not checking no_proxy list for "
+              "host '%s'",
+              std::string(server_uri).c_str());
+    } else {
+      auto address = StringToSockaddr(server_host, 0);
+      if (AddressIncluded(address.ok()
+                              ? absl::optional<grpc_resolved_address>(*address)
+                              : absl::nullopt,
+                          server_host, *no_proxy_str)) {
+        gpr_log(GPR_INFO, "not using proxy for host in no_proxy list '%s'",
+                std::string(server_uri).c_str());
+        return absl::nullopt;
+      }
+    }
+  }
+  *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER,
+                    MaybeAddDefaultPort(absl::StripPrefix(uri->path(), "/")));
+  if (user_cred.has_value()) {
+    // Use base64 encoding for user credentials as stated in RFC 7617
+    auto encoded_user_cred = UniquePtr<char>(
+        grpc_base64_encode(user_cred->data(), user_cred->length(), 0, 0));
+    *args = args->Set(
+        GRPC_ARG_HTTP_CONNECT_HEADERS,
+        absl::StrCat("Proxy-Authorization:Basic ", encoded_user_cred.get()));
+  }
+  return name_to_resolve;
+}
+
+absl::optional<grpc_resolved_address> HttpProxyMapper::MapAddress(
+    const grpc_resolved_address& address, ChannelArgs* args) {
+  auto proxy_address = GetAddressProxyServer(*args);
+  if (!proxy_address.has_value()) {
+    return absl::nullopt;
+  }
+  auto address_string = grpc_sockaddr_to_string(&address, true);
+  if (!address_string.ok()) {
+    gpr_log(GPR_ERROR, "Unable to convert address to string: %s",
+            std::string(address_string.status().message()).c_str());
+    return absl::nullopt;
+  }
+  std::string host_name, port;
+  if (!SplitHostPort(*address_string, &host_name, &port)) {
+    gpr_log(GPR_ERROR, "Address %s cannot be split in host and port",
+            address_string->c_str());
+    return absl::nullopt;
+  }
+  auto enabled_addresses = GetChannelArgOrEnvVarValue(
+      *args, GRPC_ARG_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES,
+      kAddressProxyEnabledAddressesEnvVar);
+  if (!enabled_addresses.has_value() ||
+      !AddressIncluded(address, host_name, *enabled_addresses)) {
+    return absl::nullopt;
+  }
+  *args = args->Set(GRPC_ARG_HTTP_CONNECT_SERVER, *address_string);
+  return proxy_address;
+}
+
+void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder) {
+  builder->proxy_mapper_registry()->Register(
+      true /* at_start */,
+      std::unique_ptr<ProxyMapperInterface>(new HttpProxyMapper()));
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/client_channel/http_proxy_mapper.h

@@ -0,0 +1,53 @@
+//
+//
+// Copyright 2016 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#ifndef GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_MAPPER_H
+#define GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_MAPPER_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/config/core_configuration.h"
+#include "src/core/lib/handshaker/proxy_mapper.h"
+#include "src/core/lib/iomgr/resolved_address.h"
+
+namespace grpc_core {
+
+class HttpProxyMapper : public ProxyMapperInterface {
+ public:
+  static constexpr char const* kAddressProxyEnvVar = "GRPC_ADDRESS_HTTP_PROXY";
+  static constexpr char const* kAddressProxyEnabledAddressesEnvVar =
+      "GRPC_ADDRESS_HTTP_PROXY_ENABLED_ADDRESSES";
+
+  absl::optional<std::string> MapName(absl::string_view server_uri,
+                                      ChannelArgs* args) override;
+
+  absl::optional<grpc_resolved_address> MapAddress(
+      const grpc_resolved_address& address, ChannelArgs* args) override;
+};
+
+void RegisterHttpProxyMapper(CoreConfiguration::Builder* builder);
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_FILTERS_CLIENT_CHANNEL_HTTP_PROXY_MAPPER_H

data/src/core/ext/filters/client_channel/lb_policy/address_filtering.cc

@@ -44,18 +44,19 @@ int HierarchicalPathArg::ChannelArgsCompare(const HierarchicalPathArg* a,
 }
 
 absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
-    const absl::StatusOr<ServerAddressList>& addresses) {
+    const absl::StatusOr<EndpointAddressesList>& addresses) {
   if (!addresses.ok()) return addresses.status();
   HierarchicalAddressMap result;
   RefCountedPtr<HierarchicalPathArg> remaining_path_attr;
-  for (const ServerAddress& address : *addresses) {
-    const auto* path_arg = address.args().GetObject<HierarchicalPathArg>();
+  for (const EndpointAddresses& endpoint_addresses : *addresses) {
+    const auto* path_arg =
+        endpoint_addresses.args().GetObject<HierarchicalPathArg>();
     if (path_arg == nullptr) continue;
     const std::vector<RefCountedStringValue>& path = path_arg->path();
     auto it = path.begin();
     if (it == path.end()) continue;
-    ServerAddressList& target_list = result[*it];
-    ChannelArgs args = address.args();
+    EndpointAddressesList& target_list = result[*it];
+    ChannelArgs args = endpoint_addresses.args();
     ++it;
     if (it != path.end()) {
       std::vector<RefCountedStringValue> remaining_path(it, path.end());
@@ -66,7 +67,7 @@ absl::StatusOr<HierarchicalAddressMap> MakeHierarchicalAddressMap(
       }
       args = args.SetObject(remaining_path_attr);
     }
-    target_list.emplace_back(address.address(), args);
+    target_list.emplace_back(endpoint_addresses.addresses(), args);
   }
   return result;
 }