async-http 0.74.0 → 0.76.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a21c7008b5509bd6f8bdffd7dad87a7679bdc9f32584cc71fa2b468518cd57c
-  data.tar.gz: 2836fc0ef066dfeb60240dce08dd88c07201250b948cfb04617ab52e9d20371c
+  metadata.gz: bd45f82b4d28a3e9a72bbdd7eaec1877b69cfce59a3d67b49a09b99b59b42fa4
+  data.tar.gz: 05ceb7e93478b63e53bc9a16b829cc2c34efdc22953143192a5a60b310aa04b1
 SHA512:
-  metadata.gz: c249984efd9030c199c6b1199dfb4ededdd25a7db33e5156c0ecec2a5d883d703bc976216da13c33426d4814514676f80296687293c53cb4ddc33f44ff4f38a3
-  data.tar.gz: f707e1908dc79b1e16f2be6546f1781003f4d88e21307fd5172d27198b61a08f87e350a43f784445a761cda89cb674669b552e77ef1e9de4cfaeb4095040ffa9
+  metadata.gz: 8b293794ba1fb14494a7187a0c1255674ea771df8cc587c6fa031abca25b8bf803f32ba4889d772d53fb8f4dce0705938f1013ab72c22353b4e09c7cc54f4467
+  data.tar.gz: b0c407ee2c817bd8436bff520ae09744f44e35ba79bd992e76a783be52911fdedb0b397ab12c3cd1ffb00b3042bfc5d429f11b5252e16edbc2bab178172d747d

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

@@ -36,7 +36,7 @@ module Async
 				end
 				
 				def call(stream)
-					return @block.call(stream)
+					@block.call(stream)
 				end
 				
 				attr :input

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

@@ -17,7 +17,7 @@ module Async
 					
 					head, tail = ::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
 					
-					@head = ::IO::Stream::Buffered.new(head)
+					@head = ::IO::Stream(head)
 					@tail = tail
 					
 					@reader = nil
@@ -52,8 +52,10 @@ module Async
 					end
 					
 					@head.close_write
+				rescue => error
+					raise
 				ensure
-					@input.close($!)
+					@input.close(error)
 					
 					close_head if @writer&.finished?
 				end
@@ -68,8 +70,10 @@ module Async
 					while chunk = @head.read_partial
 						@output.write(chunk)
 					end
+				rescue => error
+					raise
 				ensure
-					@output.close($!)
+					@output.close_write(error)
 					
 					close_head if @reader&.finished?
 				end

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

@@ -3,104 +3,13 @@
 # Released under the MIT License.
 # Copyright, 2018-2023, by Samuel Williams.
 
-require 'protocol/http/body/readable'
+require 'protocol/http/body/writable'
 require 'async/queue'
 
 module Async
 	module HTTP
 		module Body
-			include ::Protocol::HTTP::Body
-			
-			# A dynamic body which you can write to and read from.
-			class Writable < Readable
-				class Closed < StandardError
-				end
-				
-				# @param [Integer] length The length of the response body if known.
-				# @param [Async::Queue] queue Specify a different queue implementation, e.g. `Async::LimitedQueue.new(8)` to enable back-pressure streaming.
-				def initialize(length = nil, queue: Async::Queue.new)
-					@queue = queue
-					
-					@length = length
-					
-					@count = 0
-					
-					@finished = false
-					
-					@closed = false
-					@error = nil
-				end
-				
-				def length
-					@length
-				end
-				
-				# Stop generating output; cause the next call to write to fail with the given error.
-				def close(error = nil)
-					unless @closed
-						@queue.enqueue(nil)
-						
-						@closed = true
-						@error = error
-					end
-					
-					super
-				end
-				
-				def closed?
-					@closed
-				end
-				
-				def ready?
-					!@queue.empty?
-				end
-				
-				# Has the producer called #finish and has the reader consumed the nil token?
-				def empty?
-					@finished
-				end
-				
-				# Read the next available chunk.
-				def read
-					return if @finished
-					
-					unless chunk = @queue.dequeue
-						@finished = true
-					end
-					
-					return chunk
-				end
-				
-				# Write a single chunk to the body. Signal completion by calling `#finish`.
-				def write(chunk)
-					# If the reader breaks, the writer will break.
-					# The inverse of this is less obvious (*)
-					if @closed
-						raise(@error || Closed)
-					end
-					
-					@count += 1
-					@queue.enqueue(chunk)
-				end
-				
-				alias << write
-				
-				def inspect
-					"\#<#{self.class} #{@count} chunks written, #{status}>"
-				end
-				
-				private
-				
-				def status
-					if @finished
-						'finished'
-					elsif @closed
-						'closing'
-					else
-						'waiting'
-					end
-				end
-			end
+			Writable = ::Protocol::HTTP::Body::Writable
 		end
 	end
 end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 require_relative 'connection'
 
@@ -33,22 +33,16 @@ module Async
 							
 							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 |subtask|
-									subtask.annotate("Upgrading request.")
-									
+								task.async(annotation: "Upgrading request...") do
 									# If this fails, this connection will be closed.
 									write_upgrade_body(protocol, body)
 								end
 							elsif request.connect?
-								task.async do |subtask|
-									subtask.annotate("Tunnelling body.")
-									
+								task.async(annotation: "Tunnneling request...") do
 									write_tunnel_body(@version, body)
 								end
 							else
-								task.async do |subtask|
-									subtask.annotate("Streaming body.")
-									
+								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)
 								end

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

@@ -59,33 +59,54 @@ module Async
 								if response
 									trailer = response.headers.trailer!
 									
-									write_response(@version, response.status, response.headers)
-									
 									# Some operations in this method are long running, that is, it's expected that `body.call(stream)` could literally run indefinitely. In order to facilitate garbage collection, we want to nullify as many local variables before calling the streaming body. This ensures that the garbage collection can clean up as much state as possible during the long running operation, so we don't retain objects that are no longer needed.
-
+									
 									if body and protocol = response.protocol
+										# 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 = response = nil
+										request = nil
+										response = nil
+										
+										# We must return here as no further request processing can be done:
+										return body.call(stream)
+									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)
 										
-										body.call(stream)
-									elsif request.connect? and response.success?
 										stream = write_tunnel_body(request.version)
 										
 										# Same as above:
-										request = response = nil
+										request = nil
+										response = nil
 										
-										body.call(stream)
+										# We must return here as no further request processing can be done:
+										return body&.call(stream)
 									else
-										head = request.head?
-										version = request.version
-										
-										# Same as above:
-										request = nil unless request.body
-										response = nil
+										write_response(@version, response.status, response.headers)
 										
-										write_body(version, body, head, trailer)
+										if request.connect? and response.success?
+											stream = write_tunnel_body(request.version)
+											
+											# Same as above:
+											request = nil
+											response = nil
+											
+											# We must return here as no further request processing can be done:
+											return body.call(stream)
+										else
+											head = request.head?
+											version = request.version
+											
+											# Same as above:
+											request = nil unless request.body
+											response = nil
+											
+											write_body(version, body, head, trailer)
+										end
 									end
 									
 									# We are done with the body, you shouldn't need to call close on it:

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

@@ -66,14 +66,14 @@ module Async
 					end
 					
 					def close(error = nil)
-						super
-						
 						# Ensure the reader task is stopped.
 						if @reader
 							reader = @reader
 							@reader = nil
 							reader.stop
 						end
+						
+						super
 					end
 					
 					def read_in_background(parent: Task.current)
@@ -101,6 +101,8 @@ module Async
 							ensure
 								# Don't call #close twice.
 								if @reader
+									@reader = nil
+									
 									self.close(error)
 								end
 							end

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

@@ -3,14 +3,14 @@
 # Released under the MIT License.
 # Copyright, 2020-2023, by Samuel Williams.
 
-require_relative '../../body/writable'
+require 'protocol/http/body/writable'
 
 module Async
 	module HTTP
 		module Protocol
 			module HTTP2
 				# A writable body which requests window updates when data is read from it.
-				class Input < Body::Writable
+				class Input < ::Protocol::HTTP::Body::Writable
 					def initialize(stream, length)
 						super(length)
 						

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

@@ -50,18 +50,25 @@ module Async
 						end
 					end
 					
-					# This method should only be called from within the context of the output task.
-					def close(error = nil)
-						if @stream
-							@stream.finish_output(error)
+					def close_write(error = nil)
+						if stream = @stream
 							@stream = nil
+							stream.finish_output(error)
 						end
 					end
 					
+					# This method should only be called from within the context of the output task.
+					def close(error = nil)
+						close_write(error)
+						stop(error)
+					end
+					
 					# This method should only be called from within the context of the HTTP/2 stream.
 					def stop(error)
-						@task&.stop
-						@task = nil
+						if task = @task
+							@task = nil
+							task.stop(error)
+						end
 					end
 					
 					private
@@ -70,10 +77,12 @@ module Async
 						task.annotate("Streaming #{@body} to #{@stream}.")
 						
 						input = @stream.wait_for_input
+						stream = ::Protocol::HTTP::Body::Stream.new(input, self)
 						
-						@body.call(::Protocol::HTTP::Body::Stream.new(input, self))
-					rescue Async::Stop
-						# Ignore.
+						@body.call(stream)
+					rescue => error
+						self.close(error)
+						raise
 					end
 					
 					# Reads chunks from the given body and writes them to the stream as fast as possible.
@@ -86,11 +95,17 @@ module Async
 							# chunk.clear unless chunk.frozen?
 							# GC.start
 						end
-						
-						self.close
+					rescue => error
+						raise
 					ensure
-						@body&.close($!)
-						@body = nil
+						# Ensure the body we are reading from is fully closed:
+						if body = @body
+							@body = nil
+							body.close(error)
+						end
+						
+						# Ensure the output of this body is closed:
+						self.close_write(error)
 					end
 					
 					# Send `maximum_size` bytes of data using the specified `stream`. If the buffer has no more chunks, `END_STREAM` will be sent on the final chunk.

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 require_relative '../request'
 require_relative 'stream'

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 require_relative '../response'
 require_relative 'stream'
@@ -54,6 +54,11 @@ module Async
 							@response.status = status
 							@headers = ::Protocol::HTTP::Headers.new
 							
+							# If the protocol request was successful, ensure the response protocol matches:
+							if status == 200 and protocol = @response.request.protocol
+								@response.protocol = Array(protocol).first
+							end
+							
 							headers.each do |key, value|
 								# It's guaranteed that this should be the first header:
 								if key == CONTENT_LENGTH
@@ -118,7 +123,7 @@ module Async
 							
 							@exception = error
 							
-							notify!
+							self.notify!
 						end
 					end
 					

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

@@ -59,7 +59,7 @@ module Async
 						
 						# TODO this might need to be in an ensure block:
 						if @input and frame.end_stream?
-							@input.close($!)
+							@input.close_write
 							@input = nil
 						end
 					rescue ::Protocol::HTTP2::HeaderError => error
@@ -98,7 +98,7 @@ module Async
 							end
 							
 							if frame.end_stream?
-								@input.close
+								@input.close_write
 								@input = nil
 							end
 						end
@@ -149,7 +149,7 @@ module Async
 						super
 						
 						if @input
-							@input.close(error)
+							@input.close_write(error)
 							@input = nil
 						end
 						

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2023, by Samuel Williams.
+# Copyright, 2017-2024, by Samuel Williams.
 
 require 'protocol/http/request'
 require 'protocol/http/headers'

data/lib/async/http/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.74.0"
+		VERSION = "0.76.0"
 	end
 end

data/readme.md

@@ -16,6 +16,10 @@ Please see the [project documentation](https://socketry.github.io/async-http/) f
 
 Please see the [project releases](https://socketry.github.io/async-http/releases/index) for all releases.
 
+### v0.75.0
+
+  - Better handling of HTTP/1 \<-\> HTTP/2 proxying, specifically upgrade/CONNECT requests.
+
 ### v0.74.0
 
   - [`Async::HTTP::Internet` accepts keyword arguments](https://socketry.github.io/async-http/releases/index#async::http::internet-accepts-keyword-arguments)

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v0.75.0
+
+  - Better handling of HTTP/1 \<-\> HTTP/2 proxying, specifically upgrade/CONNECT requests.
+
 ## v0.74.0
 
 ### `Async::HTTP::Internet` accepts keyword arguments

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.74.0
+  version: 0.76.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -58,7 +58,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-08-31 00:00:00.000000000 Z
+date: 2024-09-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -122,14 +122,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: '0.34'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.30'
+        version: '0.34'
 - !ruby/object:Gem::Dependency
   name: protocol-http1
   requirement: !ruby/object:Gem::Requirement
@@ -182,10 +182,8 @@ files:
 - bake/async/http/h2spec.rb
 - lib/async/http.rb
 - lib/async/http/body.rb
-- lib/async/http/body/delayed.rb
 - lib/async/http/body/hijack.rb
 - lib/async/http/body/pipe.rb
-- lib/async/http/body/slowloris.rb
 - lib/async/http/body/writable.rb
 - lib/async/http/client.rb
 - lib/async/http/endpoint.rb

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

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
-# Copyright, 2020, by Bruno Sutic.
-# Copyright, 2023, by Thomas Morgan.
-
-require 'protocol/http/body/wrapper'
-
-module Async
-	module HTTP
-		module Body
-			class Delayed < ::Protocol::HTTP::Body::Wrapper
-				def initialize(body, delay = 0.01)
-					super(body)
-					
-					@delay = delay
-				end
-				
-				def ready?
-					false
-				end
-				
-				def read
-					Async::Task.current.sleep(@delay)
-					
-					return super
-				end
-			end
-		end
-	end
-end

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

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-# Released under the MIT License.
-# Copyright, 2019-2023, by Samuel Williams.
-
-require_relative 'writable'
-
-require 'async/clock'
-
-module Async
-	module HTTP
-		module Body
-			# A dynamic body which you can write to and read from.
-			class Slowloris < Writable
-				class ThroughputError < StandardError
-					def initialize(throughput, minimum_throughput, time_since_last_write)
-						super("Slow write: #{throughput.round(1)}bytes/s less than required #{minimum_throughput.round}bytes/s.")
-					end
-				end
-				
-				# In order for this implementation to work correctly, you need to use a LimitedQueue.
-				# @param minimum_throughput [Integer] the minimum bytes per second otherwise this body will be forcefully closed.
-				def initialize(*arguments, minimum_throughput: 1024, **options)
-					super(*arguments, **options)
-					
-					@minimum_throughput = minimum_throughput
-					
-					@last_write_at = nil
-					@last_chunk_size = nil
-				end
-				
-				attr :minimum_throughput
-				
-				# If #read is called regularly to maintain throughput, that is good. If #read is not called, that is a problem. Throughput is dependent on data being available, from #write, so it doesn't seem particularly problimatic to do this check in #write.
-				def write(chunk)
-					if @last_chunk_size
-						time_since_last_write = Async::Clock.now - @last_write_at
-						throughput = @last_chunk_size / time_since_last_write
-						
-						if throughput < @minimum_throughput
-							error = ThroughputError.new(throughput, @minimum_throughput, time_since_last_write)
-							
-							self.close(error)
-						end
-					end
-					
-					super.tap do
-						@last_write_at = Async::Clock.now
-						@last_chunk_size = chunk&.bytesize
-					end
-				end
-			end
-		end
-	end
-end