Sync c-core 1.74.0-pre1

Author: HannahShiSFB

gRPC-C++.podspec

@@ -21,7 +21,7 @@
 
 Pod::Spec.new do |s|
   s.name     = 'gRPC-ProtoRPC'
-  version = '1.73.1'
+  version = '1.74.0-pre1'
   s.version  = version
   s.summary  = 'RPC library for Protocol Buffers, based on gRPC'
   s.homepage = 'https://grpc.io'

gRPC-Core.podspec

@@ -21,7 +21,7 @@
 
 Pod::Spec.new do |s|
   s.name     = 'gRPC-RxLibrary'
-  version = '1.73.1'
+  version = '1.74.0-pre1'
   s.version  = version
   s.summary  = 'Reactive Extensions library for iOS/OSX.'
   s.homepage = 'https://grpc.io'

gRPC-ProtoRPC.podspec

@@ -20,7 +20,7 @@
 
 Pod::Spec.new do |s|
   s.name     = 'gRPC'
-  version = '1.73.1'
+  version = '1.74.0-pre1'
   s.version  = version
   s.summary  = 'gRPC client library for iOS/OSX'
   s.homepage = 'https://grpc.io'

gRPC-RxLibrary.podspec

@@ -0,0 +1,54 @@
+/*
+ *
+ * Copyright 2025 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_CREATE_CHANNEL_FROM_ENDPOINT_H
+#define GRPC_CREATE_CHANNEL_FROM_ENDPOINT_H
+
+#include <grpc/grpc.h>
+#include <grpc/impl/grpc_types.h>
+#include <grpc/support/port_platform.h>
+#include <stddef.h>
+
+#ifdef __cplusplus
+#include <grpc/event_engine/event_engine.h>
+
+#include <memory>
+namespace grpc_core::experimental {
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This function creates a gRPC channel using a pre-established
+ * endpoint from the EventEngine. This API supports both secure and insecure
+ * channel credentials.
+ *
+ * \param endpoint A unique pointer to an EventEngine endpoint representing
+ *        an established connection.
+ * \param creds The channel credentials used to secure the connection.
+ * \param args Optional channel arguments to configure the channel behavior.
+ */
+grpc_channel* CreateChannelFromEndpoint(
+    std::unique_ptr<grpc_event_engine::experimental::EventEngine::Endpoint>
+        endpoint,
+    grpc_channel_credentials* creds, const grpc_channel_args* args);
+
+}  // namespace grpc_core::experimental
+
+#endif  // __cplusplus
+
+#endif /* GRPC_CREATE_CHANNEL_FROM_ENDPOINT_H */

gRPC.podspec

@@ -206,21 +206,27 @@ GRPCAPI void grpc_call_credentials_release(grpc_call_credentials* creds);
    this could result in an oauth2 token leak. The security level of the
    resulting connection is GRPC_PRIVACY_AND_INTEGRITY.
 
-   If specified, the supplied call credentials object will be attached to the
-   returned channel credentials object. The call_credentials object must remain
+   If specified, the supplied call credentials objects will be attached to the
+   returned channel credentials object. The call_credentials objects must remain
    valid throughout the lifetime of the returned grpc_channel_credentials
-   object. It is expected that the call credentials object was generated
+   object. It is expected that each call credentials object was generated
    according to the Application Default Credentials mechanism and asserts the
    identity of the default service account of the machine. Supplying any other
    sort of call credential will result in undefined behavior, up to and
    including the sudden and unexpected failure of RPCs.
 
    If nullptr is supplied, the returned channel credentials object will use a
-   call credentials object based on the Application Default Credentials
+   default call credentials object based on the Application Default Credentials
    mechanism.
+
+   The caller may choose to create the default credential with a secondary alts
+   credentials object to attach to the channel for ALTS connections. If an alts
+   credentials object is specified, it will be used if the underlying channel
+   type is ALTS.
 */
 GRPCAPI grpc_channel_credentials* grpc_google_default_credentials_create(
-    grpc_call_credentials* call_credentials);
+    grpc_call_credentials* call_creds_for_tls,
+    grpc_call_credentials* call_creds_for_alts);
 
 /** Server certificate config object holds the server's public certificates and
    associated private keys, as well as any CA certificates needed for client

include/grpc/create_channel_from_endpoint.h

@@ -23,12 +23,17 @@
 #include <grpc/support/port_platform.h>
 
 #include <bitset>
+#include <cstddef>
 #include <initializer_list>
+#include <memory>
+#include <optional>
+#include <utility>
 #include <vector>
 
 #include "absl/functional/any_invocable.h"
 #include "absl/status/status.h"
 #include "absl/status/statusor.h"
+#include "absl/types/span.h"
 
 // TODO(vigneshbabu): Define the Endpoint::Write metrics collection system
 // TODO(hork): remove all references to the factory methods.
@@ -240,28 +245,40 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
       size_t key;
       int64_t value;
     };
+    // It is the responsibility of the caller of WriteEventCallback to make sure
+    // that the corresponding endpoint is still valid. HINT: Do NOT offload
+    // callbacks onto the EventEngine or other threads.
     using WriteEventCallback = absl::AnyInvocable<void(
         WriteEvent, absl::Time, std::vector<WriteMetric>) const>;
     // A bitmask of the events that the caller is interested in.
     // Each bit corresponds to an entry in WriteEvent.
     using WriteEventSet = std::bitset<static_cast<int>(WriteEvent::kCount)>;
+
+    // A set of metrics that the caller is interested in.
+    class MetricsSet {
+     public:
+      virtual ~MetricsSet() = default;
+
+      virtual bool IsSet(size_t key) const = 0;
+    };
+
     // A sink to receive write events.
     // The requested metrics are the keys of the metrics that the caller is
     // interested in. The on_event callback will be called on each event
     // requested.
     class WriteEventSink final {
      public:
-      WriteEventSink(absl::Span<const size_t> requested_metrics,
+      WriteEventSink(std::shared_ptr<MetricsSet> requested_metrics,
                      std::initializer_list<WriteEvent> requested_events,
                      WriteEventCallback on_event)
-          : requested_metrics_(requested_metrics),
+          : requested_metrics_(std::move(requested_metrics)),
             on_event_(std::move(on_event)) {
         for (auto event : requested_events) {
           requested_events_mask_.set(static_cast<int>(event));
         }
       }
 
-      absl::Span<const size_t> requested_metrics() const {
+      const std::shared_ptr<MetricsSet>& requested_metrics() const {
         return requested_metrics_;
       }
 
@@ -273,10 +290,12 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
         return requested_events_mask_;
       }
 
+      /// Takes the callback. Ownership is transferred. It is illegal to destroy
+      /// the endpoint before this callback is invoked.
       WriteEventCallback TakeEventCallback() { return std::move(on_event_); }
 
      private:
-      absl::Span<const size_t> requested_metrics_;
+      std::shared_ptr<MetricsSet> requested_metrics_;
       WriteEventSet requested_events_mask_;
       // The callback to be called on each event.
       WriteEventCallback on_event_;
@@ -288,10 +307,28 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
     class WriteArgs final {
      public:
       WriteArgs() = default;
+
+      ~WriteArgs();
+
       WriteArgs(const WriteArgs&) = delete;
       WriteArgs& operator=(const WriteArgs&) = delete;
-      WriteArgs(WriteArgs&&) = default;
-      WriteArgs& operator=(WriteArgs&&) = default;
+
+      WriteArgs(WriteArgs&& other) noexcept
+          : metrics_sink_(std::move(other.metrics_sink_)),
+            google_specific_(other.google_specific_),
+            max_frame_size_(other.max_frame_size_) {
+        other.google_specific_ = nullptr;
+      }
+
+      WriteArgs& operator=(WriteArgs&& other) noexcept {
+        if (this != &other) {
+          metrics_sink_ = std::move(other.metrics_sink_);
+          google_specific_ = other.google_specific_;
+          other.google_specific_ = nullptr;  // Nullify source
+          max_frame_size_ = other.max_frame_size_;
+        }
+        return *this;
+      }
 
       // A sink to receive write events.
       std::optional<WriteEventSink> TakeMetricsSink() {
@@ -314,6 +351,10 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
         return google_specific_;
       }
 
+      void* TakeDeprecatedAndDiscouragedGoogleSpecificPointer() {
+        return std::exchange(google_specific_, nullptr);
+      }
+
       void SetDeprecatedAndDiscouragedGoogleSpecificPointer(void* pointer) {
         google_specific_ = pointer;
       }
@@ -333,6 +374,31 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
       void* google_specific_ = nullptr;
       int64_t max_frame_size_ = 1024 * 1024;
     };
+
+    class TelemetryInfo {
+     public:
+      virtual ~TelemetryInfo() = default;
+
+      /// Returns the list of write metrics that the endpoint supports.
+      /// The keys are used to identify the metrics in the GetMetricName and
+      /// GetMetricKey APIs. The current value of the metric can be queried by
+      /// adding a WriteEventSink to the WriteArgs of a Write call.
+      virtual std::vector<size_t> AllWriteMetrics() const = 0;
+      /// Returns the name of the write metric with the given key.
+      /// If the key is not found, returns std::nullopt.
+      virtual std::optional<absl::string_view> GetMetricName(
+          size_t key) const = 0;
+      /// Returns the key of the write metric with the given name.
+      /// If the name is not found, returns std::nullopt.
+      virtual std::optional<size_t> GetMetricKey(
+          absl::string_view name) const = 0;
+      /// Returns a MetricsSet with all the keys from \a keys set.
+      virtual std::shared_ptr<MetricsSet> GetMetricsSet(
+          absl::Span<const size_t> keys) const = 0;
+      /// Returns a MetricsSet with all supported keys set.
+      virtual std::shared_ptr<MetricsSet> GetFullMetricsSet() const = 0;
+    };
+
     /// Writes data out on the connection.
     ///
     /// If the write succeeds immediately, it returns true and the
@@ -359,17 +425,8 @@ class EventEngine : public std::enable_shared_from_this<EventEngine>,
     /// values are expected to remain valid for the life of the Endpoint.
     virtual const ResolvedAddress& GetPeerAddress() const = 0;
     virtual const ResolvedAddress& GetLocalAddress() const = 0;
-    /// Returns the list of write metrics that the endpoint supports.
-    /// The keys are used to identify the metrics in the GetMetricName and
-    /// GetMetricKey APIs. The current value of the metric can be queried by
-    /// adding a WriteEventSink to the WriteArgs of a Write call.
-    virtual std::vector<size_t> AllWriteMetrics() = 0;
-    /// Returns the name of the write metric with the given key.
-    /// If the key is not found, returns std::nullopt.
-    virtual std::optional<absl::string_view> GetMetricName(size_t key) = 0;
-    /// Returns the key of the write metric with the given name.
-    /// If the name is not found, returns std::nullopt.
-    virtual std::optional<size_t> GetMetricKey(absl::string_view name) = 0;
+
+    virtual std::shared_ptr<TelemetryInfo> GetTelemetryInfo() const = 0;
   };
 
   /// Called when a new connection is established.

include/grpc/credentials.h

@@ -56,6 +56,25 @@ GRPCAPI void grpc_server_add_channel_from_fd(grpc_server* server, int fd,
 
 #ifdef __cplusplus
 }
-#endif
+
+namespace grpc_core::experimental {
+
+/**
+ * EXPERIMENTAL API - Subject to change
+ *
+ * This function creates a gRPC channel using a raw file descriptor
+ * that represents an open socket. This API supports both secure and insecure
+ * channel credentials.
+ *
+ * \param fd The file descriptor representing the connection.
+ * \param creds The channel credentials used to secure the connection.
+ * \param args Optional channel arguments to configure the channel behavior.
+ */
+grpc_channel* CreateChannelFromFd(int fd, grpc_channel_credentials* creds,
+                                  const grpc_channel_args* args);
+
+}  // namespace grpc_core::experimental
+
+#endif  // __cplusplus
 
 #endif /* GRPC_GRPC_POSIX_H */

include/grpc/event_engine/event_engine.h

@@ -123,10 +123,8 @@
 /** Channel arg to override the http2 :scheme header. String valued. */
 #define GRPC_ARG_HTTP2_SCHEME "grpc.http2_scheme"
 /** How many pings can the client send before needing to send a data/header
-   frame? (0 indicates that an infinite number of pings can be sent without
-   sending a data frame or header frame).
-   If experiment "max_pings_wo_data_throttle" is enabled, instead of pings being
-   completely blocked, they are throttled.
+   frame, without being throttled? (0 indicates that an infinite number of pings
+  can be sent without sending a data frame or header frame).
   * Integer valued. Defaults to 2. */
 #define GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA \
   "grpc.http2.max_pings_without_data"