RubyGems - grpc - Versions diffs - 1.28.0 → 1.42.0 - Mend

grpc 1.28.0 → 1.42.0

Potentially problematic release.

This version of grpc might be problematic. Click here for more details.

Files changed (1954) hide show

data/src/core/ext/filters/client_channel/xds/xds_client.h DELETED Viewed

@@ -1,274 +0,0 @@
-//
-// Copyright 2019 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_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H
-#include <grpc/support/port_platform.h>
-#include <set>
-#include "absl/types/optional.h"
-#include "src/core/ext/filters/client_channel/service_config.h"
-#include "src/core/ext/filters/client_channel/xds/xds_api.h"
-#include "src/core/ext/filters/client_channel/xds/xds_bootstrap.h"
-#include "src/core/ext/filters/client_channel/xds/xds_client_stats.h"
-#include "src/core/lib/gprpp/map.h"
-#include "src/core/lib/gprpp/memory.h"
-#include "src/core/lib/gprpp/orphanable.h"
-#include "src/core/lib/gprpp/ref_counted.h"
-#include "src/core/lib/gprpp/ref_counted_ptr.h"
-#include "src/core/lib/gprpp/string_view.h"
-#include "src/core/lib/iomgr/combiner.h"
-namespace grpc_core {
-extern TraceFlag xds_client_trace;
-class XdsClient : public InternallyRefCounted<XdsClient> {
- public:
-  // Service config watcher interface.  Implemented by callers.
-  class ServiceConfigWatcherInterface {
-   public:
-    virtual ~ServiceConfigWatcherInterface() = default;
-    virtual void OnServiceConfigChanged(
-        RefCountedPtr<ServiceConfig> service_config) = 0;
-    virtual void OnError(grpc_error* error) = 0;
-  };
-  // Cluster data watcher interface.  Implemented by callers.
-  class ClusterWatcherInterface {
-   public:
-    virtual ~ClusterWatcherInterface() = default;
-    virtual void OnClusterChanged(XdsApi::CdsUpdate cluster_data) = 0;
-    virtual void OnError(grpc_error* error) = 0;
-  };
-  // Endpoint data watcher interface.  Implemented by callers.
-  class EndpointWatcherInterface {
-   public:
-    virtual ~EndpointWatcherInterface() = default;
-    virtual void OnEndpointChanged(XdsApi::EdsUpdate update) = 0;
-    virtual void OnError(grpc_error* error) = 0;
-  };
-  // If *error is not GRPC_ERROR_NONE after construction, then there was
-  // an error initializing the client.
-  XdsClient(Combiner* combiner, grpc_pollset_set* interested_parties,
-            StringView server_name,
-            std::unique_ptr<ServiceConfigWatcherInterface> watcher,
-            const grpc_channel_args& channel_args, grpc_error** error);
-  ~XdsClient();
-  void Orphan() override;
-  // Start and cancel cluster data watch for a cluster.
-  // The XdsClient takes ownership of the watcher, but the caller may
-  // keep a raw pointer to the watcher, which may be used only for
-  // cancellation.  (Because the caller does not own the watcher, the
-  // pointer must not be used for any other purpose.)
-  // If the caller is going to start a new watch after cancelling the
-  // old one, it should set delay_unsubscription to true.
-  void WatchClusterData(StringView cluster_name,
-                        std::unique_ptr<ClusterWatcherInterface> watcher);
-  void CancelClusterDataWatch(StringView cluster_name,
-                              ClusterWatcherInterface* watcher,
-                              bool delay_unsubscription = false);
-  // Start and cancel endpoint data watch for a cluster.
-  // The XdsClient takes ownership of the watcher, but the caller may
-  // keep a raw pointer to the watcher, which may be used only for
-  // cancellation.  (Because the caller does not own the watcher, the
-  // pointer must not be used for any other purpose.)
-  // If the caller is going to start a new watch after cancelling the
-  // old one, it should set delay_unsubscription to true.
-  void WatchEndpointData(StringView eds_service_name,
-                         std::unique_ptr<EndpointWatcherInterface> watcher);
-  void CancelEndpointDataWatch(StringView eds_service_name,
-                               EndpointWatcherInterface* watcher,
-                               bool delay_unsubscription = false);
-  // Adds and removes drop stats for cluster_name and eds_service_name.
-  RefCountedPtr<XdsClusterDropStats> AddClusterDropStats(
-      StringView lrs_server, StringView cluster_name,
-      StringView eds_service_name);
-  void RemoveClusterDropStats(StringView /*lrs_server*/,
-                              StringView cluster_name,
-                              StringView eds_service_name,
-                              XdsClusterDropStats* cluster_drop_stats);
-  // Adds and removes locality stats for cluster_name and eds_service_name
-  // for the specified locality.
-  RefCountedPtr<XdsClusterLocalityStats> AddClusterLocalityStats(
-      StringView lrs_server, StringView cluster_name,
-      StringView eds_service_name, RefCountedPtr<XdsLocalityName> locality);
-  void RemoveClusterLocalityStats(
-      StringView /*lrs_server*/, StringView cluster_name,
-      StringView eds_service_name,
-      const RefCountedPtr<XdsLocalityName>& locality,
-      XdsClusterLocalityStats* cluster_locality_stats);
-  // Resets connection backoff state.
-  void ResetBackoff();
-  // Helpers for encoding the XdsClient object in channel args.
-  grpc_arg MakeChannelArg() const;
-  static RefCountedPtr<XdsClient> GetFromChannelArgs(
-      const grpc_channel_args& args);
- private:
-  // Contains a channel to the xds server and all the data related to the
-  // channel.  Holds a ref to the xds client object.
-  // TODO(roth): This is separate from the XdsClient object because it was
-  // originally designed to be able to swap itself out in case the
-  // balancer name changed.  Now that the balancer name is going to be
-  // coming from the bootstrap file, we don't really need this level of
-  // indirection unless we decide to support watching the bootstrap file
-  // for changes.  At some point, if we decide that we're never going to
-  // need to do that, then we can eliminate this class and move its
-  // contents directly into the XdsClient class.
-  class ChannelState : public InternallyRefCounted<ChannelState> {
-   public:
-    template <typename T>
-    class RetryableCall;
-    class AdsCallState;
-    class LrsCallState;
-    ChannelState(RefCountedPtr<XdsClient> xds_client, grpc_channel* channel);
-    ~ChannelState();
-    void Orphan() override;
-    grpc_channel* channel() const { return channel_; }
-    XdsClient* xds_client() const { return xds_client_.get(); }
-    AdsCallState* ads_calld() const;
-    LrsCallState* lrs_calld() const;
-    void MaybeStartLrsCall();
-    void StopLrsCall();
-    bool HasActiveAdsCall() const;
-    void StartConnectivityWatchLocked();
-    void CancelConnectivityWatchLocked();
-    void Subscribe(const std::string& type_url, const std::string& name);
-    void Unsubscribe(const std::string& type_url, const std::string& name,
-                     bool delay_unsubscription);
-   private:
-    class StateWatcher;
-    // The owning xds client.
-    RefCountedPtr<XdsClient> xds_client_;
-    // The channel and its status.
-    grpc_channel* channel_;
-    bool shutting_down_ = false;
-    StateWatcher* watcher_ = nullptr;
-    // The retryable XDS calls.
-    OrphanablePtr<RetryableCall<AdsCallState>> ads_calld_;
-    OrphanablePtr<RetryableCall<LrsCallState>> lrs_calld_;
-  };
-  struct ClusterState {
-    std::map<ClusterWatcherInterface*, std::unique_ptr<ClusterWatcherInterface>>
-        watchers;
-    // The latest data seen from CDS.
-    absl::optional<XdsApi::CdsUpdate> update;
-  };
-  struct EndpointState {
-    std::map<EndpointWatcherInterface*,
-             std::unique_ptr<EndpointWatcherInterface>>
-        watchers;
-    // The latest data seen from EDS.
-    absl::optional<XdsApi::EdsUpdate> update;
-  };
-  struct LoadReportState {
-    struct LocalityState {
-      std::set<XdsClusterLocalityStats*> locality_stats;
-      std::vector<XdsClusterLocalityStats::Snapshot> deleted_locality_stats;
-    };
-    std::set<XdsClusterDropStats*> drop_stats;
-    XdsClusterDropStats::DroppedRequestsMap deleted_drop_stats;
-    std::map<RefCountedPtr<XdsLocalityName>, LocalityState,
-             XdsLocalityName::Less>
-        locality_stats;
-    grpc_millis last_report_time = ExecCtx::Get()->Now();
-  };
-  // Sends an error notification to all watchers.
-  void NotifyOnError(grpc_error* error);
-  grpc_error* CreateServiceConfig(
-      const std::string& cluster_name,
-      RefCountedPtr<ServiceConfig>* service_config) const;
-  XdsApi::ClusterLoadReportMap BuildLoadReportSnapshot(
-      const std::set<std::string>& clusters);
-  // Channel arg vtable functions.
-  static void* ChannelArgCopy(void* p);
-  static void ChannelArgDestroy(void* p);
-  static int ChannelArgCmp(void* p, void* q);
-  static const grpc_arg_pointer_vtable kXdsClientVtable;
-  const grpc_millis request_timeout_;
-  Combiner* combiner_;
-  grpc_pollset_set* interested_parties_;
-  std::unique_ptr<XdsBootstrap> bootstrap_;
-  XdsApi api_;
-  const std::string server_name_;
-  std::unique_ptr<ServiceConfigWatcherInterface> service_config_watcher_;
-  // The channel for communicating with the xds server.
-  OrphanablePtr<ChannelState> chand_;
-  absl::optional<XdsApi::LdsUpdate> lds_result_;
-  absl::optional<XdsApi::RdsUpdate> rds_result_;
-  // One entry for each watched CDS resource.
-  std::map<std::string /*cluster_name*/, ClusterState> cluster_map_;
-  // One entry for each watched EDS resource.
-  std::map<std::string /*eds_service_name*/, EndpointState> endpoint_map_;
-  std::map<
-      std::pair<std::string /*cluster_name*/, std::string /*eds_service_name*/>,
-      LoadReportState>
-      load_report_map_;
-  bool shutting_down_ = false;
-};
-}  // namespace grpc_core
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_XDS_XDS_CLIENT_H */

data/src/core/ext/filters/client_channel/xds/xds_client_stats.cc DELETED Viewed

@@ -1,116 +0,0 @@
-/*
- *
- * Copyright 2018 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/xds/xds_client_stats.h"
-#include <string.h>
-#include <grpc/support/atm.h>
-#include <grpc/support/string_util.h>
-#include "src/core/ext/filters/client_channel/xds/xds_client.h"
-namespace grpc_core {
-//
-// XdsClusterDropStats
-//
-XdsClusterDropStats::XdsClusterDropStats(RefCountedPtr<XdsClient> xds_client,
-                                         StringView lrs_server_name,
-                                         StringView cluster_name,
-                                         StringView eds_service_name)
-    : xds_client_(std::move(xds_client)),
-      lrs_server_name_(lrs_server_name),
-      cluster_name_(cluster_name),
-      eds_service_name_(eds_service_name) {}
-XdsClusterDropStats::~XdsClusterDropStats() {
-  xds_client_->RemoveClusterDropStats(lrs_server_name_, cluster_name_,
-                                      eds_service_name_, this);
-  xds_client_.reset(DEBUG_LOCATION, "DropStats");
-}
-XdsClusterDropStats::DroppedRequestsMap
-XdsClusterDropStats::GetSnapshotAndReset() {
-  MutexLock lock(&mu_);
-  return std::move(dropped_requests_);
-}
-void XdsClusterDropStats::AddCallDropped(const std::string& category) {
-  MutexLock lock(&mu_);
-  ++dropped_requests_[category];
-}
-//
-// XdsClusterLocalityStats
-//
-XdsClusterLocalityStats::XdsClusterLocalityStats(
-    RefCountedPtr<XdsClient> xds_client, StringView lrs_server_name,
-    StringView cluster_name, StringView eds_service_name,
-    RefCountedPtr<XdsLocalityName> name)
-    : xds_client_(std::move(xds_client)),
-      lrs_server_name_(lrs_server_name),
-      cluster_name_(cluster_name),
-      eds_service_name_(eds_service_name),
-      name_(std::move(name)) {}
-XdsClusterLocalityStats::~XdsClusterLocalityStats() {
-  xds_client_->RemoveClusterLocalityStats(lrs_server_name_, cluster_name_,
-                                          eds_service_name_, name_, this);
-  xds_client_.reset(DEBUG_LOCATION, "LocalityStats");
-}
-namespace {
-uint64_t GetAndResetCounter(Atomic<uint64_t>* from) {
-  return from->Exchange(0, MemoryOrder::RELAXED);
-}
-}  // namespace
-XdsClusterLocalityStats::Snapshot
-XdsClusterLocalityStats::GetSnapshotAndReset() {
-  Snapshot snapshot = {
-      GetAndResetCounter(&total_successful_requests_),
-      // Don't reset total_requests_in_progress because it's not
-      // related to a single reporting interval.
-      total_requests_in_progress_.Load(MemoryOrder::RELAXED),
-      GetAndResetCounter(&total_error_requests_),
-      GetAndResetCounter(&total_issued_requests_)};
-  MutexLock lock(&backend_metrics_mu_);
-  snapshot.backend_metrics = std::move(backend_metrics_);
-  return snapshot;
-}
-void XdsClusterLocalityStats::AddCallStarted() {
-  total_issued_requests_.FetchAdd(1, MemoryOrder::RELAXED);
-  total_requests_in_progress_.FetchAdd(1, MemoryOrder::RELAXED);
-}
-void XdsClusterLocalityStats::AddCallFinished(bool fail) {
-  Atomic<uint64_t>& to_increment =
-      fail ? total_error_requests_ : total_successful_requests_;
-  to_increment.FetchAdd(1, MemoryOrder::RELAXED);
-  total_requests_in_progress_.FetchAdd(-1, MemoryOrder::ACQ_REL);
-}
-}  // namespace grpc_core

data/src/core/ext/filters/workarounds/workaround_cronet_compression_filter.cc DELETED Viewed

@@ -1,210 +0,0 @@
-//
-// Copyright 2017 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/workarounds/workaround_cronet_compression_filter.h"
-#include <string.h>
-#include <grpc/support/alloc.h>
-#include "src/core/ext/filters/workarounds/workaround_utils.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/surface/channel_init.h"
-#include "src/core/lib/transport/metadata.h"
-namespace {
-struct call_data {
-  // Receive closures are chained: we inject this closure as the
-  // recv_initial_metadata_ready up-call on transport_stream_op, and remember to
-  // call our next_recv_initial_metadata_ready member after handling it.
-  grpc_closure recv_initial_metadata_ready;
-  // Used by recv_initial_metadata_ready.
-  grpc_metadata_batch* recv_initial_metadata;
-  // Original recv_initial_metadata_ready callback, invoked after our own.
-  grpc_closure* next_recv_initial_metadata_ready;
-  // Marks whether the workaround is active
-  bool workaround_active;
-};
-}  // namespace
-// Find the user agent metadata element in the batch
-static bool get_user_agent_mdelem(const grpc_metadata_batch* batch,
-                                  grpc_mdelem* md) {
-  if (batch->idx.named.user_agent != nullptr) {
-    *md = batch->idx.named.user_agent->md;
-    return true;
-  }
-  return false;
-}
-// Callback invoked when we receive an initial metadata.
-static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
-  grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  if (GRPC_ERROR_NONE == error) {
-    grpc_mdelem md;
-    if (get_user_agent_mdelem(calld->recv_initial_metadata, &md)) {
-      grpc_workaround_user_agent_md* user_agent_md = grpc_parse_user_agent(md);
-      if (user_agent_md
-              ->workaround_active[GRPC_WORKAROUND_ID_CRONET_COMPRESSION]) {
-        calld->workaround_active = true;
-      }
-    }
-  }
-  // Invoke the next callback.
-  grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->next_recv_initial_metadata_ready,
-                          GRPC_ERROR_REF(error));
-}
-// Start transport stream op.
-static void cronet_compression_start_transport_stream_op_batch(
-    grpc_call_element* elem, grpc_transport_stream_op_batch* op) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  // Inject callback for receiving initial metadata
-  if (op->recv_initial_metadata) {
-    calld->next_recv_initial_metadata_ready =
-        op->payload->recv_initial_metadata.recv_initial_metadata_ready;
-    op->payload->recv_initial_metadata.recv_initial_metadata_ready =
-        &calld->recv_initial_metadata_ready;
-    calld->recv_initial_metadata =
-        op->payload->recv_initial_metadata.recv_initial_metadata;
-  }
-  if (op->send_message) {
-    /* Send message happens after client's user-agent (initial metadata) is
-     * received, so workaround_active must be set already */
-    if (calld->workaround_active) {
-      op->payload->send_message.send_message->set_flags(
-          op->payload->send_message.send_message->flags() |
-          GRPC_WRITE_NO_COMPRESS);
-    }
-  }
-  // Chain to the next filter.
-  grpc_call_next_op(elem, op);
-}
-// Constructor for call_data.
-static grpc_error* cronet_compression_init_call_elem(
-    grpc_call_element* elem, const grpc_call_element_args* /*args*/) {
-  call_data* calld = static_cast<call_data*>(elem->call_data);
-  calld->next_recv_initial_metadata_ready = nullptr;
-  calld->workaround_active = false;
-  GRPC_CLOSURE_INIT(&calld->recv_initial_metadata_ready,
-                    recv_initial_metadata_ready, elem,
-                    grpc_schedule_on_exec_ctx);
-  return GRPC_ERROR_NONE;
-}
-// Destructor for call_data.
-static void cronet_compression_destroy_call_elem(
-    grpc_call_element* /*elem*/, const grpc_call_final_info* /*final_info*/,
-    grpc_closure* /*ignored*/) {}
-// Constructor for channel_data.
-static grpc_error* cronet_compression_init_channel_elem(
-    grpc_channel_element* /*elem*/, grpc_channel_element_args* /*args*/) {
-  return GRPC_ERROR_NONE;
-}
-// Destructor for channel_data.
-static void cronet_compression_destroy_channel_elem(
-    grpc_channel_element* /*elem*/) {}
-// Parse the user agent
-static bool parse_user_agent(grpc_mdelem md) {
-  const char grpc_objc_specifier[] = "grpc-objc/";
-  const size_t grpc_objc_specifier_len = sizeof(grpc_objc_specifier) - 1;
-  const char cronet_specifier[] = "cronet_http";
-  const size_t cronet_specifier_len = sizeof(cronet_specifier) - 1;
-  char* user_agent_str = grpc_slice_to_c_string(GRPC_MDVALUE(md));
-  bool grpc_objc_specifier_seen = false;
-  bool cronet_specifier_seen = false;
-  char *major_version_str = user_agent_str, *minor_version_str;
-  long major_version = 0, minor_version = 0;
-  char* head = strtok(user_agent_str, " ");
-  while (head != nullptr) {
-    if (!grpc_objc_specifier_seen &&
-        0 == strncmp(head, grpc_objc_specifier, grpc_objc_specifier_len)) {
-      major_version_str = head + grpc_objc_specifier_len;
-      grpc_objc_specifier_seen = true;
-    } else if (grpc_objc_specifier_seen &&
-               0 == strncmp(head, cronet_specifier, cronet_specifier_len)) {
-      cronet_specifier_seen = true;
-      break;
-    }
-    head = strtok(nullptr, " ");
-  }
-  if (grpc_objc_specifier_seen) {
-    major_version_str = strtok(major_version_str, ".");
-    minor_version_str = strtok(nullptr, ".");
-    major_version = atol(major_version_str);
-    minor_version = atol(minor_version_str);
-  }
-  gpr_free(user_agent_str);
-  return (grpc_objc_specifier_seen && cronet_specifier_seen &&
-          (major_version < 1 || (major_version == 1 && minor_version <= 3)));
-}
-const grpc_channel_filter grpc_workaround_cronet_compression_filter = {
-    cronet_compression_start_transport_stream_op_batch,
-    grpc_channel_next_op,
-    sizeof(call_data),
-    cronet_compression_init_call_elem,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    cronet_compression_destroy_call_elem,
-    0,
-    cronet_compression_init_channel_elem,
-    cronet_compression_destroy_channel_elem,
-    grpc_channel_next_get_info,
-    "workaround_cronet_compression"};
-static bool register_workaround_cronet_compression(
-    grpc_channel_stack_builder* builder, void* /*arg*/) {
-  const grpc_channel_args* channel_args =
-      grpc_channel_stack_builder_get_channel_arguments(builder);
-  const grpc_arg* a = grpc_channel_args_find(
-      channel_args, GRPC_ARG_WORKAROUND_CRONET_COMPRESSION);
-  if (a == nullptr) {
-    return true;
-  }
-  if (grpc_channel_arg_get_bool(a, false) == false) {
-    return true;
-  }
-  return grpc_channel_stack_builder_prepend_filter(
-      builder, &grpc_workaround_cronet_compression_filter, nullptr, nullptr);
-}
-void grpc_workaround_cronet_compression_filter_init(void) {
-  grpc_channel_init_register_stage(
-      GRPC_SERVER_CHANNEL, GRPC_WORKAROUND_PRIORITY_HIGH,
-      register_workaround_cronet_compression, nullptr);
-  grpc_register_workaround(GRPC_WORKAROUND_ID_CRONET_COMPRESSION,
-                           parse_user_agent);
-}
-void grpc_workaround_cronet_compression_filter_shutdown(void) {}

data/src/core/ext/filters/workarounds/workaround_utils.cc DELETED Viewed

@@ -1,53 +0,0 @@
-//
-// Copyright 2017 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/workarounds/workaround_utils.h"
-#include <grpc/support/alloc.h>
-#include <grpc/support/log.h>
-user_agent_parser ua_parser[GRPC_MAX_WORKAROUND_ID];
-static void destroy_user_agent_md(void* user_agent_md) {
-  gpr_free(user_agent_md);
-}
-grpc_workaround_user_agent_md* grpc_parse_user_agent(grpc_mdelem md) {
-  grpc_workaround_user_agent_md* user_agent_md =
-      static_cast<grpc_workaround_user_agent_md*>(
-          grpc_mdelem_get_user_data(md, destroy_user_agent_md));
-  if (nullptr != user_agent_md) {
-    return user_agent_md;
-  }
-  user_agent_md = static_cast<grpc_workaround_user_agent_md*>(
-      gpr_malloc(sizeof(grpc_workaround_user_agent_md)));
-  for (int i = 0; i < GRPC_MAX_WORKAROUND_ID; i++) {
-    if (ua_parser[i]) {
-      user_agent_md->workaround_active[i] = ua_parser[i](md);
-    }
-  }
-  grpc_mdelem_set_user_data(md, destroy_user_agent_md, (void*)user_agent_md);
-  return user_agent_md;
-}
-void grpc_register_workaround(uint32_t id, user_agent_parser parser) {
-  GPR_ASSERT(id < GRPC_MAX_WORKAROUND_ID);
-  ua_parser[id] = parser;
-}

data/src/core/ext/filters/workarounds/workaround_utils.h DELETED Viewed

@@ -1,39 +0,0 @@
-//
-// Copyright 2017 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_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_UTILS_H
-#define GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_UTILS_H
-#include <grpc/support/port_platform.h>
-#include <grpc/support/workaround_list.h>
-#include "src/core/lib/transport/metadata.h"
-#define GRPC_WORKAROUND_PRIORITY_HIGH 10001
-#define GRPC_WORKAROUND_PROIRITY_LOW 9999
-typedef struct grpc_workaround_user_agent_md {
-  bool workaround_active[GRPC_MAX_WORKAROUND_ID];
-} grpc_workaround_user_agent_md;
-grpc_workaround_user_agent_md* grpc_parse_user_agent(grpc_mdelem md);
-typedef bool (*user_agent_parser)(grpc_mdelem);
-void grpc_register_workaround(uint32_t id, user_agent_parser parser);
-#endif /* GRPC_CORE_EXT_FILTERS_WORKAROUNDS_WORKAROUND_UTILS_H */