grpc 1.70.1 → 1.72.0

data/src/core/{lib/transport → call}/call_filters.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FILTERS_H
-#define GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FILTERS_H
+#ifndef GRPC_SRC_CORE_CALL_CALL_FILTERS_H
+#define GRPC_SRC_CORE_CALL_CALL_FILTERS_H
 
 #include <grpc/support/port_platform.h>
 
@@ -24,6 +24,9 @@
 #include <type_traits>
 
 #include "absl/log/check.h"
+#include "src/core/call/call_state.h"
+#include "src/core/call/message.h"
+#include "src/core/call/metadata.h"
 #include "src/core/lib/promise/for_each.h"
 #include "src/core/lib/promise/if.h"
 #include "src/core/lib/promise/latch.h"
@@ -33,9 +36,6 @@
 #include "src/core/lib/promise/status_flag.h"
 #include "src/core/lib/promise/try_seq.h"
 #include "src/core/lib/transport/call_final_info.h"
-#include "src/core/lib/transport/call_state.h"
-#include "src/core/lib/transport/message.h"
-#include "src/core/lib/transport/metadata.h"
 #include "src/core/util/dump_args.h"
 #include "src/core/util/ref_counted.h"
 #include "src/core/util/ref_counted_ptr.h"
@@ -58,7 +58,7 @@
 //
 // The type of these members matters, and is selectable by the class
 // author. For $INTERCEPTOR_NAME in the above list:
-// - static const NoInterceptor $INTERCEPTOR_NAME:
+// - static inline const NoInterceptor $INTERCEPTOR_NAME:
 //   defines that this filter does not intercept this event.
 //   there is zero runtime cost added to handling that event by this filter.
 // - void $INTERCEPTOR_NAME($VALUE_TYPE&):
@@ -91,7 +91,7 @@
 //
 // Finally, OnFinalize is added to intecept call finalization.
 // It must have one of the signatures:
-// - static const NoInterceptor OnFinalize:
+// - static inline const NoInterceptor OnFinalize:
 //   the filter does not intercept call finalization.
 // - void OnFinalize(const grpc_call_final_info*):
 //   the filter intercepts call finalization.
@@ -111,13 +111,8 @@ namespace grpc_core {
 // Tag type to indicate no interception.
 // This is used to indicate that a filter does not intercept a particular
 // event.
-// In C++14 we declare these as (for example):
-//   static const NoInterceptor OnClientInitialMetadata;
-// and out-of-line provide the definition:
-//   const MyFilter::Call::NoInterceptor
-//   MyFilter::Call::OnClientInitialMetadata;
-// In C++17 and later we can use inline variables instead:
-//   inline static const NoInterceptor OnClientInitialMetadata;
+// We declare these as (for example):
+//   inline static inline const NoInterceptor OnClientInitialMetadata;
 struct NoInterceptor {};
 
 namespace filters_detail {
@@ -191,6 +186,12 @@ class NextMessage {
     DCHECK(has_value());
     return *message_;
   }
+  const Message& value() const {
+    DCHECK_NE(message_, taken());
+    DCHECK(ok());
+    DCHECK(has_value());
+    return *message_;
+  }
   MessageHandle TakeValue() {
     DCHECK_NE(message_, taken());
     DCHECK(ok());
@@ -205,6 +206,19 @@ class NextMessage {
     call_state_ = nullptr;
   }
 
+  template <typename Sink>
+  friend void AbslStringify(Sink& sink, const NextMessage& msg) {
+    if (!msg.ok()) {
+      sink.Append("<failure>");
+      return;
+    }
+    if (!msg.has_value()) {
+      sink.Append("<end-of-stream>");
+      return;
+    }
+    AbslStringify(sink, msg.value());
+  }
+
  private:
   static Message* end_of_stream() { return nullptr; }
   static Message* error() { return reinterpret_cast<Message*>(1); }
@@ -545,6 +559,31 @@ struct AddOpImpl<
   }
 };
 
+// void $INTERCEPTOR_NAME(const $VALUE_TYPE&, FilterType*)
+template <typename FilterType, typename T,
+          void (FilterType::Call::*impl)(const typename T::element_type&,
+                                         FilterType*)>
+struct AddOpImpl<FilterType, T,
+                 void (FilterType::Call::*)(const typename T::element_type&,
+                                            FilterType*),
+                 impl> {
+  static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
+    to.Add(0, 0,
+           Operator<T>{
+               channel_data,
+               call_offset,
+               [](void*, void* call_data, void* channel_data,
+                  T value) -> Poll<ResultOr<T>> {
+                 (static_cast<typename FilterType::Call*>(call_data)->*impl)(
+                     *value, static_cast<FilterType*>(channel_data));
+                 return ResultOr<T>{std::move(value), nullptr};
+               },
+               nullptr,
+               nullptr,
+           });
+  }
+};
+
 // $VALUE_HANDLE $INTERCEPTOR_NAME($VALUE_HANDLE, FilterType*)
 template <typename FilterType, typename T,
           T (FilterType::Call::*impl)(T, FilterType*)>
@@ -932,6 +971,30 @@ struct AddOpImpl<FilterType, T, R (FilterType::Call::*)(T, FilterType*), impl,
                  absl::enable_if_t<std::is_same<absl::StatusOr<T>,
                                                 PromiseResult<R>>::value>> {
   static void Add(FilterType* channel_data, size_t call_offset, Layout<T>& to) {
+#if defined(__GNUC__) && __GNUC__ == 9
+    // Workaround for a bug in GNU C++ 9 compilers that fail to compile this
+    // class.
+    class Promise {
+     public:
+      Promise(T value, typename FilterType::Call* call_data,
+              FilterType* channel_data)
+          : impl_(std::make_unique<R>(
+                (call_data->*impl)(std::move(value), channel_data))) {}
+
+      Poll<ResultOr<T>> PollOnce() {
+        auto p = (*impl_)();
+        auto* r = p.value_if_ready();
+        if (r == nullptr) return Pending{};
+        this->~Promise();
+        if (r->ok()) return ResultOr<T>{std::move(**r), nullptr};
+        return ResultOr<T>{nullptr,
+                           CancelledServerMetadataFromStatus(r->status())};
+      }
+
+     private:
+      std::unique_ptr<R> impl_;
+    };
+#else
     class Promise {
      public:
       Promise(T value, typename FilterType::Call* call_data,
@@ -951,6 +1014,7 @@ struct AddOpImpl<FilterType, T, R (FilterType::Call::*)(T, FilterType*), impl,
      private:
       GPR_NO_UNIQUE_ADDRESS R impl_;
     };
+#endif
     to.Add(sizeof(Promise), alignof(Promise),
            Operator<T>{
                channel_data,
@@ -1323,12 +1387,12 @@ class ServerTrailingMetadataInterceptor {
  public:
   class Call {
    public:
-    static const NoInterceptor OnClientInitialMetadata;
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnFinalize;
+    static const inline NoInterceptor OnClientInitialMetadata;
+    static const inline NoInterceptor OnServerInitialMetadata;
+    static const inline NoInterceptor OnClientToServerMessage;
+    static const inline NoInterceptor OnClientToServerHalfClose;
+    static const inline NoInterceptor OnServerToClientMessage;
+    static const inline NoInterceptor OnFinalize;
     void OnServerTrailingMetadata(ServerMetadata& md,
                                   ServerTrailingMetadataInterceptor* filter) {
       filter->fn_(md);
@@ -1340,23 +1404,6 @@ class ServerTrailingMetadataInterceptor {
  private:
   GPR_NO_UNIQUE_ADDRESS Fn fn_;
 };
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnClientInitialMetadata;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnServerInitialMetadata;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnClientToServerMessage;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnClientToServerHalfClose;
-template <typename Fn>
-const NoInterceptor
-    ServerTrailingMetadataInterceptor<Fn>::Call::OnServerToClientMessage;
-template <typename Fn>
-const NoInterceptor ServerTrailingMetadataInterceptor<Fn>::Call::OnFinalize;
 
 template <typename Fn>
 class ClientInitialMetadataInterceptor {
@@ -1367,12 +1414,12 @@ class ClientInitialMetadataInterceptor {
                                  ClientInitialMetadataInterceptor* filter) {
       return filter->fn_(md);
     }
-    static const NoInterceptor OnServerInitialMetadata;
-    static const NoInterceptor OnClientToServerMessage;
-    static const NoInterceptor OnClientToServerHalfClose;
-    static const NoInterceptor OnServerToClientMessage;
-    static const NoInterceptor OnServerTrailingMetadata;
-    static const NoInterceptor OnFinalize;
+    static const inline NoInterceptor OnServerInitialMetadata;
+    static const inline NoInterceptor OnClientToServerMessage;
+    static const inline NoInterceptor OnClientToServerHalfClose;
+    static const inline NoInterceptor OnServerToClientMessage;
+    static const inline NoInterceptor OnServerTrailingMetadata;
+    static const inline NoInterceptor OnFinalize;
   };
 
   explicit ClientInitialMetadataInterceptor(Fn fn) : fn_(std::move(fn)) {}
@@ -1380,24 +1427,37 @@ class ClientInitialMetadataInterceptor {
  private:
   GPR_NO_UNIQUE_ADDRESS Fn fn_;
 };
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnServerInitialMetadata;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnClientToServerMessage;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnClientToServerHalfClose;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnServerToClientMessage;
-template <typename Fn>
-const NoInterceptor
-    ClientInitialMetadataInterceptor<Fn>::Call::OnServerTrailingMetadata;
-template <typename Fn>
-const NoInterceptor ClientInitialMetadataInterceptor<Fn>::Call::OnFinalize;
 
+// Determine if an interceptor needs to access the channel via one of its
+// arguments.
+
+template <typename T>
+constexpr bool MethodHasChannelAccess = false;
+
+template <typename T, typename R, typename A>
+constexpr bool MethodHasChannelAccess<R (T::*)(A)> = false;
+
+template <typename T, typename R>
+constexpr bool MethodHasChannelAccess<R (T::*)()> = false;
+
+template <typename T, typename R, typename A, typename C>
+constexpr bool MethodHasChannelAccess<R (T::*)(A, C)> = true;
+
+template <auto... Ts>
+constexpr bool AnyMethodHasChannelAccess =
+    (MethodHasChannelAccess<decltype(Ts)> || ...);
+
+// Composite for a given channel type to determine if any of its interceptors
+// fall into this category: later code should use this.
+template <typename Derived>
+inline constexpr bool CallHasChannelAccess() {
+  return AnyMethodHasChannelAccess<&Derived::Call::OnClientInitialMetadata,
+                                   &Derived::Call::OnClientToServerMessage,
+                                   &Derived::Call::OnServerInitialMetadata,
+                                   &Derived::Call::OnServerToClientMessage,
+                                   &Derived::Call::OnServerTrailingMetadata,
+                                   &Derived::Call::OnFinalize>;
+}
 }  // namespace filters_detail
 
 namespace for_each_detail {
@@ -1725,20 +1785,20 @@ class CallFilters {
               [this]() {
                 return Map(
                     MetadataExecutor<
-                        absl::optional<ServerMetadataHandle>,
+                        std::optional<ServerMetadataHandle>,
                         ServerMetadataHandle,
                         &CallFilters::push_server_initial_metadata_,
                         &filters_detail::StackData::server_initial_metadata,
                         &CallState::FinishPullServerInitialMetadata,
                         StacksVector::const_reverse_iterator>(
                         this, stacks_.crbegin(), stacks_.crend()),
-                    [](ValueOrFailure<absl::optional<ServerMetadataHandle>> r) {
+                    [](ValueOrFailure<std::optional<ServerMetadataHandle>> r) {
                       if (r.ok()) return std::move(*r);
-                      return absl::optional<ServerMetadataHandle>{};
+                      return std::optional<ServerMetadataHandle>{};
                     });
               },
               []() {
-                return Immediate(absl::optional<ServerMetadataHandle>{});
+                return Immediate(std::optional<ServerMetadataHandle>{});
               });
         });
   }
@@ -1904,4 +1964,4 @@ static_assert(
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_TRANSPORT_CALL_FILTERS_H
+#endif  // GRPC_SRC_CORE_CALL_CALL_FILTERS_H

data/src/core/{lib/channel → call}/call_finalization.h

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef GRPC_SRC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
-#define GRPC_SRC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
+#ifndef GRPC_SRC_CORE_CALL_CALL_FINALIZATION_H
+#define GRPC_SRC_CORE_CALL_CALL_FINALIZATION_H
 
 #include <grpc/support/port_platform.h>
 
@@ -85,4 +85,4 @@ struct ContextType<CallFinalization> {};
 
 }  // namespace grpc_core
 
-#endif  // GRPC_SRC_CORE_LIB_CHANNEL_CALL_FINALIZATION_H
+#endif  // GRPC_SRC_CORE_CALL_CALL_FINALIZATION_H

data/src/core/{lib/transport → call}/call_spine.cc

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "src/core/lib/transport/call_spine.h"
+#include "src/core/call/call_spine.h"
 
 #include <grpc/support/port_platform.h>
 
@@ -28,46 +28,44 @@ void ForwardCall(CallHandler call_handler, CallInitiator call_initiator,
                      on_server_trailing_metadata_from_initiator) {
   call_handler.AddChildCall(call_initiator);
   // Read messages from handler into initiator.
-  call_handler.SpawnInfallible("read_messages", [call_handler,
-                                                 call_initiator]() mutable {
-    return Seq(ForEach(MessagesFrom(call_handler),
-                       [call_initiator](MessageHandle msg) mutable {
-                         // Need to spawn a job into the initiator's activity to
-                         // push the message in.
-                         return call_initiator.SpawnPushMessage(std::move(msg));
-                       }),
-               [call_initiator](StatusFlag result) mutable {
-                 if (result.ok()) {
-                   call_initiator.SpawnFinishSends();
-                 }
-               });
-  });
+  call_handler.SpawnInfallible(
+      "read_messages", [call_handler, call_initiator]() mutable {
+        return Seq(
+            ForEach(MessagesFrom(call_handler),
+                    [call_initiator](MessageHandle msg) mutable {
+                      // Need to spawn a job into the initiator's activity to
+                      // push the message in.
+                      call_initiator.SpawnPushMessage(std::move(msg));
+                      return Success{};
+                    }),
+            [call_initiator]() mutable { call_initiator.SpawnFinishSends(); });
+      });
   call_initiator.SpawnInfallible(
       "read_the_things",
       [call_initiator, call_handler,
        on_server_trailing_metadata_from_initiator =
            std::move(on_server_trailing_metadata_from_initiator)]() mutable {
         return Seq(
-            call_initiator.CancelIfFails(
-                TrySeq(call_initiator.PullServerInitialMetadata(),
-                       [call_handler, call_initiator](
-                           absl::optional<ServerMetadataHandle> md) mutable {
-                         const bool has_md = md.has_value();
-                         return If(
-                             has_md,
-                             [&call_handler, &call_initiator,
-                              md = std::move(md)]() mutable {
-                               call_handler.SpawnPushServerInitialMetadata(
-                                   std::move(*md));
-                               return ForEach(
-                                   MessagesFrom(call_initiator),
-                                   [call_handler](MessageHandle msg) mutable {
-                                     return call_handler.SpawnPushMessage(
-                                         std::move(msg));
-                                   });
-                             },
-                             []() -> StatusFlag { return Success{}; });
-                       })),
+            call_initiator.CancelIfFails(TrySeq(
+                call_initiator.PullServerInitialMetadata(),
+                [call_handler, call_initiator](
+                    std::optional<ServerMetadataHandle> md) mutable {
+                  const bool has_md = md.has_value();
+                  return If(
+                      has_md,
+                      [&call_handler, &call_initiator,
+                       md = std::move(md)]() mutable {
+                        call_handler.SpawnPushServerInitialMetadata(
+                            std::move(*md));
+                        return ForEach(
+                            MessagesFrom(call_initiator),
+                            [call_handler](MessageHandle msg) mutable {
+                              call_handler.SpawnPushMessage(std::move(msg));
+                              return Success{};
+                            });
+                      },
+                      []() -> StatusFlag { return Success{}; });
+                })),
             call_initiator.PullServerTrailingMetadata(),
             [call_handler,
              on_server_trailing_metadata_from_initiator =