grpc 1.50.0.pre1 → 1.52.0.pre2

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

@@ -21,9 +21,9 @@
 
 #include <stddef.h>
 
-#include <deque>
 #include <functional>
 #include <map>
+#include <memory>
 #include <string>
 
 #include "absl/base/thread_annotations.h"
@@ -31,7 +31,7 @@
 #include "absl/types/optional.h"
 
 #include <grpc/event_engine/event_engine.h>
-#include <grpc/impl/codegen/connectivity_state.h>
+#include <grpc/impl/connectivity_state.h>
 
 #include "src/core/ext/filters/client_channel/client_channel_channelz.h"
 #include "src/core/ext/filters/client_channel/connector.h"
@@ -49,6 +49,7 @@
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/gprpp/unique_type_name.h"
+#include "src/core/lib/gprpp/work_serializer.h"
 #include "src/core/lib/iomgr/call_combiner.h"
 #include "src/core/lib/iomgr/closure.h"
 #include "src/core/lib/iomgr/error.h"
@@ -166,46 +167,18 @@ class SubchannelCall {
 // (SubchannelWrapper) that "converts" between the two.
 class Subchannel : public DualRefCounted<Subchannel> {
  public:
+  // TODO(roth): Once we remove pollset_set, consider whether this can
+  // just use the normal AsyncConnectivityStateWatcherInterface API.
   class ConnectivityStateWatcherInterface
       : public RefCounted<ConnectivityStateWatcherInterface> {
    public:
-    struct ConnectivityStateChange {
-      grpc_connectivity_state state;
-      absl::Status status;
-    };
-
-    ~ConnectivityStateWatcherInterface() override = default;
-
-    // Will be invoked whenever the subchannel's connectivity state
-    // changes.  There will be only one invocation of this method on a
-    // given watcher instance at any given time.
-    // Implementations should call PopConnectivityStateChange to get the next
-    // connectivity state change.
-    virtual void OnConnectivityStateChange() = 0;
+    // Invoked whenever the subchannel's connectivity state changes.
+    // There will be only one invocation of this method on a given watcher
+    // instance at any given time.
+    virtual void OnConnectivityStateChange(grpc_connectivity_state state,
+                                           const absl::Status& status) = 0;
 
     virtual grpc_pollset_set* interested_parties() = 0;
-
-    // Enqueues connectivity state change notifications.
-    // When the state changes to READY, connected_subchannel will
-    // contain a ref to the connected subchannel.  When it changes from
-    // READY to some other state, the implementation must release its
-    // ref to the connected subchannel.
-    // TODO(yashkt): This is currently needed to send the state updates in the
-    // right order when asynchronously notifying. This will no longer be
-    // necessary when we have access to EventManager.
-    void PushConnectivityStateChange(ConnectivityStateChange state_change);
-
-    // Dequeues connectivity state change notifications.
-    ConnectivityStateChange PopConnectivityStateChange();
-
-   private:
-    Mutex mu_;  // protects the queue
-    // Keeps track of the updates that the watcher instance must be notified of.
-    // TODO(yashkt): This is currently needed to send the state updates in the
-    // right order when asynchronously notifying. This will no longer be
-    // necessary when we have access to EventManager.
-    std::deque<ConnectivityStateChange> connectivity_state_queue_
-        ABSL_GUARDED_BY(&mu_);
   };
 
   // A base class for producers of subchannel-specific data.
@@ -239,8 +212,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
 
   grpc_pollset_set* pollset_set() const { return pollset_set_; }
 
-  const ChannelArgs& channel_args() const { return args_; }
-
   channelz::SubchannelNode* channelz_node();
 
   // Starts watching the subchannel's connectivity state.
@@ -299,6 +270,9 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // the subchannel's state.
   class ConnectivityStateWatcherList {
    public:
+    explicit ConnectivityStateWatcherList(Subchannel* subchannel)
+        : subchannel_(subchannel) {}
+
     ~ConnectivityStateWatcherList() { Clear(); }
 
     void AddWatcherLocked(
@@ -314,6 +288,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
     bool empty() const { return watchers_.empty(); }
 
    private:
+    Subchannel* subchannel_;
     // TODO(roth): Once we can use C++-14 heterogeneous lookups, this can
     // be a set instead of a map.
     std::map<ConnectivityStateWatcherInterface*,
@@ -356,7 +331,6 @@ class Subchannel : public DualRefCounted<Subchannel> {
   };
 
   class ConnectedSubchannelStateWatcher;
-  class AsyncWatcherNotifierLocked;
 
   // Sets the subchannel's connectivity state to \a state.
   void SetConnectivityStateLocked(grpc_connectivity_state state,
@@ -412,6 +386,8 @@ class Subchannel : public DualRefCounted<Subchannel> {
   ConnectivityStateWatcherList watcher_list_ ABSL_GUARDED_BY(mu_);
   // The map of watchers with health check service names.
   HealthWatcherMap health_watcher_map_ ABSL_GUARDED_BY(mu_);
+  // Used for sending connectivity state notifications.
+  WorkSerializer work_serializer_;
 
   // Active connection, or null.
   RefCountedPtr<ConnectedSubchannel> connected_subchannel_ ABSL_GUARDED_BY(mu_);
@@ -428,6 +404,7 @@ class Subchannel : public DualRefCounted<Subchannel> {
   // Data producer map.
   std::map<UniqueTypeName, DataProducerInterface*> data_producer_map_
       ABSL_GUARDED_BY(mu_);
+  std::shared_ptr<grpc_event_engine::experimental::EventEngine> event_engine_;
 };
 
 }  // namespace grpc_core

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

@@ -1,20 +1,20 @@
-/*
- *
- * 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.
- *
- */
+//
+//
+// 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.
+//
+//
 
 #ifndef GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
 #define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H
@@ -97,4 +97,4 @@ class SubchannelPoolInterface : public RefCounted<SubchannelPoolInterface> {
 
 }  // namespace grpc_core
 
-#endif /* GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H */
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_POOL_INTERFACE_H

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

@@ -30,6 +30,7 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/gpr/time_precise.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/gprpp/sync.h"
 #include "src/core/lib/gprpp/time.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -146,7 +147,7 @@ void SubchannelStreamClient::OnRetryTimer(void* arg, grpc_error_handle error) {
   {
     MutexLock lock(&self->mu_);
     self->retry_timer_callback_pending_ = false;
-    if (self->event_handler_ != nullptr && GRPC_ERROR_IS_NONE(error) &&
+    if (self->event_handler_ != nullptr && error.ok() &&
         self->call_state_ == nullptr) {
       if (GPR_UNLIKELY(self->tracer_ != nullptr)) {
         gpr_log(GPR_INFO,
@@ -196,7 +197,7 @@ SubchannelStreamClient::CallState::~CallState() {
 }
 
 void SubchannelStreamClient::CallState::Orphan() {
-  call_combiner_.Cancel(GRPC_ERROR_CANCELLED);
+  call_combiner_.Cancel(absl::CancelledError());
   Cancel();
 }
 
@@ -211,21 +212,19 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
       context_,
       &call_combiner_,
   };
-  grpc_error_handle error = GRPC_ERROR_NONE;
+  grpc_error_handle error;
   call_ = SubchannelCall::Create(std::move(args), &error).release();
   // Register after-destruction callback.
   GRPC_CLOSURE_INIT(&after_call_stack_destruction_, AfterCallStackDestruction,
                     this, grpc_schedule_on_exec_ctx);
   call_->SetAfterCallStackDestroy(&after_call_stack_destruction_);
   // Check if creation failed.
-  if (!GRPC_ERROR_IS_NONE(error) ||
-      subchannel_stream_client_->event_handler_ == nullptr) {
+  if (!error.ok() || subchannel_stream_client_->event_handler_ == nullptr) {
     gpr_log(GPR_ERROR,
             "SubchannelStreamClient %p CallState %p: error creating "
             "stream on subchannel (%s); will retry",
             subchannel_stream_client_.get(), this,
-            grpc_error_std_string(error).c_str());
-    GRPC_ERROR_UNREF(error);
+            StatusToString(error).c_str());
     CallEndedLocked(/*retry=*/true);
     return;
   }
@@ -240,7 +239,7 @@ void SubchannelStreamClient::CallState::StartCallLocked() {
   send_initial_metadata_.Set(
       HttpPathMetadata(),
       subchannel_stream_client_->event_handler_->GetPathLocked());
-  GPR_ASSERT(GRPC_ERROR_IS_NONE(error));
+  GPR_ASSERT(error.ok());
   payload_.send_initial_metadata.send_initial_metadata =
       &send_initial_metadata_;
   payload_.send_initial_metadata.peer_string = nullptr;
@@ -306,7 +305,7 @@ void SubchannelStreamClient::CallState::StartBatch(
   GRPC_CLOSURE_INIT(&batch->handler_private.closure, StartBatchInCallCombiner,
                     batch, grpc_schedule_on_exec_ctx);
   GRPC_CALL_COMBINER_START(&call_combiner_, &batch->handler_private.closure,
-                           GRPC_ERROR_NONE, "start_subchannel_batch");
+                           absl::OkStatus(), "start_subchannel_batch");
 }
 
 void SubchannelStreamClient::CallState::AfterCallStackDestruction(
@@ -328,7 +327,7 @@ void SubchannelStreamClient::CallState::StartCancel(
   auto* batch = grpc_make_transport_stream_op(
       GRPC_CLOSURE_CREATE(OnCancelComplete, self, grpc_schedule_on_exec_ctx));
   batch->cancel_stream = true;
-  batch->payload->cancel_stream.cancel_error = GRPC_ERROR_CANCELLED;
+  batch->payload->cancel_stream.cancel_error = absl::CancelledError();
   self->call_->StartTransportStreamOpBatch(batch);
 }
 
@@ -341,7 +340,7 @@ void SubchannelStreamClient::CallState::Cancel() {
     GRPC_CALL_COMBINER_START(
         &call_combiner_,
         GRPC_CLOSURE_CREATE(StartCancel, this, grpc_schedule_on_exec_ctx),
-        GRPC_ERROR_NONE, "health_cancel");
+        absl::OkStatus(), "health_cancel");
   }
 }
 
@@ -418,7 +417,7 @@ void SubchannelStreamClient::CallState::RecvTrailingMetadataReady(
   grpc_status_code status =
       self->recv_trailing_metadata_.get(GrpcStatusMetadata())
           .value_or(GRPC_STATUS_UNKNOWN);
-  if (!GRPC_ERROR_IS_NONE(error)) {
+  if (!error.ok()) {
     grpc_error_get_status(error, Timestamp::InfFuture(), &status,
                           nullptr /* slice */, nullptr /* http_error */,
                           nullptr /* error_string */);

data/src/core/ext/filters/deadline/deadline_filter.cc

@@ -18,12 +18,15 @@
 
 #include "src/core/ext/filters/deadline/deadline_filter.h"
 
+#include <functional>
+#include <memory>
 #include <new>
+#include <utility>
 
 #include "absl/status/status.h"
 #include "absl/types/optional.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
@@ -31,9 +34,13 @@
 #include "src/core/lib/channel/channel_stack_builder.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/debug_location.h"
+#include "src/core/lib/gprpp/status_helper.h"
 #include "src/core/lib/iomgr/error.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/promise/arena_promise.h"
+#include "src/core/lib/promise/context.h"
+#include "src/core/lib/surface/call.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/transport/metadata_batch.h"
@@ -73,7 +80,7 @@ class TimerState {
     grpc_transport_stream_op_batch* batch = grpc_make_transport_stream_op(
         GRPC_CLOSURE_INIT(&self->closure_, YieldCallCombiner, self, nullptr));
     batch->cancel_stream = true;
-    batch->payload->cancel_stream.cancel_error = GRPC_ERROR_REF(error);
+    batch->payload->cancel_stream.cancel_error = error;
     self->elem_->filter->start_transport_stream_op_batch(self->elem_, batch);
   }
 
@@ -82,11 +89,11 @@ class TimerState {
     TimerState* self = static_cast<TimerState*>(arg);
     grpc_deadline_state* deadline_state =
         static_cast<grpc_deadline_state*>(self->elem_->call_data);
-    if (error != GRPC_ERROR_CANCELLED) {
-      error = grpc_error_set_int(
-          GRPC_ERROR_CREATE_FROM_STATIC_STRING("Deadline Exceeded"),
-          GRPC_ERROR_INT_GRPC_STATUS, GRPC_STATUS_DEADLINE_EXCEEDED);
-      deadline_state->call_combiner->Cancel(GRPC_ERROR_REF(error));
+    if (error != absl::CancelledError()) {
+      error = grpc_error_set_int(GRPC_ERROR_CREATE("Deadline Exceeded"),
+                                 StatusIntProperty::kRpcStatus,
+                                 GRPC_STATUS_DEADLINE_EXCEEDED);
+      deadline_state->call_combiner->Cancel(error);
       GRPC_CLOSURE_INIT(&self->closure_, SendCancelOpInCallCombiner, self,
                         nullptr);
       GRPC_CALL_COMBINER_START(deadline_state->call_combiner, &self->closure_,
@@ -145,7 +152,7 @@ static void recv_trailing_metadata_ready(void* arg, grpc_error_handle error) {
   // Invoke the original callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           deadline_state->original_recv_trailing_metadata_ready,
-                          GRPC_ERROR_REF(error));
+                          error);
 }
 
 // Inject our own recv_trailing_metadata_ready callback into op.
@@ -183,8 +190,7 @@ static void start_timer_after_init(void* arg, grpc_error_handle error) {
     // need to bounce ourselves into it.
     state->in_call_combiner = true;
     GRPC_CALL_COMBINER_START(deadline_state->call_combiner, &state->closure,
-                             GRPC_ERROR_REF(error),
-                             "scheduling deadline timer");
+                             error, "scheduling deadline timer");
     return;
   }
   delete state;
@@ -212,7 +218,7 @@ grpc_deadline_state::grpc_deadline_state(grpc_call_element* elem,
         new start_timer_after_init_state(elem, deadline);
     GRPC_CLOSURE_INIT(&state->closure, start_timer_after_init, state,
                       grpc_schedule_on_exec_ctx);
-    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &state->closure, GRPC_ERROR_NONE);
+    grpc_core::ExecCtx::Run(DEBUG_LOCATION, &state->closure, absl::OkStatus());
   }
 }
 
@@ -249,7 +255,7 @@ void grpc_deadline_state_client_start_transport_stream_op_batch(
 static grpc_error_handle deadline_init_channel_elem(
     grpc_channel_element* /*elem*/, grpc_channel_element_args* args) {
   GPR_ASSERT(!args->is_last);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 // Destructor for channel_data.  Used for both client and server filters.
@@ -276,7 +282,7 @@ typedef struct server_call_data {
 static grpc_error_handle deadline_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   new (elem->call_data) grpc_deadline_state(elem, *args, args->deadline);
-  return GRPC_ERROR_NONE;
+  return absl::OkStatus();
 }
 
 // Destructor for call_data.  Used for both client and server filters.
@@ -305,8 +311,7 @@ static void recv_initial_metadata_ready(void* arg, grpc_error_handle error) {
                 .value_or(grpc_core::Timestamp::InfFuture()));
   // Invoke the next callback.
   grpc_core::Closure::Run(DEBUG_LOCATION,
-                          calld->next_recv_initial_metadata_ready,
-                          GRPC_ERROR_REF(error));
+                          calld->next_recv_initial_metadata_ready, error);
 }
 
 // Method for starting a call op for server filter.
@@ -345,7 +350,10 @@ static void deadline_server_start_transport_stream_op_batch(
 
 const grpc_channel_filter grpc_client_deadline_filter = {
     deadline_client_start_transport_stream_op_batch,
-    nullptr,
+    [](grpc_channel_element*, grpc_core::CallArgs call_args,
+       grpc_core::NextPromiseFactory next_promise_factory) {
+      return next_promise_factory(std::move(call_args));
+    },
     grpc_channel_next_op,
     sizeof(base_call_data),
     deadline_init_call_elem,
@@ -361,7 +369,16 @@ const grpc_channel_filter grpc_client_deadline_filter = {
 
 const grpc_channel_filter grpc_server_deadline_filter = {
     deadline_server_start_transport_stream_op_batch,
-    nullptr,
+    [](grpc_channel_element*, grpc_core::CallArgs call_args,
+       grpc_core::NextPromiseFactory next_promise_factory) {
+      auto deadline = call_args.client_initial_metadata->get(
+          grpc_core::GrpcTimeoutMetadata());
+      if (deadline.has_value()) {
+        grpc_core::GetContext<grpc_core::CallContext>()->UpdateDeadline(
+            *deadline);
+      }
+      return next_promise_factory(std::move(call_args));
+    },
     grpc_channel_next_op,
     sizeof(server_call_data),
     deadline_init_call_elem,

data/src/core/ext/filters/deadline/deadline_filter.h

@@ -90,4 +90,4 @@ bool grpc_deadline_checking_enabled(const grpc_core::ChannelArgs& args);
 extern const grpc_channel_filter grpc_client_deadline_filter;
 extern const grpc_channel_filter grpc_server_deadline_filter;
 
-#endif /* GRPC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H */
+#endif  // GRPC_CORE_EXT_FILTERS_DEADLINE_DEADLINE_FILTER_H

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

@@ -24,6 +24,7 @@
 #include <atomic>
 #include <functional>
 #include <string>
+#include <type_traits>
 #include <utility>
 
 #include "absl/status/status.h"
@@ -35,7 +36,7 @@
 #include <grpc/status.h>
 #include <grpc/support/log.h>
 
-#include "src/core/ext/filters/fault_injection/service_config_parser.h"
+#include "src/core/ext/filters/fault_injection/fault_injection_service_config_parser.h"
 #include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/channel/context.h"
 #include "src/core/lib/channel/status_util.h"
@@ -206,7 +207,7 @@ FaultInjectionFilter::MakeInjectionDecision(
           initial_metadata->GetStringValue(fi_policy->delay_header, &buffer);
       if (value.has_value()) {
         delay = Duration::Milliseconds(
-            std::max(AsInt<int64_t>(*value).value_or(0), int64_t(0)));
+            std::max(AsInt<int64_t>(*value).value_or(0), int64_t{0}));
       }
     }
     if (!fi_policy->delay_percentage_header.empty()) {

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

@@ -34,10 +34,6 @@
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/transport/transport.h"
 
-// Channel arg key for enabling parsing fault injection via method config.
-#define GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG \
-  "grpc.parse_fault_injection_method_config"
-
 namespace grpc_core {
 
 // This channel filter is intended to be used by the dynamic filters, instead

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

@@ -0,0 +1,118 @@
+//
+// 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/fault_injection_service_config_parser.h"
+
+#include <vector>
+
+#include "absl/types/optional.h"
+
+#include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/status_util.h"
+
+namespace grpc_core {
+
+const JsonLoaderInterface*
+FaultInjectionMethodParsedConfig::FaultInjectionPolicy::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<FaultInjectionPolicy>()
+          .OptionalField("abortMessage", &FaultInjectionPolicy::abort_message)
+          .OptionalField("abortCodeHeader",
+                         &FaultInjectionPolicy::abort_code_header)
+          .OptionalField("abortPercentageHeader",
+                         &FaultInjectionPolicy::abort_percentage_header)
+          .OptionalField("abortPercentageNumerator",
+                         &FaultInjectionPolicy::abort_percentage_numerator)
+          .OptionalField("abortPercentageDenominator",
+                         &FaultInjectionPolicy::abort_percentage_denominator)
+          .OptionalField("delay", &FaultInjectionPolicy::delay)
+          .OptionalField("delayHeader", &FaultInjectionPolicy::delay_header)
+          .OptionalField("delayPercentageHeader",
+                         &FaultInjectionPolicy::delay_percentage_header)
+          .OptionalField("delayPercentageNumerator",
+                         &FaultInjectionPolicy::delay_percentage_numerator)
+          .OptionalField("delayPercentageDenominator",
+                         &FaultInjectionPolicy::delay_percentage_denominator)
+          .OptionalField("maxFaults", &FaultInjectionPolicy::max_faults)
+          .Finish();
+  return loader;
+}
+
+void FaultInjectionMethodParsedConfig::FaultInjectionPolicy::JsonPostLoad(
+    const Json& json, const JsonArgs& args, ValidationErrors* errors) {
+  // Parse abort_code.
+  auto abort_code_string = LoadJsonObjectField<std::string>(
+      json.object_value(), args, "abortCode", errors, /*required=*/false);
+  if (abort_code_string.has_value() &&
+      !grpc_status_code_from_string(abort_code_string->c_str(), &abort_code)) {
+    ValidationErrors::ScopedField field(errors, ".abortCode");
+    errors->AddError("failed to parse status code");
+  }
+  // Validate abort_percentage_denominator.
+  if (abort_percentage_denominator != 100 &&
+      abort_percentage_denominator != 10000 &&
+      abort_percentage_denominator != 1000000) {
+    ValidationErrors::ScopedField field(errors, ".abortPercentageDenominator");
+    errors->AddError("must be one of 100, 10000, or 1000000");
+  }
+  // Validate delay_percentage_denominator.
+  if (delay_percentage_denominator != 100 &&
+      delay_percentage_denominator != 10000 &&
+      delay_percentage_denominator != 1000000) {
+    ValidationErrors::ScopedField field(errors, ".delayPercentageDenominator");
+    errors->AddError("must be one of 100, 10000, or 1000000");
+  }
+}
+
+const JsonLoaderInterface* FaultInjectionMethodParsedConfig::JsonLoader(
+    const JsonArgs&) {
+  static const auto* loader =
+      JsonObjectLoader<FaultInjectionMethodParsedConfig>()
+          .OptionalField(
+              "faultInjectionPolicy",
+              &FaultInjectionMethodParsedConfig::fault_injection_policies_)
+          .Finish();
+  return loader;
+}
+
+std::unique_ptr<ServiceConfigParser::ParsedConfig>
+FaultInjectionServiceConfigParser::ParsePerMethodParams(
+    const ChannelArgs& args, const Json& json, ValidationErrors* errors) {
+  // Only parse fault injection policy if the following channel arg is present.
+  if (!args.GetBool(GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG)
+           .value_or(false)) {
+    return nullptr;
+  }
+  // Parse fault injection policy from given Json
+  return LoadFromJson<std::unique_ptr<FaultInjectionMethodParsedConfig>>(
+      json, JsonArgs(), errors);
+}
+
+void FaultInjectionServiceConfigParser::Register(
+    CoreConfiguration::Builder* builder) {
+  builder->service_config_parser()->RegisterParser(
+      std::make_unique<FaultInjectionServiceConfigParser>());
+}
+
+size_t FaultInjectionServiceConfigParser::ParserIndex() {
+  return CoreConfiguration::Get().service_config_parser().GetParserIndex(
+      parser_name());
+}
+
+}  // namespace grpc_core

data/src/core/ext/filters/fault_injection/{service_config_parser.h → fault_injection_service_config_parser.h}

@@ -14,8 +14,8 @@
 // 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
+#ifndef GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#define GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
 
 #include <grpc/support/port_platform.h>
 
@@ -25,10 +25,8 @@
 #include <limits>
 #include <memory>
 #include <string>
-#include <utility>
 #include <vector>
 
-#include "absl/status/statusor.h"
 #include "absl/strings/string_view.h"
 
 #include <grpc/status.h>
@@ -36,9 +34,16 @@
 #include "src/core/lib/channel/channel_args.h"
 #include "src/core/lib/config/core_configuration.h"
 #include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/gprpp/validation_errors.h"
 #include "src/core/lib/json/json.h"
+#include "src/core/lib/json/json_args.h"
+#include "src/core/lib/json/json_object_loader.h"
 #include "src/core/lib/service_config/service_config_parser.h"
 
+// Channel arg key for enabling parsing fault injection via method config.
+#define GRPC_ARG_PARSE_FAULT_INJECTION_METHOD_CONFIG \
+  "grpc.internal.parse_fault_injection_method_config"
+
 namespace grpc_core {
 
 class FaultInjectionMethodParsedConfig
@@ -46,7 +51,7 @@ class FaultInjectionMethodParsedConfig
  public:
   struct FaultInjectionPolicy {
     grpc_status_code abort_code = GRPC_STATUS_OK;
-    std::string abort_message;
+    std::string abort_message = "Fault injected";
     std::string abort_code_header;
     std::string abort_percentage_header;
     uint32_t abort_percentage_numerator = 0;
@@ -60,11 +65,11 @@ class FaultInjectionMethodParsedConfig
 
     // 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)) {}
+    static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+    void JsonPostLoad(const Json& json, const JsonArgs&,
+                      ValidationErrors* errors);
+  };
 
   // Returns the fault injection policy at certain index.
   // There might be multiple fault injection policies functioning at the same
@@ -79,6 +84,8 @@ class FaultInjectionMethodParsedConfig
     return &fault_injection_policies_[index];
   }
 
+  static const JsonLoaderInterface* JsonLoader(const JsonArgs&);
+
  private:
   std::vector<FaultInjectionPolicy> fault_injection_policies_;
 };
@@ -88,8 +95,9 @@ class FaultInjectionServiceConfigParser final
  public:
   absl::string_view name() const override { return parser_name(); }
   // Parses the per-method service config for fault injection filter.
-  absl::StatusOr<std::unique_ptr<ServiceConfigParser::ParsedConfig>>
-  ParsePerMethodParams(const ChannelArgs& args, const Json& json) override;
+  std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
+      const ChannelArgs& args, const Json& json,
+      ValidationErrors* errors) override;
   // Returns the parser index for FaultInjectionServiceConfigParser.
   static size_t ParserIndex();
   // Registers FaultInjectionServiceConfigParser to ServiceConfigParser.
@@ -101,4 +109,4 @@ class FaultInjectionServiceConfigParser final
 
 }  // namespace grpc_core
 
-#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H
+#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_SERVICE_CONFIG_PARSER_H