simpler/faster mock

motivation: faster mock server for perf testing

changes: no logger, always keep-alive

Author: tomerd

Sources/MockServer/main.swift

@@ -13,44 +13,35 @@
 //===----------------------------------------------------------------------===//
 
 import Foundation
-import Logging
 import NIO
 import NIOHTTP1
 
 internal struct MockServer {
-    private let logger: Logger
     private let group: EventLoopGroup
     private let host: String
     private let port: Int
     private let mode: Mode
-    private let keepAlive: Bool
 
     public init() {
-        var logger = Logger(label: "MockServer")
-        logger.logLevel = env("LOG_LEVEL").flatMap(Logger.Level.init) ?? .info
-        self.logger = logger
         self.group = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
         self.host = env("HOST") ?? "127.0.0.1"
         self.port = env("PORT").flatMap(Int.init) ?? 7000
         self.mode = env("MODE").flatMap(Mode.init) ?? .string
-        self.keepAlive = env("KEEP_ALIVE").flatMap(Bool.init) ?? true
     }
 
     func start() throws {
         let bootstrap = ServerBootstrap(group: group)
             .serverChannelOption(ChannelOptions.socket(SocketOptionLevel(SOL_SOCKET), SO_REUSEADDR), value: 1)
             .childChannelInitializer { channel in
                 channel.pipeline.configureHTTPServerPipeline(withErrorHandling: true).flatMap { _ in
-                    channel.pipeline.addHandler(HTTPHandler(logger: self.logger,
-                                                            keepAlive: self.keepAlive,
-                                                            mode: self.mode))
+                    channel.pipeline.addHandler(HTTPHandler(mode: self.mode))
                 }
             }
         try bootstrap.bind(host: self.host, port: self.port).flatMap { channel -> EventLoopFuture<Void> in
             guard let localAddress = channel.localAddress else {
                 return channel.eventLoop.makeFailedFuture(ServerError.cantBind)
             }
-            self.logger.info("\(self) started and listening on \(localAddress)")
+            print("\(self) started and listening on \(localAddress)")
             return channel.eventLoop.makeSucceededFuture(())
         }.wait()
     }
@@ -60,15 +51,11 @@ internal final class HTTPHandler: ChannelInboundHandler {
     public typealias InboundIn = HTTPServerRequestPart
     public typealias OutboundOut = HTTPServerResponsePart
 
-    private let logger: Logger
     private let mode: Mode
-    private let keepAlive: Bool
 
     private var pending = CircularBuffer<(head: HTTPRequestHead, body: ByteBuffer?)>()
 
-    public init(logger: Logger, keepAlive: Bool, mode: Mode) {
-        self.logger = logger
-        self.keepAlive = keepAlive
+    public init(mode: Mode) {
         self.mode = mode
     }
 
@@ -93,8 +80,6 @@ internal final class HTTPHandler: ChannelInboundHandler {
     }
 
     func processRequest(context: ChannelHandlerContext, request: (head: HTTPRequestHead, body: ByteBuffer?)) {
-        self.logger.debug("\(self) processing \(request.head.uri)")
-
         var responseStatus: HTTPResponseStatus
         var responseBody: String?
         var responseHeaders: [(String, String)]?
@@ -125,33 +110,24 @@ internal final class HTTPHandler: ChannelInboundHandler {
 
     func writeResponse(context: ChannelHandlerContext, status: HTTPResponseStatus, headers: [(String, String)]? = nil, body: String? = nil) {
         var headers = HTTPHeaders(headers ?? [])
-        headers.add(name: "Content-Length", value: "\(body?.utf8.count ?? 0)")
-        if !self.keepAlive {
-            // We only need to add a "Connection" header if we really want to close the connection
-            headers.add(name: "Connection", value: "close")
-        }
+        headers.add(name: "content-length", value: "\(body?.utf8.count ?? 0)")
         let head = HTTPResponseHead(version: HTTPVersion(major: 1, minor: 1), status: status, headers: headers)
 
         context.write(wrapOutboundOut(.head(head))).whenFailure { error in
-            self.logger.error("\(self) write error \(error)")
+            print("\(self) write error \(error)")
         }
 
         if let b = body {
             var buffer = context.channel.allocator.buffer(capacity: b.utf8.count)
             buffer.writeString(b)
             context.write(wrapOutboundOut(.body(.byteBuffer(buffer)))).whenFailure { error in
-                self.logger.error("\(self) write error \(error)")
+                print("\(self) write error \(error)")
             }
         }
 
         context.writeAndFlush(wrapOutboundOut(.end(nil))).whenComplete { result in
             if case .failure(let error) = result {
-                self.logger.error("\(self) write error \(error)")
-            }
-            if !self.keepAlive {
-                context.close().whenFailure { error in
-                    self.logger.error("\(self) close error \(error)")
-                }
+                print("\(self) write error \(error)")
             }
         }
     }