Precompute interceptors when creating Server

Author: gjcairo

Sources/GRPCCore/Call/Server/RPCRouter.swift

@@ -82,7 +82,7 @@ public struct RPCRouter: Sendable {
   }
 
   @usableFromInline
-  private(set) var handlers: [MethodDescriptor: RPCHandler]
+  private(set) var handlers: [MethodDescriptor: (handler: RPCHandler, interceptors: [any ServerInterceptor])]
 
   /// Creates a new router with no methods registered.
   public init() {
@@ -126,12 +126,25 @@ public struct RPCRouter: Sendable {
       _ context: ServerContext
     ) async throws -> StreamingServerResponse<Output>
   ) {
-    self.handlers[descriptor] = RPCHandler(
+    let handler = RPCHandler(
       method: descriptor,
       deserializer: deserializer,
       serializer: serializer,
       handler: handler
     )
+    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.
@@ -150,10 +163,9 @@ extension RPCRouter {
       RPCAsyncSequence<RPCRequestPart, any Error>,
       RPCWriter<RPCResponsePart>.Closable
     >,
-    context: ServerContext,
-    interceptors: [any ServerInterceptor]
+    context: ServerContext
   ) async {
-    if let handler = self.handlers[stream.descriptor] {
+    if let (handler, interceptors) = self.handlers[stream.descriptor] {
       await handler.handle(stream: stream, context: context, interceptors: interceptors)
     } else {
       // If this throws then the stream must be closed which we can't do anything about, so ignore

Sources/GRPCCore/GRPCServer.swift

@@ -78,13 +78,6 @@ public final class GRPCServer: Sendable {
   /// The services registered which the server is serving.
   private let router: RPCRouter
 
-  /// A collection of ``ServerInterceptorOperation``s which may be applied to all accepted RPCs.
-  ///
-  /// RPCs are intercepted in the order that interceptors are added. That is, a request received
-  /// from the client will first be intercepted by the first added interceptor followed by the
-  /// second, and so on.
-  private let interceptors: [ServerInterceptorOperation]
-
   /// The state of the server.
   private let state: Mutex<State>
 
@@ -224,10 +217,12 @@ public final class GRPCServer: Sendable {
     router: RPCRouter,
     interceptorPipeline: [ServerInterceptorOperation]
   ) {
+    var router = router
+    router.registerInterceptors(pipeline: interceptorPipeline)
+
     self.state = Mutex(.notStarted)
     self.transport = transport
     self.router = router
-    self.interceptors = interceptorPipeline
   }
 
   /// Starts the server and runs until the registered transport has closed.
@@ -255,10 +250,7 @@ public final class GRPCServer: Sendable {
       try await transport.listen { stream, context in
         await self.router.handle(
           stream: stream,
-          context: context,
-          interceptors: self.interceptors
-            .filter { $0.applies(to: context.descriptor) }
-            .map { $0.interceptor }
+          context: context
         )
       }
     } catch {