add support for LOCAL_LAMBDA_PORT

Author: sebsto

Sources/AWSLambdaRuntime/Lambda+LocalServer.swift

@@ -42,18 +42,21 @@ extension Lambda {
     ///
     /// - parameters:
     ///     - invocationEndpoint: The endpoint to post events to.
+    ///     - port: the TCP port to listen to
     ///     - body: Code to run within the context of the mock server. Typically this would be a Lambda.run function call.
     ///
     /// - note: This API is designed strictly for local testing and is behind a DEBUG flag
     @usableFromInline
     static func withLocalServer(
         invocationEndpoint: String? = nil,
+        port: Int,
         logger: Logger,
         _ body: sending @escaping () async throws -> Void
     ) async throws {
         do {
             try await LambdaHTTPServer.withLocalServer(
                 invocationEndpoint: invocationEndpoint,
+                port: port,
                 logger: logger
             ) {
                 try await body()
@@ -112,7 +115,7 @@ internal struct LambdaHTTPServer {
     static func withLocalServer<Result: Sendable>(
         invocationEndpoint: String?,
         host: String = "127.0.0.1",
-        port: Int = 7000,
+        port: Int,
         eventLoopGroup: MultiThreadedEventLoopGroup = .singleton,
         logger: Logger,
         _ closure: sending @escaping () async throws -> Result

Sources/AWSLambdaRuntime/LambdaRuntime.swift

@@ -122,15 +122,20 @@ public final class LambdaRuntime<Handler>: Sendable where Handler: StreamingLamb
         } else {
 
             #if LocalServerSupport
+
             // we're not running on Lambda and we're compiled in DEBUG mode,
             // let's start a local server for testing
+
+            let port = Lambda.env("LOCAL_LAMBDA_PORT").flatMap(Int.init) ?? 7000
+
             try await Lambda.withLocalServer(
                 invocationEndpoint: Lambda.env("LOCAL_LAMBDA_SERVER_INVOCATION_ENDPOINT"),
+                port: port,
                 logger: self.logger
             ) {
 
                 try await LambdaRuntimeClient.withRuntimeClient(
-                    configuration: .init(ip: "127.0.0.1", port: 7000),
+                    configuration: .init(ip: "127.0.0.1", port: port),
                     eventLoop: self.eventLoop,
                     logger: self.logger
                 ) { runtimeClient in

Tests/AWSLambdaRuntimeTests/LambdaLocalServerTests.swift

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftAWSLambdaRuntime open source project
+//
+// Copyright (c) 2024 Apple Inc. and the SwiftAWSLambdaRuntime project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftAWSLambdaRuntime project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import Logging
+import NIOCore
+import NIOPosix
+import Testing
+
+@testable import AWSLambdaRuntime
+
+@Suite("Lambda Local Server Tests")
+struct LambdaLocalServerTests {
+
+    @Test("Local server respects LOCAL_LAMBDA_PORT environment variable")
+    func testLocalServerCustomPort() async throws {
+        let customPort = 8080
+
+        // Set environment variable
+        setenv("LOCAL_LAMBDA_PORT", "\(customPort)", 1)
+        defer { unsetenv("LOCAL_LAMBDA_PORT") }
+
+        let result = try? await withThrowingTaskGroup(of: Bool.self) { group in
+
+            // start a local lambda + local server on custom port
+            group.addTask {
+                // Create a simple handler
+                struct TestHandler: StreamingLambdaHandler {
+                    func handle(
+                        _ event: ByteBuffer,
+                        responseWriter: some LambdaResponseStreamWriter,
+                        context: LambdaContext
+                    ) async throws {
+                        try await responseWriter.write(ByteBuffer(string: "test"))
+                        try await responseWriter.finish()
+                    }
+                }
+
+                // create the Lambda Runtime
+                let runtime = LambdaRuntime(
+                    handler: TestHandler(),
+                    logger: Logger(label: "test", factory: { _ in SwiftLogNoOpLogHandler() })
+                )
+
+                // Start runtime
+                try await runtime._run()
+
+                // we reach this line when the group is cancelled
+                return false
+            }
+
+            // start a client to check if tsomething responds on the custom port
+            group.addTask {
+                // Give server time to start
+                try await Task.sleep(for: .milliseconds(100))
+
+                // Verify server is listening on custom port
+                return try await isPortResponding(host: "127.0.0.1", port: customPort)
+            }
+
+            let first = try await group.next()
+            group.cancelAll()
+            return first ?? false
+
+        }
+
+        #expect(result == true)
+    }
+
+    private func isPortResponding(host: String, port: Int) async throws -> Bool {
+        let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+
+        let bootstrap = ClientBootstrap(group: group)
+
+        do {
+            let channel = try await bootstrap.connect(host: host, port: port).get()
+            try await channel.close().get()
+            try await group.shutdownGracefully()
+            return true
+        } catch {
+            try await group.shutdownGracefully()
+            return false
+        }
+    }
+}

readme.md

@@ -476,6 +476,18 @@ Example:
 LOCAL_LAMBDA_SERVER_INVOCATION_ENDPOINT=/2015-03-31/functions/function/invocations swift run
 ```
 
+## Modifying the local port 
+
+By default, when using the local Lambda server, it listens on TCP port 7000.
+
+On macOS, this port might be used by AirPlay under some configurations. You can use the `LOCAL_LAMBDA_PORT` environment variable to configure the runtime to listen on a different TCP port.
+
+Example:
+
+```sh
+LOCAL_LAMBDA_PORT=7777 swift run
+```
+
 ## Deploying your Swift Lambda functions
 
 There is a full deployment guide available in [the documentation](https://swiftpackageindex.com/swift-server/swift-aws-lambda-runtime/main/documentation/awslambdaruntime/deployment).