Avoid trouble with shutting down HTTPClient

UseCases/Sources/HTTPEndToEnd/InstrumentedHTTPClient.swift

@@ -6,21 +6,36 @@ import NIO
 import NIOHTTP1
 
 struct InstrumentedHTTPClient {
-    private let client = HTTPClient(eventLoopGroupProvider: .createNew)
+    private let client: HTTPClient
     private let instrument: Instrument<HTTPHeaders, HTTPHeaders>
 
     init<I>(instrument: I, eventLoopGroupProvider: HTTPClient.EventLoopGroupProvider)
         where
         I: InstrumentProtocol,
         I.InjectInto == HTTPHeaders,
         I.ExtractFrom == HTTPHeaders {
+        self.client = HTTPClient(eventLoopGroupProvider: eventLoopGroupProvider)
         self.instrument = Instrument(instrument)
     }
 
+    // TODO: deadline: NIODeadline? would move into baggage?
+    public func get(url: String, baggage: BaggageContext = .init()) -> EventLoopFuture<HTTPClient.Response> {
+        do {
+            let request = try HTTPClient.Request(url: url, method: .GET)
+            return self.execute(request: request, baggage: baggage)
+        } catch {
+            return self.client.eventLoopGroup.next().makeFailedFuture(error)
+        }
+    }
+
     func execute(request: HTTPClient.Request, baggage: BaggageContext) -> EventLoopFuture<HTTPClient.Response> {
         var request = request
         self.instrument.inject(from: baggage, into: &request.headers)
         baggage.logger.info("AsyncHTTPClient: Execute request")
         return self.client.execute(request: request)
     }
+
+    func syncShutdown() throws {
+        try self.client.syncShutdown()
+    }
 }

UseCases/Sources/HTTPEndToEnd/Services/OrderServiceHandler.swift

@@ -10,12 +10,15 @@ final class OrderServiceHandler: ChannelInboundHandler {
     typealias InboundIn = HTTPServerRequestPart
     typealias OutboundOut = HTTPServerResponsePart
 
+    private let httpClient: InstrumentedHTTPClient
     private let instrument: Instrument<HTTPHeaders, HTTPHeaders>
 
-    init<I>(instrument: I)
+    init<I>(httpClient: InstrumentedHTTPClient, instrument: I)
         where I: InstrumentProtocol,
         I.InjectInto == HTTPHeaders,
         I.ExtractFrom == HTTPHeaders {
+
+        self.httpClient = httpClient
         self.instrument = Instrument(instrument)
     }
 
@@ -30,20 +33,16 @@ final class OrderServiceHandler: ChannelInboundHandler {
 
         baggage.logger.info("Handling order service request")
 
-        let client = InstrumentedHTTPClient(
-            instrument: self.instrument,
-            eventLoopGroupProvider: .shared(context.eventLoop)
-        )
+
         let request = try! HTTPClient.Request(url: "http://localhost:8081")
-        client.execute(request: request, baggage: baggage).whenComplete { _ in
+        httpClient.execute(request: request, baggage: baggage).whenComplete { _ in
             let responseHead = HTTPResponseHead(version: requestHead.version, status: .ok)
             context.eventLoop.execute {
                 context.channel.write(self.wrapOutboundOut(.head(responseHead)), promise: nil)
                 context.channel.write(self.wrapOutboundOut(.end(nil)), promise: nil)
                 context.channel.flush()
             }
         }
-
-        // TODO: Shut down client before deinit
     }
+
 }

UseCases/Sources/HTTPEndToEnd/Services/StorageServiceHandler.swift

@@ -9,11 +9,12 @@ final class StorageServiceHandler: ChannelInboundHandler {
     typealias InboundIn = HTTPServerRequestPart
     typealias OutboundOut = HTTPServerResponsePart
 
+    let logger = Logger(label: "StorageService")
+
     func channelRead(context: ChannelHandlerContext, data: NIOAny) {
         guard case .head(let requestHead) = self.unwrapInboundIn(data) else { return }
 
         var baggage = BaggageContext()
-        let logger = Logger(label: "StorageService")
         baggage[BaggageContext.BaseLoggerKey.self] = logger
         baggage.logger.info("Handling storage service request")
 

UseCases/Sources/HTTPEndToEnd/main.swift

@@ -9,15 +9,15 @@ import NIOHTTP1
 import NIO
 
 let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: System.coreCount)
-let threadPool = NIOThreadPool(numberOfThreads: 6)
-threadPool.start()
+
+let httpClient = InstrumentedHTTPClient(instrument: FakeTracer(), eventLoopGroupProvider: .createNew)
 
 let orderServiceBootstrap = ServerBootstrap(group: eventLoopGroup)
     .serverChannelOption(ChannelOptions.backlog, value: 256)
     .serverChannelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
     .childChannelInitializer { channel in
         channel.pipeline.configureHTTPServerPipeline().flatMap {
-            channel.pipeline.addHandler(OrderServiceHandler(instrument: FakeTracer()))
+            channel.pipeline.addHandler(OrderServiceHandler(httpClient: httpClient, instrument: FakeTracer()))
         }
     }
     .childChannelOption(ChannelOptions.socketOption(.so_reuseaddr), value: 1)
@@ -44,7 +44,6 @@ logger.info("Order service listening on ::1:8080")
 let storageServiceChannel = try storageServiceBootstrap.bind(host: "localhost", port: 8081).wait()
 logger.info("Storage service listening on ::1:8081")
 
-let httpClient = HTTPClient(eventLoopGroupProvider: .createNew)
 httpClient.get(url: "http://localhost:8080").whenComplete { result in
     switch result {
     case .success(let response):
@@ -57,8 +56,9 @@ httpClient.get(url: "http://localhost:8080").whenComplete { result in
 sleep(20)
 
 try httpClient.syncShutdown()
+try orderServiceChannel.close().wait()
+try storageServiceChannel.close().wait()
 try eventLoopGroup.syncShutdownGracefully()
-try threadPool.syncShutdownGracefully()
 
 // MARK: - Fake Tracer