async-http 0.40.3 → 0.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9467ea667ebfd156ef91b71cfa8da9598d73839cc378545672aa4db3338f80f9
-  data.tar.gz: 03e93ca6e98b1e22f58cde6542e44eba52f6193d779492dfba1be835c2f31d02
+  metadata.gz: 35e99a53d484c9c4e0ee98db95695ea2a238dc71e03c958425c37f4a2c6560dd
+  data.tar.gz: 7a6bcefcc687b98652d0fa1b23d234f6223ca8c5dd80fd88c44624883e871322
 SHA512:
-  metadata.gz: 9890cd89c5e1148863714c1f517f3ad7edd62cefb6a7f513580a32649a055b67929b7e7c26b8440b00667b42854a9ccb4e8275df17bacbed6b9e73721e2f61e7
-  data.tar.gz: 7cc0038e3cd139cda370e485d29719b611224a156928de22de597293108b399057809b43c813d7b171cadc2ea926cb0e0760d6cd267bcf67d1bc5e9ac1290060
+  metadata.gz: 16b58d9b615e7ddb4fe12cda38dd48c3f4a598e27e4175cc14063faad08a8aab42e75e66ff8e7d47207af882f03fe5339b11ac28d281e02f91ca6278da77a3d5
+  data.tar.gz: 388048425c3444cc34d69712be5d33e6854023be0339a91b2b1f748a74e703339beb5c03de90cdaa693af51d3aa512b6591b57a161c94e6151dbbb327c7fc349

data/README.md

@@ -97,13 +97,13 @@ Here is a basic example of a client/server running in the same reactor:
 require 'async/http/server'
 require 'async/http/client'
 require 'async/reactor'
-require 'async/http/url_endpoint'
+require 'async/http/endpoint'
 require 'async/http/response'
 
-endpoint = Async::HTTP::URLEndpoint.parse('http://127.0.0.1:9294')
+endpoint = Async::HTTP::Endpoint.parse('http://127.0.0.1:9294')
 
 app = lambda do |request|
-	Async::HTTP::Response[200, {}, ["Hello World"]]
+	Protocol::HTTP::Response[200, {}, ["Hello World"]]
 end
 
 server = Async::HTTP::Server.new(app, endpoint)
@@ -140,7 +140,7 @@ trusted_fingerprints = {
 }
 
 Async do
-	endpoint = Async::HTTP::URLEndpoint.parse("https://www.codeotaku.com/index")
+	endpoint = Async::HTTP::Endpoint.parse("https://www.codeotaku.com/index")
 	
 	# This is a quick hack/POC:
 	ssl_context = endpoint.ssl_context

data/async-http.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
 	spec.add_dependency("async", "~> 1.14")
 	spec.add_dependency("async-io", "~> 1.18")
 	
-	spec.add_dependency("protocol-http", "~> 0.3.0")
-	spec.add_dependency("protocol-http1", "~> 0.5.0")
-	spec.add_dependency("protocol-http2", "~> 0.2.0")
+	spec.add_dependency("protocol-http", "~> 0.5.0")
+	spec.add_dependency("protocol-http1", "~> 0.6.0")
+	spec.add_dependency("protocol-http2", "~> 0.3.0")
 	
 	# spec.add_dependency("openssl")
 	

data/examples/request.rb

@@ -6,12 +6,12 @@
 require 'async'
 require 'async/logger'
 require 'async/http/client'
-require 'async/http/url_endpoint'
+require 'async/http/endpoint'
 
 # Async.logger.level = Logger::DEBUG
 
 Async.run do |task|
-	endpoint = Async::HTTP::URLEndpoint.parse("https://www.google.com")
+	endpoint = Async::HTTP::Endpoint.parse("https://www.google.com")
 	
 	client = Async::HTTP::Client.new(endpoint)
 	
@@ -19,7 +19,7 @@ Async.run do |task|
 		'accept' => 'text/html',
 	}
 	
-	request = Async::HTTP::Request.new(client.scheme, "www.google.com", "GET", "/search?q=cats", headers)
+	request = Protocol::HTTP::Request.new(client.scheme, "www.google.com", "GET", "/search?q=cats", headers)
 	
 	puts "Sending request..."
 	response = client.call(request)

data/examples/upload/client.rb

@@ -6,10 +6,10 @@ require 'async'
 require 'async/http/body/file'
 require 'async/http/body/delayed'
 require 'async/http/client'
-require 'async/http/url_endpoint'
+require 'async/http/endpoint'
 
 Async.run do
-	endpoint = Async::HTTP::URLEndpoint.parse("http://localhost:9222")
+	endpoint = Async::HTTP::Endpoint.parse("http://localhost:9222")
 	client = Async::HTTP::Client.new(endpoint, Async::HTTP::Protocol::HTTP2)
 	
 	headers = [

data/examples/upload/server.rb

@@ -3,16 +3,16 @@ $LOAD_PATH.unshift File.expand_path("../../lib", __dir__)
 
 require 'async'
 require 'async/http/server'
-require 'async/http/url_endpoint'
+require 'async/http/endpoint'
 
 protocol = Async::HTTP::Protocol::HTTP2
-endpoint = Async::HTTP::URLEndpoint.parse('http://127.0.0.1:9222', reuse_port: true)
+endpoint = Async::HTTP::Endpoint.parse('http://127.0.0.1:9222', reuse_port: true)
 
 Async.logger.level = Logger::DEBUG
 
 Async.run do
 	server = Async::HTTP::Server.for(endpoint, protocol) do |request|
-		Async::HTTP::Response[200, {}, request.body]
+		Protocol::HTTP::Response[200, {}, request.body]
 	end
 	
 	server.run

data/lib/async/http.rb

@@ -23,4 +23,4 @@ require_relative 'http/version'
 require_relative 'http/client'
 require_relative 'http/server'
 
-require_relative 'http/url_endpoint'
+require_relative 'http/endpoint'

data/lib/async/http/body.rb

@@ -18,22 +18,13 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'protocol/http/body/buffered'
 require_relative 'body/writable'
-require_relative 'body/buffered'
 
 module Async
 	module HTTP
-		# These classes implement a general IO model for streaming HTTP bodies.
 		module Body
-			# The implementation assumes a sequential unbuffered stream of data.
-			# class Body
-			# 	def each -> yield(String | nil)
-			# 	def read -> String | nil
-			# 	def join -> String
-			
-			# 	def finish -> buffer the stream and close it.
-			# 	def close(error = nil) -> close the stream immediately.
-			# end
+			include ::Protocol::HTTP::Body
 		end
 	end
 end

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

@@ -18,16 +18,16 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'readable'
+require 'protocol/http/body/readable'
 require_relative 'stream'
 
 module Async
 	module HTTP
 		module Body
 			# A body which is designed for hijacked connections.
-			class Hijack < Readable
+			class Hijack < ::Protocol::HTTP::Body::Readable
 				def self.response(request, status, headers, &block)
-					Async::HTTP::Response[status, headers, self.wrap(request, &block)]
+					::Protocol::HTTP::Response[status, headers, self.wrap(request, &block)]
 				end
 				
 				def self.wrap(request, &block)

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

@@ -18,13 +18,14 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'readable'
-
+require 'protocol/http/body/readable'
 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

data/lib/async/http/client.rb

@@ -21,13 +21,14 @@
 require 'async/io/endpoint'
 require 'async/io/stream'
 
+require 'protocol/http/body/streamable'
+require 'protocol/http/methods'
+
 require_relative 'protocol'
-require_relative 'body/streamable'
-require_relative 'middleware'
 
 module Async
 	module HTTP
-		class Client
+		class Client < ::Protocol::HTTP::Methods
 			# Provides a robust interface to a server.
 			# * If there are no connections, it will create one.
 			# * If there are already connections, it will reuse it.
@@ -53,6 +54,10 @@ module Async
 			attr :scheme
 			attr :authority
 			
+			def secure?
+				@endpoint.secure?
+			end
+			
 			def self.open(*args, &block)
 				client = self.new(*args)
 				
@@ -69,8 +74,6 @@ module Async
 				@pool.close
 			end
 			
-			include Methods
-			
 			def call(request)
 				request.scheme ||= self.scheme
 				request.authority ||= self.authority
@@ -84,10 +87,10 @@ module Async
 					# As we cache pool, it's possible these pool go bad (e.g. closed by remote host). In this case, we need to try again. It's up to the caller to impose a timeout on this. If this is the last attempt, we force a new connection.
 					connection = @pool.acquire
 					
-					response = connection.call(request)
+					response = request.call(connection)
 					
 					# The connection won't be released until the body is completely read/released.
-					Body::Streamable.wrap(response) do
+					::Protocol::HTTP::Body::Streamable.wrap(response) do
 						@pool.release(connection)
 					end
 					
@@ -118,9 +121,7 @@ module Async
 				Pool.new(connection_limit) do
 					Async.logger.debug(self) {"Making connection to #{@endpoint.inspect}"}
 					
-					peer = @endpoint.connect
-					
-					@protocol.client(IO::Stream.new(peer))
+					@protocol.client(IO::Stream.new(@endpoint.connect))
 				end
 			end
 		end

data/lib/async/http/{url_endpoint.rb → endpoint.rb}

@@ -27,7 +27,7 @@ require_relative 'protocol/https'
 
 module Async
 	module HTTP
-		class URLEndpoint < Async::IO::Endpoint
+		class Endpoint < Async::IO::Endpoint
 			def self.parse(string, **options)
 				url = URI.parse(string).normalize
 				

data/lib/async/http/internet.rb

@@ -19,9 +19,9 @@
 # THE SOFTWARE.
 
 require_relative 'client'
-require_relative 'url_endpoint'
-require_relative 'middleware'
-require_relative 'body/buffered'
+require_relative 'endpoint'
+require 'protocol/http/middleware'
+require 'protocol/http/body/buffered'
 
 module Async
 	module HTTP
@@ -31,7 +31,7 @@ module Async
 			end
 			
 			def call(method, url, headers = [], body = nil)
-				endpoint = URLEndpoint.parse(url)
+				endpoint = Endpoint.parse(url)
 				
 				client = @clients.fetch(endpoint) do
 					@clients[endpoint] = Client.new(endpoint)
@@ -39,7 +39,7 @@ module Async
 				
 				body = Body::Buffered.wrap(body)
 				
-				request = Request.new(client.scheme, endpoint.authority, method, endpoint.path, nil, headers, body)
+				request = ::Protocol::HTTP::Request.new(client.scheme, endpoint.authority, method, endpoint.path, nil, headers, body)
 				
 				return client.call(request)
 			end
@@ -49,7 +49,7 @@ module Async
 				@clients.clear
 			end
 			
-			VERBS.each do |verb|
+			::Protocol::HTTP::Methods.each do |name, verb|
 				define_method(verb.downcase) do |url, headers = [], body = nil|
 					self.call(verb, url.to_str, headers, body)
 				end

data/lib/async/http/pool.rb

@@ -97,7 +97,7 @@ module Async
 			end
 			
 			def to_s
-				"\#<#{self.class} resources=#{availability_string} limit=#{@limit}>"
+				"\#<#{self.class} resources=#{availability_string} limit=#{@limit.inspect}>"
 			end
 			
 			protected

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

@@ -31,23 +31,34 @@ module Async
 						
 						# We carefully interpret https://tools.ietf.org/html/rfc7230#section-6.3.1 to implement this correctly.
 						begin
-							self.write_request(request.authority, request.method, request.path, self.version, request.headers)
+							write_request(request.authority, request.method, request.path, @version, request.headers)
 						rescue
 							# If we fail to fully write the request and body, we can retry this request.
-							raise RequestFailed.new
+							raise RequestFailed
 						end
 						
 						if request.body?
-							task.async 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.
-								self.write_body(request.body)
+							body = request.body
+							
+							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
+									# If this fails, this connection will be closed.
+									write_upgrade_body(protocol, body)
+								end
+							else
+								task.async 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)
+								end
 							end
+						elsif protocol = request.protocol
+							write_upgrade_body(protocol)
 						else
-							self.write_empty_body(request.body)
+							write_empty_body(request.body)
 						end
 						
-						# This won't return the response until the entire body is written.
-						return Response.new(self, request)
+						return Response.read(self, request)
 					rescue
 						# This will ensure that #reusable? returns false.
 						@stream.close

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

@@ -23,10 +23,6 @@ require 'protocol/http1'
 require_relative 'request'
 require_relative 'response'
 
-require_relative '../../body/chunked'
-require_relative '../../body/fixed'
-require_relative '../../body/remainder'
-
 module Async
 	module HTTP
 		module Protocol
@@ -40,17 +36,16 @@ module Async
 					
 					attr :version
 					
-					def read_line?
-						@stream.read_until(CRLF)
+					def http1?
+						true
 					end
 					
-					# @return [Async::Wrapper] the underlying non-blocking IO.
-					def hijack!
-						@persistent = false
-						
-						@stream.flush
-						
-						return @stream.io
+					def http2?
+						false
+					end
+					
+					def read_line?
+						@stream.read_until(CRLF)
 					end
 					
 					def peer
@@ -78,18 +73,6 @@ module Async
 						
 						@stream.close
 					end
-					
-					def read_chunked_body
-						Body::Chunked.new(self)
-					end
-					
-					def read_fixed_body(length)
-						Body::Fixed.new(@stream, length)
-					end
-					
-					def read_remainder_body
-						Body::Remainder.new(@stream)
-					end
 				end
 			end
 		end

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

@@ -25,15 +25,18 @@ module Async
 		module Protocol
 			module HTTP1
 				class Request < Protocol::Request
-					def self.read(protocol)
-						if parts = protocol.read_request
-							self.new(protocol, *parts)
+					def self.read(connection)
+						if parts = connection.read_request
+							self.new(connection, *parts)
 						end
 					end
 					
-					def initialize(protocol, *parts)
-						super(nil, *parts)
-						@protocol = protocol
+					def initialize(connection, authority, method, path, version, headers, body)
+						@connection = connection
+						
+						protocol = connection.upgrade?(headers)
+						
+						super(nil, authority, method, path, version, headers, body, protocol)
 					end
 					
 					def hijack?
@@ -41,7 +44,7 @@ module Async
 					end
 					
 					def hijack!
-						@protocol.hijack!
+						@connection.hijack!
 					end
 				end
 			end

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

@@ -25,10 +25,26 @@ module Async
 		module Protocol
 			module HTTP1
 				class Response < Protocol::Response
-					def initialize(protocol, request)
-						super(*protocol.read_response(request.method))
+					def self.read(connection, request)
+						if parts = connection.read_response(request.method)
+							self.new(connection, *parts)
+						end
+					end
+					
+					def initialize(connection, version, status, reason, headers, body)
+						@connection = connection
+						
+						protocol = connection.upgrade?(headers)
 						
-						@protocol = protocol
+						super(version, status, reason, headers, body, protocol)
+					end
+					
+					def hijack?
+						@body.nil?
+					end
+					
+					def hijack!
+						@connection.hijack!
 					end
 				end
 			end