async-http 0.77.0 → 0.79.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a6e20407a7969b8eebeaf3f3a2dac09bdb3fe48130454ae49f46251a03b5c98
-  data.tar.gz: a827ae19dc5c7f60ed338357091f556d1e48b183fe8ab0c119d75547fce4a6cd
+  metadata.gz: 93d3d9d22a84537ba522b417586a7bc02d243d56defe26fb9a3937470675b244
+  data.tar.gz: 8c16add5b2c301948235c739d076f92c400cdd745cc36881fac49125a41c5bc4
 SHA512:
-  metadata.gz: 116770838b19e96fdc9ed4e1db8af834f0ed8676542d1090ed88c90d02ac0b978bd94378b41edc151108d86e61c39d2fbb9680d217790e1b1cb3f2ceed2aa64e
-  data.tar.gz: 2b05b93835b83052a89127f12db03fdcd79007b6b0f396134d9818352e48ffaf012057c0b818a56633f3e8b510e7861438e8016d2519bd4d0dec425dfd1113f7
+  metadata.gz: cf362c7394967d2746e6d37984f25f5fc02e8e1fa89b7d5f6afcf31d87e665d75877cd5a9cd920f1ae87b6ecbc73e7d9b7cedc72467a69d95b5d24a04b897a8e
+  data.tar.gz: e922cf9cfd745423d9350f633d1a152dd8f6e06ae23abd3c8b1e403f49abb7089181aa68a1ded1a329cf2017b7bf98feb6a60fed45e1f8582eb3b01ca401ce4d

data/lib/async/http/client.rb

@@ -14,7 +14,6 @@ require "protocol/http/methods"
 require "traces/provider"
 
 require_relative "protocol"
-require_relative "body/finishable"
 
 module Async
 	module HTTP

data/lib/async/http/protocol/http1/client.rb

@@ -18,11 +18,12 @@ module Async
 					
 					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
@@ -50,30 +51,32 @@ module Async
 								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

data/lib/async/http/protocol/http1/connection.rb

@@ -43,6 +43,8 @@ module Async
 					
 					def read_line?
 						@stream.read_until(CRLF)
+					rescue Errno::ECONNRESET
+						return nil
 					end
 					
 					def read_line

data/lib/async/http/protocol/http1/finishable.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require "protocol/http/body/wrapper"
+require "async/variable"
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP1
+				# Keeps track of whether a body is being read, and if so, waits for it to be closed.
+				class Finishable < ::Protocol::HTTP::Body::Wrapper
+					def initialize(body)
+						super(body)
+						
+						@closed = Async::Variable.new
+						@error = nil
+						
+						@reading = false
+					end
+					
+					def reading?
+						@reading
+					end
+					
+					def read
+						@reading = true
+						
+						super
+					end
+					
+					def close(error = nil)
+						super
+						
+						unless @closed.resolved?
+							@error = error
+							@closed.value = true
+						end
+					end
+					
+					def wait(persistent = true)
+						if @reading
+							@closed.wait
+						elsif persistent
+							# If the connection can be reused, let's gracefully discard the body:
+							self.discard
+						else
+							# Else, we don't care about the body, so we can close it immediately:
+							self.close
+						end
+					end
+					
+					def inspect
+						"#<#{self.class} closed=#{@closed} error=#{@error}> | #{super}"
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/http/protocol/http1/server.rb

@@ -7,7 +7,7 @@
 # Copyright, 2024, by Anton Zhuravsky.
 
 require_relative "connection"
-require_relative "../../body/finishable"
+require_relative "finishable"
 
 require "console/event/failure"
 
@@ -16,6 +16,18 @@ module Async
 		module Protocol
 			module HTTP1
 				class Server < Connection
+					def initialize(...)
+						super
+						
+						@ready = Async::Notification.new
+					end
+					
+					def closed(error = nil)
+						super
+						
+						@ready.signal
+					end
+					
 					def fail_request(status)
 						@persistent = false
 						write_response(@version, status, {})
@@ -26,8 +38,11 @@ module Async
 					end
 					
 					def next_request
-						# The default is true.
-						return unless @persistent
+						if closed?
+							return nil
+						elsif !idle?
+							@ready.wait
+						end
 						
 						# Read an incoming request:
 						return unless request = Request.read(self)
@@ -49,7 +64,7 @@ module Async
 						
 						while request = next_request
 							if body = request.body
-								finishable = Body::Finishable.new(body)
+								finishable = Finishable.new(body)
 								request.body = finishable
 							end
 							
@@ -73,38 +88,41 @@ module Async
 										# We force a 101 response if the protocol is upgraded - HTTP/2 CONNECT will return 200 for success, but this won't be understood by HTTP/1 clients:
 										write_response(@version, 101, response.headers)
 										
-										stream = write_upgrade_body(protocol)
-										
 										# At this point, the request body is hijacked, so we don't want to call #finish below.
 										request = nil
 										response = nil
 										
-										# We must return here as no further request processing can be done:
-										return body.call(stream)
+										if body.stream?
+											return body.call(write_upgrade_body(protocol))
+										else
+											write_upgrade_body(protocol, body)
+										end
 									elsif response.status == 101
 										# This code path is to support legacy behavior where the response status is set to 101, but the protocol is not upgraded. This may not be a valid use case, but it is supported for compatibility. We expect the response headers to contain the `upgrade` header.
 										write_response(@version, response.status, response.headers)
 										
-										stream = write_tunnel_body(version)
-										
 										# Same as above:
 										request = nil
 										response = nil
 										
-										# We must return here as no further request processing can be done:
-										return body&.call(stream)
+										if body.stream?
+											return body.call(write_tunnel_body(version))
+										else
+											write_tunnel_body(version, body)
+										end
 									else
 										write_response(@version, response.status, response.headers)
 										
 										if request.connect? and response.success?
-											stream = write_tunnel_body(version)
-											
 											# Same as above:
 											request = nil
 											response = nil
 											
-											# We must return here as no further request processing can be done:
-											return body.call(stream)
+											if body.stream?
+												return body.call(write_tunnel_body(version))
+											else
+												write_tunnel_body(version, body)
+											end
 										else
 											head = request.head?
 											
@@ -126,10 +144,12 @@ module Async
 									request&.finish
 								end
 								
-								finishable&.wait
-								
-								# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
-								task.yield
+								if finishable
+									finishable.wait(@persistent)
+								else
+									# Do not remove this line or you will unleash the gods of concurrency hell.
+									task.yield
+								end
 							rescue => error
 								raise
 							ensure

data/lib/async/http/protocol/http2/stream.rb

@@ -62,9 +62,9 @@ module Async
 						end
 						
 						# TODO this might need to be in an ensure block:
-						if @input and frame.end_stream?
-							@input.close_write
+						if input = @input and frame.end_stream?
 							@input = nil
+							input.close_write
 						end
 					rescue ::Protocol::HTTP2::HeaderError => error
 						Console.logger.debug(self, error)
@@ -123,6 +123,8 @@ module Async
 					
 					# Called when the output terminates normally.
 					def finish_output(error = nil)
+						return if self.closed?
+						
 						trailer = @output&.trailer
 						
 						@output = nil
@@ -152,14 +154,14 @@ module Async
 					def closed(error)
 						super
 						
-						if @input
-							@input.close_write(error)
+						if input = @input
 							@input = nil
+							input.close_write(error)
 						end
 						
-						if @output
-							@output.stop(error)
+						if output = @output
 							@output = nil
+							output.stop(error)
 						end
 						
 						if pool = @pool and @connection

data/lib/async/http/protocol/request.rb

@@ -41,6 +41,10 @@ module Async
 				def remote_address= value
 					@remote_address = value
 				end
+				
+				def inspect
+					"#<#{self.class}:0x#{self.object_id.to_s(16)} method=#{method} path=#{path} version=#{version}>"
+				end
 			end
 		end
 	end

data/lib/async/http/protocol/response.rb

@@ -33,6 +33,10 @@ module Async
 				def remote_address= value
 					@remote_address = value
 				end
+				
+				def inspect
+					"#<#{self.class}:0x#{self.object_id.to_s(16)} status=#{status}>"
+				end
 			end
 		end
 	end

data/lib/async/http/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.77.0"
+		VERSION = "0.79.0"
 	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.77.0
+  version: 0.79.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -58,7 +58,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2024-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -136,28 +136,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.27'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.25'
+        version: '0.27'
 - !ruby/object:Gem::Dependency
   name: protocol-http2
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.18'
+        version: '0.19'
 - !ruby/object:Gem::Dependency
   name: traces
   requirement: !ruby/object:Gem::Requirement
@@ -182,7 +182,6 @@ files:
 - bake/async/http/h2spec.rb
 - lib/async/http.rb
 - lib/async/http/body.rb
-- lib/async/http/body/finishable.rb
 - lib/async/http/body/hijack.rb
 - lib/async/http/body/pipe.rb
 - lib/async/http/body/writable.rb
@@ -198,6 +197,7 @@ files:
 - lib/async/http/protocol/http1.rb
 - lib/async/http/protocol/http1/client.rb
 - lib/async/http/protocol/http1/connection.rb
+- lib/async/http/protocol/http1/finishable.rb
 - lib/async/http/protocol/http1/request.rb
 - lib/async/http/protocol/http1/response.rb
 - lib/async/http/protocol/http1/server.rb

data/lib/async/http/body/finishable.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2024, by Samuel Williams.
-
-require "protocol/http/body/wrapper"
-require "async/variable"
-
-module Async
-	module HTTP
-		module Body
-			# Keeps track of whether a body is being read, and if so, waits for it to be closed.
-			class Finishable < ::Protocol::HTTP::Body::Wrapper
-				def initialize(body)
-					super(body)
-					
-					@closed = Async::Variable.new
-					@error = nil
-					
-					@reading = false
-				end
-				
-				def reading?
-					@reading
-				end
-				
-				def read
-					@reading = true
-					
-					super
-				end
-				
-				def close(error = nil)
-					unless @closed.resolved?
-						@error = error
-						@closed.value = true
-					end
-					
-					super
-				end
-				
-				def wait
-					if @reading
-						@closed.wait
-					else
-						self.discard
-					end
-				end
-				
-				def inspect
-					"#<#{self.class} closed=#{@closed} error=#{@error}> | #{super}"
-				end
-			end
-		end
-	end
-end