grpc 1.60.0 → 1.61.0.pre2

data/src/core/lib/surface/call.h

@@ -77,34 +77,35 @@ typedef struct grpc_call_create_args {
 } grpc_call_create_args;
 
 namespace grpc_core {
-class PromiseBasedCall;
+class BasicPromiseBasedCall;
 class ServerPromiseBasedCall;
 
 class ServerCallContext {
  public:
-  ServerCallContext(ServerPromiseBasedCall* call,
-                    const void* server_stream_data)
-      : call_(call), server_stream_data_(server_stream_data) {}
-  ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
+  virtual void PublishInitialMetadata(
+      ClientMetadataHandle metadata,
+      grpc_metadata_array* publish_initial_metadata) = 0;
+
+  // Construct the top of the server call promise for the v2 filter stack.
+  // TODO(ctiller): delete when v3 is available.
+  virtual ArenaPromise<ServerMetadataHandle> MakeTopOfServerCallPromise(
       CallArgs call_args, grpc_completion_queue* cq,
-      grpc_metadata_array* publish_initial_metadata,
-      absl::FunctionRef<void(grpc_call* call)> publish);
+      absl::FunctionRef<void(grpc_call* call)> publish) = 0;
 
   // Server stream data as supplied by the transport (so we can link the
   // transport stream up with the call again).
   // TODO(ctiller): legacy API - once we move transports to promises we'll
   // create the promise directly and not need to pass around this token.
-  const void* server_stream_data() { return server_stream_data_; }
+  virtual const void* server_stream_data() = 0;
 
- private:
-  ServerPromiseBasedCall* const call_;
-  const void* const server_stream_data_;
+ protected:
+  ~ServerCallContext() = default;
 };
 
 // TODO(ctiller): move more call things into this type
 class CallContext {
  public:
-  explicit CallContext(PromiseBasedCall* call) : call_(call) {}
+  explicit CallContext(BasicPromiseBasedCall* call) : call_(call) {}
 
   // Update the deadline (if deadline < the current deadline).
   void UpdateDeadline(Timestamp deadline);
@@ -135,13 +136,21 @@ class CallContext {
   void set_traced(bool traced) { traced_ = traced; }
   bool traced() const { return traced_; }
 
+  // TEMPORARY HACK
+  // Create a call spine object for this call.
+  // Said object should only be created once.
+  // Allows interop between the v2 call stack and the v3 (which is required by
+  // transports).
+  RefCountedPtr<CallSpineInterface> MakeCallSpine(CallArgs call_args);
+  grpc_call* c_call();
+
  private:
   friend class PromiseBasedCall;
   // Call final info.
   grpc_call_stats call_stats_;
   // TODO(ctiller): remove this once transport APIs are promise based and we
   // don't need refcounting here.
-  PromiseBasedCall* const call_;
+  BasicPromiseBasedCall* const call_;
   gpr_cycle_counter start_time_ = gpr_get_cycle_counter();
   // Is this call traced?
   bool traced_ = false;
@@ -150,6 +159,10 @@ class CallContext {
 template <>
 struct ContextType<CallContext> {};
 
+RefCountedPtr<CallSpineInterface> MakeServerCall(Server* server,
+                                                 Channel* channel,
+                                                 Arena* arena);
+
 }  // namespace grpc_core
 
 // Create a new call based on \a args.

data/src/core/lib/surface/call_trace.cc

@@ -77,7 +77,48 @@ const grpc_channel_filter* PromiseTracingFilterFor(
                   return r;
                 };
               },
-              grpc_channel_next_op, /* sizeof_call_data: */ 0,
+              /* init_call: */
+              [](grpc_channel_element* elem, CallSpineInterface* call) {
+                auto* source_filter =
+                    static_cast<const DerivedFilter*>(elem->filter)->filter;
+                call->client_initial_metadata().receiver.InterceptAndMap(
+                    [source_filter](ClientMetadataHandle md) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnClientInitialMetadata: %s",
+                              Activity::current()->DebugTag().c_str(),
+                              source_filter->name, md->DebugString().c_str());
+                      return md;
+                    });
+                call->client_to_server_messages().receiver.InterceptAndMap(
+                    [source_filter](MessageHandle msg) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnClientToServerMessage: %s",
+                              Activity::current()->DebugTag().c_str(),
+                              source_filter->name, msg->DebugString().c_str());
+                      return msg;
+                    });
+                call->server_initial_metadata().sender.InterceptAndMap(
+                    [source_filter](ServerMetadataHandle md) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnServerInitialMetadata: %s",
+                              Activity::current()->DebugTag().c_str(),
+                              source_filter->name, md->DebugString().c_str());
+                      return md;
+                    });
+                call->server_to_client_messages().sender.InterceptAndMap(
+                    [source_filter](MessageHandle msg) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnServerToClientMessage: %s",
+                              Activity::current()->DebugTag().c_str(),
+                              source_filter->name, msg->DebugString().c_str());
+                      return msg;
+                    });
+                call->server_trailing_metadata().sender.InterceptAndMap(
+                    [source_filter](ServerMetadataHandle md) {
+                      gpr_log(GPR_DEBUG, "%s[%s] OnServerTrailingMetadata: %s",
+                              Activity::current()->DebugTag().c_str(),
+                              source_filter->name, md->DebugString().c_str());
+                      return md;
+                    });
+              },
+              grpc_channel_next_op,
+              /* sizeof_call_data: */ 0,
               // init_call_elem:
               [](grpc_call_element*, const grpc_call_element_args*) {
                 return absl::OkStatus();

data/src/core/lib/surface/channel.cc

@@ -376,7 +376,6 @@ namespace grpc_core {
 
 RegisteredCall* Channel::RegisterCall(const char* method, const char* host) {
   MutexLock lock(&registration_table_.mu);
-  registration_table_.method_registration_attempts++;
   auto key = std::make_pair(std::string(host != nullptr ? host : ""),
                             std::string(method != nullptr ? method : ""));
   auto rc_posn = registration_table_.map.find(key);

data/src/core/lib/surface/channel.h

@@ -103,7 +103,6 @@ struct CallRegistrationTable {
   // C++ or other wrapped language Channel that registered these calls).
   std::map<std::pair<std::string, std::string>, RegisteredCall> map
       ABSL_GUARDED_BY(mu);
-  int method_registration_attempts ABSL_GUARDED_BY(mu) = 0;
 };
 
 class Channel : public RefCounted<Channel>,
@@ -150,11 +149,6 @@ class Channel : public RefCounted<Channel>,
     return registration_table_.map.size();
   }
 
-  int TestOnlyRegistrationAttempts() {
-    MutexLock lock(&registration_table_.mu);
-    return registration_table_.method_registration_attempts;
-  }
-
   grpc_event_engine::experimental::EventEngine* event_engine() const {
     return channel_stack_->EventEngine();
   }

data/src/core/lib/surface/channel_init.h

@@ -87,11 +87,30 @@ class ChannelInit {
     // Ensure that this filter is placed *after* the filters listed here.
     // By Build() time all filters listed here must also be registered against
     // the same channel stack type as this registration.
+    template <typename Filter>
+    FilterRegistration& After() {
+      return After({&Filter::kFilter});
+    }
+    // Ensure that this filter is placed *before* the filters listed here.
+    // By Build() time all filters listed here must also be registered against
+    // the same channel stack type as this registration.
+    template <typename Filter>
+    FilterRegistration& Before() {
+      return Before({&Filter::kFilter});
+    }
+
+    // Ensure that this filter is placed *after* the filters listed here.
+    // By Build() time all filters listed here must also be registered against
+    // the same channel stack type as this registration.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
     FilterRegistration& After(
         std::initializer_list<const grpc_channel_filter*> filters);
     // Ensure that this filter is placed *before* the filters listed here.
     // By Build() time all filters listed here must also be registered against
     // the same channel stack type as this registration.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
     FilterRegistration& Before(
         std::initializer_list<const grpc_channel_filter*> filters);
     // Add a predicate for this filters inclusion.
@@ -145,9 +164,16 @@ class ChannelInit {
     // This occurs first during channel build time.
     // The FilterRegistration methods can be called to declaratively define
     // properties of the filter being registered.
+    // TODO(ctiller): remove in favor of the version that does not mention
+    // grpc_channel_filter
     FilterRegistration& RegisterFilter(grpc_channel_stack_type type,
                                        const grpc_channel_filter* filter,
                                        SourceLocation registration_source = {});
+    template <typename Filter>
+    FilterRegistration& RegisterFilter(
+        grpc_channel_stack_type type, SourceLocation registration_source = {}) {
+      return RegisterFilter(type, &Filter::kFilter, registration_source);
+    }
 
     // Register a post processor for the builder.
     // These run after the main graph has been placed into the builder.

data/src/core/lib/surface/init.cc

@@ -67,19 +67,25 @@ static bool g_shutting_down ABSL_GUARDED_BY(g_init_mu) = false;
 namespace grpc_core {
 void RegisterSecurityFilters(CoreConfiguration::Builder* builder) {
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_SUBCHANNEL, &ClientAuthFilter::kFilter)
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_SUBCHANNEL)
       .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
   builder->channel_init()
-      ->RegisterFilter(GRPC_CLIENT_DIRECT_CHANNEL, &ClientAuthFilter::kFilter)
+      ->RegisterFilter<ClientAuthFilter>(GRPC_CLIENT_DIRECT_CHANNEL)
       .IfHasChannelArg(GRPC_ARG_SECURITY_CONNECTOR);
+  if (IsV3ServerAuthFilterEnabled()) {
+    builder->channel_init()
+        ->RegisterFilter<ServerAuthFilter>(GRPC_SERVER_CHANNEL)
+        .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
+  } else {
+    builder->channel_init()
+        ->RegisterFilter<LegacyServerAuthFilter>(GRPC_SERVER_CHANNEL)
+        .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
+  }
   builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL, &ServerAuthFilter::kFilter)
-      .IfHasChannelArg(GRPC_SERVER_CREDENTIALS_ARG);
-  builder->channel_init()
-      ->RegisterFilter(GRPC_SERVER_CHANNEL,
-                       &GrpcServerAuthzFilter::kFilterVtable)
+      ->RegisterFilter<GrpcServerAuthzFilter>(GRPC_SERVER_CHANNEL)
       .IfHasChannelArg(GRPC_ARG_AUTHORIZATION_POLICY_PROVIDER)
-      .After({&ServerAuthFilter::kFilter});
+      .After<ServerAuthFilter>()
+      .After<LegacyServerAuthFilter>();
 }
 }  // namespace grpc_core