async-http 0.46.4 → 0.46.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a113b8685408552c9b24fd5abbb0d9ba844c91105b1c6e1f96e4a516c8223ac
-  data.tar.gz: bbf73351618744ce86a1dc7bf1ea884c8221dd483b13ad111d9a5e79ab5cf8a9
+  metadata.gz: b9fb9d8fd91de95c63e2a7fc133902457a812394c80bb37773ddd04a74592cda
+  data.tar.gz: 460f4a0505a7fe53ee91246728ed601464f86c85eb01db3bc1f3c1ee322b7834
 SHA512:
-  metadata.gz: a508faf1a1431687767c3256c9b740e7c7baa5b009bb7cfd7c887c79a324f06d6bfce4ce2809af82419a42d38f8ed4a5b840f2363620bb276d65885ac85f37da
-  data.tar.gz: 696a1dcabdbb82549f5efa24ab2795f3086f677ef325ae7f5c25c59f14e41888baaccc8d62a1b5b8fef6a9e08441744b89828041a1ab0eeffb2043d875b472cf
+  metadata.gz: f356561f16a0829428ca4733cb9af6cde0f871ce2df662871e0c78b299d16d4a25be5f562719e752037f64dbaba3ab2328a1deb7579e66c06c4452a9269462aa
+  data.tar.gz: 914b845234e8c98eac84ee45dbc9f5e745bc07e61f23bbaf6017cab898b8455e70b978e31735a5b898cb22b7e4918fb3705d51e258ac5632c7a4f2f5e1cb8cc3

data/async-http.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
 	spec.add_dependency("async", "~> 1.19")
 	spec.add_dependency("async-io", "~> 1.24")
 	
-	spec.add_dependency("protocol-http", "~> 0.10.0")
+	spec.add_dependency("protocol-http", "~> 0.11.0")
 	spec.add_dependency("protocol-http1", "~> 0.8.0")
 	spec.add_dependency("protocol-http2", "~> 0.9.0")
 	

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

@@ -46,6 +46,8 @@ module Async
 					return @block.call(stream)
 				end
 				
+				attr :input
+				
 				# Has the producer called #finish and has the reader consumed the nil token?
 				def empty?
 					if @stream
@@ -60,7 +62,9 @@ module Async
 					unless @task
 						@stream = Stream.new(@input)
 						
-						@task = Task.current.async do
+						@task = Task.current.async do |task|
+							task.annotate "Streaming hijacked body."
+							
 							@block.call(@stream)
 						end
 					end
@@ -71,6 +75,10 @@ module Async
 				def inspect
 					"\#<#{self.class} #{@block.inspect}>"
 				end
+				
+				def to_s
+					"<Hijack #{@block.class}>"
+				end
 			end
 		end
 	end

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

@@ -42,12 +42,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
+								task.async do |subtask|
+									subtask.annotate("Upgrading request.")
+									
 									# If this fails, this connection will be closed.
 									write_upgrade_body(protocol, body)
 								end
 							else
-								task.async do
+								task.async do |subtask|
+									subtask.annotate("Streaming body.")
+									
 									# 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

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

@@ -84,7 +84,7 @@ module Async
 					
 					def read_in_background(task: Task.current)
 						task.async do |nested_task|
-							nested_task.annotate("#{version} reading data for #{self.class}")
+							nested_task.annotate("#{version} reading data for #{self.class}.")
 							
 							begin
 								while !self.closed?

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

@@ -60,6 +60,8 @@ module Async
 					def each
 						# It's possible the connection has died before we get here...
 						@requests&.async do |task, request|
+							task.annotate("Incoming request: #{request.method} #{request.path.inspect}.")
+							
 							@count += 1
 							
 							begin

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

@@ -44,20 +44,38 @@ module Async
 					end
 					
 					class Output
-						def initialize(stream, body, task: Task.current)
-							@stream = stream
+						def self.for(stream, body)
+							output = self.new(stream, body)
+							
+							output.start
 							
+							return output
+						end
+						
+						def initialize(stream, body)
+							@stream = stream
 							@body = body
-							@remainder = nil
 							
 							@window_updated = Async::Condition.new
+						end
+						
+						def start(parent: Task.current)
+							if @body.respond_to?(:call)
+								@task = parent.async(&self.method(:stream))
+							else
+								@task = parent.async(&self.method(:passthrough))
+							end
+						end
+						
+						def stop(error)
+							# Ensure that invoking #close doesn't try to close the stream.
+							@stream = nil
 							
-							@task = task.async(&self.method(:passthrough))
+							@task&.stop
 						end
 						
-						# Reads chunks from the given body and writes them to the stream as fast as possible.
-						def passthrough(task)
-							while chunk = self.read
+						def write(chunk)
+							until chunk.empty?
 								maximum_size = @stream.available_frame_size
 								
 								while maximum_size <= 0
@@ -66,35 +84,60 @@ module Async
 									maximum_size = @stream.available_frame_size
 								end
 								
-								self.send_data(chunk, maximum_size)
+								break unless chunk = send_data(chunk, maximum_size)
 							end
-							
-							self.end_stream
-						rescue Async::Stop
-							# Ignore.
-						ensure
-							@body&.close($!)
-							@body = nil
 						end
 						
-						def read
-							if @remainder
-								remainder = @remainder
-								@remainder = nil
+						def window_updated(size)
+							@window_updated.signal
+						end
+						
+						def close(error = nil)
+							if @stream
+								if error
+									@stream.close(error)
+								else
+									self.close_write
+								end
 								
-								return remainder
-							else
-								@body&.read
+								@stream = nil
 							end
 						end
 						
-						def push(chunk)
-							@remainder = chunk
+						def close_write
+							@stream.send_data(nil, ::Protocol::HTTP2::END_STREAM)
+						end
+						
+						private
+						
+						def stream(task)
+							task.annotate("Streaming #{@body} to #{@stream}.")
+							
+							@body.call(Body::Stream.new(@stream.input, self))
+						rescue Async::Stop
+							# Ignore.
+						end
+						
+						# Reads chunks from the given body and writes them to the stream as fast as possible.
+						def passthrough(task)
+							task.annotate("Writing #{@body} to #{@stream}.")
+							
+							while chunk = @body&.read
+								self.write(chunk)
+							end
+							
+							self.close_write
+						rescue Async::Stop
+							# Ignore.
+						ensure
+							@body&.close($!)
+							@body = nil
 						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.
 						# @param maximum_size [Integer] send up to this many bytes of data.
 						# @param stream [Stream] the stream to use for sending data frames.
+						# @return [String, nil] any data that could not be written.
 						def send_data(chunk, maximum_size)
 							if chunk.bytesize <= maximum_size
 								@stream.send_data(chunk, maximum_size: maximum_size)
@@ -102,27 +145,10 @@ module Async
 								@stream.send_data(chunk.byteslice(0, maximum_size), maximum_size: maximum_size)
 								
 								# The window was not big enough to send all the data, so we save it for next time:
-								self.push(
-									chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
-								)
-							end
-						end
-						
-						def end_stream
-							@stream.send_data(nil, ::Protocol::HTTP2::END_STREAM)
-						end
-						
-						def window_updated(size)
-							@window_updated.signal
-						end
-						
-						def close(error)
-							if @body
-								@body.close(error)
-								@body = nil
+								return chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
 							end
 							
-							@task&.stop
+							return nil
 						end
 					end
 					
@@ -142,6 +168,8 @@ module Async
 					
 					attr_accessor :headers
 					
+					attr :input
+					
 					def add_header(key, value)
 						if key == CONNECTION
 							raise ::Protocol::HTTP2::HeaderError, "Connection header is not allowed!"
@@ -222,7 +250,7 @@ module Async
 					
 					# Set the body and begin sending it.
 					def send_body(body)
-						@output = Output.new(self, body)
+						@output = Output.for(self, body)
 					end
 					
 					def window_updated(size)
@@ -240,7 +268,7 @@ module Async
 						end
 						
 						if @output
-							@output.close(error)
+							@output.stop(error)
 							@output = nil
 						end
 					end

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.46.4"
+		VERSION = "0.46.5"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.46.4
+  version: 0.46.5
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-13 00:00:00.000000000 Z
+date: 2019-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.10.0
+        version: 0.11.0
 - !ruby/object:Gem::Dependency
   name: protocol-http1
   requirement: !ruby/object:Gem::Requirement