PR changes

Author: gjcairo

Sources/GRPCCore/Call/Server/Internal/ServerRPCExecutor.swift

@@ -316,10 +316,7 @@ extension ServerRPCExecutor {
     case .some(let interceptor):
       let iter = iterator
       do {
-        return try await interceptor.intercept(
-          request: request,
-          context: context
-        ) {
+        return try await interceptor.intercept(request: request, context: context) {
           try await self._intercept(request: $0, context: $1, iterator: iter, finally: finally)
         }
       } catch let error as RPCError {

Sources/GRPCCore/Call/Server/RPCRouter.swift

@@ -136,18 +136,6 @@ public struct RPCRouter: Sendable {
     self.handlers[descriptor] = (handler, [])
   }
 
-  @inlinable
-  public mutating func registerInterceptors(
-    pipeline: [ServerInterceptorOperation]
-  ) {
-    for descriptor in self.handlers.keys {
-      let applicableOperations = pipeline.filter { $0.applies(to: descriptor) }
-      if !applicableOperations.isEmpty {
-        self.handlers[descriptor]?.interceptors = applicableOperations.map { $0.interceptor }
-      }
-    }
-  }
-
   /// Removes any handler registered for the specified method.
   ///
   /// - Parameter descriptor: A descriptor of the method to remove a handler for.
@@ -156,6 +144,16 @@ public struct RPCRouter: Sendable {
   public mutating func removeHandler(forMethod descriptor: MethodDescriptor) -> Bool {
     return self.handlers.removeValue(forKey: descriptor) != nil
   }
+
+  @inlinable
+  mutating func registerInterceptors(pipeline: [ServerInterceptorOperation]) {
+    for descriptor in self.handlers.keys {
+      let applicableOperations = pipeline.filter { $0._applies(to: descriptor) }
+      if !applicableOperations.isEmpty {
+        self.handlers[descriptor]?.interceptors = applicableOperations.map { $0.interceptor }
+      }
+    }
+  }
 }
 
 extension RPCRouter {

Sources/GRPCCore/Call/Server/ServerInterceptorOperation.swift

@@ -15,93 +15,82 @@
  */
 
 /// A `ServerInterceptorOperation` describes to which RPCs a server interceptor should be applied.
-///
+///  
 /// You can configure a server interceptor to be applied to:
 /// - all RPCs and services;
 /// - requests directed only to specific services registered with your server; or
 /// - requests directed only to specific methods (of a specific service).
-///
+///  
 /// - SeeAlso: ``ServerInterceptor`` for more information on server interceptors, and
 ///  ``ClientInterceptorOperation`` for the client-side version of this type.
 public struct ServerInterceptorOperation: Sendable {
-  internal enum Wrapped: Sendable {
-    case allServices(interceptor: any ServerInterceptor)
-    case serviceSpecific(interceptor: any ServerInterceptor, services: [String])
-    case methodSpecific(interceptor: any ServerInterceptor, methods: [MethodDescriptor])
-  }
+  /// The subject of a ``ServerInterceptorOperation``.
+  /// The subject of an interceptor can either be all services and methods, only specific services, or only specific methods.
+  public struct Subject: Sendable {
+    internal enum Wrapped: Sendable {
+      case all
+      case services([ServiceDescriptor])
+      case methods([MethodDescriptor])
+    }
 
-  /// An operation specifying an interceptor that applies to all RPCs across all services will be registered with this server.
-  /// - Parameter interceptor: The interceptor to register with the server.
-  /// - Returns: A ``ServerInterceptorOperation``.
-  public static func applyToAllServices(
-    _ interceptor: any ServerInterceptor
-  ) -> Self {
-    Self(wrapped: .allServices(interceptor: interceptor))
-  }
+    private let wrapped: Wrapped
 
-  /// An operation specifying an interceptor that will be applied only to RPCs directed to the specified services.
-  /// - Parameters:
-  ///   - interceptor: The interceptor to register with the server.
-  ///   - services: The list of service names for which this interceptor should intercept RPCs.
-  /// - Returns: A ``ServerInterceptorOperation``.
-  public static func apply(
-    _ interceptor: any ServerInterceptor,
-    onlyToServices services: [String]
-  ) -> Self {
-    Self(
-      wrapped: .serviceSpecific(
-        interceptor: interceptor,
-        services: services
-      )
-    )
-  }
+    /// An operation subject specifying an interceptor that applies to all RPCs across all services will be registered with this server.
+    public static var all: Self { .init(wrapped: .all) }
 
-  /// An operation specifying an interceptor that will be applied only to RPCs directed to the specified service methods.
-  /// - Parameters:
-  ///   - interceptor: The interceptor to register with the server.
-  ///   - services: The list of method descriptors for which this interceptor should intercept RPCs.
-  /// - Returns: A ``ServerInterceptorOperation``.
-  public static func apply(
-    _ interceptor: any ServerInterceptor,
-    onlyToMethods methods: [MethodDescriptor]
-  ) -> Self {
-    Self(
-      wrapped: .methodSpecific(
-        interceptor: interceptor,
-        methods: methods
-      )
-    )
+    /// An operation subject specifying an interceptor that will be applied only to RPCs directed to the specified services.
+    /// - Parameters:
+    ///   - services: The list of service names for which this interceptor should intercept RPCs.
+    /// - Returns: A ``ServerInterceptorOperation``.
+    public static func services(_ services: [ServiceDescriptor]) -> Self {
+      Self(wrapped: .services(services))
+    }
+
+    /// An operation subject specifying an interceptor that will be applied only to RPCs directed to the specified service methods.
+    /// - Parameters:
+    ///   - methods: The list of method descriptors for which this interceptor should intercept RPCs.
+    /// - Returns: A ``ServerInterceptorOperation``.
+    public static func methods(_ methods: [MethodDescriptor]) -> Self {
+      Self(wrapped: .methods(methods))
+    }
+
+    internal func applies(to descriptor: MethodDescriptor) -> Bool {
+      switch self.wrapped {
+      case .all:
+        return true
+
+      case .services(let services):
+        return services.map({ $0.fullyQualifiedService }).contains(descriptor.service)
+
+      case .methods(let methods):
+        return methods.contains(descriptor)
+      }
+    }
   }
 
-  private let wrapped: Wrapped
+  /// The interceptor specified for this operation.
+  public let interceptor: any ServerInterceptor
 
-  private init(wrapped: Wrapped) {
-    self.wrapped = wrapped
+  private let subject: Subject
+
+  private init(interceptor: any ServerInterceptor, appliesTo: Subject) {
+    self.interceptor = interceptor
+    self.subject = appliesTo
   }
 
-  /// Get the ``ServerInterceptor`` associated with this ``ServerInterceptorOperation``.
-  public var interceptor: any ServerInterceptor {
-    switch self.wrapped {
-    case .allServices(let interceptor):
-      return interceptor
-    case .serviceSpecific(let interceptor, _):
-      return interceptor
-    case .methodSpecific(let interceptor, _):
-      return interceptor
-    }
+  /// Create an operation, specifying which ``ServerInterceptor`` to apply and to which ``Subject``.
+  /// - Parameters:
+  ///   - interceptor: The ``ServerInterceptor`` to register with the server.
+  ///   - subject: The ``Subject`` to which the `interceptor` applies.
+  /// - Returns: A ``ServerInterceptorOperation``.
+  public static func apply(_ interceptor: any ServerInterceptor, to subject: Subject) -> Self {
+    Self(interceptor: interceptor, appliesTo: subject)
   }
 
   /// Returns whether this ``ServerInterceptorOperation`` applies to the given `descriptor`.
   /// - Parameter descriptor: A ``MethodDescriptor`` for which to test whether this interceptor applies.
   /// - Returns: `true` if this interceptor applies to the given `descriptor`, or `false` otherwise.
-  public func applies(to descriptor: MethodDescriptor) -> Bool {
-    switch self.wrapped {
-    case .allServices:
-      return true
-    case .serviceSpecific(_, let services):
-      return services.contains(descriptor.service)
-    case .methodSpecific(_, let methods):
-      return methods.contains(descriptor)
-    }
+  public func _applies(to descriptor: MethodDescriptor) -> Bool {
+    self.subject.applies(to: descriptor)
   }
 }

Sources/GRPCCore/GRPCServer.swift

@@ -48,7 +48,7 @@ private import Synchronization
 /// let server = GRPCServer(
 ///   transport: inProcessTransport.server,
 ///   services: [greeter, echo],
-///   interceptors: [.allServices(interceptor: statsRecorder)]
+///   interceptors: [statsRecorder]
 /// )
 /// ```
 ///
@@ -149,7 +149,7 @@ public final class GRPCServer: Sendable {
     self.init(
       transport: transport,
       services: services,
-      interceptorPipeline: interceptors.map { .applyToAllServices($0) }
+      interceptorPipeline: interceptors.map { .apply($0, to: .all) }
     )
   }
 
@@ -172,54 +172,17 @@ public final class GRPCServer: Sendable {
     for service in services {
       service.registerMethods(with: &router)
     }
+    router.registerInterceptors(pipeline: interceptorPipeline)
 
-    self.init(
-      transport: transport,
-      router: router,
-      interceptorPipeline: interceptorPipeline
-    )
-  }
-
-  /// Creates a new server with no resources.
-  ///
-  /// - Parameters:
-  ///   - transport: The transport the server should listen on.
-  ///   - router: A ``RPCRouter`` used by the server to route accepted streams to method handlers.
-  ///   - interceptors: A collection of interceptors providing cross-cutting functionality to each
-  ///       accepted RPC. The order in which interceptors are added reflects the order in which they
-  ///       are called. The first interceptor added will be the first interceptor to intercept each
-  ///       request. The last interceptor added will be the final interceptor to intercept each
-  ///       request before calling the appropriate handler.
-  public convenience init(
-    transport: any ServerTransport,
-    router: RPCRouter,
-    interceptors: [any ServerInterceptor] = []
-  ) {
-    self.init(
-      transport: transport,
-      router: router,
-      interceptorPipeline: interceptors.map { .applyToAllServices($0) }
-    )
+    self.init(transport: transport, router: router)
   }
 
   /// Creates a new server with no resources.
   ///
   /// - Parameters:
   ///   - transport: The transport the server should listen on.
   ///   - router: A ``RPCRouter`` used by the server to route accepted streams to method handlers.
-  ///   - interceptors: A collection of interceptors providing cross-cutting functionality to each
-  ///       accepted RPC. The order in which interceptors are added reflects the order in which they
-  ///       are called. The first interceptor added will be the first interceptor to intercept each
-  ///       request. The last interceptor added will be the final interceptor to intercept each
-  ///       request before calling the appropriate handler.
-  public init(
-    transport: any ServerTransport,
-    router: RPCRouter,
-    interceptorPipeline: [ServerInterceptorOperation]
-  ) {
-    var router = router
-    router.registerInterceptors(pipeline: interceptorPipeline)
-
+  public init(transport: any ServerTransport, router: RPCRouter) {
     self.state = Mutex(.notStarted)
     self.transport = transport
     self.router = router
@@ -248,10 +211,7 @@ public final class GRPCServer: Sendable {
 
     do {
       try await transport.listen { stream, context in
-        await self.router.handle(
-          stream: stream,
-          context: context
-        )
+        await self.router.handle(stream: stream, context: context)
       }
     } catch {
       throw RuntimeError(

Tests/GRPCCoreTests/Call/Server/Internal/ServerRPCExecutorTests.swift

@@ -258,9 +258,7 @@ final class ServerRPCExecutorTests: XCTestCase {
     )
 
     // The interceptor skips the handler altogether.
-    let harness = ServerRPCExecutorTestHarness(interceptors: [
-      .rejectAll(with: error)
-    ])
+    let harness = ServerRPCExecutorTestHarness(interceptors: [.rejectAll(with: error)])
     try await harness.execute(
       deserializer: IdentityDeserializer(),
       serializer: IdentitySerializer()

Tests/GRPCCoreTests/GRPCServerTests.swift

@@ -221,9 +221,9 @@ final class GRPCServerTests: XCTestCase {
     try await self.withInProcessClientConnectedToServer(
       services: [BinaryEcho()],
       interceptorPipeline: [
-        .applyToAllServices(.requestCounter(counter1)),
-        .applyToAllServices(.rejectAll(with: RPCError(code: .unavailable, message: ""))),
-        .applyToAllServices(.requestCounter(counter2)),
+        .apply(.requestCounter(counter1), to: .all),
+        .apply(.rejectAll(with: RPCError(code: .unavailable, message: "")), to: .all),
+        .apply(.requestCounter(counter2), to: .all),
       ]
     ) { client, _ in
       try await client.withStream(
@@ -249,7 +249,7 @@ final class GRPCServerTests: XCTestCase {
 
     try await self.withInProcessClientConnectedToServer(
       services: [BinaryEcho()],
-      interceptorPipeline: [.applyToAllServices(.requestCounter(counter))]
+      interceptorPipeline: [.apply(.requestCounter(counter), to: .all)]
     ) { client, _ in
       try await client.withStream(
         descriptor: MethodDescriptor(service: "not", method: "implemented"),
@@ -390,16 +390,16 @@ struct ServerTests {
       interceptorPipeline: [
         .apply(
           .requestCounter(onlyBinaryEchoCounter),
-          onlyToServices: [BinaryEcho.serviceName]
+          to: .services([BinaryEcho.serviceDescriptor])
         ),
-        .applyToAllServices(.requestCounter(allServicesCounter)),
+        .apply(.requestCounter(allServicesCounter), to: .all),
         .apply(
           .requestCounter(onlyHelloWorldCounter),
-          onlyToServices: [HelloWorld.serviceName]
+          to: .services([HelloWorld.serviceDescriptor])
         ),
         .apply(
           .requestCounter(bothServicesCounter),
-          onlyToServices: [BinaryEcho.serviceName, HelloWorld.serviceName]
+          to: .services([BinaryEcho.serviceDescriptor, HelloWorld.serviceDescriptor])
         ),
       ]
     ) { client, _ in
@@ -477,16 +477,16 @@ struct ServerTests {
       interceptorPipeline: [
         .apply(
           .requestCounter(onlyBinaryEchoGetCounter),
-          onlyToMethods: [BinaryEcho.Methods.get]
+          to: .methods([BinaryEcho.Methods.get])
         ),
-        .applyToAllServices(.requestCounter(allMethodsCounter)),
+        .apply(.requestCounter(allMethodsCounter), to: .all),
         .apply(
           .requestCounter(onlyBinaryEchoCollectCounter),
-          onlyToMethods: [BinaryEcho.Methods.collect]
+          to: .methods([BinaryEcho.Methods.collect])
         ),
         .apply(
           .requestCounter(bothBinaryEchoMethodsCounter),
-          onlyToMethods: [BinaryEcho.Methods.get, BinaryEcho.Methods.collect]
+          to: .methods([BinaryEcho.Methods.get, BinaryEcho.Methods.collect])
         ),
       ]
     ) { client, _ in

Tests/GRPCCoreTests/Test Utilities/Services/BinaryEcho.swift

@@ -16,7 +16,7 @@
 import GRPCCore
 
 struct BinaryEcho: RegistrableRPCService {
-  static let serviceName = "echo.Echo"
+  static let serviceDescriptor = ServiceDescriptor(package: "echo", service: "Echo")
 
   func get(
     _ request: ServerRequest<[UInt8]>
@@ -97,9 +97,21 @@ struct BinaryEcho: RegistrableRPCService {
   }
 
   enum Methods {
-    static let get = MethodDescriptor(service: BinaryEcho.serviceName, method: "Get")
-    static let collect = MethodDescriptor(service: BinaryEcho.serviceName, method: "Collect")
-    static let expand = MethodDescriptor(service: BinaryEcho.serviceName, method: "Expand")
-    static let update = MethodDescriptor(service: BinaryEcho.serviceName, method: "Update")
+    static let get = MethodDescriptor(
+      service: BinaryEcho.serviceDescriptor.fullyQualifiedService,
+      method: "Get"
+    )
+    static let collect = MethodDescriptor(
+      service: BinaryEcho.serviceDescriptor.fullyQualifiedService,
+      method: "Collect"
+    )
+    static let expand = MethodDescriptor(
+      service: BinaryEcho.serviceDescriptor.fullyQualifiedService,
+      method: "Expand"
+    )
+    static let update = MethodDescriptor(
+      service: BinaryEcho.serviceDescriptor.fullyQualifiedService,
+      method: "Update"
+    )
   }
 }