async-http 0.52.4 → 0.54.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 99b5cbef0cb74dedeea089ac42ff1aa5315e1089079f812ff4120e9147ab22ec
-  data.tar.gz: dda68448abfa958e9a98814f35482bda367990191f9742292512c8f242745fe8
+  metadata.gz: 82df1313e46a49ebe4ba6c345c911dcf0c899e59361f09abaedc5f7c7979e61f
+  data.tar.gz: 838d76ab9e99d661ac7be82169d6931325e64d22fab02ca93089d5da2ed13b31
 SHA512:
-  metadata.gz: 74ddbd13c0e1b3c5bae03ded50129ab73fac1285d480bef0ff8a944c1163651037d6a258f36757b8969f72ea7e63eaf145384b346aa7733f2a51430c85cba642
-  data.tar.gz: e1036b972800356861167204b1ecfbab6e164dbe51351bd15a2881214d5e437f1cda9bd53a75715bd41c74f91ea6911d438b2ebcc04adceede636d0814e79e1f
+  metadata.gz: 0d78d6636a59967ab8de9c76eddad387d6a607c04224563bf6599ab4b637d5fccceffa462d700c7f4d19c4ce1bee6b6f72562dd91cc6f9532802dbe1769f4315
+  data.tar.gz: bcdc8bc22dfeb30ed425ad4117c682aca370acfab125a478cba7af03ec83b29eafabd5f8b0194adaf060dbdf03d7c926f348658cd9b89d4b5b12b583e33a9dc6

data/bake/async/http/h2spec.rb

@@ -29,7 +29,7 @@ def server
 	Async.logger.info(self){"Starting server..."}
 	
 	container.run(count: 1) do
-		server = Async::HTTP::Server.for(endpoint, Async::HTTP::Protocol::HTTP2, "https") do |request|
+		server = Async::HTTP::Server.for(endpoint, protocol: Async::HTTP::Protocol::HTTP2, scheme: "https") do |request|
 			Protocol::HTTP::Response[200, {'content-type' => 'text/plain'}, ["Hello World"]]
 		end
 		

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

@@ -20,12 +20,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'wrapper'
+require 'protocol/http/body/wrapper'
 
 module Async
 	module HTTP
 		module Body
-			class Delayed < Async::HTTP::Body::Wrapper
+			class Delayed < Protocol::HTTP::Body::Wrapper
 				def initialize(body, delay = 0.01)
 					super(body)
 					

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

@@ -44,6 +44,11 @@ module Async
 					@stream = nil
 				end
 				
+				# We prefer streaming directly as it's the lowest overhead.
+				def stream?
+					true
+				end
+				
 				def call(stream)
 					return @block.call(stream)
 				end

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

@@ -20,6 +20,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'async/io/socket'
+require 'async/io/stream'
+
 require_relative 'writable'
 
 module Async
@@ -39,8 +42,8 @@ module Async
 					@reader = nil
 					@writer = nil
 					
-					task.async(&self.method(:reader))
-					task.async(&self.method(:writer))
+					task.async(transient: true, &self.method(:reader))
+					task.async(transient: true, &self.method(:writer))
 				end
 				
 				def to_io
@@ -69,10 +72,9 @@ module Async
 					
 					@head.close_write
 				ensure
-					@reader = nil
 					@input.close($!)
 					
-					@head.close if @writer.nil?
+					close_head if @writer&.finished?
 				end
 				
 				# Read from the head of the pipe and write to the @output stream.
@@ -86,11 +88,17 @@ module Async
 						@output.write(chunk)
 					end
 				ensure
-					@writer = nil
-					
 					@output.close($!)
 					
-					@head.close if @reader.nil?
+					close_head if @reader&.finished?
+				end
+				
+				def close_head
+					@head.close
+					
+					# Both tasks are done, don't keep references:
+					@reader = nil
+					@writer = nil
 				end
 			end
 		end

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

@@ -139,7 +139,7 @@ module Async
 				end
 				
 				# Close the input and output bodies.
-				def close
+				def close(error = nil)
 					self.close_read
 					self.close_write
 				ensure

data/lib/async/http/client.rb

@@ -25,7 +25,7 @@ require 'async/io/stream'
 
 require 'async/pool/controller'
 
-require 'protocol/http/body/streamable'
+require 'protocol/http/body/completable'
 require 'protocol/http/methods'
 
 require_relative 'protocol'
@@ -45,7 +45,7 @@ module Async
 			# @param protocol [Protocol::HTTP1 | Protocol::HTTP2 | Protocol::HTTPS] the protocol to use.
 			# @param scheme [String] The default scheme to set to requests.
 			# @param authority [String] The default authority to set to requests.
-			def initialize(endpoint, protocol = endpoint.protocol, scheme = endpoint.scheme, authority = endpoint.authority, retries: DEFAULT_RETRIES, connection_limit: DEFAULT_CONNECTION_LIMIT)
+			def initialize(endpoint, protocol: endpoint.protocol, scheme: endpoint.scheme, authority: endpoint.authority, retries: DEFAULT_RETRIES, connection_limit: DEFAULT_CONNECTION_LIMIT)
 				@endpoint = endpoint
 				@protocol = protocol
 				
@@ -143,7 +143,7 @@ module Async
 				response = request.call(connection)
 				
 				# The connection won't be released until the body is completely read/released.
-				::Protocol::HTTP::Body::Streamable.wrap(response) do
+				::Protocol::HTTP::Body::Completable.wrap(response) do
 					@pool.release(connection)
 				end
 				

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

@@ -38,13 +38,13 @@ module Async
 				end
 				
 				def self.client(peer)
-					stream = IO::Stream.new(peer, sync: false)
+					stream = IO::Stream.new(peer, sync: true)
 					
 					return HTTP1::Client.new(stream, VERSION)
 				end
 				
 				def self.server(peer)
-					stream = IO::Stream.new(peer, sync: false)
+					stream = IO::Stream.new(peer, sync: true)
 					
 					return HTTP1::Server.new(stream, VERSION)
 				end

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

@@ -74,11 +74,6 @@ module Async
 					def reusable?
 						@persistent && @stream && !@stream.closed?
 					end
-					
-					def close
-						Async.logger.debug(self) {"Closing connection"}
-						super
-					end
 				end
 			end
 		end

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

@@ -80,7 +80,7 @@ module Async
 									response = nil
 									
 									body.call(stream)
-								elsif body and request.connect?
+								elsif request.connect? and response.success?
 									stream = write_tunnel_body(request.version)
 									
 									# Same as above:

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

@@ -37,13 +37,13 @@ module Async
 				end
 				
 				def self.client(peer)
-					stream = IO::Stream.new(peer, sync: false)
+					stream = IO::Stream.new(peer, sync: true)
 					
 					return HTTP1::Client.new(stream, VERSION)
 				end
 				
 				def self.server(peer)
-					stream = IO::Stream.new(peer, sync: false)
+					stream = IO::Stream.new(peer, sync: true)
 					
 					return HTTP1::Server.new(stream, VERSION)
 				end

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

@@ -37,13 +37,13 @@ module Async
 				end
 				
 				def self.client(peer)
-					stream = IO::Stream.new(peer, sync: false)
+					stream = IO::Stream.new(peer, sync: true)
 					
 					return HTTP1::Client.new(stream, VERSION)
 				end
 				
 				def self.server(peer)
-					stream = IO::Stream.new(peer, sync: false)
+					stream = IO::Stream.new(peer, sync: true)
 					
 					return HTTP1::Server.new(stream, VERSION)
 				end

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

@@ -76,24 +76,6 @@ module Async
 				def self.names
 					["h2"]
 				end
-				
-				module WithPush
-					CLIENT_SETTINGS = HTTP2::CLIENT_SETTINGS.merge(
-						::Protocol::HTTP2::Settings::ENABLE_PUSH => 1,
-					)
-					
-					def self.client(peer, settings = CLIENT_SETTINGS)
-						HTTP2.client(peer, settings)
-					end
-					
-					def self.server(peer, settings = SERVER_SETTINGS)
-						HTTP2.server(peer, settings)
-					end
-					
-					def self.names
-						HTTP2.names
-					end
-				end
 			end
 		end
 	end

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

@@ -107,6 +107,13 @@ module Async
 								end
 							rescue SocketError, IOError, EOFError, Errno::ECONNRESET, Errno::EPIPE, Async::Wrapper::Cancelled
 								# Ignore.
+							rescue ::Protocol::HTTP2::GoawayError => error
+								# Error is raised if a response is actively reading from the
+								# connection. The connection is silently closed if GOAWAY is
+								# received outside the request/response cycle.
+								if @reader
+									self.close(error)
+								end
 							ensure
 								# Don't call #close twice.
 								if @reader

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

@@ -42,7 +42,7 @@ module Async
 					def start(parent: Task.current)
 						raise "Task already started!" if @task
 						
-						if @body.respond_to?(:call)
+						if @body.stream?
 							@task = parent.async(&self.method(:stream))
 						else
 							@task = parent.async(&self.method(:passthrough))

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

@@ -39,18 +39,6 @@ module Async
 						
 						attr :request
 						
-						# Create a fake request on the server, with the given headers.
-						def create_push_promise_stream(headers)
-							stream = @connection.create_push_promise_stream(&Stream.method(:create))
-							
-							stream.headers = ::Protocol::HTTP::Headers.new
-							
-							# This will ultimately enqueue the request to be processed by the server:
-							stream.receive_initial_headers(headers, false)
-							
-							return stream
-						end
-						
 						def receive_initial_headers(headers, end_stream)
 							headers.each do |key, value|
 								if key == SCHEME
@@ -133,32 +121,6 @@ module Async
 						false
 					end
 					
-					def push?
-						@stream.connection.enable_push?
-					end
-					
-					# @return [Stream] the promised stream, on which to send data.
-					def push(path, headers = nil, scheme = @scheme, authority = @authority)
-						raise ArgumentError, "Missing scheme!" unless scheme
-						raise ArgumentError, "Missing authority!" unless authority
-						
-						push_headers = [
-							[SCHEME, scheme],
-							[METHOD, ::Protocol::HTTP::Methods::GET],
-							[PATH, path],
-							[AUTHORITY, authority]
-						]
-						
-						if headers
-							push_headers = Headers::Merged.new(
-								push_headers,
-								headers
-							)
-						end
-						
-						@stream.send_push_promise(push_headers)
-					end
-					
 					NO_RESPONSE = [
 						[STATUS, '500'],
 					]

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

@@ -50,13 +50,7 @@ module Async
 						end
 						
 						def accept_push_promise_stream(promised_stream_id, headers)
-							stream = @connection.accept_push_promise_stream(promised_stream_id, &Stream.method(:create))
-							
-							stream.response.build_request(headers)
-							
-							@response.promises.enqueue(stream.response)
-							
-							return stream
+							raise ProtocolError, "Cannot accept push promise stream!"
 						end
 						
 						# This should be invoked from the background reader, and notifies the task waiting for the headers that we are done.
@@ -113,7 +107,6 @@ module Async
 							super
 							
 							if @response
-								@response.promises.enqueue nil
 								@response = nil
 							end
 							
@@ -128,7 +121,6 @@ module Async
 						
 						@stream = stream
 						@request = nil
-						@promises = nil
 					end
 					
 					attr :stream
@@ -150,10 +142,6 @@ module Async
 						!!@status
 					end
 					
-					def promises
-						@promises ||= Async::Queue.new
-					end
-					
 					def build_request(headers)
 						request = ::Protocol::HTTP::Request.new
 						request.headers = ::Protocol::HTTP::Headers.new
@@ -215,6 +203,11 @@ module Async
 						if request.body.nil?
 							@stream.send_headers(nil, headers, ::Protocol::HTTP2::END_STREAM)
 						else
+							if length = request.body.length
+								# This puts it at the end of the pseudo-headers:
+								pseudo_headers << [CONTENT_LENGTH, length]
+							end
+							
 							# This function informs the headers object that any subsequent headers are going to be trailers. Therefore, it must be called *before* sending the headers, to avoid any race conditions.
 							trailers = request.headers.trailers!
 							

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

@@ -42,10 +42,6 @@ module Async
 					false
 				end
 				
-				def push?
-					false
-				end
-				
 				def peer
 					if connection = self.connection
 						connection.peer

data/lib/async/http/proxy.rb

@@ -30,6 +30,15 @@ module Async
 		# Wraps a client, address and headers required to initiate a connectio to a remote host using the CONNECT verb.
 		# Behaves like a TCP endpoint for the purposes of connecting to a remote host.
 		class Proxy
+			class ConnectFailure < StandardError
+				def initialize(response)
+					super "Failed to connect: #{response.status}"
+					@response = response
+				end
+				
+				attr :response
+			end
+			
 			module Client
 				def proxy(endpoint, headers = nil)
 					Proxy.new(self, endpoint.authority(false), headers)
@@ -92,14 +101,21 @@ module Async
 				
 				response = @client.connect(@address.to_s, @headers, input)
 				
-				pipe = Body::Pipe.new(response.body, input)
-				
-				return pipe.to_io unless block_given?
-				
-				begin
-					yield pipe.to_io
-				ensure
-					pipe.close
+				if response.success?
+					pipe = Body::Pipe.new(response.body, input)
+					
+					return pipe.to_io unless block_given?
+					
+					begin
+						yield pipe.to_io
+					ensure
+						pipe.close
+					end
+				else
+					# This ensures we don't leave a response dangling:
+					response.close
+					
+					raise ConnectFailure, response
 				end
 			end
 			

data/lib/async/http/server.rb

@@ -29,11 +29,11 @@ require 'protocol/http/middleware'
 module Async
 	module HTTP
 		class Server < ::Protocol::HTTP::Middleware
-			def self.for(*arguments, &block)
-				self.new(block, *arguments)
+			def self.for(*arguments, **options, &block)
+				self.new(block, *arguments, **options)
 			end
 			
-			def initialize(app, endpoint, protocol = endpoint.protocol, scheme = endpoint.scheme)
+			def initialize(app, endpoint, protocol: endpoint.protocol, scheme: endpoint.scheme)
 				super(app)
 				
 				@endpoint = endpoint

data/lib/async/http/version.rb

@@ -22,6 +22,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.52.4"
+		VERSION = "0.54.1"
 	end
 end