grpc 1.35.0 → 1.38.0

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

@@ -0,0 +1,39 @@
+//
+// 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_FAULT_INJECTION_FILTER_H
+#define GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/filters/fault_injection/service_config_parser.h"
+#include "src/core/lib/channel/channel_stack.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
+// of the ordinary channel stack. The fault injection filter fetches fault
+// injection policy from the method config of service config returned by the
+// resolver, and enforces the fault injection policy.
+extern const grpc_channel_filter FaultInjectionFilterVtable;
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_FAULT_INJECTION_FAULT_INJECTION_FILTER_H

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

@@ -0,0 +1,189 @@
+//
+// 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/client_channel/service_config.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_COPIED_STRING(
+          absl::StrCat("faultInjectionPolicy index ", i,
+                       " is not a JSON object")
+              .c_str()));
+      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()) {
+      // Can't use GRPC_ERROR_CREATE_FROM_VECTOR() here, because the error
+      // string is not static in this case.
+      grpc_error_handle error = GRPC_ERROR_CREATE_FROM_COPIED_STRING(
+          absl::StrCat("failed to parse faultInjectionPolicy index ", i)
+              .c_str());
+      for (size_t i = 0; i < sub_error_list.size(); ++i) {
+        error = grpc_error_add_child(error, sub_error_list[i]);
+      }
+      error_list->push_back(error);
+    }
+    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

@@ -0,0 +1,85 @@
+//
+// 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/filters/client_channel/service_config.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

data/src/core/ext/filters/http/client/http_client_filter.cc

@@ -48,10 +48,12 @@
 /* default maximum size of payload eligible for GET request */
 static constexpr size_t kMaxPayloadSizeForGet = 2048;
 
-static void recv_initial_metadata_ready(void* user_data, grpc_error* error);
-static void recv_trailing_metadata_ready(void* user_data, grpc_error* error);
-static void on_send_message_next_done(void* arg, grpc_error* error);
-static void send_message_on_complete(void* arg, grpc_error* error);
+static void recv_initial_metadata_ready(void* user_data,
+                                        grpc_error_handle error);
+static void recv_trailing_metadata_ready(void* user_data,
+                                         grpc_error_handle error);
+static void on_send_message_next_done(void* arg, grpc_error_handle error);
+static void send_message_on_complete(void* arg, grpc_error_handle error);
 
 namespace {
 struct call_data {
@@ -81,14 +83,14 @@ struct call_data {
   grpc_linked_mdelem user_agent;
   // State for handling recv_initial_metadata ops.
   grpc_metadata_batch* recv_initial_metadata;
-  grpc_error* recv_initial_metadata_error = GRPC_ERROR_NONE;
+  grpc_error_handle recv_initial_metadata_error = GRPC_ERROR_NONE;
   grpc_closure* original_recv_initial_metadata_ready = nullptr;
   grpc_closure recv_initial_metadata_ready;
   // State for handling recv_trailing_metadata ops.
   grpc_metadata_batch* recv_trailing_metadata;
   grpc_closure* original_recv_trailing_metadata_ready;
   grpc_closure recv_trailing_metadata_ready;
-  grpc_error* recv_trailing_metadata_error = GRPC_ERROR_NONE;
+  grpc_error_handle recv_trailing_metadata_error = GRPC_ERROR_NONE;
   bool seen_recv_trailing_metadata_ready = false;
   // State for handling send_message ops.
   grpc_transport_stream_op_batch* send_message_batch;
@@ -108,7 +110,8 @@ struct channel_data {
 };
 }  // namespace
 
-static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
+static grpc_error_handle client_filter_incoming_metadata(
+    grpc_metadata_batch* b) {
   if (b->idx.named.status != nullptr) {
     /* If both gRPC status and HTTP status are provided in the response, we
      * should prefer the gRPC status code, as mentioned in
@@ -123,7 +126,7 @@ static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
                                   GPR_DUMP_ASCII);
       std::string msg =
           absl::StrCat("Received http2 header with status: ", val);
-      grpc_error* e = grpc_error_set_str(
+      grpc_error_handle e = grpc_error_set_str(
           grpc_error_set_int(
               grpc_error_set_str(
                   GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -182,7 +185,8 @@ static grpc_error* client_filter_incoming_metadata(grpc_metadata_batch* b) {
   return GRPC_ERROR_NONE;
 }
 
-static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
+static void recv_initial_metadata_ready(void* user_data,
+                                        grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error == GRPC_ERROR_NONE) {
@@ -201,7 +205,8 @@ static void recv_initial_metadata_ready(void* user_data, grpc_error* error) {
   grpc_core::Closure::Run(DEBUG_LOCATION, closure, error);
 }
 
-static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
+static void recv_trailing_metadata_ready(void* user_data,
+                                         grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(user_data);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (calld->original_recv_initial_metadata_ready != nullptr) {
@@ -223,7 +228,7 @@ static void recv_trailing_metadata_ready(void* user_data, grpc_error* error) {
                           calld->original_recv_trailing_metadata_ready, error);
 }
 
-static void send_message_on_complete(void* arg, grpc_error* error) {
+static void send_message_on_complete(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   calld->send_message_cache.Destroy();
@@ -234,9 +239,10 @@ static void send_message_on_complete(void* arg, grpc_error* error) {
 
 // Pulls a slice from the send_message byte stream, updating
 // calld->send_message_bytes_read.
-static grpc_error* pull_slice_from_send_message(call_data* calld) {
+static grpc_error_handle pull_slice_from_send_message(call_data* calld) {
   grpc_slice incoming_slice;
-  grpc_error* error = calld->send_message_caching_stream->Pull(&incoming_slice);
+  grpc_error_handle error =
+      calld->send_message_caching_stream->Pull(&incoming_slice);
   if (error == GRPC_ERROR_NONE) {
     calld->send_message_bytes_read += GRPC_SLICE_LENGTH(incoming_slice);
     grpc_slice_unref_internal(incoming_slice);
@@ -249,10 +255,11 @@ static grpc_error* pull_slice_from_send_message(call_data* calld) {
 // calld->send_message_caching_stream->length(), then we have completed
 // reading from the byte stream; otherwise, an async read has been dispatched
 // and on_send_message_next_done() will be invoked when it is complete.
-static grpc_error* read_all_available_send_message_data(call_data* calld) {
+static grpc_error_handle read_all_available_send_message_data(
+    call_data* calld) {
   while (calld->send_message_caching_stream->Next(
       SIZE_MAX, &calld->on_send_message_next_done)) {
-    grpc_error* error = pull_slice_from_send_message(calld);
+    grpc_error_handle error = pull_slice_from_send_message(calld);
     if (error != GRPC_ERROR_NONE) return error;
     if (calld->send_message_bytes_read ==
         calld->send_message_caching_stream->length()) {
@@ -263,7 +270,7 @@ static grpc_error* read_all_available_send_message_data(call_data* calld) {
 }
 
 // Async callback for ByteStream::Next().
-static void on_send_message_next_done(void* arg, grpc_error* error) {
+static void on_send_message_next_done(void* arg, grpc_error_handle error) {
   grpc_call_element* elem = static_cast<grpc_call_element*>(arg);
   call_data* calld = static_cast<call_data*>(elem->call_data);
   if (error != GRPC_ERROR_NONE) {
@@ -301,8 +308,8 @@ static char* slice_buffer_to_string(grpc_slice_buffer* slice_buffer) {
 
 // Modifies the path entry in the batch's send_initial_metadata to
 // append the base64-encoded query for a GET request.
-static grpc_error* update_path_for_get(grpc_call_element* elem,
-                                       grpc_transport_stream_op_batch* batch) {
+static grpc_error_handle update_path_for_get(
+    grpc_call_element* elem, grpc_transport_stream_op_batch* batch) {
   call_data* calld = static_cast<call_data*>(elem->call_data);
   grpc_slice path_slice =
       GRPC_MDVALUE(batch->payload->send_initial_metadata.send_initial_metadata
@@ -376,7 +383,7 @@ static void http_client_start_transport_stream_op_batch(
         &calld->recv_trailing_metadata_ready;
   }
 
-  grpc_error* error = GRPC_ERROR_NONE;
+  grpc_error_handle error = GRPC_ERROR_NONE;
   bool batch_will_be_handled_asynchronously = false;
   if (batch->send_initial_metadata) {
     // Decide which HTTP VERB to use. We use GET if the request is marked
@@ -475,7 +482,7 @@ done:
 }
 
 /* Constructor for call_data */
-static grpc_error* http_client_init_call_elem(
+static grpc_error_handle http_client_init_call_elem(
     grpc_call_element* elem, const grpc_call_element_args* args) {
   new (elem->call_data) call_data(elem, *args);
   return GRPC_ERROR_NONE;
@@ -561,7 +568,7 @@ static grpc_core::ManagedMemorySlice user_agent_from_args(
 }
 
 /* Constructor for channel_data */
-static grpc_error* http_client_init_channel_elem(
+static grpc_error_handle http_client_init_channel_elem(
     grpc_channel_element* elem, grpc_channel_element_args* args) {
   channel_data* chand = static_cast<channel_data*>(elem->channel_data);
   GPR_ASSERT(!args->is_last);