grpc 1.80.0 → 1.81.0

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

@@ -51,10 +51,13 @@
 #include "src/core/lib/iomgr/exec_ctx.h"
 #include "src/core/lib/iomgr/polling_entity.h"
 #include "src/core/lib/promise/activity.h"
+#include "src/core/lib/promise/all_ok.h"
 #include "src/core/lib/promise/arena_promise.h"
 #include "src/core/lib/promise/cancel_callback.h"
 #include "src/core/lib/promise/context.h"
 #include "src/core/lib/promise/detail/promise_like.h"
+#include "src/core/lib/promise/inter_activity_latch.h"
+#include "src/core/lib/promise/inter_activity_pipe.h"
 #include "src/core/lib/promise/pipe.h"
 #include "src/core/lib/promise/poll.h"
 #include "src/core/lib/promise/promise.h"
@@ -1220,6 +1223,270 @@ class ImplementChannelFilter : public ChannelFilter,
   }
 };
 
+struct V3InterceptorToV2State {
+  InterActivityLatch<CallHandler> call_handler_latch;
+};
+
+template <>
+struct ArenaContextType<V3InterceptorToV2State> {
+  static void Destroy(V3InterceptorToV2State*) {}
+};
+
+// Allows writing v3 interceptor that works with v2 stacks (and consequently
+// also v1 stacks since we can run v2 filters in v1 stacks).
+//
+// Note that this bridge does not support the full functionality of the
+// v3 interceptor API.  In particular, it assumes that the interceptor
+// will create exactly one child call.
+template <typename Derived>
+class V3InterceptorToV2Bridge : public ChannelFilter, public Interceptor {
+ public:
+  V3InterceptorToV2Bridge() {
+    // Insert CallDestinationToNextV2Filter as the wrapped destination in
+    // Interceptor, so that we can route the server side of the
+    // interceptor back into the v2 filter chain.
+    wrapped_destination_ = MakeRefCounted<CallDestinationToNextV2Filter>();
+  }
+
+  ArenaPromise<ServerMetadataHandle> MakeCallPromise(
+      CallArgs call_args, NextPromiseFactory next_promise_factory) final {
+    // Create a latch to get the call handler, and put a pointer to it
+    // in call context, so that CallDestinationToNextV2Filter can set
+    // it when it starts the call.
+    auto* arena = GetContext<Arena>();
+    auto* state = arena->ManagedNew<V3InterceptorToV2State>();
+    arena->SetContext<V3InterceptorToV2State>(state);
+    // Now we create a new v3 call pair.  The initiator will be the
+    // client side of the v3 interceptor, and the unstarted handler will be
+    // passed to the v3 interceptor.  The interceptor will wind up returning
+    // a handler to us via state->call_handler_latch, which will represent
+    // the server side of the v3 interceptor.
+    auto [initiator, unstarted_handler] =
+        MakeCallPair(std::move(call_args.client_initial_metadata),
+                     GetContext<Arena>()->Ref());
+    // Inject the unstarted handler into the interceptor.
+    StartCall(std::move(unstarted_handler));
+    // We need inter-activity mechanisms to move data between the v2 and v3
+    // activities.
+    struct PipeOwner {
+      InterActivityLatch<ClientMetadataHandle> client_initial_metadata;
+      InterActivityPipe<MessageHandle, 1> client_to_server_messages;
+      InterActivityLatch<std::optional<ServerMetadataHandle>>
+          server_initial_metadata;
+      InterActivityPipe<MessageHandle, 1> server_to_client_messages;
+    };
+    auto* pipe_owner = GetContext<Arena>()->ManagedNew<PipeOwner>();
+    // Now return a promise that does all the things.
+    return Race(
+        // We need to start polling the initiator for server trailing
+        // metadata immediately, since the v3 interceptor may generate a
+        // failure before any of the other promises resolve.
+        initiator.PullServerTrailingMetadata(),
+        // This promise does the rest of the things, but it will always
+        // return pending, because the promise can't actually finish
+        // until the initiator returns trailing metadata above.
+        TrySeq(
+            state->call_handler_latch.Wait(),
+            [initiator = initiator, pipe_owner,
+             call_args = std::move(call_args),
+             next_promise_factory =
+                 std::move(next_promise_factory)](CallHandler handler) mutable {
+              // Intercept all pipes from v2 API.
+              //
+              // For client-to-server messages, we do the following:
+              // 1. Push the message into the v3 initiator, which sends
+              //    it to the v3 interceptor.  Note that this needs to
+              //    be done inside of the v3 initiator's activity.
+              // 2. Pull the message from the v3 handler, where it will
+              //    arrive when the v3 interceptor is done with it.
+              //    Note that this needs to be done inside of the v3
+              //    handler's activity.  We then push the message into
+              //    an inter-activity pipe to return it to the v2 activity.
+              // 3. In the v2 activity, read the message from the
+              //    inter-activity pipe and send it on to the next
+              //    filter.
+              //
+              // Step 2: Spawn a promise to pull messages from the v3
+              // handler and push them into an inter-activity pipe to
+              // return them to the v2 activity.
+              handler.SpawnGuarded(
+                  "pull_client_to_server_message",
+                  [handler, pipe_owner]() mutable {
+                    return ForEach(
+                        MessagesFrom(handler),
+                        [pipe_owner](MessageHandle message) {
+                          return Map(
+                              pipe_owner->client_to_server_messages.sender.Push(
+                                  std::move(message)),
+                              [](bool x) { return StatusFlag(x); });
+                        });
+                  });
+              call_args.client_to_server_messages->InterceptAndMap(
+                  [initiator, handler,
+                   pipe_owner](MessageHandle message) mutable {
+                    // Step 1: Push the message onto the v3 initiator in
+                    // its activity.
+                    initiator.SpawnPushMessage(std::move(message));
+                    // Step 3: Here in the v2 activity, read the message
+                    // from the inter-activity pipe and return it.
+                    return Map(
+                        pipe_owner->client_to_server_messages.receiver.Next(),
+                        [](InterActivityPipe<MessageHandle, 1>::NextResult
+                               message) -> std::optional<MessageHandle> {
+                          if (!message.has_value()) return std::nullopt;
+                          return std::move(*message);
+                        });
+                  });
+              // For server initial metadata, we do a similar thing, but
+              // in the opposite direction, and using an inter-activity
+              // latch instead of a pipe:
+              // 1. Push the metadata into the v3 handler, which sends
+              //    it to the v3 interceptor.  Note that this needs to
+              //    be done inside of the v3 handler's activity.
+              // 2. Pull the metadata from the v3 initiator, where it will
+              //    arrive when the v3 interceptor is done with it.
+              //    Note that this needs to be done inside of the v3
+              //    initiator's activity.  We then use an inter-activity
+              //    latch to return the metadata to the v2 activity.
+              // 3. In the v2 activity, read the metadata from the
+              //    inter-activity latch and send it on to the previous
+              //    filter.
+              //
+              // Step 2: Spawn a promise to pull the metadata from the v3
+              // initiator and use an inter-activity latch to return it to
+              // the v2 activity.
+              initiator.SpawnGuarded(
+                  "pull_server_initial_metadata",
+                  [initiator, pipe_owner]() mutable {
+                    return TrySeq(
+                        initiator.PullServerInitialMetadata(),
+                        [pipe_owner](
+                            std::optional<ServerMetadataHandle> metadata) {
+                          pipe_owner->server_initial_metadata.Set(
+                              std::move(metadata));
+                        });
+                  });
+              call_args.server_initial_metadata->InterceptAndMap(
+                  [initiator, handler,
+                   pipe_owner](ServerMetadataHandle metadata) mutable {
+                    // Step 1: Push the metadata onto the v3 handler in
+                    // its activity.
+                    handler.SpawnPushServerInitialMetadata(std::move(metadata));
+                    // Step 3: Here in the v2 activity, read from the
+                    // inter-activity latch and return the metadata.
+                    return pipe_owner->server_initial_metadata.Wait();
+                  });
+              // We handle server-to-client messages the same as
+              // client-to-server messages, except in the opposite
+              // direction:
+              // 1. Push the message into the v3 handler, which sends
+              //    it to the v3 interceptor.  Note that this needs to
+              //    be done inside of the v3 handler's activity.
+              // 2. Pull the message from the v3 initiator, where it will
+              //    arrive when the v3 interceptor is done with it.
+              //    Note that this needs to be done inside of the v3
+              //    initiator's activity.  We then push the message into
+              //    an inter-activity pipe to return it to the v2 activity.
+              // 3. In the v2 activity, read the message from the
+              //    inter-activity pipe and send it on to the next
+              //    filter.
+              //
+              // Step 2: Spawn a promise to pull messages from the v3
+              // initiator and push them into an inter-activity pipe to
+              // return them to the v2 activity.
+              initiator.SpawnGuarded(
+                  "pull_server_to_client_message",
+                  [initiator, pipe_owner]() mutable {
+                    return ForEach(
+                        MessagesFrom(initiator),
+                        [pipe_owner](MessageHandle message) {
+                          return Map(
+                              pipe_owner->server_to_client_messages.sender.Push(
+                                  std::move(message)),
+                              [](bool x) { return StatusFlag(x); });
+                        });
+                  });
+              call_args.server_to_client_messages->InterceptAndMap(
+                  [initiator, handler,
+                   pipe_owner](MessageHandle message) mutable {
+                    // Step 1: Push the message onto the v3 handler in
+                    // its activity.
+                    handler.SpawnPushMessage(std::move(message));
+                    // Step 3: Here in the v2 activity, read from the
+                    // inter-activity pipe and return the messages.
+                    return Map(
+                        pipe_owner->server_to_client_messages.receiver.Next(),
+                        [](InterActivityPipe<MessageHandle, 1>::NextResult
+                               message) -> std::optional<MessageHandle> {
+                          if (!message.has_value()) return std::nullopt;
+                          return std::move(*message);
+                        });
+                  });
+              // In the v3 handler's activity, pull client initial metadata.
+              // Use an inter-acitivity latch to get it back to the v2
+              // activity.
+              handler.SpawnGuarded(
+                  "pull_client_initial_metadata",
+                  [handler, pipe_owner]() mutable {
+                    return TrySeq(handler.PullClientInitialMetadata(),
+                                  [pipe_owner](ClientMetadataHandle metadata) {
+                                    pipe_owner->client_initial_metadata.Set(
+                                        std::move(metadata));
+                                  });
+                  });
+              // A wrapper for next_promise_factory that does the following:
+              // - Pulls client initial metadata from the V3 handler via
+              //   the inter-activity latch and injects it into the next
+              //   V2 filter via CallArgs.
+              // - Polls the next promise to get server trailing metadata
+              //   from the next V2 filter and feeds it into the V3 handler.
+              // Note that this does not actually pull the trailing metadata
+              // from the V3 initiator; instead, we do that in a separate
+              // promise above.  That promise will always complete at the
+              // end of the call, so we always return pending here.
+              return Seq(
+                  pipe_owner->client_initial_metadata.Wait(),
+                  [next_promise_factory = std::move(next_promise_factory),
+                   call_args = std::move(call_args),
+                   handler](ClientMetadataHandle metadata) mutable {
+                    call_args.client_initial_metadata = std::move(metadata);
+                    return Seq(next_promise_factory(std::move(call_args)),
+                               [handler](ServerMetadataHandle metadata) mutable
+                                   -> Poll<ServerMetadataHandle> {
+                                 handler.SpawnPushServerTrailingMetadata(
+                                     std::move(metadata));
+                                 // We always lose the race.
+                                 return Pending{};
+                               });
+                  });
+            }));
+  }
+
+ protected:
+  RefCountedPtr<UnstartedCallDestination> wrapped_destination() const {
+    return wrapped_destination_;  // From Interceptor class.
+  }
+
+ private:
+  // A custom UnstartedCallDestination that starts the call and returns
+  // the resulting handler via a latch obtained from call context.
+  class CallDestinationToNextV2Filter final : public UnstartedCallDestination {
+   public:
+    void StartCall(UnstartedCallHandler unstarted_call_handler) override {
+      // Get the latch from call context.
+      auto* arena = GetContext<Arena>();
+      auto* state = arena->GetContext<V3InterceptorToV2State>();
+      arena->SetContext<V3InterceptorToV2State>(nullptr);
+      // Start the call.
+      CallHandler handler = unstarted_call_handler.StartCall();
+      // Pass call handler to the latch.
+      state->call_handler_latch.Set(std::move(handler));
+    }
+
+    void Orphaned() override {}
+  };
+};
+
 // Designator for whether a filter is client side or server side.
 // Please don't use this outside calls to MakePromiseBasedFilter - it's
 // intended to be deleted once the promise conversion is complete.

data/src/core/lib/event_engine/cf_engine/cfsocket_listener.cc

@@ -70,8 +70,9 @@ void CFSocketListenerImpl::Shutdown() {
     CFSocketInvalidate(ipv6cfsock);
   }
   if (runloop_) {
-    CFRunLoopWakeUp(runloop_);
     CFRunLoopStop(runloop_);
+    CFRelease(runloop_);
+    runloop_ = nullptr;
   }
 }
 
@@ -178,7 +179,7 @@ absl::Status CFSocketListenerImpl::Start() {
         return;
       }
 
-      that->runloop_ = CFRunLoopGetCurrent();
+      that->runloop_ = (CFRunLoopRef)CFRetain(CFRunLoopGetCurrent());
       for (auto& [ipv6cfsock] : that->ipv6cfsocks_) {
         CFTypeUniqueRef<CFRunLoopSourceRef> ipv6cfsock_source =
             CFSocketCreateRunLoopSource(kCFAllocatorDefault, ipv6cfsock, 0);

data/src/core/lib/event_engine/extensions/blocking_dns.h

@@ -27,7 +27,7 @@ class ResolverSupportsBlockingLookups {
   virtual ~ResolverSupportsBlockingLookups() = default;
 
   static constexpr absl::string_view EndpointExtensionName() {
-    return "io.grpc.event_engine.extension.can_track_errors";
+    return "io.grpc.event_engine.extension.resolver_supports_blocking_lookups";
   }
 
   virtual absl::StatusOr<std::vector<EventEngine::ResolvedAddress>>

data/src/core/lib/event_engine/posix_engine/posix_interface_posix.cc

@@ -1067,7 +1067,11 @@ bool EventEnginePosixInterface::IsCorrectGeneration(
 absl::StatusOr<std::pair<FileDescriptor, FileDescriptor> >
 EventEnginePosixInterface::Pipe() {
   int pipefd[2];
+#if defined(GPR_ANDROID)
+  int r = pipe2(pipefd, 0);
+#else
   int r = pipe(pipefd);
+#endif  // GPR_ANDROID
   if (0 != r) {
     return absl::Status(absl::StatusCode::kInternal,
                         absl::StrCat("pipe: ", grpc_core::StrError(errno)));

data/src/core/lib/event_engine/windows/windows_engine.cc

@@ -398,13 +398,21 @@ void WindowsEventEngine::OnConnectCompleted(
       erased_handles =
           known_connection_handles_.erase(state->connection_handle());
     }
-    if (erased_handles != 1 || !Cancel(state->timer_handle())) {
+    if (erased_handles != 1) {
       GRPC_TRACE_LOG(event_engine, INFO)
           << "Not accepting connection since the deadline timer has fired";
       return;
     }
-    // Release refs held by the deadline timer.
-    state->AbortDeadlineTimer();
+    // Cancel the deadline timer, to avoid having a dangling handle. It is OK
+    // if this fails, meaning that the deadline timer has already fired,
+    // because it won't cancel the connection attempt.
+    if (Cancel(state->timer_handle())) {
+      // Release refs held by the deadline timer.
+      // Only call this if we successfully cancel the deadline timer.
+      // Otherwise, we needto let the deadline timer run, and it will
+      // release the refs itself.
+      state->AbortDeadlineTimer();
+    }
     const auto& overlapped_result = state->socket()->write_info()->result();
     if (!overlapped_result.error_status.ok()) {
       state->socket()->Shutdown(DEBUG_LOCATION, "ConnectEx failure");