grpc 1.42.0 → 1.52.0

data/src/core/ext/filters/client_idle/client_idle_filter.cc

@@ -1,264 +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.
- *
- */
-
-#include <grpc/support/port_platform.h>
-
-#include <limits.h>
-
-#include <atomic>
-
-#include "src/core/ext/filters/client_idle/idle_filter_state.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/channel_stack_builder.h"
-#include "src/core/lib/config/core_configuration.h"
-#include "src/core/lib/iomgr/timer.h"
-#include "src/core/lib/transport/http2_errors.h"
-
-// TODO(juanlishen): The idle filter is disabled in client channel by default
-// due to b/143502997. Try to fix the bug and enable the filter by default.
-#define DEFAULT_IDLE_TIMEOUT_MS INT_MAX
-// The user input idle timeout smaller than this would be capped to it.
-#define MIN_IDLE_TIMEOUT_MS (1 /*second*/ * 1000)
-
-namespace grpc_core {
-
-TraceFlag grpc_trace_client_idle_filter(false, "client_idle_filter");
-
-#define GRPC_IDLE_FILTER_LOG(format, ...)                               \
-  do {                                                                  \
-    if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_client_idle_filter)) {       \
-      gpr_log(GPR_INFO, "(client idle filter) " format, ##__VA_ARGS__); \
-    }                                                                   \
-  } while (0)
-
-namespace {
-
-grpc_millis GetClientIdleTimeout(const grpc_channel_args* args) {
-  return std::max(
-      grpc_channel_arg_get_integer(
-          grpc_channel_args_find(args, GRPC_ARG_CLIENT_IDLE_TIMEOUT_MS),
-          {DEFAULT_IDLE_TIMEOUT_MS, 0, INT_MAX}),
-      MIN_IDLE_TIMEOUT_MS);
-}
-
-class ChannelData {
- public:
-  static grpc_error_handle Init(grpc_channel_element* elem,
-                                grpc_channel_element_args* args);
-  static void Destroy(grpc_channel_element* elem);
-
-  static void StartTransportOp(grpc_channel_element* elem,
-                               grpc_transport_op* op);
-
-  void IncreaseCallCount();
-
-  void DecreaseCallCount();
-
- private:
-  ChannelData(grpc_channel_element* elem, grpc_channel_element_args* args,
-              grpc_error_handle* error);
-  ~ChannelData() = default;
-
-  static void IdleTimerCallback(void* arg, grpc_error_handle error);
-  static void IdleTransportOpCompleteCallback(void* arg,
-                                              grpc_error_handle error);
-
-  void StartIdleTimer();
-
-  void EnterIdle();
-
-  grpc_channel_element* elem_;
-  // The channel stack to which we take refs for pending callbacks.
-  grpc_channel_stack* channel_stack_;
-  // Timeout after the last RPC finishes on the client channel at which the
-  // channel goes back into IDLE state.
-  const grpc_millis client_idle_timeout_;
-
-  // Member data used to track the state of channel.
-  IdleFilterState idle_filter_state_{false};
-
-  // Idle timer and its callback closure.
-  grpc_timer idle_timer_;
-  grpc_closure idle_timer_callback_;
-
-  // The transport op telling the client channel to enter IDLE.
-  grpc_transport_op idle_transport_op_;
-  grpc_closure idle_transport_op_complete_callback_;
-};
-
-grpc_error_handle ChannelData::Init(grpc_channel_element* elem,
-                                    grpc_channel_element_args* args) {
-  grpc_error_handle error = GRPC_ERROR_NONE;
-  new (elem->channel_data) ChannelData(elem, args, &error);
-  return error;
-}
-
-void ChannelData::Destroy(grpc_channel_element* elem) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->~ChannelData();
-}
-
-void ChannelData::StartTransportOp(grpc_channel_element* elem,
-                                   grpc_transport_op* op) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  // Catch the disconnect_with_error transport op.
-  if (op->disconnect_with_error != GRPC_ERROR_NONE) {
-    // IncreaseCallCount() introduces a phony call and prevent the timer from
-    // being reset by other threads.
-    chand->IncreaseCallCount();
-    // If the timer has been set, cancel the timer.
-    // No synchronization issues here. grpc_timer_cancel() is valid as long as
-    // the timer has been init()ed before.
-    grpc_timer_cancel(&chand->idle_timer_);
-  }
-  // Pass the op to the next filter.
-  grpc_channel_next_op(elem, op);
-}
-
-void ChannelData::IncreaseCallCount() {
-  idle_filter_state_.IncreaseCallCount();
-}
-
-void ChannelData::DecreaseCallCount() {
-  if (idle_filter_state_.DecreaseCallCount()) {
-    // If there are no more calls in progress, start the idle timer.
-    StartIdleTimer();
-  }
-}
-
-ChannelData::ChannelData(grpc_channel_element* elem,
-                         grpc_channel_element_args* args,
-                         grpc_error_handle* /*error*/)
-    : elem_(elem),
-      channel_stack_(args->channel_stack),
-      client_idle_timeout_(GetClientIdleTimeout(args->channel_args)) {
-  // If the idle filter is explicitly disabled in channel args, this ctor should
-  // not get called.
-  GPR_ASSERT(client_idle_timeout_ != GRPC_MILLIS_INF_FUTURE);
-  GRPC_IDLE_FILTER_LOG("created with max_leisure_time = %" PRId64 " ms",
-                       client_idle_timeout_);
-  // Initialize the idle timer without setting it.
-  grpc_timer_init_unset(&idle_timer_);
-  // Initialize the idle timer callback closure.
-  GRPC_CLOSURE_INIT(&idle_timer_callback_, IdleTimerCallback, this,
-                    grpc_schedule_on_exec_ctx);
-  // Initialize the idle transport op complete callback.
-  GRPC_CLOSURE_INIT(&idle_transport_op_complete_callback_,
-                    IdleTransportOpCompleteCallback, this,
-                    grpc_schedule_on_exec_ctx);
-}
-
-void ChannelData::IdleTimerCallback(void* arg, grpc_error_handle error) {
-  GRPC_IDLE_FILTER_LOG("timer alarms");
-  ChannelData* chand = static_cast<ChannelData*>(arg);
-  if (error != GRPC_ERROR_NONE) {
-    GRPC_IDLE_FILTER_LOG("timer canceled");
-    GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
-    return;
-  }
-  if (chand->idle_filter_state_.CheckTimer()) {
-    chand->StartIdleTimer();
-  } else {
-    chand->EnterIdle();
-  }
-  GRPC_IDLE_FILTER_LOG("timer finishes");
-  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "max idle timer callback");
-}
-
-void ChannelData::IdleTransportOpCompleteCallback(void* arg,
-                                                  grpc_error_handle /*error*/) {
-  ChannelData* chand = static_cast<ChannelData*>(arg);
-  GRPC_CHANNEL_STACK_UNREF(chand->channel_stack_, "idle transport op");
-}
-
-void ChannelData::StartIdleTimer() {
-  GRPC_IDLE_FILTER_LOG("timer has started");
-  // Hold a ref to the channel stack for the timer callback.
-  GRPC_CHANNEL_STACK_REF(channel_stack_, "max idle timer callback");
-  grpc_timer_init(&idle_timer_, ExecCtx::Get()->Now() + client_idle_timeout_,
-                  &idle_timer_callback_);
-}
-
-void ChannelData::EnterIdle() {
-  GRPC_IDLE_FILTER_LOG("the channel will enter IDLE");
-  // Hold a ref to the channel stack for the transport op.
-  GRPC_CHANNEL_STACK_REF(channel_stack_, "idle transport op");
-  // Initialize the transport op.
-  idle_transport_op_ = {};
-  idle_transport_op_.disconnect_with_error = grpc_error_set_int(
-      GRPC_ERROR_CREATE_FROM_STATIC_STRING("enter idle"),
-      GRPC_ERROR_INT_CHANNEL_CONNECTIVITY_STATE, GRPC_CHANNEL_IDLE);
-  idle_transport_op_.on_consumed = &idle_transport_op_complete_callback_;
-  // Pass the transport op down to the channel stack.
-  grpc_channel_next_op(elem_, &idle_transport_op_);
-}
-
-class CallData {
- public:
-  static grpc_error_handle Init(grpc_call_element* elem,
-                                const grpc_call_element_args* args);
-  static void Destroy(grpc_call_element* elem,
-                      const grpc_call_final_info* final_info,
-                      grpc_closure* then_schedule_closure);
-};
-
-grpc_error_handle CallData::Init(grpc_call_element* elem,
-                                 const grpc_call_element_args* /*args*/) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->IncreaseCallCount();
-  return GRPC_ERROR_NONE;
-}
-
-void CallData::Destroy(grpc_call_element* elem,
-                       const grpc_call_final_info* /*final_info*/,
-                       grpc_closure* /*ignored*/) {
-  ChannelData* chand = static_cast<ChannelData*>(elem->channel_data);
-  chand->DecreaseCallCount();
-}
-
-const grpc_channel_filter grpc_client_idle_filter = {
-    grpc_call_next_op,
-    ChannelData::StartTransportOp,
-    sizeof(CallData),
-    CallData::Init,
-    grpc_call_stack_ignore_set_pollset_or_pollset_set,
-    CallData::Destroy,
-    sizeof(ChannelData),
-    ChannelData::Init,
-    ChannelData::Destroy,
-    grpc_channel_next_get_info,
-    "client_idle"};
-
-}  // namespace
-
-void RegisterClientIdleFilter(CoreConfiguration::Builder* builder) {
-  builder->channel_init()->RegisterStage(
-      GRPC_CLIENT_CHANNEL, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
-      [](grpc_channel_stack_builder* builder) {
-        const grpc_channel_args* channel_args =
-            grpc_channel_stack_builder_get_channel_arguments(builder);
-        if (!grpc_channel_args_want_minimal_stack(channel_args) &&
-            GetClientIdleTimeout(channel_args) != INT_MAX) {
-          return grpc_channel_stack_builder_prepend_filter(
-              builder, &grpc_client_idle_filter, nullptr, nullptr);
-        } else {
-          return true;
-        }
-      });
-}
-}  // namespace grpc_core

data/src/core/ext/filters/client_idle/idle_filter_state.cc

@@ -1,96 +0,0 @@
-// Copyright 2021 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_idle/idle_filter_state.h"
-
-#include <assert.h>
-
-namespace grpc_core {
-
-IdleFilterState::IdleFilterState(bool start_timer)
-    : state_(start_timer ? kTimerStarted : 0) {}
-
-void IdleFilterState::IncreaseCallCount() {
-  uintptr_t state = state_.load(std::memory_order_relaxed);
-  uintptr_t new_state;
-  do {
-    // Increment the counter, and flag that there's been activity.
-    new_state = state;
-    new_state |= kCallsStartedSinceLastTimerCheck;
-    new_state += kCallIncrement;
-  } while (!state_.compare_exchange_weak(
-      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
-}
-
-bool IdleFilterState::DecreaseCallCount() {
-  uintptr_t state = state_.load(std::memory_order_relaxed);
-  uintptr_t new_state;
-  bool start_timer;
-  do {
-    start_timer = false;
-    new_state = state;
-    // Decrement call count (and assert there's at least one call outstanding!)
-    assert(new_state >= kCallIncrement);
-    new_state -= kCallIncrement;
-    // If that decrement reaches a call count of zero and we have not started a
-    // timer
-    if ((new_state >> kCallsInProgressShift) == 0 &&
-        (new_state & kTimerStarted) == 0) {
-      // Flag that we will start a timer, and mark it started so nobody else
-      // does.
-      start_timer = true;
-      new_state |= kTimerStarted;
-      new_state &= ~kCallsInProgressShift;
-    }
-  } while (!state_.compare_exchange_weak(
-      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
-  return start_timer;
-}
-
-bool IdleFilterState::CheckTimer() {
-  uintptr_t state = state_.load(std::memory_order_relaxed);
-  uintptr_t new_state;
-  bool start_timer;
-  do {
-    if ((state >> kCallsInProgressShift) != 0) {
-      // Still calls in progress: nothing needs updating, just return
-      // and keep the timer going!
-      return true;
-    }
-    new_state = state;
-    bool is_active = false;
-    if (new_state & kCallsStartedSinceLastTimerCheck) {
-      // If any calls started since the last time we checked, then consider the
-      // channel still active and try again.
-      is_active = true;
-      new_state &= ~kCallsStartedSinceLastTimerCheck;
-    }
-    if (is_active) {
-      // If we are still active, we should signal that the timer should start
-      // again.
-      start_timer = true;
-    } else {
-      // Otherwise, we should not start the timer again, and we should signal
-      // that in the updated state.
-      start_timer = false;
-      new_state &= ~kTimerStarted;
-    }
-  } while (!state_.compare_exchange_weak(
-      state, new_state, std::memory_order_acq_rel, std::memory_order_relaxed));
-  return start_timer;
-}
-
-}  // namespace grpc_core

data/src/core/ext/filters/client_idle/idle_filter_state.h

@@ -1,66 +0,0 @@
-// Copyright 2021 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_IDLE_IDLE_FILTER_STATE_H
-#define GRPC_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H
-
-#include <grpc/support/port_platform.h>
-
-#include <atomic>
-
-namespace grpc_core {
-
-// State machine for the idle filter.
-// Keeps track of how many calls are in progress, whether there is a timer
-// started, and whether we've seen calls since the previous timer fired.
-class IdleFilterState {
- public:
-  explicit IdleFilterState(bool start_timer);
-  ~IdleFilterState() = default;
-
-  IdleFilterState(const IdleFilterState&);
-  IdleFilterState& operator=(const IdleFilterState&);
-
-  // Increment the number of calls in progress.
-  void IncreaseCallCount();
-
-  // Decrement the number of calls in progress.
-  // Return true if we reached idle with no timer started.
-  GRPC_MUST_USE_RESULT bool DecreaseCallCount();
-
-  // Check if there's been any activity since the last timer check.
-  // If there was, reset the activity flag and return true to indicated that
-  // a new timer should be started.
-  // If there was not, reset the timer flag and return false - in this case
-  // we know that the channel is idle and has been for one full cycle.
-  GRPC_MUST_USE_RESULT bool CheckTimer();
-
- private:
-  // Bit in state_ indicating that the timer has been started.
-  static constexpr uintptr_t kTimerStarted = 1;
-  // Bit in state_ indicating that we've seen a call start or stop since the
-  // last timer.
-  static constexpr uintptr_t kCallsStartedSinceLastTimerCheck = 2;
-  // How much should we shift to get the number of calls in progress.
-  static constexpr uintptr_t kCallsInProgressShift = 2;
-  // How much to increment/decrement the state_ when a call is started/stopped.
-  // Ensures we don't clobber the preceding bits.
-  static constexpr uintptr_t kCallIncrement = uintptr_t(1)
-                                              << kCallsInProgressShift;
-  std::atomic<uintptr_t> state_;
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_IDLE_IDLE_FILTER_STATE_H

data/src/core/ext/filters/fault_injection/service_config_parser.cc

@@ -1,181 +0,0 @@
-//
-// Copyright 2021 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/fault_injection/service_config_parser.h"
-
-#include <vector>
-
-#include "absl/strings/str_cat.h"
-#include "absl/strings/string_view.h"
-
-#include "src/core/ext/filters/fault_injection/fault_injection_filter.h"
-#include "src/core/lib/channel/channel_args.h"
-#include "src/core/lib/channel/status_util.h"
-#include "src/core/lib/gpr/string.h"
-#include "src/core/lib/json/json_util.h"
-
-namespace grpc_core {
-
-namespace {
-
-size_t g_fault_injection_parser_index;
-
-std::vector<FaultInjectionMethodParsedConfig::FaultInjectionPolicy>
-ParseFaultInjectionPolicy(const Json::Array& policies_json_array,
-                          std::vector<grpc_error_handle>* error_list) {
-  std::vector<FaultInjectionMethodParsedConfig::FaultInjectionPolicy> policies;
-  for (size_t i = 0; i < policies_json_array.size(); i++) {
-    FaultInjectionMethodParsedConfig::FaultInjectionPolicy
-        fault_injection_policy;
-    std::vector<grpc_error_handle> sub_error_list;
-    if (policies_json_array[i].type() != Json::Type::OBJECT) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_CPP_STRING(absl::StrCat(
-          "faultInjectionPolicy index ", i, " is not a JSON object")));
-      continue;
-    }
-    const Json::Object& json_object = policies_json_array[i].object_value();
-    // Parse abort_code
-    std::string abort_code_string;
-    if (ParseJsonObjectField(json_object, "abortCode", &abort_code_string,
-                             &sub_error_list, false)) {
-      if (!grpc_status_code_from_string(abort_code_string.c_str(),
-                                        &(fault_injection_policy.abort_code))) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:abortCode error:failed to parse status code"));
-      }
-    }
-    // Parse abort_message
-    if (!ParseJsonObjectField(json_object, "abortMessage",
-                              &fault_injection_policy.abort_message,
-                              &sub_error_list, false)) {
-      fault_injection_policy.abort_message = "Fault injected";
-    }
-    // Parse abort_code_header
-    ParseJsonObjectField(json_object, "abortCodeHeader",
-                         &fault_injection_policy.abort_code_header,
-                         &sub_error_list, false);
-    // Parse abort_percentage_header
-    ParseJsonObjectField(json_object, "abortPercentageHeader",
-                         &fault_injection_policy.abort_percentage_header,
-                         &sub_error_list, false);
-    // Parse abort_percentage_numerator
-    ParseJsonObjectField(json_object, "abortPercentageNumerator",
-                         &fault_injection_policy.abort_percentage_numerator,
-                         &sub_error_list, false);
-    // Parse abort_percentage_denominator
-    if (ParseJsonObjectField(
-            json_object, "abortPercentageDenominator",
-            &fault_injection_policy.abort_percentage_denominator,
-            &sub_error_list, false)) {
-      if (fault_injection_policy.abort_percentage_denominator != 100 &&
-          fault_injection_policy.abort_percentage_denominator != 10000 &&
-          fault_injection_policy.abort_percentage_denominator != 1000000) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:abortPercentageDenominator error:Denominator can only be "
-            "one of "
-            "100, 10000, 1000000"));
-      }
-    }
-    // Parse delay
-    ParseJsonObjectFieldAsDuration(json_object, "delay",
-                                   &fault_injection_policy.delay,
-                                   &sub_error_list, false);
-    // Parse delay_header
-    ParseJsonObjectField(json_object, "delayHeader",
-                         &fault_injection_policy.delay_header, &sub_error_list,
-                         false);
-    // Parse delay_percentage_header
-    ParseJsonObjectField(json_object, "delayPercentageHeader",
-                         &fault_injection_policy.delay_percentage_header,
-                         &sub_error_list, false);
-    // Parse delay_percentage_numerator
-    ParseJsonObjectField(json_object, "delayPercentageNumerator",
-                         &fault_injection_policy.delay_percentage_numerator,
-                         &sub_error_list, false);
-    // Parse delay_percentage_denominator
-    if (ParseJsonObjectField(
-            json_object, "delayPercentageDenominator",
-            &fault_injection_policy.delay_percentage_denominator,
-            &sub_error_list, false)) {
-      if (fault_injection_policy.delay_percentage_denominator != 100 &&
-          fault_injection_policy.delay_percentage_denominator != 10000 &&
-          fault_injection_policy.delay_percentage_denominator != 1000000) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:delayPercentageDenominator error:Denominator can only be "
-            "one of "
-            "100, 10000, 1000000"));
-      }
-    }
-    // Parse max_faults
-    if (ParseJsonObjectField(json_object, "maxFaults",
-                             &fault_injection_policy.max_faults,
-                             &sub_error_list, false)) {
-      if (fault_injection_policy.max_faults < 0) {
-        sub_error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:maxFaults error:should be zero or positive"));
-      }
-    }
-    if (!sub_error_list.empty()) {
-      error_list->push_back(GRPC_ERROR_CREATE_FROM_VECTOR_AND_CPP_STRING(
-          absl::StrCat("failed to parse faultInjectionPolicy index ", i),
-          &sub_error_list));
-    }
-    policies.push_back(std::move(fault_injection_policy));
-  }
-  return policies;
-}
-
-}  // namespace
-
-std::unique_ptr<ServiceConfigParser::ParsedConfig>
-FaultInjectionServiceConfigParser::ParsePerMethodParams(
-    const grpc_channel_args* args, const Json& json, grpc_error_handle* error) {
-  GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
-  // Only parse fault injection policy if the following channel arg is present.
-  if (!grpc_channel_args_find_bool(
-          args, GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG, false)) {
-    return nullptr;
-  }
-  // Parse fault injection policy from given Json
-  std::vector<FaultInjectionMethodParsedConfig::FaultInjectionPolicy>
-      fault_injection_policies;
-  std::vector<grpc_error_handle> error_list;
-  const Json::Array* policies_json_array;
-  if (ParseJsonObjectField(json.object_value(), "faultInjectionPolicy",
-                           &policies_json_array, &error_list)) {
-    fault_injection_policies =
-        ParseFaultInjectionPolicy(*policies_json_array, &error_list);
-  }
-  *error = GRPC_ERROR_CREATE_FROM_VECTOR("Fault injection parser", &error_list);
-  if (*error != GRPC_ERROR_NONE || fault_injection_policies.empty()) {
-    return nullptr;
-  }
-  return absl::make_unique<FaultInjectionMethodParsedConfig>(
-      std::move(fault_injection_policies));
-}
-
-void FaultInjectionServiceConfigParser::Register() {
-  g_fault_injection_parser_index = ServiceConfigParser::RegisterParser(
-      absl::make_unique<FaultInjectionServiceConfigParser>());
-}
-
-size_t FaultInjectionServiceConfigParser::ParserIndex() {
-  return g_fault_injection_parser_index;
-}
-
-}  // namespace grpc_core

data/src/core/ext/filters/fault_injection/service_config_parser.h

@@ -1,85 +0,0 @@
-//
-// Copyright 2021 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_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
-#define GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
-
-#include <grpc/support/port_platform.h>
-
-#include <vector>
-
-#include "src/core/ext/service_config/service_config_parser.h"
-#include "src/core/lib/iomgr/exec_ctx.h"
-
-namespace grpc_core {
-
-class FaultInjectionMethodParsedConfig
-    : public ServiceConfigParser::ParsedConfig {
- public:
-  struct FaultInjectionPolicy {
-    grpc_status_code abort_code = GRPC_STATUS_OK;
-    std::string abort_message;
-    std::string abort_code_header;
-    std::string abort_percentage_header;
-    uint32_t abort_percentage_numerator = 0;
-    uint32_t abort_percentage_denominator = 100;
-
-    grpc_millis delay = 0;
-    std::string delay_header;
-    std::string delay_percentage_header;
-    uint32_t delay_percentage_numerator = 0;
-    uint32_t delay_percentage_denominator = 100;
-
-    // By default, the max allowed active faults are unlimited.
-    uint32_t max_faults = std::numeric_limits<uint32_t>::max();
-  };
-
-  explicit FaultInjectionMethodParsedConfig(
-      std::vector<FaultInjectionPolicy> fault_injection_policies)
-      : fault_injection_policies_(std::move(fault_injection_policies)) {}
-
-  // Returns the fault injection policy at certain index.
-  // There might be multiple fault injection policies functioning at the same
-  // time. The order between the policies are stable, and an index is used to
-  // keep track of their relative positions. The FaultInjectionFilter uses this
-  // method to access the parsed fault injection policy in service config,
-  // whether it came from xDS resolver or directly from service config
-  const FaultInjectionPolicy* fault_injection_policy(int index) const {
-    if (static_cast<size_t>(index) >= fault_injection_policies_.size()) {
-      return nullptr;
-    }
-    return &fault_injection_policies_[index];
-  }
-
- private:
-  std::vector<FaultInjectionPolicy> fault_injection_policies_;
-};
-
-class FaultInjectionServiceConfigParser : public ServiceConfigParser::Parser {
- public:
-  // Parses the per-method service config for fault injection filter.
-  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const grpc_channel_args* args, const Json& json,
-      grpc_error_handle* error) override;
-  // Returns the parser index for FaultInjectionServiceConfigParser.
-  static size_t ParserIndex();
-  // Registers FaultInjectionServiceConfigParser to ServiceConfigParser.
-  static void Register();
-};
-
-}  // namespace grpc_core
-
-#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H