Optimization of synchronization when sending HTTP/2 frames

awwit · awwit · commit cdc448fd298e · 2017-04-05T16:48:46.000+03:00
diff --git a/src/server/protocol/ServerHttp2.cpp b/src/server/protocol/ServerHttp2.cpp
@@ -40,7 +40,7 @@ namespace HttpServer
 		return streams.emplace(streamId, Http2::IncStream(streamId, conn) ).first->second;
 	}
 
-	static void sendWindowUpdate(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::IncStream &stream, const uint32_t size) noexcept
+	static void sendWindowUpdate(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const Http2::IncStream &stream, const uint32_t size) noexcept
 	{
 		std::array<uint8_t, Http2::FRAME_HEADER_SIZE + sizeof(uint32_t)> buf;
 		uint8_t *addr = buf.data();
@@ -49,6 +49,8 @@ namespace HttpServer
 
 		*reinterpret_cast<uint32_t *>(addr) = ::htonl(size);
 
+		const std::unique_lock<std::mutex> lock(stream.conn.sync.mtx);
+
 		sock.nonblock_send(buf.data(), buf.size(), timeout);
 	}
 
@@ -305,18 +307,22 @@ namespace HttpServer
 		return Http2::ErrorCode::NO_ERROR;
 	}
 
-	static void ping(const Socket::Adapter &sock, const struct Request &req, const uint64_t pingData)
+	static void ping(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const uint64_t pingData)
 	{
 		constexpr uint32_t frame_size = sizeof(uint64_t);
 
 		std::array<uint8_t, Http2::FRAME_HEADER_SIZE + frame_size> buf;
 		uint8_t *addr = buf.data();
 
-		addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::PING, Http2::FrameFlag::ACK, 0);
+		constexpr uint32_t stream_id = 0;
+
+		addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::PING, Http2::FrameFlag::ACK, stream_id);
 
 		*reinterpret_cast<uint64_t *>(addr) = pingData;
 
-		sock.nonblock_send(buf.data(), buf.size(), req.timeout);
+		const std::unique_lock<std::mutex> lock(conn.sync.mtx);
+
+		sock.nonblock_send(buf.data(), buf.size(), timeout);
 	}
 
 	static Http2::ErrorCode parseHttp2Ping(Http2::FrameMeta &meta)
@@ -374,21 +380,23 @@ namespace HttpServer
 		return Http2::ErrorCode::NO_ERROR;
 	}
 
-	static void rstStream(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const uint32_t streamId, const Http2::ErrorCode errorCode)
+	static void rstStream(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::IncStream &stream, const Http2::ErrorCode errorCode)
 	{
 		constexpr uint32_t frame_size = sizeof(uint32_t);
 
 		std::array<uint8_t, Http2::FRAME_HEADER_SIZE + frame_size> buf;
 		uint8_t *addr = buf.data();
 
-		addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::RST_STREAM, Http2::FrameFlag::EMPTY, streamId);
+		addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::RST_STREAM, Http2::FrameFlag::EMPTY, stream.stream_id);
 
 		*reinterpret_cast<uint32_t *>(addr) = ::htonl(static_cast<const uint32_t>(errorCode) );
 
+		const std::unique_lock<std::mutex> lock(stream.conn.sync.mtx);
+
 		sock.nonblock_send(buf.data(), buf.size(), timeout);
 	}
 
-	static void sendSettings(const Socket::Adapter &sock, const struct Request &req, const uint8_t *src, const uint8_t *end)
+	static void sendSettings(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const uint8_t *src, const uint8_t *end)
 	{
 		const uint32_t frame_size = end - src;
 
@@ -402,10 +410,12 @@ namespace HttpServer
 
 		std::copy(src, end, addr);
 
-		sock.nonblock_send(buf.data(), buf.size(), req.timeout);
+		const std::unique_lock<std::mutex> lock(conn.sync.mtx);
+
+		sock.nonblock_send(buf.data(), buf.size(), timeout);
 	}
 
-	static void goAway(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const uint32_t lastStreamId, const Http2::ErrorCode errorCode)
+	static void goAway(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const uint32_t lastStreamId, const Http2::ErrorCode errorCode)
 	{
 		constexpr uint32_t frame_size = sizeof(uint32_t) * 2;
 
@@ -418,6 +428,8 @@ namespace HttpServer
 		*reinterpret_cast<uint32_t *>(addr) = ::htonl(static_cast<const uint32_t>(lastStreamId) );
 		*reinterpret_cast<uint32_t *>(addr + sizeof(uint32_t) ) = ::htonl(static_cast<const uint32_t>(errorCode) );
 
+		const std::unique_lock<std::mutex> lock(conn.sync.mtx);
+
 		sock.nonblock_send(buf.data(), buf.size(), timeout);
 	}
 
@@ -446,7 +458,7 @@ namespace HttpServer
 		return 0 == compare;
 	}
 
-	static void sendEmptySettings(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const Http2::FrameFlag flags)
+	static void sendEmptySettings(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const Http2::FrameFlag flags)
 	{
 		constexpr uint32_t frame_size = 0;
 
@@ -457,21 +469,7 @@ namespace HttpServer
 
 		addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::SETTINGS, flags, stream_id);
 
-		sock.nonblock_send(buf.data(), buf.size(), timeout);
-	}
-
-	static void windowUpdate(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout)
-	{
-		constexpr uint32_t frame_size = 4;
-
-		std::array<uint8_t, Http2::FRAME_HEADER_SIZE + frame_size> buf;
-		uint8_t *addr = buf.data();
-
-		constexpr uint32_t stream_id = 0;
-
-		addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::WINDOW_UPDATE, Http2::FrameFlag::EMPTY, stream_id);
-
-		*reinterpret_cast<uint32_t *>(addr) = ::htonl(static_cast<const uint32_t>(1 << 16) - 1);
+		const std::unique_lock<std::mutex> lock(conn.sync.mtx);
 
 		sock.nonblock_send(buf.data(), buf.size(), timeout);
 	}
@@ -512,22 +510,22 @@ namespace HttpServer
 	ServerProtocol *ServerHttp2::process()
 	{
 		struct Request req;
-		req.timeout = std::chrono::milliseconds(5000);
+		req.timeout = std::chrono::milliseconds(15000);
 		req.protocol_variant = Transfer::ProtocolVariant::HTTP_2;
 
-		sendEmptySettings(this->sock, req.timeout, Http2::FrameFlag::EMPTY);
+		Http2::ConnectionData conn;
+
+		sendEmptySettings(this->sock, req.timeout, conn, Http2::FrameFlag::EMPTY);
 
 		if (false == getClientPreface(this->sock, req.timeout) )
 		{
 			constexpr uint32_t last_stream_id = 0;
 
-			goAway(this->sock, req.timeout, last_stream_id, Http2::ErrorCode::PROTOCOL_ERROR);
+			goAway(this->sock, req.timeout, conn, last_stream_id, Http2::ErrorCode::PROTOCOL_ERROR);
 
 			return this;
 		}
 
-		Http2::ConnectionData conn;
-
 		conn.client_settings = Http2::ConnectionSettings::defaultSettings();
 		conn.server_settings = Http2::ConnectionSettings::defaultSettings();
 
@@ -565,7 +563,7 @@ namespace HttpServer
 
 			if (Http2::StreamState::CLOSED == stream.state)
 			{
-				rstStream(this->sock, req.timeout, stream.stream_id, Http2::ErrorCode::STREAM_CLOSED);
+				rstStream(this->sock, req.timeout, stream, Http2::ErrorCode::STREAM_CLOSED);
 
 				continue;
 			}
@@ -646,7 +644,7 @@ namespace HttpServer
 					conn.decoding_dynamic_table.changeHeaderTableSize(conn.client_settings.header_table_size);
 					conn.decoding_dynamic_table.changeMaxHeaderListSize(conn.client_settings.max_header_list_size);
 
-					sendEmptySettings(this->sock, req.timeout, Http2::FrameFlag::ACK);
+					sendEmptySettings(this->sock, req.timeout, conn, Http2::FrameFlag::ACK);
 				}
 
 				break;
@@ -664,7 +662,7 @@ namespace HttpServer
 				{
 					const uint64_t ping_data = *reinterpret_cast<const uint64_t *>(addr);
 
-					ping(this->sock, req, ping_data);
+					ping(this->sock, req.timeout, conn, ping_data);
 				}
 
 				break;
@@ -687,7 +685,7 @@ namespace HttpServer
 			{
 				stream.state = Http2::StreamState::CLOSED;
 
-				rstStream(this->sock, req.timeout, meta.stream_id, result);
+				rstStream(this->sock, req.timeout, stream, result);
 
 				// TODO: remove closed stream(s) from unordered map
 			}
@@ -718,7 +716,7 @@ namespace HttpServer
 			conn.sync.event.wait();
 		}
 
-		goAway(this->sock, req.timeout, last_stream_id, Http2::ErrorCode::NO_ERROR);
+		goAway(this->sock, req.timeout, conn, last_stream_id, Http2::ErrorCode::NO_ERROR);
 
 		for (auto &pair : streams)
 		{
diff --git a/src/server/protocol/ServerHttp2Protocol.cpp b/src/server/protocol/ServerHttp2Protocol.cpp
@@ -53,16 +53,9 @@ namespace HttpServer
 
 		this->stream->setHttp2FrameHeader(reinterpret_cast<uint8_t *>(buf.data() ), frame_size, Http2::FrameType::HEADERS, flags);
 
-		this->stream->lock();
+		const std::unique_lock<std::mutex> lock(this->stream->conn.sync.mtx);
 
-		auto const is_sended = this->sock.nonblock_send(buf.data(), buf.size(), timeout) > 0; // >= 0;
-
-		if (endStream || false == is_sended)
-		{
-			this->stream->unlock();
-		}
-
-		return is_sended;
+		return this->sock.nonblock_send(buf.data(), buf.size(), timeout) > 0; // >= 0;
 	}
 
 	long ServerHttp2Protocol::sendData(const void *src, size_t size, const std::chrono::milliseconds &timeout, DataTransfer *dt) const
@@ -128,9 +121,7 @@ namespace HttpServer
 				++cur;
 			}
 
-			const Http2::FrameType frame_type = Http2::FrameType::DATA;
-
-			this->stream->setHttp2FrameHeader(buf.data(), frame_size, frame_type, flags);
+			this->stream->setHttp2FrameHeader(buf.data(), frame_size, Http2::FrameType::DATA, flags);
 
 			std::copy(data, data + data_size, buf.begin() + cur);
 
@@ -139,7 +130,11 @@ namespace HttpServer
 				std::fill(buf.end() - padding, buf.end(), 0);
 			}
 
-			long sended = this->sock.nonblock_send(buf.data(), buf.size(), timeout);
+			this->stream->lock();
+
+			const long sended = this->sock.nonblock_send(buf.data(), buf.size(), timeout);
+
+			this->stream->unlock();
 
 			if (sended <= 0)
 			{
@@ -155,11 +150,6 @@ namespace HttpServer
 			size -= data_size;
 		}
 
-		if (0 >= send_size || dt->full_size == dt->send_total)
-		{
-			this->stream->unlock();
-		}
-
 		return send_size;
 	}
 
@@ -192,4 +182,3 @@ namespace HttpServer
 		Utils::unpackContainer(req.outgoing_headers, reinterpret_cast<const uint8_t *>(src) );
 	}
 };
-

Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ namespace HttpServer`
`40`	`40`	`return streams.emplace(streamId, Http2::IncStream(streamId, conn) ).first->second;`
`41`	`41`	`}`
`42`	`42`
`43`		`- static void sendWindowUpdate(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::IncStream &stream, const uint32_t size) noexcept`
	`43`	`+ static void sendWindowUpdate(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const Http2::IncStream &stream, const uint32_t size) noexcept`
`44`	`44`	`{`
`45`	`45`	`std::array<uint8_t, Http2::FRAME_HEADER_SIZE + sizeof(uint32_t)> buf;`
`46`	`46`	`uint8_t *addr = buf.data();`
`@@ -49,6 +49,8 @@ namespace HttpServer`
`49`	`49`
`50`	`50`	`reinterpret_cast<uint32_t >(addr) = ::htonl(size);`
`51`	`51`
	`52`	`+ const std::unique_lock<std::mutex> lock(stream.conn.sync.mtx);`
	`53`	`+`
`52`	`54`	`sock.nonblock_send(buf.data(), buf.size(), timeout);`
`53`	`55`	`}`
`54`	`56`
`@@ -305,18 +307,22 @@ namespace HttpServer`
`305`	`307`	`return Http2::ErrorCode::NO_ERROR;`
`306`	`308`	`}`
`307`	`309`
`308`		`- static void ping(const Socket::Adapter &sock, const struct Request &req, const uint64_t pingData)`
	`310`	`+ static void ping(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const uint64_t pingData)`
`309`	`311`	`{`
`310`	`312`	`constexpr uint32_t frame_size = sizeof(uint64_t);`
`311`	`313`
`312`	`314`	`std::array<uint8_t, Http2::FRAME_HEADER_SIZE + frame_size> buf;`
`313`	`315`	`uint8_t *addr = buf.data();`
`314`	`316`
`315`		`- addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::PING, Http2::FrameFlag::ACK, 0);`
	`317`	`+ constexpr uint32_t stream_id = 0;`
	`318`	`+`
	`319`	`+ addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::PING, Http2::FrameFlag::ACK, stream_id);`
`316`	`320`
`317`	`321`	`reinterpret_cast<uint64_t >(addr) = pingData;`
`318`	`322`
`319`		`- sock.nonblock_send(buf.data(), buf.size(), req.timeout);`
	`323`	`+ const std::unique_lock<std::mutex> lock(conn.sync.mtx);`
	`324`	`+`
	`325`	`+ sock.nonblock_send(buf.data(), buf.size(), timeout);`
`320`	`326`	`}`
`321`	`327`
`322`	`328`	`static Http2::ErrorCode parseHttp2Ping(Http2::FrameMeta &meta)`
`@@ -374,21 +380,23 @@ namespace HttpServer`
`374`	`380`	`return Http2::ErrorCode::NO_ERROR;`
`375`	`381`	`}`
`376`	`382`
`377`		`- static void rstStream(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const uint32_t streamId, const Http2::ErrorCode errorCode)`
	`383`	`+ static void rstStream(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::IncStream &stream, const Http2::ErrorCode errorCode)`
`378`	`384`	`{`
`379`	`385`	`constexpr uint32_t frame_size = sizeof(uint32_t);`
`380`	`386`
`381`	`387`	`std::array<uint8_t, Http2::FRAME_HEADER_SIZE + frame_size> buf;`
`382`	`388`	`uint8_t *addr = buf.data();`
`383`	`389`
`384`		`- addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::RST_STREAM, Http2::FrameFlag::EMPTY, streamId);`
	`390`	`+ addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::RST_STREAM, Http2::FrameFlag::EMPTY, stream.stream_id);`
`385`	`391`
`386`	`392`	`reinterpret_cast<uint32_t >(addr) = ::htonl(static_cast<const uint32_t>(errorCode) );`
`387`	`393`
	`394`	`+ const std::unique_lock<std::mutex> lock(stream.conn.sync.mtx);`
	`395`	`+`
`388`	`396`	`sock.nonblock_send(buf.data(), buf.size(), timeout);`
`389`	`397`	`}`
`390`	`398`
`391`		`- static void sendSettings(const Socket::Adapter &sock, const struct Request &req, const uint8_t src, const uint8_t end)`
	`399`	`+ static void sendSettings(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const uint8_t src, const uint8_t end)`
`392`	`400`	`{`
`393`	`401`	`const uint32_t frame_size = end - src;`
`394`	`402`
`@@ -402,10 +410,12 @@ namespace HttpServer`
`402`	`410`
`403`	`411`	`std::copy(src, end, addr);`
`404`	`412`
`405`		`- sock.nonblock_send(buf.data(), buf.size(), req.timeout);`
	`413`	`+ const std::unique_lock<std::mutex> lock(conn.sync.mtx);`
	`414`	`+`
	`415`	`+ sock.nonblock_send(buf.data(), buf.size(), timeout);`
`406`	`416`	`}`
`407`	`417`
`408`		`- static void goAway(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const uint32_t lastStreamId, const Http2::ErrorCode errorCode)`
	`418`	`+ static void goAway(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const uint32_t lastStreamId, const Http2::ErrorCode errorCode)`
`409`	`419`	`{`
`410`	`420`	`constexpr uint32_t frame_size = sizeof(uint32_t) * 2;`
`411`	`421`
`@@ -418,6 +428,8 @@ namespace HttpServer`
`418`	`428`	`reinterpret_cast<uint32_t >(addr) = ::htonl(static_cast<const uint32_t>(lastStreamId) );`
`419`	`429`	`reinterpret_cast<uint32_t >(addr + sizeof(uint32_t) ) = ::htonl(static_cast<const uint32_t>(errorCode) );`
`420`	`430`
	`431`	`+ const std::unique_lock<std::mutex> lock(conn.sync.mtx);`
	`432`	`+`
`421`	`433`	`sock.nonblock_send(buf.data(), buf.size(), timeout);`
`422`	`434`	`}`
`423`	`435`
`@@ -446,7 +458,7 @@ namespace HttpServer`
`446`	`458`	`return 0 == compare;`
`447`	`459`	`}`
`448`	`460`
`449`		`- static void sendEmptySettings(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, const Http2::FrameFlag flags)`
	`461`	`+ static void sendEmptySettings(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout, Http2::ConnectionData &conn, const Http2::FrameFlag flags)`
`450`	`462`	`{`
`451`	`463`	`constexpr uint32_t frame_size = 0;`
`452`	`464`
`@@ -457,21 +469,7 @@ namespace HttpServer`
`457`	`469`
`458`	`470`	`addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::SETTINGS, flags, stream_id);`
`459`	`471`
`460`		`- sock.nonblock_send(buf.data(), buf.size(), timeout);`
`461`		`- }`
`462`		`-`
`463`		`- static void windowUpdate(const Socket::Adapter &sock, const std::chrono::milliseconds &timeout)`
`464`		`- {`
`465`		`- constexpr uint32_t frame_size = 4;`
`466`		`-`
`467`		`- std::array<uint8_t, Http2::FRAME_HEADER_SIZE + frame_size> buf;`
`468`		`- uint8_t *addr = buf.data();`
`469`		`-`
`470`		`- constexpr uint32_t stream_id = 0;`
`471`		`-`
`472`		`- addr = setHttp2FrameHeader(addr, frame_size, Http2::FrameType::WINDOW_UPDATE, Http2::FrameFlag::EMPTY, stream_id);`
`473`		`-`
`474`		`- reinterpret_cast<uint32_t >(addr) = ::htonl(static_cast<const uint32_t>(1 << 16) - 1);`
	`472`	`+ const std::unique_lock<std::mutex> lock(conn.sync.mtx);`
`475`	`473`
`476`	`474`	`sock.nonblock_send(buf.data(), buf.size(), timeout);`
`477`	`475`	`}`
`@@ -512,22 +510,22 @@ namespace HttpServer`
`512`	`510`	`ServerProtocol *ServerHttp2::process()`
`513`	`511`	`{`
`514`	`512`	`struct Request req;`
`515`		`- req.timeout = std::chrono::milliseconds(5000);`
	`513`	`+ req.timeout = std::chrono::milliseconds(15000);`
`516`	`514`	`req.protocol_variant = Transfer::ProtocolVariant::HTTP_2;`
`517`	`515`
`518`		`- sendEmptySettings(this->sock, req.timeout, Http2::FrameFlag::EMPTY);`
	`516`	`+ Http2::ConnectionData conn;`
	`517`	`+`
	`518`	`+ sendEmptySettings(this->sock, req.timeout, conn, Http2::FrameFlag::EMPTY);`
`519`	`519`
`520`	`520`	`if (false == getClientPreface(this->sock, req.timeout) )`
`521`	`521`	`{`
`522`	`522`	`constexpr uint32_t last_stream_id = 0;`
`523`	`523`
`524`		`- goAway(this->sock, req.timeout, last_stream_id, Http2::ErrorCode::PROTOCOL_ERROR);`
	`524`	`+ goAway(this->sock, req.timeout, conn, last_stream_id, Http2::ErrorCode::PROTOCOL_ERROR);`
`525`	`525`
`526`	`526`	`return this;`
`527`	`527`	`}`
`528`	`528`
`529`		`- Http2::ConnectionData conn;`
`530`		`-`
`531`	`529`	`conn.client_settings = Http2::ConnectionSettings::defaultSettings();`
`532`	`530`	`conn.server_settings = Http2::ConnectionSettings::defaultSettings();`
`533`	`531`
`@@ -565,7 +563,7 @@ namespace HttpServer`
`565`	`563`
`566`	`564`	`if (Http2::StreamState::CLOSED == stream.state)`
`567`	`565`	`{`
`568`		`- rstStream(this->sock, req.timeout, stream.stream_id, Http2::ErrorCode::STREAM_CLOSED);`
	`566`	`+ rstStream(this->sock, req.timeout, stream, Http2::ErrorCode::STREAM_CLOSED);`
`569`	`567`
`570`	`568`	`continue;`
`571`	`569`	`}`
`@@ -646,7 +644,7 @@ namespace HttpServer`
`646`	`644`	`conn.decoding_dynamic_table.changeHeaderTableSize(conn.client_settings.header_table_size);`
`647`	`645`	`conn.decoding_dynamic_table.changeMaxHeaderListSize(conn.client_settings.max_header_list_size);`
`648`	`646`
`649`		`- sendEmptySettings(this->sock, req.timeout, Http2::FrameFlag::ACK);`
	`647`	`+ sendEmptySettings(this->sock, req.timeout, conn, Http2::FrameFlag::ACK);`
`650`	`648`	`}`
`651`	`649`
`652`	`650`	`break;`
`@@ -664,7 +662,7 @@ namespace HttpServer`
`664`	`662`	`{`
`665`	`663`	`const uint64_t ping_data = reinterpret_cast<const uint64_t >(addr);`
`666`	`664`
`667`		`- ping(this->sock, req, ping_data);`
	`665`	`+ ping(this->sock, req.timeout, conn, ping_data);`
`668`	`666`	`}`
`669`	`667`
`670`	`668`	`break;`
`@@ -687,7 +685,7 @@ namespace HttpServer`
`687`	`685`	`{`
`688`	`686`	`stream.state = Http2::StreamState::CLOSED;`
`689`	`687`
`690`		`- rstStream(this->sock, req.timeout, meta.stream_id, result);`
	`688`	`+ rstStream(this->sock, req.timeout, stream, result);`
`691`	`689`
`692`	`690`	`// TODO: remove closed stream(s) from unordered map`
`693`	`691`	`}`
`@@ -718,7 +716,7 @@ namespace HttpServer`
`718`	`716`	`conn.sync.event.wait();`
`719`	`717`	`}`
`720`	`718`
`721`		`- goAway(this->sock, req.timeout, last_stream_id, Http2::ErrorCode::NO_ERROR);`
	`719`	`+ goAway(this->sock, req.timeout, conn, last_stream_id, Http2::ErrorCode::NO_ERROR);`
`722`	`720`
`723`	`721`	`for (auto &pair : streams)`
`724`	`722`	`{`