func run()

in Sources/NIOExtrasPerformanceTester/HTTP1PerformanceTestFramework.swift [164:203]
38 lines of code
4 McCabe index (conditional complexity)

    func run() throws -> Int {
        var reqs: [Int] = []
        reqs.reserveCapacity(self.numberOfRepeats)
        for _ in 0..<self.numberOfRepeats {
            var requestHandlers: [RepeatedRequests] = []
            requestHandlers.reserveCapacity(self.numberOfClients)
            var clientChannels: [Channel] = []
            clientChannels.reserveCapacity(self.numberOfClients)
            for _ in 0 ..< self.numberOfClients {
                let clientChannel = try! ClientBootstrap(group: self.group)
                    .channelInitializer { channel in
                        channel.pipeline.addHTTPClientHandlers().flatMap {
                            let repeatedRequestsHandler = RepeatedRequests(numberOfRequests: self.requestsPerClient,
                                                                           eventLoop: channel.eventLoop,
                                                                           head: self.head)
                            requestHandlers.append(repeatedRequestsHandler)
                            return channel.pipeline.addHandler(repeatedRequestsHandler)
                        }.flatMap {
                            self.extraInitialiser(channel)
                        }
                    }
                    .connect(to: self.serverChannel.localAddress!)
                    .wait()
                clientChannels.append(clientChannel)
            }

            var writeFutures: [EventLoopFuture<Void>] = []
            for clientChannel in clientChannels {
                clientChannel.write(NIOAny(HTTPClientRequestPart.head(self.head)), promise: nil)
                writeFutures.append(clientChannel.writeAndFlush(NIOAny(HTTPClientRequestPart.end(nil))))
            }
            let allWrites = EventLoopFuture<Void>.andAllComplete(writeFutures, on: writeFutures.first!.eventLoop)
            try! allWrites.wait()

            let streamCompletedFutures = requestHandlers.map { rh in rh.completedFuture }
            let requestsServed = EventLoopFuture<Int>.reduce(0, streamCompletedFutures, on: streamCompletedFutures.first!.eventLoop, +)
            reqs.append(try! requestsServed.wait())
        }
        return reqs.reduce(0, +) / self.numberOfRepeats
    }