client.rb in async-http-0.41.0

- old
+ new
@@ -29,26 +29,37 @@
 					def call(request, task: Task.current)
 						Async.logger.debug(self) {"#{request.method} #{request.path} #{request.headers.inspect}"}
 						
 						# We carefully interpret https://tools.ietf.org/html/rfc7230#section-6.3.1 to implement this correctly.
 						begin
-							self.write_request(request.authority, request.method, request.path, self.version, request.headers)
+							write_request(request.authority, request.method, request.path, @version, request.headers)
 						rescue
 							# If we fail to fully write the request and body, we can retry this request.
-							raise RequestFailed.new
+							raise RequestFailed
 						end
 						
 						if request.body?
-							task.async do
-								# Once we start writing the body, we can't recover if the request fails. That's because the body might be generated dynamically, streaming, etc.
-								self.write_body(request.body)
+							body = request.body
+							
+							if protocol = request.protocol
+								# This is a very tricky apect of handling HTTP/1 upgrade connections. In theory, this approach is a bit inefficient, because we spin up a task just to handle writing to the underlying stream when we could be writing to the stream directly. But we need to maintain some level of compatibility with HTTP/2. Additionally, we don't know if the upgrade request will be accepted, so starting to write the body at this point needs to be handled with care.
+								task.async do
+									# If this fails, this connection will be closed.
+									write_upgrade_body(protocol, body)
+								end
+							else
+								task.async do
+									# Once we start writing the body, we can't recover if the request fails. That's because the body might be generated dynamically, streaming, etc.
+									write_body(@version, body)
+								end
 							end
+						elsif protocol = request.protocol
+							write_upgrade_body(protocol)
 						else
-							self.write_empty_body(request.body)
+							write_empty_body(request.body)
 						end
 						
-						# This won't return the response until the entire body is written.
-						return Response.new(self, request)
+						return Response.read(self, request)
 					rescue
 						# This will ensure that #reusable? returns false.
 						@stream.close
 						
 						raise