async-http 0.75.0 → 0.76.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 946e45fa80db4dc1a3416f91a6533d58e7e4c5b8e7db9a687b922e9161f84dcf
-  data.tar.gz: 7810dfb04b6c120e91660c4cabec884ef531bb4b4078c149558a6190314f88cb
+  metadata.gz: bd45f82b4d28a3e9a72bbdd7eaec1877b69cfce59a3d67b49a09b99b59b42fa4
+  data.tar.gz: 05ceb7e93478b63e53bc9a16b829cc2c34efdc22953143192a5a60b310aa04b1
 SHA512:
-  metadata.gz: 456325793d94251a8b8b117000361e512c23aad9ce03dd2df6c387a35405ac83a7cae1b0de270bf0264485ab98ff5fff3778d720845fe26753950bedd1066b38
-  data.tar.gz: de2cb3749808740c03bd0d0d6cfe5facb3282d26f8465ddeb734158389cfdd70b2bf5610a01bf1d4f0af44fdc1d6c15249f912942038778e9f38217e96ad9c84
+  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/server.rb

@@ -68,11 +68,23 @@ module Async
 										stream = write_upgrade_body(protocol)
 										
 										# At this point, the request body is hijacked, so we don't want to call #finish below.
-										request = nil unless request.body
+										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)
+										
+										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
 										write_response(@version, response.status, response.headers)
 										
@@ -80,7 +92,7 @@ module Async
 											stream = write_tunnel_body(request.version)
 											
 											# Same as above:
-											request = nil unless request.body
+											request = nil
 											response = nil
 											
 											# We must return here as no further request processing can be done:

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/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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.75.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-09-04 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