Remove /init/error and improve /invocation/error output

Author: stevapple

Sources/TencentSCFRuntimeCore/SCF+LocalServer.swift

@@ -165,7 +165,7 @@ private enum LocalFunction {
                 }
 
             // `/next` endpoint is called by the SCF instance polling for work.
-            case (.GET, let url) where url == Consts.getNextInvocationURL:
+            case (.GET, let url) where url == Endpoint.getNextInvocation:
                 // Check if our server is in the correct state.
                 guard case .waitingForSCFRequest = Self.invocationState else {
                     self.logger.error("invalid invocation state \(Self.invocationState)")
@@ -197,7 +197,7 @@ private enum LocalFunction {
                 }
 
             // `/response` endpoint is called by the cloud function posting the response.
-            case (.POST, let url) where url == Consts.postResponseURL:
+            case (.POST, let url) where url == Endpoint.postResponse:
                 guard case .waitingForSCFResponse(let invocation) = Self.invocationState else {
                     // A response was sent, but we did not expect to receive one.
                     self.logger.error("invalid invocation state \(Self.invocationState)")
@@ -209,7 +209,7 @@ private enum LocalFunction {
                 Self.invocationState = .waitingForSCFRequest
 
             // `/error` endpoint is called by the cloud function posting an error response.
-            case (.POST, let url) where url == Consts.postErrorURL:
+            case (.POST, let url) where url == Endpoint.postError:
                 guard case .waitingForSCFResponse(let invocation) = Self.invocationState else {
                     // A response was sent, but we did not expect to receive one.
                     self.logger.error("invalid invocation state \(Self.invocationState)")

Sources/TencentSCFRuntimeCore/SCFRunner.swift

@@ -65,12 +65,10 @@ extension SCF {
                     self.runtimeClient.reportInitializationReady(logger: logger)
                         .mapResult { _ in handler }
                 }
-                .peekError { error in
-                    self.runtimeClient.reportInitializationError(logger: logger, error: error).peekError { reportingError in
-                        // We're going to bail out because the init failed, so there's not a lot we
-                        // can do other than log that we couldn't report this error back to the runtime.
-                        logger.error("failed reporting initialization error to scf runtime engine: \(reportingError)")
-                    }
+                .peekError { error -> Void in
+                    // We're going to terminate because the init failed, so there's not a lot we
+                    // can do other than log the error back to the runtime.
+                    logger.error("initialization fail with error: \(error)")
                 }
         }
 

Sources/TencentSCFRuntimeCore/SCFRuntimeClient.swift

@@ -30,11 +30,10 @@ import NIO
 import NIOHTTP1
 
 /// An HTTP based client for SCF Runtime Engine. This encapsulates the RESTful methods exposed by the runtime engine:
-/// * /runtime/invocation/next
-/// * /runtime/invocation/response
-/// * /runtime/invocation/error
-/// * /runtime/init/ready
-/// * /runtime/init/error
+/// - POST /runtime/init/ready
+/// - GET /runtime/invocation/next
+/// - POST /runtime/invocation/response
+/// - POST /runtime/invocation/error
 extension SCF {
     internal struct RuntimeClient {
         private let eventLoop: EventLoop
@@ -48,7 +47,7 @@ extension SCF {
 
         /// Requests invocation from the API server.
         func getNextInvocation(logger: Logger) -> EventLoopFuture<(Invocation, ByteBuffer)> {
-            let url = Consts.getNextInvocationURL
+            let url = Endpoint.getNextInvocation
             logger.debug("requesting work from scf runtime engine using \(url)")
             return self.httpClient.get(url: url, headers: RuntimeClient.defaultHeaders).flatMapThrowing { response in
                 guard response.status == .ok else {
@@ -79,15 +78,12 @@ extension SCF {
 
             switch result {
             case .success(let buffer):
-                url = Consts.postResponseURL
+                url = Endpoint.postResponse
                 body = buffer
                 headers = RuntimeClient.defaultHeaders
             case .failure(let error):
-                url = Consts.postErrorURL
-                let errorResponse = ErrorResponse(errorType: Consts.functionError, errorMessage: "\(error)")
-                let bytes = errorResponse.toJSONBytes()
-                body = self.allocator.buffer(capacity: bytes.count)
-                body!.writeBytes(bytes)
+                url = Endpoint.postError
+                body = self.allocator.buffer(string: "\(error)")
                 headers = RuntimeClient.errorHeaders
             }
             logger.debug("reporting results to scf runtime engine using \(url)")
@@ -110,7 +106,7 @@ extension SCF {
 
         /// Reports initialization ready to the runtime engine.
         func reportInitializationReady(logger: Logger) -> EventLoopFuture<Void> {
-            let url = Consts.postInitReadyURL
+            let url = Endpoint.postInitReady
             logger.info("reporting initialization ready to scf runtime engine using \(url)")
             return self.httpClient.post(url: url, headers: RuntimeClient.defaultHeaders, body: .init(string: " ")).flatMapThrowing { response in
                 guard response.status == .ok else {
@@ -129,31 +125,6 @@ extension SCF {
             }
         }
 
-        /// Reports an initialization error to the runtime engine.
-        func reportInitializationError(logger: Logger, error: Error) -> EventLoopFuture<Void> {
-            let url = Consts.postInitErrorURL
-            let errorResponse = ErrorResponse(errorType: Consts.initializationError, errorMessage: "\(error)")
-            let bytes = errorResponse.toJSONBytes()
-            var body = self.allocator.buffer(capacity: bytes.count)
-            body.writeBytes(bytes)
-            logger.warning("reporting initialization error to scf runtime engine using \(url)")
-            return self.httpClient.post(url: url, headers: RuntimeClient.errorHeaders, body: body).flatMapThrowing { response in
-                guard response.status == .ok else {
-                    throw RuntimeError.badStatusCode(response.status)
-                }
-                return ()
-            }.flatMapErrorThrowing { error in
-                switch error {
-                case HTTPClient.Errors.timeout:
-                    throw RuntimeError.upstreamError("timeout")
-                case HTTPClient.Errors.connectionResetByPeer:
-                    throw RuntimeError.upstreamError("connectionResetByPeer")
-                default:
-                    throw error
-                }
-            }
-        }
-
         /// Cancels the current request if one is already running. Only needed for debugging purposes.
         func cancel() {
             self.httpClient.cancel()
@@ -172,24 +143,6 @@ internal extension SCF {
     }
 }
 
-internal struct ErrorResponse: Codable {
-    var errorType: String
-    var errorMessage: String
-}
-
-internal extension ErrorResponse {
-    func toJSONBytes() -> [UInt8] {
-        var bytes = [UInt8]()
-        bytes.append(UInt8(ascii: "{"))
-        bytes.append(contentsOf: #""errorType":"# .utf8)
-        self.errorType.encodeAsJSONString(into: &bytes)
-        bytes.append(contentsOf: #","errorMessage":"# .utf8)
-        self.errorMessage.encodeAsJSONString(into: &bytes)
-        bytes.append(UInt8(ascii: "}"))
-        return bytes
-    }
-}
-
 extension SCF {
     internal struct Invocation {
         let requestID: String

Sources/TencentSCFRuntimeCore/Utils.swift

@@ -28,14 +28,11 @@
 import Dispatch
 import NIO
 
-internal enum Consts {
-    static let getNextInvocationURL = "/runtime/invocation/next"
-    static let postResponseURL = "/runtime/invocation/response"
-    static let postErrorURL = "/runtime/invocation/error"
-    static let postInitErrorURL = "/runtime/init/error"
-    static let postInitReadyURL = "/runtime/init/ready"
-    static let functionError = "FunctionError"
-    static let initializationError = "InitializationError"
+internal enum Endpoint {
+    static let getNextInvocation = "/runtime/invocation/next"
+    static let postResponse = "/runtime/invocation/response"
+    static let postError = "/runtime/invocation/error"
+    static let postInitReady = "/runtime/init/ready"
 }
 
 /// Tencent SCF HTTP Headers, used to populate the `SCF.Context` object.

Tests/TencentSCFRuntimeCoreTests/MockSCFServer.swift

@@ -132,18 +132,7 @@ internal final class HTTPHandler: ChannelInboundHandler {
         var responseBody: String?
         var responseHeaders: [(String, String)]?
 
-        // Handle post-init-error first to avoid matching the less specific post-error suffix.
-        if request.head.uri == Consts.postInitErrorURL {
-            guard let json = requestBody, let error = ErrorResponse.fromJson(json) else {
-                return self.writeResponse(context: context, status: .badRequest)
-            }
-            switch self.behavior.process(initError: error) {
-            case .success:
-                responseStatus = .ok
-            case .failure(let error):
-                responseStatus = .init(statusCode: error.rawValue)
-            }
-        } else if request.head.uri == Consts.getNextInvocationURL {
+        if request.head.uri == Endpoint.getNextInvocation {
             switch self.behavior.getInvocation() {
             case .success(let (requestId, result)):
                 if requestId == "timeout" {
@@ -161,17 +150,15 @@ internal final class HTTPHandler: ChannelInboundHandler {
             case .failure(let error):
                 responseStatus = .init(statusCode: error.rawValue)
             }
-        } else if request.head.uri == Consts.postResponseURL {
+        } else if request.head.uri == Endpoint.postResponse {
             switch self.behavior.process(response: requestBody) {
             case .success:
                 responseStatus = .ok
             case .failure(let error):
                 responseStatus = .init(statusCode: error.rawValue)
             }
-        } else if request.head.uri == Consts.postErrorURL {
-            guard let json = requestBody,
-                let error = ErrorResponse.fromJson(json)
-            else {
+        } else if request.head.uri == Endpoint.postError {
+            guard let error = requestBody else {
                 return self.writeResponse(context: context, status: .badRequest)
             }
             switch self.behavior.process(error: error) {
@@ -222,8 +209,7 @@ internal final class HTTPHandler: ChannelInboundHandler {
 internal protocol SCFServerBehavior {
     func getInvocation() -> GetInvocationResult
     func process(response: String?) -> Result<Void, ProcessResponseError>
-    func process(error: ErrorResponse) -> Result<Void, ProcessErrorError>
-    func process(initError: ErrorResponse) -> Result<Void, ProcessErrorError>
+    func process(error: String) -> Result<Void, ProcessErrorError>
 }
 
 internal typealias GetInvocationResult = Result<(String, String), GetWorkError>
@@ -251,18 +237,3 @@ internal enum ServerError: Error {
     case notReady
     case cantBind
 }
-
-private extension ErrorResponse {
-    static func fromJson(_ s: String) -> ErrorResponse? {
-        let decoder = JSONDecoder()
-        do {
-            if let data = s.data(using: .utf8) {
-                return try decoder.decode(ErrorResponse.self, from: data)
-            } else {
-                return nil
-            }
-        } catch {
-            return nil
-        }
-    }
-}

Tests/TencentSCFRuntimeCoreTests/SCF+StringTest.swift

@@ -239,20 +239,15 @@ private struct Behavior: SCFServerBehavior {
         }
     }
 
-    func process(error: ErrorResponse) -> Result<Void, ProcessErrorError> {
+    func process(error: String) -> Result<Void, ProcessErrorError> {
         XCTAssertEqual(self.requestId, self.requestId, "expecting requestId to match")
         switch self.result {
         case .success:
             XCTFail("unexpected to succeed, but failed with: \(error)")
             return .failure(.internalServerError)
         case .failure(let expected):
-            XCTAssertEqual(expected.description, error.errorMessage, "expecting error to match")
+            XCTAssertEqual(expected.description, error, "expecting error to match")
             return .success(())
         }
     }
-
-    func process(initError: ErrorResponse) -> Result<Void, ProcessErrorError> {
-        XCTFail("should not report init error")
-        return .failure(.internalServerError)
-    }
 }

Tests/TencentSCFRuntimeCoreTests/SCFLifecycleTest.swift

@@ -143,12 +143,7 @@ struct BadBehavior: SCFServerBehavior {
         return .failure(.internalServerError)
     }
 
-    func process(error: ErrorResponse) -> Result<Void, ProcessErrorError> {
-        XCTFail("should not report an error")
-        return .failure(.internalServerError)
-    }
-
-    func process(initError: ErrorResponse) -> Result<Void, ProcessErrorError> {
+    func process(error: String) -> Result<Void, ProcessErrorError> {
         XCTFail("should not report an error")
         return .failure(.internalServerError)
     }

Tests/TencentSCFRuntimeCoreTests/SCFRunnerTest.swift

@@ -42,15 +42,10 @@ class SCFRunnerTest: XCTestCase {
                 return .success(())
             }
 
-            func process(error: ErrorResponse) -> Result<Void, ProcessErrorError> {
+            func process(error: String) -> Result<Void, ProcessErrorError> {
                 XCTFail("should not report error")
                 return .failure(.internalServerError)
             }
-
-            func process(initError: ErrorResponse) -> Result<Void, ProcessErrorError> {
-                XCTFail("should not report init error")
-                return .failure(.internalServerError)
-            }
         }
         XCTAssertNoThrow(try runSCF(behavior: Behavior(), handler: EchoHandler()))
     }
@@ -68,15 +63,10 @@ class SCFRunnerTest: XCTestCase {
                 return .failure(.internalServerError)
             }
 
-            func process(error: ErrorResponse) -> Result<Void, ProcessErrorError> {
-                XCTAssertEqual(Behavior.error, error.errorMessage, "expecting error to match")
+            func process(error: String) -> Result<Void, ProcessErrorError> {
+                XCTAssertEqual(Behavior.error, error, "expecting error to match")
                 return .success(())
             }
-
-            func process(initError: ErrorResponse) -> Result<Void, ProcessErrorError> {
-                XCTFail("should not report init error")
-                return .failure(.internalServerError)
-            }
         }
         XCTAssertNoThrow(try runSCF(behavior: Behavior(), handler: FailedHandler(Behavior.error)))
     }