async-http 0.30.1 → 0.30.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e4879744da01c80a5eabb09a27baa3d24d69850ce077f4aa4e434d22c5ab3e7
-  data.tar.gz: c877962aff587aa7966f5c7a94b9f594f6d303225adb35f70267ff9818be6bf3
+  metadata.gz: a937910aa49ee7d30c1941ac83a39f4f5ba2c5c52beec347b510dffd0ac2b40e
+  data.tar.gz: 62e34957a999e3e83636f2c00e6f9b6227264f1a7c0d00e69048bf7ff9ceab88
 SHA512:
-  metadata.gz: 9bca1257fabc99664358645840f0fc0cb7934e07a5697ffdeff00078302bd16fb251a569922c50d1753998f04b5c3008adb376c72f0a166e43a2781e29a50ce7
-  data.tar.gz: '0282c23bb974961e316ccc99dc6188c041b0bb1855eaba7bdaeb117646e758f8e3d9ef3d5000f610482f153d374d63c0cac70ad872a4bf56d46a2832b7b2c264'
+  metadata.gz: 5256304facd1f375f6d668b10361d89262d5c367f50eff8d0c9f5c3d8ab6374a70c51a28997357b45bad40d4bb569d7daf3d7fb2a527a88735a8a10083abe2dc
+  data.tar.gz: c91d8eef348500108f6186bd80ba79eaaac72af42153f7a00fbb4ea05b6db91196b7b421755fe754e8ae6d05b2c560d6e2d49c172447cd2cbeb8dcd84fc77db8

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

@@ -47,9 +47,9 @@ module Async
 					self.new(chunks)
 				end
 				
-				def initialize(chunks)
+				def initialize(chunks, length = nil)
 					@chunks = chunks
-					@length = nil
+					@length = length
 					
 					@index = 0
 				end

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

@@ -53,6 +53,11 @@ module Async
 				def close
 					self.stop
 				end
+				
+				# Whether there is a body?
+				def body?
+					@body and !@body.empty?
+				end
 			end
 		end
 	end

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

@@ -27,16 +27,21 @@ module Async
 			class Streamable < Wrapper
 				def self.wrap(message, &block)
 					if message and message.body
-						message.body = self.new(message.body, block)
+						if remaining = message.headers['content-length']
+							remaining = Integer(remaining)
+						end
+						
+						message.body = self.new(message.body, block, remaining)
 					else
 						yield
 					end
 				end
 				
-				def initialize(body, callback)
+				def initialize(body, callback, remaining = nil)
 					super(body)
 					
 					@callback = callback
+					@remaining = remaining
 				end
 				
 				def stop(*)
@@ -46,7 +51,13 @@ module Async
 				end
 				
 				def read
-					unless chunk = super
+					if chunk = super
+						@remaining -= chunk.bytesize if @remaining
+					else
+						if @remaining and @remaining > 0
+							raise EOFError, "Expected #{@remaining} more bytes!"
+						end
+						
 						@callback.call
 					end
 					

data/lib/async/http/headers.rb

@@ -190,6 +190,10 @@ module Async
 					@all = all
 				end
 				
+				def << headers
+					@all << headers
+				end
+				
 				def each(&block)
 					@all.each do |headers|
 						headers.each do |key, value|

data/lib/async/http/pool.rb

@@ -18,6 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require 'async/notification'
+
 module Async
 	module HTTP
 		# Pool behaviours
@@ -36,22 +38,23 @@ module Async
 		#
 		class Pool
 			def initialize(limit = nil, &block)
-				@available = {} # resource => count
-				@waiting = []
+				@resources = {} # resource => count
+				@available = Async::Notification.new
 				
 				@limit = limit
+				@active = 0
 				
 				@constructor = block
 			end
 			
-			attr :available
+			attr :resources
 			
 			def empty?
-				@available.empty?
+				@resources.empty?
 			end
 			
 			def acquire
-				resource = wait_for_next_available
+				resource = wait_for_resource
 				
 				return resource unless block_given?
 				
@@ -62,7 +65,7 @@ module Async
 				end
 			end
 			
-			# Make the resource available and let waiting tasks know that there is something available.
+			# Make the resource resources and let waiting tasks know that there is something resources.
 			def release(resource)
 				# A resource that is not good should also not be reusable.
 				if resource.reusable?
@@ -73,55 +76,69 @@ module Async
 			end
 			
 			def close
-				@available.each_key(&:close)
-				@available.clear
+				@resources.each_key(&:close)
+				@resources.clear
+				
+				@active = 0
+			end
+			
+			def to_s
+				"\#<#{self.class} resources=#{availability_string} limit=#{@limit}>"
 			end
 			
 			protected
 			
+			def availability_string
+				@resources.collect{|resource,usage| "#{usage}/#{resource.multiplex}#{resource.good? ? '' : '*'}"}.join(";")
+			end
+			
 			def reuse(resource)
 				Async.logger.debug(self) {"Reuse #{resource}"}
 				
-				@available[resource] -= 1
+				@resources[resource] -= 1
 				
-				if task = @waiting.pop
-					task.resume
-				end
+				@available.signal
 			end
 			
 			def retire(resource)
 				Async.logger.debug(self) {"Retire #{resource}"}
 				
-				@available.delete(resource)
+				@resources.delete(resource)
+				
+				@active -= 1
 				
 				resource.close
+				
+				@available.signal
 			end
 			
-			def wait_for_next_available
-				# If we fail to create a resource (below), we will end up waiting for one to become available.
-				until resource = next_available
-					@waiting << Fiber.current
-					Task.yield
+			def wait_for_resource
+				# If we fail to create a resource (below), we will end up waiting for one to become resources.
+				until resource = available_resource
+					@available.wait
 				end
 				
+				Async.logger.debug(self) {"Wait for resource #{resource}"}
+				
 				return resource
 			end
 			
 			def create
 				# This might return nil, which means creating the resource failed.
 				if resource = @constructor.call
-					@available[resource] = 1
+					@resources[resource] = 1
 				end
 				
 				return resource
 			end
 			
-			def next_available
-				@available.each do |resource, count|
+			def available_resource
+				# This is a linear search... not idea, but simple for now.
+				@resources.each do |resource, count|
 					if count < resource.multiplex
 						# We want to use this resource... but is it good?
 						if resource.good?
-							@available[resource] += 1
+							@resources[resource] += 1
 							
 							return resource
 						else
@@ -130,11 +147,15 @@ module Async
 					end
 				end
 				
-				if !@limit or @available.count < @limit
-					Async.logger.debug(self) {"No available resources, allocating new one..."}
+				if !@limit or @active < @limit
+					Async.logger.debug(self) {"No resources resources, allocating new one..."}
+					
+					@active += 1
 					
 					return create
 				end
+				
+				return nil
 			end
 		end
 	end

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

@@ -136,7 +136,7 @@ module Async
 						return if @stream.closed?
 						
 						if response
-							write_response(self.version, response.status, response.headers, response.body)
+							write_response(self.version, response.status, response.headers, response.body, request.head?)
 						else
 							# If the request failed to generate a response, it was an internal server error:
 							write_response(self.version, 500, {}, nil)
@@ -217,10 +217,15 @@ module Async
 					return headers.delete(HOST), method, path, version, headers, body
 				end
 				
-				def write_response(version, status, headers, body)
+				def write_response(version, status, headers, body = nil, head = false)
 					@stream.write("#{version} #{status}\r\n")
 					write_headers(headers)
-					write_body(body)
+					
+					if head
+						write_body_head(body)
+					else
+						write_body(body)
+					end
 					
 					@stream.flush
 				end
@@ -265,11 +270,22 @@ module Async
 					write_persistent_header
 					@stream.write("content-length: #{length}\r\n\r\n")
 					
+					chunk_length = 0
 					body.each do |chunk|
+						chunk_length += chunk.bytesize
+						
+						if chunk_length > length
+							raise ArgumentError, "Trying to write #{chunk_length} bytes, but content length was #{length} bytes!"
+						end
+						
 						@stream.write(chunk)
 					end
 					
 					@stream.flush
+					
+					if chunk_length != length
+						raise ArgumentError, "Wrote #{chunk_length} bytes, but content length was #{length} bytes!"
+					end
 				end
 				
 				def write_chunked_body(body)
@@ -316,6 +332,18 @@ module Async
 					end
 				end
 				
+				def write_body_head(body)
+					write_persistent_header
+					
+					if body.nil? or body.empty?
+						@stream.write("content-length: 0\r\n\r\n")
+					elsif length = body.length
+						@stream.write("content-length: #{length}\r\n\r\n")
+					else
+						@stream.write("\r\n")
+					end
+				end
+				
 				def read_response_body(request, status, headers)
 					# RFC 7230 3.3.3
 					# 1.  Any response to a HEAD request and any response with a 1xx

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

@@ -27,7 +27,9 @@ module Async
 			module HTTP2
 				DEFAULT_SETTINGS = {
 					::HTTP::Protocol::HTTP2::Settings::ENABLE_PUSH => 0,
-					::HTTP::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 256
+					::HTTP::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 256,
+					::HTTP::Protocol::HTTP2::Settings::MAXIMUM_FRAME_SIZE => 0x100000,
+					::HTTP::Protocol::HTTP2::Settings::INITIAL_WINDOW_SIZE => 0x7FFFFFFF,
 				}
 				
 				def self.client(stream, settings = DEFAULT_SETTINGS)

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

@@ -85,19 +85,25 @@ module Async
 					def send_response(response)
 						if response.nil?
 							@stream.send_headers(nil, NO_RESPONSE, ::HTTP::Protocol::HTTP2::END_STREAM)
+						elsif response.body?
+							headers = Headers::Merged.new([
+								[STATUS, response.status],
+							])
+							
+							if length = response.body.length
+								headers << [[CONTENT_LENGTH, length]]
+							end
+							
+							headers << response.headers
+							
+							@stream.send_headers(nil, headers)
+							@stream.send_body(response.body)
 						else
 							headers = Headers::Merged.new([
 								[STATUS, response.status],
-								# I'm not sure whether this is a good idea. Maybe it's okay for errors?
-								# [REASON, response.reason],
 							], response.headers)
 							
-							if response.body.nil? or response.body.empty?
-								@stream.send_headers(nil, headers, ::HTTP::Protocol::HTTP2::END_STREAM)
-							else
-								@stream.send_headers(nil, headers)
-								@stream.send_body(response.body)
-							end
+							@stream.send_headers(nil, headers, ::HTTP::Protocol::HTTP2::END_STREAM)
 						end
 					end
 				end

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

@@ -26,9 +26,9 @@ module Async
 			module HTTP2
 				class Response < Protocol::Response
 					def initialize(protocol, stream_id)
-						@input = Body::Writable.new
+						@input = nil
 						
-						super(protocol.version, nil, nil, Headers.new, @input)
+						super(protocol.version, nil, nil, Headers.new, nil)
 						
 						@protocol = protocol
 						@stream = Stream.new(self, protocol, stream_id)
@@ -56,8 +56,8 @@ module Async
 							end
 						end
 						
-						if end_stream
-							@input.finish
+						unless end_stream
+							@body = @input = Body::Writable.new
 						end
 						
 						# We are ready for processing:

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.30.1"
+		VERSION = "0.30.2"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.30.1
+  version: 0.30.2
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-08-07 00:00:00.000000000 Z
+date: 2018-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async