grpc 1.51.0 → 1.52.0

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

@@ -31,7 +31,7 @@
 #include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 
-#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/grpc.h>
 #include <grpc/slice.h>
 #include <grpc/status.h>
 #include <grpc/support/log.h>
@@ -59,6 +59,7 @@
 #include "src/core/lib/handshaker/proxy_mapper_registry.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/pollset_set.h"
+#include "src/core/lib/slice/slice_internal.h"
 #include "src/core/lib/surface/channel_init.h"
 #include "src/core/lib/surface/channel_stack_type.h"
 #include "src/core/lib/surface/init_internally.h"
@@ -150,14 +151,14 @@ SubchannelCall::SubchannelCall(Args args, grpc_error_handle* error)
       deadline_(args.deadline) {
   grpc_call_stack* callstk = SUBCHANNEL_CALL_TO_CALL_STACK(this);
   const grpc_call_element_args call_args = {
-      callstk,             /* call_stack */
-      nullptr,             /* server_transport_data */
-      args.context,        /* context */
-      args.path.c_slice(), /* path */
-      args.start_time,     /* start_time */
-      args.deadline,       /* deadline */
-      args.arena,          /* arena */
-      args.call_combiner   /* call_combiner */
+      callstk,              // call_stack
+      nullptr,              // server_transport_data
+      args.context,         // context
+      args.path.c_slice(),  // path
+      args.start_time,      // start_time
+      args.deadline,        // deadline
+      args.arena,           // arena
+      args.call_combiner    // call_combiner
   };
   *error = grpc_call_stack_init(connected_subchannel_->channel_stack(), 1,
                                 SubchannelCall::Destroy, this, &call_args);
@@ -310,67 +311,44 @@ class Subchannel::ConnectedSubchannelStateWatcher
   void OnConnectivityStateChange(grpc_connectivity_state new_state,
                                  const absl::Status& status) override {
     Subchannel* c = subchannel_.get();
-    MutexLock lock(&c->mu_);
-    // If we're either shutting down or have already seen this connection
-    // failure (i.e., c->connected_subchannel_ is null), do nothing.
-    //
-    // The transport reports TRANSIENT_FAILURE upon GOAWAY but SHUTDOWN
-    // upon connection close.  So if the server gracefully shuts down,
-    // we will see TRANSIENT_FAILURE followed by SHUTDOWN, but if not, we
-    // will see only SHUTDOWN.  Either way, we react to the first one we
-    // see, ignoring anything that happens after that.
-    if (c->connected_subchannel_ == nullptr) return;
-    if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
-        new_state == GRPC_CHANNEL_SHUTDOWN) {
-      if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel)) {
-        gpr_log(GPR_INFO,
-                "subchannel %p %s: Connected subchannel %p reports %s: %s", c,
-                c->key_.ToString().c_str(), c->connected_subchannel_.get(),
-                ConnectivityStateName(new_state), status.ToString().c_str());
-      }
-      c->connected_subchannel_.reset();
-      if (c->channelz_node() != nullptr) {
-        c->channelz_node()->SetChildSocket(nullptr);
+    {
+      MutexLock lock(&c->mu_);
+      // If we're either shutting down or have already seen this connection
+      // failure (i.e., c->connected_subchannel_ is null), do nothing.
+      //
+      // The transport reports TRANSIENT_FAILURE upon GOAWAY but SHUTDOWN
+      // upon connection close.  So if the server gracefully shuts down,
+      // we will see TRANSIENT_FAILURE followed by SHUTDOWN, but if not, we
+      // will see only SHUTDOWN.  Either way, we react to the first one we
+      // see, ignoring anything that happens after that.
+      if (c->connected_subchannel_ == nullptr) return;
+      if (new_state == GRPC_CHANNEL_TRANSIENT_FAILURE ||
+          new_state == GRPC_CHANNEL_SHUTDOWN) {
+        if (GRPC_TRACE_FLAG_ENABLED(grpc_trace_subchannel)) {
+          gpr_log(GPR_INFO,
+                  "subchannel %p %s: Connected subchannel %p reports %s: %s", c,
+                  c->key_.ToString().c_str(), c->connected_subchannel_.get(),
+                  ConnectivityStateName(new_state), status.ToString().c_str());
+        }
+        c->connected_subchannel_.reset();
+        if (c->channelz_node() != nullptr) {
+          c->channelz_node()->SetChildSocket(nullptr);
+        }
+        // Even though we're reporting IDLE instead of TRANSIENT_FAILURE here,
+        // pass along the status from the transport, since it may have
+        // keepalive info attached to it that the channel needs.
+        // TODO(roth): Consider whether there's a cleaner way to do this.
+        c->SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, status);
+        c->backoff_.Reset();
       }
-      // Even though we're reporting IDLE instead of TRANSIENT_FAILURE here,
-      // pass along the status from the transport, since it may have
-      // keepalive info attached to it that the channel needs.
-      // TODO(roth): Consider whether there's a cleaner way to do this.
-      c->SetConnectivityStateLocked(GRPC_CHANNEL_IDLE, status);
-      c->backoff_.Reset();
     }
+    // Drain any connectivity state notifications after releasing the mutex.
+    c->work_serializer_.DrainQueue();
   }
 
   WeakRefCountedPtr<Subchannel> subchannel_;
 };
 
-// Asynchronously notifies the \a watcher of a change in the connectvity state
-// of \a subchannel to the current \a state. Deletes itself when done.
-class Subchannel::AsyncWatcherNotifierLocked {
- public:
-  AsyncWatcherNotifierLocked(
-      RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher,
-      grpc_connectivity_state state, const absl::Status& status)
-      : watcher_(std::move(watcher)) {
-    watcher_->PushConnectivityStateChange({state, status});
-    ExecCtx::Run(DEBUG_LOCATION,
-                 GRPC_CLOSURE_INIT(
-                     &closure_,
-                     [](void* arg, grpc_error_handle /*error*/) {
-                       auto* self =
-                           static_cast<AsyncWatcherNotifierLocked*>(arg);
-                       self->watcher_->OnConnectivityStateChange();
-                       delete self;
-                     },
-                     this, nullptr),
-                 absl::OkStatus());
-  }
-
- private:
-  RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher_;
-  grpc_closure closure_;
-};
-
 //
 // Subchannel::ConnectivityStateWatcherList
 //
@@ -388,7 +366,11 @@ void Subchannel::ConnectivityStateWatcherList::RemoveWatcherLocked(
 void Subchannel::ConnectivityStateWatcherList::NotifyLocked(
     grpc_connectivity_state state, const absl::Status& status) {
   for (const auto& p : watchers_) {
-    new AsyncWatcherNotifierLocked(p.second, state, status);
+    subchannel_->work_serializer_.Schedule(
+        [watcher = p.second->Ref(), state, status]() {
+          watcher->OnConnectivityStateChange(state, status);
+        },
+        DEBUG_LOCATION);
   }
 }
 
@@ -407,7 +389,8 @@ class Subchannel::HealthWatcherMap::HealthWatcher
         health_check_service_name_(std::move(health_check_service_name)),
         state_(subchannel_->state_ == GRPC_CHANNEL_READY
                    ? GRPC_CHANNEL_CONNECTING
-                   : subchannel_->state_) {
+                   : subchannel_->state_),
+        watcher_list_(subchannel_.get()) {
     // If the subchannel is already connected, start health checking.
     if (subchannel_->state_ == GRPC_CHANNEL_READY) StartHealthCheckingLocked();
   }
@@ -424,7 +407,11 @@ class Subchannel::HealthWatcherMap::HealthWatcher
 
   void AddWatcherLocked(
       RefCountedPtr<Subchannel::ConnectivityStateWatcherInterface> watcher) {
-    new AsyncWatcherNotifierLocked(watcher, state_, status_);
+    subchannel_->work_serializer_.Schedule(
+        [watcher = watcher->Ref(), state = state_, status = status_]() {
+          watcher->OnConnectivityStateChange(state, status);
+        },
+        DEBUG_LOCATION);
     watcher_list_.AddWatcherLocked(std::move(watcher));
   }
 
@@ -467,12 +454,17 @@ class Subchannel::HealthWatcherMap::HealthWatcher
  private:
   void OnConnectivityStateChange(grpc_connectivity_state new_state,
                                  const absl::Status& status) override {
-    MutexLock lock(&subchannel_->mu_);
-    if (new_state != GRPC_CHANNEL_SHUTDOWN && health_check_client_ != nullptr) {
-      state_ = new_state;
-      status_ = status;
-      watcher_list_.NotifyLocked(new_state, status);
+    {
+      MutexLock lock(&subchannel_->mu_);
+      if (new_state != GRPC_CHANNEL_SHUTDOWN &&
+          health_check_client_ != nullptr) {
+        state_ = new_state;
+        status_ = status;
+        watcher_list_.NotifyLocked(new_state, status);
+      }
     }
+    // Drain any connectivity state notifications after releasing the mutex.
+    subchannel_->work_serializer_.DrainQueue();
   }
 
   void StartHealthCheckingLocked()
@@ -552,25 +544,6 @@ Subchannel::HealthWatcherMap::CheckConnectivityStateLocked(
 
 void Subchannel::HealthWatcherMap::ShutdownLocked() { map_.clear(); }
 
-//
-// Subchannel::ConnectivityStateWatcherInterface
-//
-
-void Subchannel::ConnectivityStateWatcherInterface::PushConnectivityStateChange(
-    ConnectivityStateChange state_change) {
-  MutexLock lock(&mu_);
-  connectivity_state_queue_.push_back(std::move(state_change));
-}
-
-Subchannel::ConnectivityStateWatcherInterface::ConnectivityStateChange
-Subchannel::ConnectivityStateWatcherInterface::PopConnectivityStateChange() {
-  MutexLock lock(&mu_);
-  GPR_ASSERT(!connectivity_state_queue_.empty());
-  ConnectivityStateChange state_change = connectivity_state_queue_.front();
-  connectivity_state_queue_.pop_front();
-  return state_change;
-}
-
 //
 // Subchannel
 //
@@ -625,6 +598,7 @@ Subchannel::Subchannel(SubchannelKey key,
       args_(args),
       pollset_set_(grpc_pollset_set_create()),
       connector_(std::move(connector)),
+      watcher_list_(this),
       backoff_(ParseArgsForBackoffValues(args_, &min_connect_timeout_)),
       event_engine_(args_.GetObjectRef<EventEngine>()) {
   // A grpc_init is added here to ensure that grpc_shutdown does not happen
@@ -717,42 +691,59 @@ channelz::SubchannelNode* Subchannel::channelz_node() {
 void Subchannel::WatchConnectivityState(
     const absl::optional<std::string>& health_check_service_name,
     RefCountedPtr<ConnectivityStateWatcherInterface> watcher) {
-  MutexLock lock(&mu_);
-  grpc_pollset_set* interested_parties = watcher->interested_parties();
-  if (interested_parties != nullptr) {
-    grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
-  }
-  if (!health_check_service_name.has_value()) {
-    new AsyncWatcherNotifierLocked(watcher, state_, status_);
-    watcher_list_.AddWatcherLocked(std::move(watcher));
-  } else {
-    health_watcher_map_.AddWatcherLocked(
-        WeakRef(DEBUG_LOCATION, "health_watcher"), *health_check_service_name,
-        std::move(watcher));
+  {
+    MutexLock lock(&mu_);
+    grpc_pollset_set* interested_parties = watcher->interested_parties();
+    if (interested_parties != nullptr) {
+      grpc_pollset_set_add_pollset_set(pollset_set_, interested_parties);
+    }
+    if (!health_check_service_name.has_value()) {
+      work_serializer_.Schedule(
+          [watcher = watcher->Ref(), state = state_, status = status_]() {
+            watcher->OnConnectivityStateChange(state, status);
+          },
+          DEBUG_LOCATION);
+      watcher_list_.AddWatcherLocked(std::move(watcher));
+    } else {
+      health_watcher_map_.AddWatcherLocked(
+          WeakRef(DEBUG_LOCATION, "health_watcher"), *health_check_service_name,
+          std::move(watcher));
+    }
   }
+  // Drain any connectivity state notifications after releasing the mutex.
+  work_serializer_.DrainQueue();
 }
 
 void Subchannel::CancelConnectivityStateWatch(
     const absl::optional<std::string>& health_check_service_name,
     ConnectivityStateWatcherInterface* watcher) {
-  MutexLock lock(&mu_);
-  grpc_pollset_set* interested_parties = watcher->interested_parties();
-  if (interested_parties != nullptr) {
-    grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
-  }
-  if (!health_check_service_name.has_value()) {
-    watcher_list_.RemoveWatcherLocked(watcher);
-  } else {
-    health_watcher_map_.RemoveWatcherLocked(*health_check_service_name,
-                                            watcher);
+  {
+    MutexLock lock(&mu_);
+    grpc_pollset_set* interested_parties = watcher->interested_parties();
+    if (interested_parties != nullptr) {
+      grpc_pollset_set_del_pollset_set(pollset_set_, interested_parties);
+    }
+    if (!health_check_service_name.has_value()) {
+      watcher_list_.RemoveWatcherLocked(watcher);
+    } else {
+      health_watcher_map_.RemoveWatcherLocked(*health_check_service_name,
+                                              watcher);
+    }
   }
+  // Drain any connectivity state notifications after releasing the mutex.
+  // (Shouldn't actually be necessary in this case, but better safe than sorry.)
+  work_serializer_.DrainQueue();
 }
 
 void Subchannel::RequestConnection() {
-  MutexLock lock(&mu_);
-  if (state_ == GRPC_CHANNEL_IDLE) {
-    StartConnectingLocked();
+  {
+    MutexLock lock(&mu_);
+    if (state_ == GRPC_CHANNEL_IDLE) {
+      StartConnectingLocked();
+    }
   }
+  // Drain any connectivity state notifications after releasing the mutex.
+  work_serializer_.DrainQueue();
 }
 
 void Subchannel::ResetBackoff() {
@@ -760,14 +751,18 @@ void Subchannel::ResetBackoff() {
   // does not eliminate the last ref and destroy the Subchannel before the
   // method returns.
   auto self = WeakRef(DEBUG_LOCATION, "ResetBackoff");
-  MutexLock lock(&mu_);
-  backoff_.Reset();
-  if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
-      event_engine_->Cancel(retry_timer_handle_)) {
-    OnRetryTimerLocked();
-  } else if (state_ == GRPC_CHANNEL_CONNECTING) {
-    next_attempt_time_ = Timestamp::Now();
+  {
+    MutexLock lock(&mu_);
+    backoff_.Reset();
+    if (state_ == GRPC_CHANNEL_TRANSIENT_FAILURE &&
+        event_engine_->Cancel(retry_timer_handle_)) {
+      OnRetryTimerLocked();
+    } else if (state_ == GRPC_CHANNEL_CONNECTING) {
+      next_attempt_time_ = Timestamp::Now();
+    }
   }
+  // Drain any connectivity state notifications after releasing the mutex.
+  work_serializer_.DrainQueue();
 }
 
 void Subchannel::Orphan() {
@@ -777,12 +772,16 @@ void Subchannel::Orphan() {
     subchannel_pool_->UnregisterSubchannel(key_, this);
     subchannel_pool_.reset();
   }
-  MutexLock lock(&mu_);
-  GPR_ASSERT(!shutdown_);
-  shutdown_ = true;
-  connector_.reset();
-  connected_subchannel_.reset();
-  health_watcher_map_.ShutdownLocked();
+  {
+    MutexLock lock(&mu_);
+    GPR_ASSERT(!shutdown_);
+    shutdown_ = true;
+    connector_.reset();
+    connected_subchannel_.reset();
+    health_watcher_map_.ShutdownLocked();
+  }
+  // Drain any connectivity state notifications after releasing the mutex.
+  work_serializer_.DrainQueue();
 }
 
 void Subchannel::GetOrAddDataProducer(
@@ -801,29 +800,6 @@ void Subchannel::RemoveDataProducer(DataProducerInterface* data_producer) {
   }
 }
 
-namespace {
-
-// Returns a string indicating the subchannel's connectivity state change to
-// \a state.
-const char* SubchannelConnectivityStateChangeString(
-    grpc_connectivity_state state) {
-  switch (state) {
-    case GRPC_CHANNEL_IDLE:
-      return "Subchannel state change to IDLE";
-    case GRPC_CHANNEL_CONNECTING:
-      return "Subchannel state change to CONNECTING";
-    case GRPC_CHANNEL_READY:
-      return "Subchannel state change to READY";
-    case GRPC_CHANNEL_TRANSIENT_FAILURE:
-      return "Subchannel state change to TRANSIENT_FAILURE";
-    case GRPC_CHANNEL_SHUTDOWN:
-      return "Subchannel state change to SHUTDOWN";
-  }
-  GPR_UNREACHABLE_CODE(return "UNKNOWN");
-}
-
-}  // namespace
-
 // Note: Must be called with a state that is different from the current state.
 void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
                                             const absl::Status& status) {
@@ -847,8 +823,10 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
     channelz_node_->UpdateConnectivityState(state);
     channelz_node_->AddTraceEvent(
         channelz::ChannelTrace::Severity::Info,
-        grpc_slice_from_static_string(
-            SubchannelConnectivityStateChangeString(state)));
+        grpc_slice_from_cpp_string(absl::StrCat(
+            "Subchannel connectivity state changed to ",
+            ConnectivityStateName(state),
+            status.ok() ? "" : absl::StrCat(": ", status_.ToString()))));
   }
   // Notify non-health watchers.
   watcher_list_.NotifyLocked(state, status_);
@@ -857,8 +835,12 @@ void Subchannel::SetConnectivityStateLocked(grpc_connectivity_state state,
 }
 
 void Subchannel::OnRetryTimer() {
-  MutexLock lock(&mu_);
-  OnRetryTimerLocked();
+  {
+    MutexLock lock(&mu_);
+    OnRetryTimerLocked();
+  }
+  // Drain any connectivity state notifications after releasing the mutex.
+  work_serializer_.DrainQueue();
 }
 
 void Subchannel::OnRetryTimerLocked() {
@@ -890,6 +872,8 @@ void Subchannel::OnConnectingFinished(void* arg, grpc_error_handle error) {
     MutexLock lock(&c->mu_);
     c->OnConnectingFinishedLocked(error);
   }
+  // Drain any connectivity state notifications after releasing the mutex.
+  c->work_serializer_.DrainQueue();
   c.reset(DEBUG_LOCATION, "Connect");
 }
 

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

@@ -21,7 +21,6 @@
 
 #include <stddef.h>
 
-#include <deque>
 #include <functional>
 #include <map>
 #include <memory>
@@ -32,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"
@@ -50,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"
@@ -167,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.
@@ -298,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(
@@ -313,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*,
@@ -355,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,
@@ -411,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_);

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/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>
 
@@ -35,6 +38,9 @@
 #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"
@@ -344,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,
@@ -360,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"
@@ -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()) {