Implemented file-by-filename and list-services requests (#1669)

Motivation:

The two requests are necessary for implementing the Reflection Service.

Modifications:

Implemented the ReflectionServiceData struct that stores the useful information from the file descriptor protos received when initiaizing the service and provides the data used for constructing the server response for each type of request. Also imlemented the
functions that create the server responses for the two requests. The requests and the functionality of the ReflectionServiceData struct's methods are tested in the "Tests/GRPCTests/GRPCReflectionServiceTests/GRPCReflectionServiceTests.swift" file.

Result:

The Reflection Service will support the file-by-filename and list-services requests.

Author: stefanadranca

Makefile

@@ -147,6 +147,27 @@ ${REFLECTION_GRPC}: ${REFLECTION_PROTO} ${PROTOC_GEN_GRPC_SWIFT}
 .PHONY:
 generate-reflection: ${REFLECTION_PB} ${REFLECTION_GRPC}
 
+TEST_REFLECTION_GRPC=Tests/GRPCTests/GRPCReflectionServiceTests/Generated/reflection.grpc.swift
+TEST_REFLECTION_PB=Tests/GRPCTests/GRPCReflectionServiceTests/Generated/reflection.pb.swift
+
+# For Reflection we'll generate only the Server code.
+${TEST_REFLECTION_GRPC}: ${REFLECTION_PROTO} ${PROTOC_GEN_GRPC_SWIFT}
+	protoc $< \
+		--proto_path=$(dir $<) \
+		--plugin=${PROTOC_GEN_GRPC_SWIFT} \
+		--grpc-swift_opt=Client=true,Server=false \
+		--grpc-swift_out=$(dir ${TEST_REFLECTION_GRPC})
+
+${TEST_REFLECTION_PB}: ${REFLECTION_PROTO} ${PROTOC_GEN_SWIFT}
+	protoc $< \
+		--proto_path=$(dir $<) \
+		--plugin=${PROTOC_GEN_SWIFT} \
+		--swift_out=$(dir ${TEST_REFLECTION_PB})
+		
+# Generates protobufs and gRPC client for the Reflection Service Tests
+.PHONY:
+generate-reflection-client: ${TEST_REFLECTION_PB} ${TEST_REFLECTION_GRPC}
+
 ### Testing ####################################################################
 
 # Normal test suite.

Package.swift

@@ -207,6 +207,7 @@ extension Target {
       .nioEmbedded,
       .nioTransportServices,
       .logging,
+      .reflectionService,
     ].appending(
       .nioSSL, if: includeNIOSSL
     ),

Sources/GRPCReflectionService/Model/reflection.pb.swift

@@ -7,7 +7,7 @@
 // For information on using the generated types, please see the documentation:
 //   https://github.com/apple/swift-protobuf/
 
-// Copyright 2023 The gRPC Authors
+// Copyright 2016 The gRPC Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.

Sources/GRPCReflectionService/Server/ReflectionProvider.swift

@@ -0,0 +1,189 @@
+/*
+ * Copyright 2023, gRPC Authors All rights reserved.
+ *
+ * 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.
+ */
+
+import DequeModule
+import Foundation
+import GRPC
+import SwiftProtobuf
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+public final class ReflectionService: CallHandlerProvider, Sendable {
+  private let reflectionService: ReflectionServiceProvider
+  public var serviceName: Substring {
+    self.reflectionService.serviceName
+  }
+
+  public init(fileDescriptors: [Google_Protobuf_FileDescriptorProto]) throws {
+    self.reflectionService = try ReflectionServiceProvider(fileDescriptorProtos: fileDescriptors)
+  }
+
+  public func handle(
+    method name: Substring,
+    context: GRPC.CallHandlerContext
+  ) -> GRPC.GRPCServerHandlerProtocol? {
+    self.reflectionService.handle(method: name, context: context)
+  }
+}
+
+internal struct ReflectionServiceData: Sendable {
+  internal struct FileDescriptorProtoData: Sendable {
+    internal var serializedFileDescriptorProto: Data
+    internal var dependencyFileNames: [String]
+  }
+
+  internal var fileDescriptorDataByFilename: [String: FileDescriptorProtoData]
+  internal var serviceNames: [String]
+
+  internal init(fileDescriptors: [Google_Protobuf_FileDescriptorProto]) throws {
+    self.serviceNames = []
+    self.fileDescriptorDataByFilename = [:]
+    for fileDescriptorProto in fileDescriptors {
+      let serializedFileDescriptorProto: Data
+      do {
+        serializedFileDescriptorProto = try fileDescriptorProto.serializedData()
+      } catch {
+        throw GRPCStatus(
+          code: .invalidArgument,
+          message:
+            "The \(fileDescriptorProto.name) could not be serialized."
+        )
+      }
+      let protoData = FileDescriptorProtoData(
+        serializedFileDescriptorProto: serializedFileDescriptorProto,
+        dependencyFileNames: fileDescriptorProto.dependency
+      )
+      self.fileDescriptorDataByFilename[fileDescriptorProto.name] = protoData
+      self.serviceNames.append(contentsOf: fileDescriptorProto.service.map { $0.name })
+    }
+  }
+
+  internal func serialisedFileDescriptorProtosForDependenciesOfFile(
+    named fileName: String
+  ) throws -> [Data] {
+    var toVisit = Deque<String>()
+    var visited = Set<String>()
+    var serializedFileDescriptorProtos: [Data] = []
+    toVisit.append(fileName)
+
+    while let currentFileName = toVisit.popFirst() {
+      if let protoData = self.fileDescriptorDataByFilename[currentFileName] {
+        toVisit.append(
+          contentsOf: protoData.dependencyFileNames
+            .filter { name in
+              return !visited.contains(name)
+            }
+        )
+
+        let serializedFileDescriptorProto = protoData.serializedFileDescriptorProto
+        serializedFileDescriptorProtos.append(serializedFileDescriptorProto)
+      } else {
+        throw GRPCStatus(
+          code: .notFound,
+          message: "The provided file or a dependency of the provided file could not be found."
+        )
+      }
+      visited.insert(currentFileName)
+    }
+    return serializedFileDescriptorProtos
+  }
+}
+
+@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
+internal final class ReflectionServiceProvider: Reflection_ServerReflectionAsyncProvider {
+  private let protoRegistry: ReflectionServiceData
+
+  internal init(fileDescriptorProtos: [Google_Protobuf_FileDescriptorProto]) throws {
+    self.protoRegistry = try ReflectionServiceData(
+      fileDescriptors: fileDescriptorProtos
+    )
+  }
+
+  internal func findFileByFileName(
+    _ fileName: String,
+    request: Reflection_ServerReflectionRequest
+  ) throws -> Reflection_ServerReflectionResponse {
+    return Reflection_ServerReflectionResponse(
+      request: request,
+      fileDescriptorResponse: try .with {
+        $0.fileDescriptorProto = try self.protoRegistry
+          .serialisedFileDescriptorProtosForDependenciesOfFile(named: fileName)
+      }
+    )
+  }
+
+  internal func getServicesNames(
+    request: Reflection_ServerReflectionRequest
+  ) throws -> Reflection_ServerReflectionResponse {
+    var listServicesResponse = Reflection_ListServiceResponse()
+    listServicesResponse.service = self.protoRegistry.serviceNames.map { serviceName in
+      Reflection_ServiceResponse.with {
+        $0.name = serviceName
+      }
+    }
+    return Reflection_ServerReflectionResponse(
+      request: request,
+      listServicesResponse: listServicesResponse
+    )
+  }
+
+  internal func serverReflectionInfo(
+    requestStream: GRPCAsyncRequestStream<Reflection_ServerReflectionRequest>,
+    responseStream: GRPCAsyncResponseStreamWriter<Reflection_ServerReflectionResponse>,
+    context: GRPCAsyncServerCallContext
+  ) async throws {
+    for try await request in requestStream {
+      switch request.messageRequest {
+      case let .fileByFilename(fileName):
+        let response = try self.findFileByFileName(
+          fileName,
+          request: request
+        )
+        try await responseStream.send(response)
+
+      case .listServices:
+        let response = try self.getServicesNames(request: request)
+        try await responseStream.send(response)
+
+      default:
+        throw GRPCStatus(code: .unimplemented)
+      }
+    }
+  }
+}
+
+extension Reflection_ServerReflectionResponse {
+  init(
+    request: Reflection_ServerReflectionRequest,
+    fileDescriptorResponse: Reflection_FileDescriptorResponse
+  ) {
+    self = .with {
+      $0.validHost = request.host
+      $0.originalRequest = request
+      $0.fileDescriptorResponse = fileDescriptorResponse
+    }
+  }
+
+  init(
+    request: Reflection_ServerReflectionRequest,
+    listServicesResponse: Reflection_ListServiceResponse
+  ) {
+    self = .with {
+      $0.validHost = request.host
+      $0.originalRequest = request
+      $0.listServicesResponse = listServicesResponse
+    }
+  }
+}