client.rb in async-http-0.79.0

- old
+ new

@@ -16,15 +16,16 @@
 						@pool = nil
 					end
 					
 					attr_accessor :pool
 					
-					def closed!
+					def closed(error = nil)
 						super
 						
 						if pool = @pool
 							@pool = nil
+							# If the connection is not reusable, this will retire it from the connection pool and invoke `#close`.
 							pool.release(self)
 						end
 					end
 					
 					# Used by the client to send requests to the remote server.
@@ -48,33 +49,35 @@
 							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(annotation: "Upgrading request...") do
 									# If this fails, this connection will be closed.
 									write_upgrade_body(protocol, body)
+								rescue => error
+									self.close(error)
 								end
 							elsif request.connect?
 								task.async(annotation: "Tunnneling request...") do
 									write_tunnel_body(@version, body)
+								rescue => error
+									self.close(error)
 								end
 							else
 								task.async(annotation: "Streaming request...") 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, false, trailer)
+								rescue => error
+									self.close(error)
 								end
 							end
 						elsif protocol = request.protocol
 							write_upgrade_body(protocol)
 						else
-							write_body(@version, body, false, trailer)
+							write_body(@version, request.body, false, trailer)
 						end
 						
-						response = Response.read(self, request)
-						
-						return response
-					rescue
-						# This will ensure that #reusable? returns false.
-						self.close
-						
+						return Response.read(self, request)
+					rescue => error
+						self.close(error)
 						raise
 					end
 				end
 			end
 		end