async-http 0.48.0 → 0.48.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd79f3f1a3f1c5c5283c9e851433bce5833c18f33b231623fb1e414de078282f
-  data.tar.gz: bc27cc3ed8568cdd884e09c0889d8d78c3a879bf0117c94c9845f8ea2bd4e5d9
+  metadata.gz: 2a0c1192533c40875a7712d03cfa8b43c654b08b28159c0d87db7ebdd4aca4d1
+  data.tar.gz: 3b2c33d137af08f87117f8a5c88dae911b148aaebe0bb2e4b91e38191e2b46e8
 SHA512:
-  metadata.gz: 5efa88bd4fb17b26b36b434879ff1e2757fdee205d08ee9b5f6a111d867ace9fd2d06ade0b6f895445fc9d5c09057b047d474d80d70f79022644a2af4b3fba0e
-  data.tar.gz: cd4863983ac3392d88e47c7d5244a5968ea90caa5b906d7335a2ccc42a70f9fd2348bc48a77e9b4e34dad736c83477af39759c6a14d08aff69d1d27775017828
+  metadata.gz: c347570d4608e7ccf62b80fbcc07d4d6da83e4dbfdb787655df8e039a7a4d90556d5b0ca0b21a0e1ecf2d13dc00488837730b94fd5ff1d6b160c4e4c2ddb92b0
+  data.tar.gz: 9c967f8ebcaaee6f2f14114917f716a0e1464a1dccb44ceda1e0409e409896838ab3a17a2134afd1cbc2ce0a767990ead112d679b89f3b016fc8be0accf58635

data/Gemfile

@@ -3,6 +3,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in async-io.gemspec
 gemspec
 
+# gem "protocol-http", path: "../protocol-http"
+# gem "protocol-http1", path: "../protocol-http1"
 # gem "protocol-http2", path: "../protocol-http2"
 # gem "protocol-hpack", path: "../protocol-hpack"
 

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

@@ -24,7 +24,7 @@ require_relative 'stream'
 module Async
 	module HTTP
 		module Body
-			# A body which is designed for hijacked connections.
+			# A body which is designed for hijacked server responses - a response which uses a block to read and write the request and response bodies respectively.
 			class Hijack < ::Protocol::HTTP::Body::Readable
 				def self.response(request, status, headers, &block)
 					::Protocol::HTTP::Response[status, headers, self.wrap(request, &block)]

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

@@ -46,32 +46,35 @@ module Async
 				# @param length [Integer] the amount of data to read
 				# @param buffer [String] the buffer which will receive the data
 				# @return a buffer containing the data
-				def read(length = nil, buffer = nil)
+				def read(size = nil, buffer = nil)
+					return '' if size == 0
+					
 					buffer ||= Async::IO::Buffer.new
-					buffer.clear
+					if @buffer
+						buffer.replace(@buffer)
+						@buffer = nil
+					end
 					
-					until buffer.bytesize == length
-						@buffer = read_next if @buffer.nil?
-						break if @buffer.nil?
+					if size
+						while buffer.bytesize < size and chunk = read_next
+							buffer << chunk
+						end
 						
-						remaining_length = length - buffer.bytesize if length
+						@buffer = buffer.byteslice(size, buffer.bytesize)
+						buffer = buffer.byteslice(0, size)
 						
-						if remaining_length && remaining_length < @buffer.bytesize
-							# We know that we are not going to reuse the original buffer.
-							# But byteslice will generate a hidden copy. So let's freeze it first:
-							@buffer.freeze
-							
-							buffer << @buffer.byteslice(0, remaining_length)
-							@buffer = @buffer.byteslice(remaining_length, @buffer.bytesize)
+						if buffer.empty?
+							return nil
 						else
-							buffer << @buffer
-							@buffer = nil
+							return buffer
 						end
+					else
+						while chunk = read_next
+							buffer << chunk
+						end
+						
+						return buffer
 					end
-					
-					return nil if buffer.empty? && length && length > 0
-					
-					return buffer
 				end
 				
 				# Read at most `size` bytes from the stream. Will avoid reading from the underlying stream if possible.
@@ -129,7 +132,6 @@ module Async
 					@input&.close
 				end
 				
-				# close must never be called on the input stream. huh?
 				def close_write
 					@output&.close
 				end

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

@@ -97,7 +97,19 @@ module Async
 				alias << write
 				
 				def inspect
-					"\#<#{self.class} #{@count} chunks written#{@finished ? ', finished' : ', waiting'}>"
+					"\#<#{self.class} #{@count} chunks written, #{status}>"
+				end
+				
+				private
+				
+				def status
+					if @finished
+						'finished'
+					elsif @closed
+						'closing'
+					else
+						'waiting'
+					end
 				end
 			end
 		end

data/lib/async/http/client.rb

@@ -75,6 +75,11 @@ module Async
 			end
 			
 			def close
+				while @pool.busy?
+					Async.logger.warn(self) {"Waiting for pool to drain: #{@pool}"}
+					@pool.wait
+				end
+				
 				@pool.close
 			end
 			

data/lib/async/http/endpoint.rb

@@ -47,7 +47,11 @@ module Async
 				
 				@url = url
 				
-				@endpoint = self.build_endpoint(endpoint)
+				if endpoint
+					@endpoint = self.build_endpoint(endpoint)
+				else
+					@endpoint = nil
+				end
 			end
 			
 			def to_url
@@ -109,8 +113,8 @@ module Async
 				@options[:scheme] || @url.scheme
 			end
 			
-			def authority
-				if default_port?
+			def authority(ignore_default_port = true)
+				if ignore_default_port and default_port?
 					@url.hostname
 				else
 					"#{@url.hostname}:#{port}"

data/lib/async/http/internet.rb

@@ -34,7 +34,7 @@ module Async
 				endpoint = Endpoint.parse(url)
 				
 				client = @clients.fetch(endpoint) do
-					@clients[endpoint] = Client.new(endpoint)
+					@clients[endpoint] = self.client_for(endpoint)
 				end
 				
 				body = Body::Buffered.wrap(body)
@@ -44,6 +44,10 @@ module Async
 				return client.call(request)
 			end
 			
+			def client_for(endpoint)
+				Client.new(endpoint)
+			end
+			
 			def close
 				@clients.each_value(&:close)
 				@clients.clear

data/lib/async/http/proxy.rb

@@ -25,11 +25,51 @@ require_relative 'body/pipe'
 
 module Async
 	module HTTP
+		# 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
+			module Client
+				def proxy(endpoint, headers = [])
+					Proxy.new(self, endpoint.authority(false), headers)
+				end
+				
+				# Create a client that will proxy requests through the current client.
+				def proxied_client(endpoint, headers = [])
+					proxy = self.proxy(endpoint, headers)
+					
+					return self.class.new(proxy.wrap_endpoint(endpoint))
+				end
+				
+				def proxied_endpoint(endpoint, headers = [])
+					proxy = self.proxyfor(endpoint, headers)
+					
+					return proxy.wrap_endpoint(endpoint)
+				end
+			end
+			
+			# Prepare and endpoint which can establish a TCP connection to the remote system.
+			# @param client [Async::HTTP::Client] the client which will be used as a proxy server.
+			# @param host [String] the hostname or address to connect to.
+			# @param port [String] the port number to connect to.
+			# @param headers [Array] an optional list of headers to use when establishing the connection.
+			# @see Async::IO::Endpoint#tcp
 			def self.tcp(client, host, port, headers = [])
 				self.new(client, "#{host}:#{port}", headers)
 			end
 			
+			# Construct a endpoint that will use the given client as a proxy for HTTP requests.
+			# @param client [Async::HTTP::Client] the client which will be used as a proxy server.
+			# @param endpoint [Async::HTTP::Endpoint] the endpoint to connect to.
+			# @param headers [Array] an optional list of headers to use when establishing the connection.
+			def self.endpoint(client, endpoint, headers = [])
+				proxy = self.new(client, endpoint.authority(false), headers)
+				
+				return proxy.endpoint(endpoint.url)
+			end
+			
+			# @param client [Async::HTTP::Client] the client which will be used as a proxy server.
+			# @param address [String] the address to connect to.
+			# @param headers [Array] an optional list of headers to use when establishing the connection.
 			def initialize(client, address, headers = [])
 				@client = client
 				@address = address
@@ -38,14 +78,13 @@ module Async
 			
 			attr :client
 			
+			# Close the underlying client connection.
 			def close
-				while @client.pool.busy?
-					@client.pool.wait
-				end
-				
 				@client.close
 			end
 			
+			# Establish a TCP connection to the specified host.
+			# @return [Socket] a connected bi-directional socket.
 			def connect(&block)
 				input = Body::Writable.new
 				
@@ -62,9 +101,12 @@ module Async
 				end
 			end
 			
-			def endpoint(url, **options)
-				Endpoint.parse(url, self, **options)
+			# @return [Async::HTTP::Endpoint] an endpoint that connects via the specified proxy.
+			def wrap_endpoint(endpoint)
+				Endpoint.new(endpoint.url, self, **endpoint.options)
 			end
 		end
+		
+		Client.prepend(Proxy::Client)
 	end
 end

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.48.0"
+		VERSION = "0.48.1"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.48.0
+  version: 0.48.1
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-11 00:00:00.000000000 Z
+date: 2019-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async