grpc 1.45.0 → 1.47.0

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

@@ -0,0 +1,226 @@
+//
+// 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_STREAM_CLIENT_H
+#define GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H
+
+#include <grpc/support/port_platform.h>
+
+#include <atomic>
+#include <memory>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+
+#include <grpc/event_engine/memory_allocator.h>
+#include <grpc/slice.h>
+#include <grpc/status.h>
+
+#include "src/core/ext/filters/client_channel/subchannel.h"
+#include "src/core/lib/backoff/backoff.h"
+#include "src/core/lib/channel/context.h"
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/sync.h"
+#include "src/core/lib/iomgr/call_combiner.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/iomgr_fwd.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+#include "src/core/lib/iomgr/timer.h"
+#include "src/core/lib/resource_quota/arena.h"
+#include "src/core/lib/resource_quota/memory_quota.h"
+#include "src/core/lib/slice/slice.h"
+#include "src/core/lib/transport/byte_stream.h"
+#include "src/core/lib/transport/metadata_batch.h"
+#include "src/core/lib/transport/transport.h"
+
+namespace grpc_core {
+
+// Represents a streaming call on a subchannel that should be maintained
+// open at all times.
+// If the call fails with UNIMPLEMENTED, no further attempts are made.
+// If the call fails with any other status (including OK), we retry the
+// call with appropriate backoff.
+// The backoff state is reset when we receive a message on a stream.
+//
+// Currently, this assumes server-side streaming, but it could be extended
+// to support full bidi streaming if there is a need in the future.
+class SubchannelStreamClient
+    : public InternallyRefCounted<SubchannelStreamClient> {
+ public:
+  // Interface implemented by caller.  Thread safety is provided for the
+  // implementation; only one method will be called by any thread at any
+  // one time (including destruction).
+  //
+  // The address of the SubchannelStreamClient object is passed to most
+  // methods for logging purposes.
+  class CallEventHandler {
+   public:
+    virtual ~CallEventHandler() = default;
+
+    // Returns the path for the streaming call.
+    virtual Slice GetPathLocked()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&SubchannelStreamClient::mu_) = 0;
+    // Called when a new call attempt is being started.
+    virtual void OnCallStartLocked(SubchannelStreamClient* client)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&SubchannelStreamClient::mu_) = 0;
+    // Called when a previous call attempt has failed and the retry
+    // timer is started before the next attempt.
+    virtual void OnRetryTimerStartLocked(SubchannelStreamClient* client)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&SubchannelStreamClient::mu_) = 0;
+    // Returns the message payload to send from the client.
+    virtual grpc_slice EncodeSendMessageLocked()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&SubchannelStreamClient::mu_) = 0;
+    // Called whenever a message is received from the server.
+    virtual absl::Status RecvMessageReadyLocked(
+        SubchannelStreamClient* client, absl::string_view serialized_message)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&SubchannelStreamClient::mu_) = 0;
+    // Called when a stream fails.
+    virtual void RecvTrailingMetadataReadyLocked(SubchannelStreamClient* client,
+                                                 grpc_status_code status)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&SubchannelStreamClient::mu_) = 0;
+  };
+
+  // If tracer is non-null, it enables trace logging, with the specified
+  // string being the first part of the log message.
+  // Does not take ownership of interested_parties; the caller is responsible
+  // for ensuring that it will outlive the SubchannelStreamClient.
+  SubchannelStreamClient(
+      RefCountedPtr<ConnectedSubchannel> connected_subchannel,
+      grpc_pollset_set* interested_parties,
+      std::unique_ptr<CallEventHandler> event_handler, const char* tracer);
+
+  ~SubchannelStreamClient() override;
+
+  void Orphan() override;
+
+ private:
+  // Contains a call to the backend and all the data related to the call.
+  class CallState : public Orphanable {
+   public:
+    CallState(RefCountedPtr<SubchannelStreamClient> client,
+              grpc_pollset_set* interested_parties);
+    ~CallState() override;
+
+    void Orphan() override;
+
+    void StartCallLocked()
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&SubchannelStreamClient::mu_);
+
+   private:
+    void Cancel();
+
+    void StartBatch(grpc_transport_stream_op_batch* batch);
+    static void StartBatchInCallCombiner(void* arg, grpc_error_handle error);
+
+    void CallEndedLocked(bool retry)
+        ABSL_EXCLUSIVE_LOCKS_REQUIRED(&subchannel_stream_client_->mu_);
+
+    static void OnComplete(void* arg, grpc_error_handle error);
+    static void RecvInitialMetadataReady(void* arg, grpc_error_handle error);
+    static void RecvMessageReady(void* arg, grpc_error_handle error);
+    static void RecvTrailingMetadataReady(void* arg, grpc_error_handle error);
+    static void StartCancel(void* arg, grpc_error_handle error);
+    static void OnCancelComplete(void* arg, grpc_error_handle error);
+
+    static void OnByteStreamNext(void* arg, grpc_error_handle error);
+    void ContinueReadingRecvMessage();
+    grpc_error_handle PullSliceFromRecvMessage();
+    void DoneReadingRecvMessage(grpc_error_handle error);
+
+    static void AfterCallStackDestruction(void* arg, grpc_error_handle error);
+
+    RefCountedPtr<SubchannelStreamClient> subchannel_stream_client_;
+    grpc_polling_entity pollent_;
+
+    ScopedArenaPtr arena_;
+    CallCombiner call_combiner_;
+    grpc_call_context_element context_[GRPC_CONTEXT_COUNT] = {};
+
+    // The streaming call to the backend. Always non-null.
+    // Refs are tracked manually; when the last ref is released, the
+    // CallState object will be automatically destroyed.
+    SubchannelCall* call_;
+
+    grpc_transport_stream_op_batch_payload payload_;
+    grpc_transport_stream_op_batch batch_;
+    grpc_transport_stream_op_batch recv_message_batch_;
+    grpc_transport_stream_op_batch recv_trailing_metadata_batch_;
+
+    grpc_closure on_complete_;
+
+    // send_initial_metadata
+    grpc_metadata_batch send_initial_metadata_;
+
+    // send_message
+    absl::optional<SliceBufferByteStream> send_message_;
+
+    // send_trailing_metadata
+    grpc_metadata_batch send_trailing_metadata_;
+
+    // recv_initial_metadata
+    grpc_metadata_batch recv_initial_metadata_;
+    grpc_closure recv_initial_metadata_ready_;
+
+    // recv_message
+    OrphanablePtr<ByteStream> recv_message_;
+    grpc_closure recv_message_ready_;
+    grpc_slice_buffer recv_message_buffer_;
+    std::atomic<bool> seen_response_{false};
+
+    // True if the cancel_stream batch has been started.
+    std::atomic<bool> cancelled_{false};
+
+    // recv_trailing_metadata
+    grpc_metadata_batch recv_trailing_metadata_;
+    grpc_transport_stream_stats collect_stats_;
+    grpc_closure recv_trailing_metadata_ready_;
+
+    // Closure for call stack destruction.
+    grpc_closure after_call_stack_destruction_;
+  };
+
+  void StartCall();
+  void StartCallLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+
+  void StartRetryTimerLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(&mu_);
+  static void OnRetryTimer(void* arg, grpc_error_handle error);
+
+  RefCountedPtr<ConnectedSubchannel> connected_subchannel_;
+  grpc_pollset_set* interested_parties_;  // Do not own.
+  const char* tracer_;
+  MemoryAllocator call_allocator_;
+
+  Mutex mu_;
+  std::unique_ptr<CallEventHandler> event_handler_ ABSL_GUARDED_BY(mu_);
+
+  // The data associated with the current health check call.  It holds a ref
+  // to this SubchannelStreamClient object.
+  OrphanablePtr<CallState> call_state_ ABSL_GUARDED_BY(mu_);
+
+  // Call retry state.
+  BackOff retry_backoff_ ABSL_GUARDED_BY(mu_);
+  grpc_timer retry_timer_ ABSL_GUARDED_BY(mu_);
+  grpc_closure retry_timer_callback_ ABSL_GUARDED_BY(mu_);
+  bool retry_timer_callback_pending_ ABSL_GUARDED_BY(mu_) = false;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_SUBCHANNEL_STREAM_CLIENT_H

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

@@ -347,6 +347,7 @@ const grpc_channel_filter grpc_client_deadline_filter = {
     deadline_destroy_call_elem,
     0,  // sizeof(channel_data)
     deadline_init_channel_elem,
+    grpc_channel_stack_no_post_init,
     deadline_destroy_channel_elem,
     grpc_channel_next_get_info,
     "deadline",
@@ -362,6 +363,7 @@ const grpc_channel_filter grpc_server_deadline_filter = {
     deadline_destroy_call_elem,
     0,  // sizeof(channel_data)
     deadline_init_channel_elem,
+    grpc_channel_stack_no_post_init,
     deadline_destroy_channel_elem,
     grpc_channel_next_get_info,
     "deadline",
@@ -380,8 +382,10 @@ void RegisterDeadlineFilter(CoreConfiguration::Builder* builder) {
     builder->channel_init()->RegisterStage(
         type, GRPC_CHANNEL_INIT_BUILTIN_PRIORITY,
         [filter](ChannelStackBuilder* builder) {
-          if (grpc_deadline_checking_enabled(builder->channel_args())) {
-            builder->PrependFilter(filter, nullptr);
+          auto args = builder->channel_args();
+          if (args.GetBool(GRPC_ARG_ENABLE_DEADLINE_CHECKS)
+                  .value_or(!args.WantMinimalStack())) {
+            builder->PrependFilter(filter);
           }
           return true;
         });