async-http 0.50.9 → 0.50.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: adaf496a96262a69c126558cde8463995949b75dc3f663ab068ca47e982a80e8
-  data.tar.gz: d4872a7d08166ac5924d984c7883a9ccbd87b923f1d5ba593899d7917f5564a9
+  metadata.gz: fde1aeafebf3bc36dc76d397da2b9b229abe58c97afe7c0ea938f671ea653765
+  data.tar.gz: d5c26ad0fbeddf88e3456148879cc89084e2a19fe1a0efa5d5effe403bdef1e3
 SHA512:
-  metadata.gz: 7fd5488f4658ae99753d09af39c5a1aabd4a1b2edd24837e5f023fea812c198e3b4e8a0879df5f5f823ff864a6095c5f6d20adda9ca4e61237272544bdee16c6
-  data.tar.gz: d0f64c4635d26f825fba0cc710388a5857469d68771335672a29bba55c0f454e35e3c9c7694aec9d101b2d4243a3e7ef3295b690e293dcbc8622b3be44f4c0f6
+  metadata.gz: 3ea998353b0bc33a8cf03f7b11ea719512306453b7be9f98faf4c2a378d78b3986505027dc812dd4dc9ea27e5d966def5150d34183d5e86762178a711e02c9ef
+  data.tar.gz: f9a5a6a6705590a1445f26e6897a1ba59dda0719023f970deb826195675616e46dc227b49160ae0c26c4548dda3cb8c9fc0151304955fea1aeb3ccf7bab7cf0d

data/async-http.gemspec

@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
 	
 	spec.add_dependency("protocol-http", "~> 0.15.1")
 	spec.add_dependency("protocol-http1", "~> 0.10.0")
-	spec.add_dependency("protocol-http2", "~> 0.12.0")
+	spec.add_dependency("protocol-http2", "~> 0.13.0")
 	
 	# spec.add_dependency("openssl")
 	

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+#
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative '../../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
+					def initialize(stream, length)
+						super(length)
+						
+						@stream = stream
+						@remaining = length
+					end
+					
+					def read
+						if chunk = super
+							# If we read a chunk fron the stream, we want to extend the window if required so more data will be provided.
+							@stream.request_window_update
+						end
+						
+						# We track the expected length and check we got what we were expecting.
+						if @remaining
+							if chunk
+								@remaining -= chunk.bytesize
+							elsif @remaining > 0
+								raise EOFError, "Expected #{self.length} bytes, #{@remaining} bytes short!"
+							elsif @remaining < 0
+								raise EOFError, "Expected #{self.length} bytes, #{@remaining} bytes over!"
+							end
+						end
+						
+						return chunk
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+#
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+require_relative '../../body/stream'
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP2
+				class Output
+					def self.for(stream, body)
+						output = self.new(stream, body)
+						
+						output.start
+						
+						return output
+					end
+					
+					def initialize(stream, body)
+						@stream = stream
+						@body = body
+						@task = nil
+						
+						@window_updated = Async::Condition.new
+					end
+					
+					def start(parent: Task.current)
+						raise "Task already started!" if @task
+						
+						if @body.respond_to?(:call)
+							@task = parent.async(&self.method(:stream))
+						else
+							@task = parent.async(&self.method(:passthrough))
+						end
+					end
+					
+					def window_updated(size)
+						@window_updated.signal
+					end
+					
+					def write(chunk)
+						until chunk.empty?
+							maximum_size = @stream.available_frame_size
+							
+							while maximum_size <= 0
+								@window_updated.wait
+								
+								maximum_size = @stream.available_frame_size
+							end
+							
+							break unless chunk = send_data(chunk, maximum_size)
+						end
+					end
+					
+					def close(error = nil)
+						@stream.finish_output(error)
+					end
+					
+					def stop(error)
+						@task&.stop
+						@task = nil
+					end
+					
+					private
+					
+					def stream(task)
+						task.annotate("Streaming #{@body} to #{@stream}.")
+						
+						input = @stream.wait_for_input
+						
+						@body.call(Body::Stream.new(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)
+							# TODO this reduces memory usage?
+							# chunk.clear unless chunk.frozen?
+							# GC.start
+						end
+						
+						@stream.finish_output
+					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)
+						else
+							@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:
+							return chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
+						end
+						
+						return nil
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -106,7 +106,7 @@ module Async
 							return headers
 						end
 						
-						def close(error)
+						def closed(error)
 							@request = nil
 							
 							super

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

@@ -109,7 +109,7 @@ module Async
 							end
 						end
 						
-						def close(error)
+						def closed(error)
 							super
 							
 							if @response

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

@@ -21,157 +21,15 @@
 # THE SOFTWARE.
 
 require 'protocol/http2/stream'
-require_relative '../../body/writable'
+
+require_relative 'input'
+require_relative 'output'
 
 module Async
 	module HTTP
 		module Protocol
 			module HTTP2
 				class Stream < ::Protocol::HTTP2::Stream
-					# A writable body which requests window updates when data is read from it.
-					class Input < Body::Writable
-						def initialize(stream, length)
-							super(length)
-							
-							@stream = stream
-							@remaining = length
-						end
-						
-						def read
-							if chunk = super
-								# If we read a chunk fron the stream, we want to extend the window if required so more data will be provided.
-								@stream.request_window_update
-							end
-							
-							# We track the expected length and check we got what we were expecting.
-							if @remaining
-								if chunk
-									@remaining -= chunk.bytesize
-								elsif @remaining > 0
-									raise EOFError, "Expected #{self.length} bytes, #{@remaining} bytes short!"
-								elsif @remaining < 0
-									raise EOFError, "Expected #{self.length} bytes, #{@remaining} bytes over!"
-								end
-							end
-							
-							return chunk
-						end
-					end
-					
-					class Output
-						def self.for(stream, body)
-							output = self.new(stream, body)
-							
-							output.start
-							
-							return output
-						end
-						
-						def initialize(stream, body)
-							@stream = stream
-							@body = body
-							
-							@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&.stop
-						end
-						
-						def write(chunk)
-							until chunk.empty?
-								maximum_size = @stream.available_frame_size
-								
-								while maximum_size <= 0
-									@window_updated.wait
-									
-									maximum_size = @stream.available_frame_size
-								end
-								
-								break unless chunk = send_data(chunk, maximum_size)
-							end
-						end
-						
-						def window_updated(size)
-							@window_updated.signal
-						end
-						
-						def close(error = nil)
-							if @stream
-								if error
-									@stream.close(error)
-								else
-									self.close_write
-								end
-								
-								@stream = nil
-							end
-						end
-						
-						def close_write
-							@stream.send_data(nil, ::Protocol::HTTP2::END_STREAM)
-						end
-						
-						private
-						
-						def stream(task)
-							task.annotate("Streaming #{@body} to #{@stream}.")
-							
-							input = @stream.wait_for_input
-							
-							@body.call(Body::Stream.new(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)
-								# TODO this reduces memory usage?
-								# chunk.clear unless chunk.frozen?
-								# GC.start
-							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)
-							else
-								@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:
-								return chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
-							end
-							
-							return nil
-						end
-					end
-					
 					def initialize(*)
 						super
 						
@@ -279,13 +137,28 @@ module Async
 						@output = Output.for(self, body)
 					end
 					
+					# Called when the output terminates normally.
+					def finish_output(error = nil)
+						@output = nil
+						
+						if error
+							send_reset_stream(::Protocol::HTTP2::Error::INTERNAL_ERROR)
+						else
+							send_data(nil, ::Protocol::HTTP2::END_STREAM)
+						end
+					end
+					
 					def window_updated(size)
 						super
 						
 						@output&.window_updated(size)
 					end
 					
-					def close(error = nil)
+					# When the stream transitions to the closed state, this method is called. There are roughly two ways this can happen:
+					# - A frame is received which causes this stream to enter the closed state. This method will be invoked from the background reader task.
+					# - A frame is sent which causes this stream to enter the closed state. This method will be invoked from that task.
+					# While the input stream is relatively straight forward, the output stream can trigger the second case above
+					def closed(error)
 						super
 						
 						if @input
@@ -297,6 +170,8 @@ module Async
 							@output.stop(error)
 							@output = nil
 						end
+						
+						return self
 					end
 				end
 			end

data/lib/async/http/version.rb

@@ -22,6 +22,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.50.9"
+		VERSION = "0.50.10"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.50.9
+  version: 0.50.10
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-31 00:00:00.000000000 Z
+date: 2020-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.13.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.12.0
+        version: 0.13.0
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -250,6 +250,8 @@ files:
 - lib/async/http/protocol/http2.rb
 - lib/async/http/protocol/http2/client.rb
 - lib/async/http/protocol/http2/connection.rb
+- lib/async/http/protocol/http2/input.rb
+- lib/async/http/protocol/http2/output.rb
 - lib/async/http/protocol/http2/request.rb
 - lib/async/http/protocol/http2/response.rb
 - lib/async/http/protocol/http2/server.rb
@@ -282,7 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: A HTTP client and server library.