grpc 1.39.0 → 1.40.0.pre1

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

@@ -159,9 +159,9 @@ RetryServiceConfigParser::ParseGlobalParams(const grpc_channel_args* /*args*/,
 namespace {
 
 grpc_error_handle ParseRetryPolicy(
-    const Json& json, int* max_attempts, grpc_millis* initial_backoff,
-    grpc_millis* max_backoff, float* backoff_multiplier,
-    StatusCodeSet* retryable_status_codes,
+    const grpc_channel_args* args, const Json& json, int* max_attempts,
+    grpc_millis* initial_backoff, grpc_millis* max_backoff,
+    float* backoff_multiplier, StatusCodeSet* retryable_status_codes,
     absl::optional<grpc_millis>* per_attempt_recv_timeout) {
   if (json.type() != Json::Type::OBJECT) {
     return GRPC_ERROR_CREATE_FROM_STATIC_STRING(
@@ -251,28 +251,38 @@ grpc_error_handle ParseRetryPolicy(
     }
   }
   // Parse perAttemptRecvTimeout.
-  it = json.object_value().find("perAttemptRecvTimeout");
-  if (it != json.object_value().end()) {
-    grpc_millis per_attempt_recv_timeout_value;
-    if (!ParseDurationFromJson(it->second, &per_attempt_recv_timeout_value)) {
-      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-          "field:perAttemptRecvTimeout error:type must be STRING of the "
-          "form given by google.proto.Duration."));
-    } else {
-      *per_attempt_recv_timeout = per_attempt_recv_timeout_value;
-      // TODO(roth): As part of implementing hedging, relax this check such
-      // that we allow a value of 0 if a hedging policy is specified.
-      if (per_attempt_recv_timeout_value == 0) {
+  if (grpc_channel_args_find_bool(args, GRPC_ARG_EXPERIMENTAL_ENABLE_HEDGING,
+                                  false)) {
+    it = json.object_value().find("perAttemptRecvTimeout");
+    if (it != json.object_value().end()) {
+      grpc_millis per_attempt_recv_timeout_value;
+      if (!ParseDurationFromJson(it->second, &per_attempt_recv_timeout_value)) {
         error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-            "field:perAttemptRecvTimeout error:must be greater than 0"));
+            "field:perAttemptRecvTimeout error:type must be STRING of the "
+            "form given by google.proto.Duration."));
+      } else {
+        *per_attempt_recv_timeout = per_attempt_recv_timeout_value;
+        // TODO(roth): As part of implementing hedging, relax this check such
+        // that we allow a value of 0 if a hedging policy is specified.
+        if (per_attempt_recv_timeout_value == 0) {
+          error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+              "field:perAttemptRecvTimeout error:must be greater than 0"));
+        }
       }
+    } else if (retryable_status_codes->Empty()) {
+      // If perAttemptRecvTimeout not present, retryableStatusCodes must be
+      // non-empty.
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:must be non-empty if "
+          "perAttemptRecvTimeout not present"));
+    }
+  } else {
+    // Hedging not enabled, so the error message for
+    // retryableStatusCodes unset should be different.
+    if (retryable_status_codes->Empty()) {
+      error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
+          "field:retryableStatusCodes error:must be non-empty"));
     }
-  } else if (retryable_status_codes->Empty()) {
-    // If perAttemptRecvTimeout not present, retryableStatusCodes must be
-    // non-empty.
-    error_list.push_back(GRPC_ERROR_CREATE_FROM_STATIC_STRING(
-        "field:retryableStatusCodes error:must be non-empty if "
-        "perAttemptRecvTimeout not present"));
   }
   return GRPC_ERROR_CREATE_FROM_VECTOR("retryPolicy", &error_list);
 }
@@ -280,9 +290,9 @@ grpc_error_handle ParseRetryPolicy(
 }  // namespace
 
 std::unique_ptr<ServiceConfigParser::ParsedConfig>
-RetryServiceConfigParser::ParsePerMethodParams(
-    const grpc_channel_args* /*args*/, const Json& json,
-    grpc_error_handle* error) {
+RetryServiceConfigParser::ParsePerMethodParams(const grpc_channel_args* args,
+                                               const Json& json,
+                                               grpc_error_handle* error) {
   GPR_DEBUG_ASSERT(error != nullptr && *error == GRPC_ERROR_NONE);
   // Parse retry policy.
   auto it = json.object_value().find("retryPolicy");
@@ -293,7 +303,7 @@ RetryServiceConfigParser::ParsePerMethodParams(
   float backoff_multiplier = 0;
   StatusCodeSet retryable_status_codes;
   absl::optional<grpc_millis> per_attempt_recv_timeout;
-  *error = ParseRetryPolicy(it->second, &max_attempts, &initial_backoff,
+  *error = ParseRetryPolicy(args, it->second, &max_attempts, &initial_backoff,
                             &max_backoff, &backoff_multiplier,
                             &retryable_status_codes, &per_attempt_recv_timeout);
   if (*error != GRPC_ERROR_NONE) return nullptr;

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

@@ -83,7 +83,7 @@ class RetryServiceConfigParser : public ServiceConfigParser::Parser {
       grpc_error_handle* error) override;
 
   std::unique_ptr<ServiceConfigParser::ParsedConfig> ParsePerMethodParams(
-      const grpc_channel_args* /*args*/, const Json& json,
+      const grpc_channel_args* args, const Json& json,
       grpc_error_handle* error) override;
 
   static size_t ParserIndex();

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

@@ -23,6 +23,7 @@
 
 #include "absl/strings/string_view.h"
 
+#include "src/core/ext/filters/client_channel/config_selector.h"
 #include "src/core/ext/filters/client_channel/service_config.h"
 #include "src/core/ext/filters/client_channel/service_config_parser.h"
 #include "src/core/lib/channel/context.h"
@@ -39,11 +40,13 @@ class ServiceConfigCallData {
   ServiceConfigCallData(
       RefCountedPtr<ServiceConfig> service_config,
       const ServiceConfigParser::ParsedConfigVector* method_configs,
-      std::map<const char*, absl::string_view> call_attributes,
+      ConfigSelector::CallAttributes call_attributes,
+      ConfigSelector::CallDispatchController* call_dispatch_controller,
       grpc_call_context_element* call_context)
       : service_config_(std::move(service_config)),
         method_configs_(method_configs),
-        call_attributes_(std::move(call_attributes)) {
+        call_attributes_(std::move(call_attributes)),
+        call_dispatch_controller_(call_dispatch_controller) {
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].value = this;
     call_context[GRPC_CONTEXT_SERVICE_CONFIG_CALL_DATA].destroy = Destroy;
   }
@@ -53,7 +56,7 @@ class ServiceConfigCallData {
       const ServiceConfigParser::ParsedConfigVector* method_configs,
       grpc_call_context_element* call_context)
       : ServiceConfigCallData(std::move(service_config), method_configs, {},
-                              call_context) {}
+                              nullptr, call_context) {}
 
   ServiceConfig* service_config() { return service_config_.get(); }
 
@@ -70,15 +73,52 @@ class ServiceConfigCallData {
     return call_attributes_;
   }
 
+  ConfigSelector::CallDispatchController* call_dispatch_controller() {
+    return &call_dispatch_controller_;
+  }
+
  private:
+  // A wrapper for the CallDispatchController returned by the ConfigSelector.
+  // Handles the case where the ConfigSelector doees not return any
+  // CallDispatchController.
+  // Also ensures that we call Commit() at most once, which allows the
+  // client channel code to call Commit() when the call is complete in case
+  // it wasn't called earlier, without needing to know whether or not it was.
+  class SingleCommitCallDispatchController
+      : public ConfigSelector::CallDispatchController {
+   public:
+    explicit SingleCommitCallDispatchController(
+        ConfigSelector::CallDispatchController* call_dispatch_controller)
+        : call_dispatch_controller_(call_dispatch_controller) {}
+
+    bool ShouldRetry() override {
+      if (call_dispatch_controller_ != nullptr) {
+        return call_dispatch_controller_->ShouldRetry();
+      }
+      return true;
+    }
+
+    void Commit() override {
+      if (call_dispatch_controller_ != nullptr && !commit_called_) {
+        call_dispatch_controller_->Commit();
+        commit_called_ = true;
+      }
+    }
+
+   private:
+    ConfigSelector::CallDispatchController* call_dispatch_controller_;
+    bool commit_called_ = false;
+  };
+
   static void Destroy(void* ptr) {
     ServiceConfigCallData* self = static_cast<ServiceConfigCallData*>(ptr);
     self->~ServiceConfigCallData();
   }
 
   RefCountedPtr<ServiceConfig> service_config_;
-  const ServiceConfigParser::ParsedConfigVector* method_configs_ = nullptr;
-  std::map<const char*, absl::string_view> call_attributes_;
+  const ServiceConfigParser::ParsedConfigVector* method_configs_;
+  ConfigSelector::CallAttributes call_attributes_;
+  SingleCommitCallDispatchController call_dispatch_controller_;
 };
 
 }  // namespace grpc_core

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

@@ -428,12 +428,6 @@ void CallData::DelayBatch(grpc_call_element* elem,
   MutexLock lock(&delay_mu_);
   delayed_batch_ = batch;
   resume_batch_canceller_ = new ResumeBatchCanceller(elem);
-  // Without this line, ExecCtx::Get()->Now() will return a cached timestamp. If
-  // there are thousands of RPCs happen on one thread, we might observe ms-level
-  // error in Now(). This could mean the construction of RPC object is
-  // microseconds earlier than the filter execution. But we still haven't found
-  // the root cause. Read more: https://github.com/grpc/grpc/pull/25738.
-  ExecCtx::Get()->InvalidateNow();
   grpc_millis resume_time = ExecCtx::Get()->Now() + fi_policy_->delay;
   GRPC_CLOSURE_INIT(&batch->handler_private.closure, ResumeBatch, elem,
                     grpc_schedule_on_exec_ctx);

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

@@ -232,6 +232,9 @@ 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();
+  // Set the batch's send_message bit back to true, so the retry code
+  // above knows what was in this batch.
+  calld->send_message_batch->send_message = true;
   grpc_core::Closure::Run(DEBUG_LOCATION,
                           calld->original_send_message_on_complete,
                           GRPC_ERROR_REF(error));
@@ -474,8 +477,8 @@ static void http_client_start_transport_stream_op_batch(
 
 done:
   if (error != GRPC_ERROR_NONE) {
-    grpc_transport_stream_op_batch_finish_with_failure(
-        calld->send_message_batch, error, calld->call_combiner);
+    grpc_transport_stream_op_batch_finish_with_failure(batch, error,
+                                                       calld->call_combiner);
   } else if (!batch_will_be_handled_asynchronously) {
     grpc_call_next_op(elem, batch);
   }

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -127,7 +127,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       static void OnHandshakeDone(void* arg, grpc_error_handle error);
       RefCountedPtr<ActiveConnection> const connection_;
       grpc_pollset* const accepting_pollset_;
-      grpc_tcp_server_acceptor* const acceptor_;
+      grpc_tcp_server_acceptor* acceptor_;
       RefCountedPtr<HandshakeManager> handshake_mgr_
           ABSL_GUARDED_BY(&connection_->mu_);
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
@@ -320,6 +320,7 @@ Chttp2ServerListener::ActiveConnection::HandshakingState::HandshakingState(
 Chttp2ServerListener::ActiveConnection::HandshakingState::~HandshakingState() {
   grpc_pollset_set_del_pollset(interested_parties_, accepting_pollset_);
   grpc_pollset_set_destroy(interested_parties_);
+  gpr_free(acceptor_);
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::Orphan() {
@@ -477,6 +478,7 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
     handshaking_state_ref = std::move(self->connection_->handshaking_state_);
   }
   gpr_free(self->acceptor_);
+  self->acceptor_ = nullptr;
   OrphanablePtr<ActiveConnection> connection;
   if (free_resource_quota && resource_user != nullptr) {
     grpc_resource_user_free(resource_user, GRPC_RESOURCE_QUOTA_CHANNEL_SIZE);
@@ -744,6 +746,8 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
   }
   auto connection =
       MakeOrphanable<ActiveConnection>(accepting_pollset, acceptor, args);
+  // We no longer own acceptor
+  acceptor = nullptr;
   // Hold a ref to connection to allow starting handshake outside the
   // critical region
   RefCountedPtr<ActiveConnection> connection_ref = connection->Ref();

data/src/core/ext/transport/chttp2/transport/bin_decoder.cc

@@ -146,7 +146,7 @@ bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx) {
       switch (input_tail) {
         case 3:
           ctx->output_cur[1] = COMPOSE_OUTPUT_BYTE_1(ctx->input_cur);
-        /* fallthrough */
+          ABSL_FALLTHROUGH_INTENDED;
         case 2:
           ctx->output_cur[0] = COMPOSE_OUTPUT_BYTE_0(ctx->input_cur);
       }

data/src/core/{lib/event_engine/slice_allocator.cc → ext/transport/chttp2/transport/chttp2_slice_allocator.cc}

@@ -17,71 +17,48 @@
 
 #include <functional>
 
+#include "absl/memory/memory.h"
 #include "absl/status/status.h"
 
+#include "src/core/ext/transport/chttp2/transport/chttp2_slice_allocator.h"
 #include "src/core/lib/iomgr/resource_quota.h"
 
 namespace grpc_event_engine {
 namespace experimental {
 
-SliceAllocator::SliceAllocator(grpc_resource_user* user)
-    : resource_user_(user) {
-  grpc_resource_user_ref(resource_user_);
-};
+Chttp2SliceAllocator::Chttp2SliceAllocator(grpc_resource_user* user)
+    : resource_user_(user) {}
 
-SliceAllocator::~SliceAllocator() {
+Chttp2SliceAllocator::~Chttp2SliceAllocator() {
   if (resource_user_ != nullptr) {
     grpc_resource_user_unref(resource_user_);
   }
-};
-
-SliceAllocator::SliceAllocator(SliceAllocator&& other) noexcept
-    : resource_user_(other.resource_user_) {
-  other.resource_user_ = nullptr;
-}
-
-SliceAllocator& SliceAllocator::operator=(SliceAllocator&& other) noexcept {
-  resource_user_ = other.resource_user_;
-  other.resource_user_ = nullptr;
-  return *this;
 }
 
-absl::Status SliceAllocator::Allocate(size_t size, SliceBuffer* dest,
-                                      SliceAllocator::AllocateCallback cb) {
+absl::Status Chttp2SliceAllocator::Allocate(
+    size_t size, SliceBuffer* dest, SliceAllocator::AllocateCallback cb) {
   // TODO(hork): merge the implementation from the uv-ee branch.
   (void)size;
   (void)dest;
   (void)cb;
   return absl::OkStatus();
-};
+}
 
-SliceAllocatorFactory::SliceAllocatorFactory(grpc_resource_quota* quota)
+Chttp2SliceAllocatorFactory::Chttp2SliceAllocatorFactory(
+    grpc_resource_quota* quota)
     : resource_quota_(quota) {
   grpc_resource_quota_ref_internal(resource_quota_);
-};
+}
 
-SliceAllocatorFactory::~SliceAllocatorFactory() {
+Chttp2SliceAllocatorFactory::~Chttp2SliceAllocatorFactory() {
   if (resource_quota_ != nullptr) {
     grpc_resource_quota_unref_internal(resource_quota_);
   }
 }
 
-SliceAllocatorFactory::SliceAllocatorFactory(
-    SliceAllocatorFactory&& other) noexcept
-    : resource_quota_(other.resource_quota_) {
-  other.resource_quota_ = nullptr;
-}
-
-SliceAllocatorFactory& SliceAllocatorFactory::operator=(
-    SliceAllocatorFactory&& other) noexcept {
-  resource_quota_ = other.resource_quota_;
-  other.resource_quota_ = nullptr;
-  return *this;
-}
-
-SliceAllocator SliceAllocatorFactory::CreateSliceAllocator(
-    absl::string_view peer_name) {
-  return SliceAllocator(
+std::unique_ptr<SliceAllocator>
+Chttp2SliceAllocatorFactory::CreateSliceAllocator(absl::string_view peer_name) {
+  return absl::make_unique<Chttp2SliceAllocator>(
       grpc_resource_user_create(resource_quota_, peer_name.data()));
 }
 

data/src/core/ext/transport/chttp2/transport/chttp2_slice_allocator.h

@@ -0,0 +1,74 @@
+// Copyright 2021 The 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_TRANSPORT_CHTTP2_TRANSPORT_CHTTP2_SLICE_ALLOCATOR_H
+#define GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CHTTP2_SLICE_ALLOCATOR_H
+
+#include <grpc/support/port_platform.h>
+
+#include "grpc/event_engine/slice_allocator.h"
+
+#include <functional>
+
+#include "absl/status/status.h"
+
+#include "src/core/lib/iomgr/resource_quota.h"
+
+namespace grpc_event_engine {
+namespace experimental {
+
+class Chttp2SliceAllocator
+    : public grpc_event_engine::experimental::SliceAllocator {
+ public:
+  /// gRPC-internal constructor. Takes ownership of a resource_user ref from the
+  /// caller.
+  explicit Chttp2SliceAllocator(grpc_resource_user* user);
+  // Not copyable
+  Chttp2SliceAllocator(Chttp2SliceAllocator& other) = delete;
+  Chttp2SliceAllocator& operator=(const Chttp2SliceAllocator& other) = delete;
+  // Not Moveable
+  Chttp2SliceAllocator(Chttp2SliceAllocator&& other) = delete;
+  Chttp2SliceAllocator& operator=(Chttp2SliceAllocator&& other) = delete;
+  ~Chttp2SliceAllocator() override;
+  absl::Status Allocate(size_t size, SliceBuffer* dest,
+                        SliceAllocator::AllocateCallback cb) override;
+
+ private:
+  grpc_resource_user* resource_user_;
+};
+
+class Chttp2SliceAllocatorFactory
+    : public grpc_event_engine::experimental::SliceAllocatorFactory {
+ public:
+  // gRPC-internal constructor
+  explicit Chttp2SliceAllocatorFactory(grpc_resource_quota* quota);
+  // Not copyable
+  Chttp2SliceAllocatorFactory(Chttp2SliceAllocatorFactory& other) = delete;
+  Chttp2SliceAllocatorFactory& operator=(
+      const Chttp2SliceAllocatorFactory& other) = delete;
+  // Not Moveable
+  Chttp2SliceAllocatorFactory(Chttp2SliceAllocatorFactory&& other) = delete;
+  Chttp2SliceAllocatorFactory& operator=(Chttp2SliceAllocatorFactory&& other) =
+      delete;
+  ~Chttp2SliceAllocatorFactory() override;
+  std::unique_ptr<SliceAllocator> CreateSliceAllocator(
+      absl::string_view peer_name) override;
+
+ private:
+  grpc_resource_quota* resource_quota_;
+};
+
+}  // namespace experimental
+}  // namespace grpc_event_engine
+
+#endif  // GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_CHTTP2_SLICE_ALLOCATOR_H

data/src/core/ext/transport/chttp2/transport/chttp2_transport.cc

@@ -215,7 +215,6 @@ grpc_chttp2_transport::~grpc_chttp2_transport() {
   cl = nullptr;
 
   grpc_slice_buffer_destroy_internal(&read_buffer);
-  grpc_chttp2_hpack_parser_destroy(&hpack_parser);
   grpc_chttp2_goaway_parser_destroy(&goaway_parser);
 
   for (i = 0; i < STREAM_LIST_COUNT; i++) {
@@ -485,7 +484,6 @@ grpc_chttp2_transport::grpc_chttp2_transport(
       settings[j][i] = grpc_chttp2_settings_parameters[i].default_value;
     }
   }
-  grpc_chttp2_hpack_parser_init(&hpack_parser);
   grpc_chttp2_goaway_parser_init(&goaway_parser);
 
   // configure http2 the way we like it
@@ -1288,7 +1286,6 @@ static void continue_fetching_send_locked(grpc_chttp2_transport* t,
     if (s->fetching_send_message == nullptr) {
       // Stream was cancelled before message fetch completed
       abort(); /* TODO(ctiller): what cleanup here? */
-      return;  /* early out */
     }
     if (s->fetched_send_message_length == s->fetching_send_message->length()) {
       int64_t notify_offset = s->next_message_end_offset;
@@ -1593,8 +1590,7 @@ static void perform_stream_op_locked(void* stream_op,
     grpc_chttp2_maybe_complete_recv_message(t, s);
     if (s->id != 0) {
       if (!s->read_closed && s->frame_storage.length == 0) {
-        size_t after = s->frame_storage.length +
-                       s->unprocessed_incoming_frames_buffer_cached_length;
+        size_t after = s->unprocessed_incoming_frames_buffer_cached_length;
         s->flow_control->IncomingByteStreamUpdate(GRPC_HEADER_SIZE_IN_BYTES,
                                                   before - after);
         grpc_chttp2_act_on_flowctl_action(s->flow_control->MakeAction(), t, s);
@@ -2447,7 +2443,7 @@ static void WithUrgency(grpc_chttp2_transport* t,
       break;
     case grpc_core::chttp2::FlowControlAction::Urgency::UPDATE_IMMEDIATELY:
       grpc_chttp2_initiate_write(t, reason);
-    // fallthrough
+      ABSL_FALLTHROUGH_INTENDED;
     case grpc_core::chttp2::FlowControlAction::Urgency::QUEUE_UPDATE:
       action();
       break;