Rename to GRPCClient

Author: gjcairo

Sources/GRPCCore/Call/Client/Internal/ClientRPCExecutor+HedgingExecutor.swift

@@ -30,7 +30,7 @@ extension ClientRPCExecutor {
     @usableFromInline
     let transport: Transport
     @usableFromInline
-    let policy: Client.MethodConfiguration.HedgingPolicy
+    let policy: GRPCClient.MethodConfiguration.HedgingPolicy
     @usableFromInline
     let timeout: Duration?
     @usableFromInline
@@ -45,7 +45,7 @@ extension ClientRPCExecutor {
     @inlinable
     init(
       transport: Transport,
-      policy: Client.MethodConfiguration.HedgingPolicy,
+      policy: GRPCClient.MethodConfiguration.HedgingPolicy,
       timeout: Duration?,
       interceptors: [any ClientInterceptor],
       serializer: Serializer,
@@ -420,7 +420,7 @@ extension ClientRPCExecutor.HedgingExecutor {
     private(set) var hasUsableResponse: Bool
 
     @inlinable
-    init(policy: Client.MethodConfiguration.HedgingPolicy) {
+    init(policy: GRPCClient.MethodConfiguration.HedgingPolicy) {
       self._maximumAttempts = policy.maximumAttempts
       self.attempt = 1
       self.hasUsableResponse = false

Sources/GRPCCore/Call/Client/Internal/ClientRPCExecutor+RetryExecutor.swift

@@ -30,7 +30,7 @@ extension ClientRPCExecutor {
     @usableFromInline
     let transport: Transport
     @usableFromInline
-    let policy: Client.MethodConfiguration.RetryPolicy
+    let policy: GRPCClient.MethodConfiguration.RetryPolicy
     @usableFromInline
     let timeout: Duration?
     @usableFromInline
@@ -45,7 +45,7 @@ extension ClientRPCExecutor {
     @inlinable
     init(
       transport: Transport,
-      policy: Client.MethodConfiguration.RetryPolicy,
+      policy: GRPCClient.MethodConfiguration.RetryPolicy,
       timeout: Duration?,
       interceptors: [any ClientInterceptor],
       serializer: Serializer,

Sources/GRPCCore/Call/Client/Internal/ClientRPCExecutor.swift

@@ -35,7 +35,7 @@ enum ClientRPCExecutor {
   static func execute<Input: Sendable, Output: Sendable, Result: Sendable>(
     request: ClientRequest.Stream<Input>,
     method: MethodDescriptor,
-    configuration: Client.MethodConfiguration,
+    configuration: GRPCClient.MethodConfiguration,
     serializer: some MessageSerializer<Input>,
     deserializer: some MessageDeserializer<Output>,
     transport: some ClientTransport,

Sources/GRPCCore/Call/Client/Internal/RetryDelaySequence.swift

@@ -26,10 +26,10 @@ struct RetryDelaySequence: Sequence {
   typealias Element = Duration
 
   @usableFromInline
-  let policy: Client.MethodConfiguration.RetryPolicy
+  let policy: GRPCClient.MethodConfiguration.RetryPolicy
 
   @inlinable
-  init(policy: Client.MethodConfiguration.RetryPolicy) {
+  init(policy: GRPCClient.MethodConfiguration.RetryPolicy) {
     self.policy = policy
   }
 
@@ -41,12 +41,12 @@ struct RetryDelaySequence: Sequence {
   @usableFromInline
   struct Iterator: IteratorProtocol {
     @usableFromInline
-    let policy: Client.MethodConfiguration.RetryPolicy
+    let policy: GRPCClient.MethodConfiguration.RetryPolicy
     @usableFromInline
     private(set) var n = 1
 
     @inlinable
-    init(policy: Client.MethodConfiguration.RetryPolicy) {
+    init(policy: GRPCClient.MethodConfiguration.RetryPolicy) {
       self.policy = policy
     }
 

Sources/GRPCCore/Client.swift renamed to Sources/GRPCCore/GRPCClient.swift

@@ -16,7 +16,7 @@
 
 /// A gRPC client.
 ///
-/// A ``Client`` communicates to a server via a given ``ClientTransport``.
+/// A ``GRPCClient`` communicates to a server via a given ``ClientTransport``.
 /// You can start RPCs to the server by calling the corresponding method:
 /// - ``unary(request:descriptor:serializer:deserializer:handler:)``
 /// - ``clientStreaming(request:descriptor:serializer:deserializer:handler:)``
@@ -35,7 +35,7 @@
 /// ```swift
 /// // Create and add an in-process transport.
 /// let inProcessTransport = InProcessClientTransport()
-/// let client = Client(transport: inProcessTransport)
+/// let client = GRPCClient(transport: inProcessTransport)
 ///
 /// // Create and add some interceptors.
 /// client.interceptors.add(StatsRecordingServerInterceptors())
@@ -66,7 +66,7 @@
 /// that need their lifecycles managed you should consider using [Swift Service
 /// Lifecycle](https://github.com/swift-server/swift-service-lifecycle).
 @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
-public final class Client: Sendable {
+public final class GRPCClient: Sendable {
   /// A collection of ``ClientInterceptor`` implementations which are applied to all accepted
   /// RPCs.
   ///
@@ -142,7 +142,7 @@ public final class Client: Sendable {
   ///
   /// - Note: Any changes to resources after ``run()`` has been called will be ignored.
   ///
-  /// - Parameter transport: The ``ClientTransport`` to be used for this ``Client``.
+  /// - Parameter transport: The ``ClientTransport`` to be used for this ``GRPCClient``.
   public init(transport: ClientTransport) {
     self.storage = LockedValueBox(Storage())
     self.transport = transport
@@ -155,11 +155,10 @@ public final class Client: Sendable {
   ///
   /// If you need to immediately stop all work, cancel the task executing this method.
   public func run() async throws {
-    let interceptors = try self.storage.withLockedValue { storage in
+    try self.storage.withLockedValue { storage in
       switch storage.state {
       case .notStarted:
         storage.state = .running
-        return storage.interceptors
       case .running:
         throw ClientError(
           code: .clientIsAlreadyRunning,
@@ -436,7 +435,7 @@ public final class Client: Sendable {
 }
 
 @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
-extension Client {
+extension GRPCClient {
   /// A collection of interceptors providing cross-cutting functionality to each accepted RPC.
   public struct Interceptors: Sendable {
     private(set) var values: [any ClientInterceptor] = []
@@ -456,7 +455,7 @@ extension Client {
 }
 
 @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
-extension Client {
+extension GRPCClient {
   /// The execution policy for an RPC.
   public enum ExecutionPolicy: Hashable, Sendable {
     /// Policy for retrying an RPC.
@@ -544,7 +543,7 @@ extension Client {
 }
 
 @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
-extension Client.MethodConfiguration {
+extension GRPCClient.MethodConfiguration {
   /// Policy for retrying an RPC.
   ///
   /// gRPC retries RPCs when the first response from the server is a status code which matches
@@ -720,7 +719,7 @@ extension Client.MethodConfiguration {
 }
 
 @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
-extension Client {
+extension GRPCClient {
   /// A collection of ``ClientRPCExecutionConfiguration``s, mapped to specific methods or services.
   ///
   /// When creating a new instance, you must provide a default configuration to be used when getting

Sources/GRPCCore/GRPCServer.swift

@@ -23,7 +23,7 @@ import Atomics
 /// streams to a service to handle the RPC or rejects them with an appropriate error if no service
 /// can handle the RPC.
 ///
-/// A ``Server`` may listen with multiple transports (for example, HTTP/2 and in-process) and route
+/// A ``GRPCServer`` may listen with multiple transports (for example, HTTP/2 and in-process) and route
 /// requests from each transport to the same service instance. You can also use "interceptors",
 /// to implement cross-cutting logic which apply to all accepted RPCs. Example uses of interceptors
 /// include request filtering, authentication, and logging. Once requests have been intercepted

Sources/GRPCCore/Transport/ClientTransport.swift

@@ -77,5 +77,5 @@ public protocol ClientTransport: Sendable {
   /// - Returns: Execution configuration for the method, if it exists.
   func executionConfiguration(
     forMethod descriptor: MethodDescriptor
-  ) -> Client.MethodConfiguration?
+  ) -> GRPCClient.MethodConfiguration?
 }

Sources/GRPCCore/Transport/InProcessClientTransport.swift

@@ -96,12 +96,12 @@ public struct InProcessClientTransport: ClientTransport {
 
   public let retryThrottle: RetryThrottle
 
-  private let executionConfigurations: Client.MethodConfigurationRegistry
+  private let executionConfigurations: GRPCClient.MethodConfigurationRegistry
   private let state: LockedValueBox<State>
 
   public init(
     server: InProcessServerTransport,
-    executionConfigurations: Client.MethodConfigurationRegistry
+    executionConfigurations: GRPCClient.MethodConfigurationRegistry
   ) {
     self.retryThrottle = RetryThrottle(maximumTokens: 10, tokenRatio: 0.1)
     self.executionConfigurations = executionConfigurations
@@ -329,7 +329,7 @@ public struct InProcessClientTransport: ClientTransport {
   /// - Returns: Execution configuration for the method, if it exists.
   public func executionConfiguration(
     forMethod descriptor: MethodDescriptor
-  ) -> Client.MethodConfiguration? {
+  ) -> GRPCClient.MethodConfiguration? {
     self.executionConfigurations[descriptor]
   }
 }

Tests/GRPCCoreTests/Call/Client/ClientRPCExecutionConfigurationCollectionTests.swift

@@ -24,73 +24,73 @@ final class ClientRPCExecutionConfigurationCollectionTests: XCTestCase {
     let result = second.duration(to: first)
     print(result.components)
 
-    let policy = Client.MethodConfiguration.HedgingPolicy(
+    let policy = GRPCClient.MethodConfiguration.HedgingPolicy(
       maximumAttempts: 10,
       hedgingDelay: .seconds(1),
       nonFatalStatusCodes: []
     )
-    let defaultConfiguration = Client.MethodConfiguration(hedgingPolicy: policy)
-    var configurations = Client.MethodConfigurationRegistry(
+    let defaultConfiguration = GRPCClient.MethodConfiguration(hedgingPolicy: policy)
+    var configurations = GRPCClient.MethodConfigurationRegistry(
       defaultConfiguration: defaultConfiguration
     )
     let descriptor = MethodDescriptor(service: "test", method: "first")
-    let retryPolicy = Client.MethodConfiguration.RetryPolicy(
+    let retryPolicy = GRPCClient.MethodConfiguration.RetryPolicy(
       maximumAttempts: 10,
       initialBackoff: .seconds(1),
       maximumBackoff: .seconds(1),
       backoffMultiplier: 1.0,
       retryableStatusCodes: [.unavailable]
     )
-    let overrideConfiguration = Client.MethodConfiguration(retryPolicy: retryPolicy)
+    let overrideConfiguration = GRPCClient.MethodConfiguration(retryPolicy: retryPolicy)
     configurations[descriptor] = overrideConfiguration
 
     XCTAssertEqual(configurations[descriptor], overrideConfiguration)
   }
 
   func testGetConfigurationForUnknownMethodButServiceOverride() {
-    let policy = Client.MethodConfiguration.HedgingPolicy(
+    let policy = GRPCClient.MethodConfiguration.HedgingPolicy(
       maximumAttempts: 10,
       hedgingDelay: .seconds(1),
       nonFatalStatusCodes: []
     )
-    let defaultConfiguration = Client.MethodConfiguration(hedgingPolicy: policy)
-    var configurations = Client.MethodConfigurationRegistry(
+    let defaultConfiguration = GRPCClient.MethodConfiguration(hedgingPolicy: policy)
+    var configurations = GRPCClient.MethodConfigurationRegistry(
       defaultConfiguration: defaultConfiguration
     )
     let firstDescriptor = MethodDescriptor(service: "test", method: "")
-    let retryPolicy = Client.MethodConfiguration.RetryPolicy(
+    let retryPolicy = GRPCClient.MethodConfiguration.RetryPolicy(
       maximumAttempts: 10,
       initialBackoff: .seconds(1),
       maximumBackoff: .seconds(1),
       backoffMultiplier: 1.0,
       retryableStatusCodes: [.unavailable]
     )
-    let overrideConfiguration = Client.MethodConfiguration(retryPolicy: retryPolicy)
+    let overrideConfiguration = GRPCClient.MethodConfiguration(retryPolicy: retryPolicy)
     configurations[firstDescriptor] = overrideConfiguration
 
     let secondDescriptor = MethodDescriptor(service: "test", method: "second")
     XCTAssertEqual(configurations[secondDescriptor], overrideConfiguration)
   }
 
   func testGetConfigurationForUnknownMethodDefaultValue() {
-    let policy = Client.MethodConfiguration.HedgingPolicy(
+    let policy = GRPCClient.MethodConfiguration.HedgingPolicy(
       maximumAttempts: 10,
       hedgingDelay: .seconds(1),
       nonFatalStatusCodes: []
     )
-    let defaultConfiguration = Client.MethodConfiguration(hedgingPolicy: policy)
-    var configurations = Client.MethodConfigurationRegistry(
+    let defaultConfiguration = GRPCClient.MethodConfiguration(hedgingPolicy: policy)
+    var configurations = GRPCClient.MethodConfigurationRegistry(
       defaultConfiguration: defaultConfiguration
     )
     let firstDescriptor = MethodDescriptor(service: "test1", method: "first")
-    let retryPolicy = Client.MethodConfiguration.RetryPolicy(
+    let retryPolicy = GRPCClient.MethodConfiguration.RetryPolicy(
       maximumAttempts: 10,
       initialBackoff: .seconds(1),
       maximumBackoff: .seconds(1),
       backoffMultiplier: 1.0,
       retryableStatusCodes: [.unavailable]
     )
-    let overrideConfiguration = Client.MethodConfiguration(retryPolicy: retryPolicy)
+    let overrideConfiguration = GRPCClient.MethodConfiguration(retryPolicy: retryPolicy)
     configurations[firstDescriptor] = overrideConfiguration
 
     let secondDescriptor = MethodDescriptor(service: "test2", method: "second")

Tests/GRPCCoreTests/Call/Client/ClientRPCExecutionConfigurationTests.swift

@@ -19,7 +19,7 @@ import XCTest
 @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *)
 final class ClientRPCExecutionConfigurationTests: XCTestCase {
   func testRetryPolicyClampsMaxAttempts() {
-    var policy = Client.MethodConfiguration.RetryPolicy(
+    var policy = GRPCClient.MethodConfiguration.RetryPolicy(
       maximumAttempts: 10,
       initialBackoff: .seconds(1),
       maximumBackoff: .seconds(1),
@@ -35,7 +35,7 @@ final class ClientRPCExecutionConfigurationTests: XCTestCase {
   }
 
   func testHedgingPolicyClampsMaxAttempts() {
-    var policy = Client.MethodConfiguration.HedgingPolicy(
+    var policy = GRPCClient.MethodConfiguration.HedgingPolicy(
       maximumAttempts: 10,
       hedgingDelay: .seconds(1),
       nonFatalStatusCodes: []