Method closeAsync

Libraries/Http/HttpAsyncServer.cpp:360–432

            if (not client.getReadableTransportStream().eventClose.addListener(closeListener))
            {
                closeAsync(client);
            }
            return;
        }

        // Register before starting the body stream, which can synchronously emit buffered body data.
        struct AfterWrite
        {
            HttpAsyncServer& pself;
            HttpConnection&  client;

            void operator()()
            {
                SC_HTTP_ASSERT_RELEASE(client.response.getWritableStream().eventFinish.removeListener(*this));

                // Determine if we should keep the connection alive
                const bool underMaxRequests =
                    (pself.maxRequestsPerConnection == 0) or (client.requestCount + 1 < pself.maxRequestsPerConnection);
                const bool shouldKeepAlive = client.response.getKeepAlive() and underMaxRequests and
                                             not client.getReadableTransportStream().isEnded();

                if (shouldKeepAlive and pself.state == State::Started) // We may get some after-writes after server stop
                {
                    // Increment request count
                    client.requestCount++;

                    // Reset request and response for next request
                    client.request.setHeaderMemory(client.getHeaderMemory());
                    client.response.reset();

                    if (&client.getWritableTransportStream() == &client.writableSocketStream)
                    {
                        SC_HTTP_ASSERT_RELEASE(client.socket.isValid());
                        Result writableRes =
                            client.writableSocketStream.init(client.buffersPool, *pself.eventLoop, client.socket);
                        SC_HTTP_TRUST_RESULT(writableRes);
                    }
                    else if (pself.transportReuse.isValid())
                    {
                        Result reuseResult = pself.transportReuse(client);
                        if (not reuseResult)
                        {
                            if (pself.onError.isValid())
                            {
                                pself.onError(reuseResult);
                            }
                            pself.closeAsync(client);
                            return;
                        }
                    }

                    // Resume reading in any case to avoid deadlocking
                    client.getReadableTransportStream().resumeReading();

                    // Re-register for next request headers
                    EventDataListener dataListener{pself, client};
                    SC_HTTP_ASSERT_RELEASE(client.getReadableTransportStream().eventData.addListener(dataListener));
                    EventEndListener endListener{pself, client};