async-http 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c74bbff1b6216d57e8d60e5a54700f9461cef5aff2436db4abbf07c300a1af09
-  data.tar.gz: 1354a61e69f69706688f112fef4c958af285bec43172f00d7993bff7fcb9dc7b
+  metadata.gz: 9f76d14d623f95c9f57dc60a00e2200e05214149eeb2625ff632d05492981183
+  data.tar.gz: e9b9191121ca54563cae6090a28725bf00029eec28e914972f6e36d24b67b082
 SHA512:
-  metadata.gz: d62959c37bc323c82d57ca4e745ef4d2a715f3ec0e580e0d4a1e5cbdb65766f6b4c671efab4f8e85fb0fabe6a5cac99be1de1aa2cc92c30bc39e5e51f9f40d51
-  data.tar.gz: 75b83edd5bd767e638ebeacbd3446e317b24b49eba17628af95e32e78690cc0b26c8c998ed1aaed7248c8e796c7e77fd43a8c80f391fcc5876a8cd84533bdd1d
+  metadata.gz: bcdeb04bb6666ed1ccbd04cf40ffa01b37e2c8e1899c109fdb654e9bb8eb5b88a150ecd1ddbd53500eff5915e505e2e54bff6f68566a4f15324a5d6cecfa1179
+  data.tar.gz: 287f239b0e75d139c1e93f701365e7062d7e90a6c21912dd4b9d27b5d8c1211a12efcb349c0cf32de15ce04bee890a98efaf0d90d9e125415ec2eb1d6991d255

data/.travis.yml

@@ -11,6 +11,7 @@ addons:
 
 before_script:
   - gem update --system
+  - gem install bundler
 
 matrix:
   include:

data/async-http.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
 	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 	spec.require_paths = ["lib"]
 	
-	spec.add_dependency("async", "~> 1.4")
+	spec.add_dependency("async", "~> 1.5")
 	spec.add_dependency("async-io", "~> 1.6")
 	
 	spec.add_dependency("http-2", "~> 0.8")

data/lib/async/http/body.rb

@@ -0,0 +1,139 @@
+# 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 'async/queue'
+
+module Async
+	module HTTP
+		class Body < Async::Queue
+			def initialize
+				super
+				
+				@closed = false
+			end
+			
+			def closed?
+				@closed
+			end
+			
+			def each
+				return if @closed
+				
+				while chunk = self.dequeue
+					yield chunk
+				end
+				
+				@closed = true
+			end
+			
+			def read
+				buffer = Async::IO::BinaryString.new
+				
+				self.each do |chunk|
+					buffer << chunk
+				end
+				
+				return buffer
+			end
+			
+			alias join read
+			
+			def write(chunk)
+				self.enqueue(chunk)
+			end
+			
+			def close
+				self.enqueue(nil)
+			end
+		end
+		
+		class BufferedBody
+			def initialize(body)
+				@chunks = []
+				
+				body.each do |chunk|
+					@chunks << chunk
+				end
+			end
+			
+			def each(&block)
+				@chunks.each(&block)
+			end
+			
+			def read
+				@buffer ||= @chunks.join
+			end
+			
+			alias join read
+			
+			def closed?
+				true
+			end
+			
+			module Reader
+				def read
+					self.body ? self.body.read : nil
+				end
+				
+				def close
+					return if self.body.nil? or self.body.closed?
+					
+					unless self.body.is_a? BufferedBody
+						self.body = BufferedBody.new(self.body)
+					end
+				end
+			end
+		end
+		
+		class FixedBody
+			CHUNK_LENGTH = 1024*1024
+			
+			def initialize(length, stream)
+				@length = length
+				@remaining = length
+				@stream = stream
+			end
+			
+			def closed?
+				@remaining == 0
+			end
+			
+			def each
+				while @remaining > 0
+					if chunk = @stream.read(CHUNK_LENGTH)
+						@remaining -= chunk.bytesize
+						
+						yield chunk
+					end
+				end
+			end
+			
+			def read
+				buffer = @stream.read(@remaining)
+				
+				@remaining = 0
+				
+				return buffer
+			end
+			
+			alias join read
+		end
+	end
+end

data/lib/async/http/client.rb

@@ -57,14 +57,23 @@ module Async
 			VERBS = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE']
 			
 			VERBS.each do |verb|
-				define_method(verb.downcase) do |*args|
-					self.request(verb, *args)
+				define_method(verb.downcase) do |*args, &block|
+					self.request(verb, *args, &block)
 				end
 			end
 			
-			def request(*args)
+			def request(*args, &block)
 				@connections.acquire do |connection|
-					connection.send_request(@authority, *args)
+					response = connection.send_request(@authority, *args)
+					
+					begin
+						yield response if block_given?
+					ensure
+						# This forces the stream to complete reading.
+						response.close
+					end
+					
+					return response
 				end
 			end
 			

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

@@ -20,9 +20,6 @@
 
 require_relative 'http11'
 
-require_relative 'request'
-require_relative 'response'
-
 module Async
 	module HTTP
 		module Protocol
@@ -35,7 +32,7 @@ module Async
 				end
 				
 				def keep_alive?(headers)
-					headers[:connection] == KEEP_ALIVE
+					headers['connection'] == KEEP_ALIVE
 				end
 				
 				# Server loop.
@@ -64,7 +61,7 @@ module Async
 				end
 				
 				def read_body(headers)
-					if content_length = headers[:content_length]
+					if content_length = headers['content-length']
 						return @stream.read(Integer(content_length))
 					# elsif !keep_alive?(headers)
 					# 	return @stream.read

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

@@ -20,18 +20,14 @@
 
 require 'async/io/protocol/line'
 
-require_relative 'request'
-require_relative 'response'
-require_relative '../headers'
+require_relative '../request'
+require_relative '../response'
 
 module Async
 	module HTTP
 		module Protocol
 			# Implements basic HTTP/1.1 request/response.
 			class HTTP11 < Async::IO::Protocol::Line
-				CONTENT_LENGTH = Headers['Content-Length']
-				TRANSFER_ENCODING = Headers['Transfer-Encoding']
-				
 				CRLF = "\r\n".freeze
 				
 				def initialize(stream)
@@ -64,7 +60,7 @@ module Async
 				end
 				
 				def keep_alive?(headers)
-					headers[:connection] != CLOSE
+					headers['connection'] != CLOSE
 				end
 				
 				# Server loop.
@@ -125,7 +121,7 @@ module Async
 					headers = read_headers
 					body = read_body(headers)
 					
-					return headers.delete(:host), method, path, version, headers, body
+					return headers.delete('host'), method, path, version, headers, body
 				end
 				
 				def write_response(version, status, headers, body)
@@ -146,11 +142,11 @@ module Async
 					end
 				end
 				
-				def read_headers(headers = Headers.new)
+				def read_headers(headers = {})
 					# Parsing headers:
 					each_line do |line|
 						if line =~ /^([a-zA-Z\-]+):\s*(.+?)\s*$/
-							headers[$1] = $2
+							headers[$1.downcase] = $2
 						else
 							break
 						end
@@ -169,6 +165,7 @@ module Async
 							@stream.write("#{chunk.bytesize.to_s(16).upcase}\r\n")
 							@stream.write(chunk)
 							@stream.write(CRLF)
+							@stream.flush
 						end
 						
 						@stream.write("0\r\n\r\n")
@@ -176,31 +173,56 @@ module Async
 						buffer = String.new
 						body.each{|chunk| buffer << chunk}
 						
-						@stream.write("Content-Length: #{chunk.bytesize}\r\n\r\n")
-						@stream.write(chunk)
+						@stream.write("Content-Length: #{buffer.bytesize}\r\n\r\n")
+						@stream.write(buffer)
 					end
 				end
 				
-				def read_body(headers)
-					if headers[:transfer_encoding] == 'chunked'
-						buffer = Async::IO::BinaryString.new
+				class ChunkedBody
+					def initialize(protocol)
+						@protocol = protocol
+						@closed = false
+					end
+					
+					def closed?
+						@closed
+					end
+					
+					def each
+						return if @closed
 						
 						while true
-							size = read_line.to_i(16)
+							size = @protocol.read_line.to_i(16)
 							
 							if size == 0
-								read_line
-								break
+								@closed = true
+								@protocol.read_line
+								
+								return
 							end
 							
-							buffer << @stream.read(size)
+							yield @protocol.stream.read(size)
 							
-							read_line # Consume the trailing CRLF
+							@protocol.read_line # Consume the trailing CRLF
+						end
+					end
+					
+					def read
+						buffer = Async::IO::BinaryString.new
+						
+						self.each do |chunk|
+							buffer << chunk
 						end
 						
 						return buffer
-					elsif content_length = headers[:content_length]
-						return @stream.read(Integer(content_length))
+					end
+				end
+				
+				def read_body(headers)
+					if headers['transfer-encoding'] == 'chunked'
+						return ChunkedBody.new(self)
+					elsif content_length = headers['content-length']
+						return FixedBody.new(Integer(content_length), @stream)
 					end
 				end
 			end

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

@@ -18,9 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'request'
-require_relative 'response'
-require_relative '../headers'
+require_relative '../request'
+require_relative '../response'
 
 require 'async/notification'
 
@@ -46,6 +45,7 @@ module Async
 				AUTHORITY = ':authority'.freeze
 				REASON = ':reason'.freeze
 				STATUS = ':status'.freeze
+				VERSION = 'HTTP/2.0'.freeze
 				
 				def initialize(controller, stream)
 					@controller = controller
@@ -56,18 +56,19 @@ module Async
 						@stream.flush
 					end
 					
-					# @controller.on(:frame_sent) do |frame|
-					# 	Async.logger.debug(self) {"Sent frame: #{frame.inspect}"}
-					# end
-					# 
-					# @controller.on(:frame_received) do |frame|
-					# 	Async.logger.debug(self) {"Received frame: #{frame.inspect}"}
-					# end
+					@controller.on(:frame_sent) do |frame|
+						Async.logger.debug(self) {"Sent frame: #{frame.inspect}"}
+					end
+					
+					@controller.on(:frame_received) do |frame|
+						Async.logger.debug(self) {"Received frame: #{frame.inspect}"}
+					end
 					
 					if @controller.is_a? ::HTTP2::Client
 						@controller.send_connection_preface
-						@reader = read_in_background
 					end
+					
+					@reader = read_in_background
 				end
 				
 				# Multiple requests can be processed at the same time.
@@ -97,15 +98,13 @@ module Async
 					@stream.close
 				end
 				
-				def receive_requests(&block)
+				def receive_requests(task: Task.current, &block)
 					# emits new streams opened by the client
 					@controller.on(:stream) do |stream|
 						request = Request.new
-						request.version = "HTTP/2.0"
-						request.headers = Headers.new
-						
-						# stream.on(:active) { } # fires when stream transitions to open state
-						# stream.on(:close) { } # stream is closed by client and server
+						request.version = VERSION
+						request.headers = {}
+						request.body = Body.new
 						
 						stream.on(:headers) do |headers|
 							headers.each do |key, value|
@@ -121,17 +120,20 @@ module Async
 							end
 						end
 						
-						stream.on(:data) do |body|
-							request.body = body
+						stream.on(:data) do |chunk|
+							request.body.write(chunk.to_s) unless chunk.empty?
 						end
 						
 						stream.on(:half_close) do
 							response = yield request
 							
+							request.body.close
+							
 							# send response
-							stream.headers(STATUS => response[0].to_s)
+							headers = {STATUS => response[0].to_s}
+							headers.update(response[1])
 							
-							stream.headers(response[1]) unless response[1].empty?
+							stream.headers(headers, end_stream: false)
 							
 							response[2].each do |chunk|
 								stream.data(chunk, end_stream: false)
@@ -141,9 +143,7 @@ module Async
 						end
 					end
 					
-					while data = @stream.io.read(1024)
-						@controller << data
-					end
+					@reader.wait
 				end
 				
 				RESPONSE_VERSION = 'HTTP/2'.freeze
@@ -158,20 +158,22 @@ module Async
 						AUTHORITY => authority,
 					}.merge(headers)
 					
-					stream.headers(internal_headers, end_stream: true)
+					stream.headers(internal_headers, end_stream: body.nil?)
 					
-					# if body
-					# 	body.each do |chunk|
-					# 		stream.data(chunk, end_stream: false)
-					# 	end
-					# 
-					# 	stream.data("", end_stream: true)
-					# end
+					if body
+						body.each do |chunk|
+							stream.data(chunk, end_stream: false)
+						end
+						
+						stream.data("", end_stream: true)
+					end
+					
+					finished = Async::Notification.new
 					
 					response = Response.new
 					response.version = RESPONSE_VERSION
-					response.headers = Headers.new
-					response.body = Async::IO::BinaryString.new
+					response.headers = {}
+					response.body = Body.new
 					
 					stream.on(:headers) do |headers|
 						# Async.logger.debug(self) {"Stream headers: #{headers.inspect}"}
@@ -185,22 +187,22 @@ module Async
 								response.headers[key] = value
 							end
 						end
+						
+						finished.signal
 					end
 					
-					stream.on(:data) do |body|
-						# Async.logger.debug(self) {"Stream data: #{body.size} bytes"}
-						response.body << body
+					stream.on(:data) do |chunk|
+						Async.logger.debug(self) {"Stream data: #{chunk.inspect}"}
+						response.body.write(chunk.to_s) unless chunk.empty?
 					end
 					
-					finished = Async::Notification.new
-					
 					stream.on(:half_close) do
-						# Async.logger.debug(self) {"Stream half-closed."}
+						Async.logger.debug(self) {"Stream half-closed."}
 					end
 					
 					stream.on(:close) do
-						# Async.logger.debug(self) {"Stream closed, sending signal."}
-						finished.signal
+						Async.logger.debug(self) {"Stream closed, sending signal."}
+						response.body.close
 					end
 					
 					@stream.flush

data/lib/async/http/{protocol/request.rb → request.rb}

@@ -18,14 +18,12 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative 'body'
+
 module Async
 	module HTTP
-		module Protocol
-			class Request < Struct.new(:authority, :method, :path, :version, :headers, :body)
-				def read
-					@body
-				end
-			end
+		class Request < Struct.new(:authority, :method, :path, :version, :headers, :body)
+			include BufferedBody::Reader
 		end
 	end
 end

data/lib/async/http/{protocol/response.rb → response.rb}

@@ -18,26 +18,28 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative 'body'
+
 module Async
 	module HTTP
-		module Protocol
-			class Response < Struct.new(:version, :status, :reason, :headers, :body)
-				def continue?
-					status == 100
-				end
-				
-				def success?
-					status >= 200 && status < 300
-				end
-				
-				def redirection?
-					status >= 300 && status < 400
-				end
-				
-				def failure?
-					status >= 400 && status < 600
-				end
+		class Response < Struct.new(:version, :status, :reason, :headers, :body)
+			def continue?
+				status == 100
+			end
+			
+			def success?
+				status >= 200 && status < 300
+			end
+			
+			def redirection?
+				status >= 300 && status < 400
+			end
+			
+			def failure?
+				status >= 400 && status < 600
 			end
+			
+			include BufferedBody::Reader
 		end
 	end
 end

data/lib/async/http/server.rb

@@ -25,9 +25,13 @@ require_relative 'protocol'
 module Async
 	module HTTP
 		class Server
-			def initialize(endpoint, protocol_class = Protocol::HTTP1)
+			def initialize(endpoint, protocol_class = Protocol::HTTP1, &block)
 				@endpoint = endpoint
-				@protocol_class = protocol_class
+				@protocol_class = protocol_class || endpoint.protocol
+				
+				if block_given?
+					self.define_singleton_method(:handle_request, block)
+				end
 			end
 			
 			def handle_request(request, peer, address)

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.10.0"
+		VERSION = "0.12.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-28 00:00:00.000000000 Z
+date: 2018-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.5'
 - !ruby/object:Gem::Dependency
   name: async-io
   requirement: !ruby/object:Gem::Requirement
@@ -124,8 +124,8 @@ files:
 - Rakefile
 - async-http.gemspec
 - lib/async/http.rb
+- lib/async/http/body.rb
 - lib/async/http/client.rb
-- lib/async/http/headers.rb
 - lib/async/http/pool.rb
 - lib/async/http/protocol.rb
 - lib/async/http/protocol/http1.rb
@@ -133,8 +133,8 @@ files:
 - lib/async/http/protocol/http11.rb
 - lib/async/http/protocol/http2.rb
 - lib/async/http/protocol/https.rb
-- lib/async/http/protocol/request.rb
-- lib/async/http/protocol/response.rb
+- lib/async/http/request.rb
+- lib/async/http/response.rb
 - lib/async/http/server.rb
 - lib/async/http/url_endpoint.rb
 - lib/async/http/version.rb

data/lib/async/http/headers.rb

@@ -1,85 +0,0 @@
-# Copyright, 2017, 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.
-
-module Async
-	module HTTP
-		class Headers
-			def initialize
-				@hash = {}
-			end
-			
-			def freeze
-				return unless frozen?
-				
-				@hash.freeze
-				
-				super
-			end
-			
-			def inspect
-				@hash.inspect
-			end
-			
-			def []= key, value
-				@hash[symbolize(key)] = value
-			end
-			
-			def [] key
-				@hash[key]
-			end
-			
-			def == other
-				@hash == other.to_hash
-			end
-			
-			def delete(key)
-				@hash.delete(key)
-			end
-			
-			def each
-				return to_enum unless block_given?
-				
-				@hash.each do |key, value|
-					yield stringify(key), value
-				end
-			end
-			
-			def symbolize(value)
-				Headers[value]
-			end
-			
-			def stringify(key)
-				key.to_s.tr('_', '-')
-			end
-			
-			def to_hash
-				@hash
-			end
-			
-			def to_http_hash
-				Hash[@hash.map{|key, value| ["HTTP_#{key.to_s.upcase}", value]}]
-			end
-			
-			def self.[] value
-				value.downcase.tr('-', '_').to_sym
-			end
-		end
-	end
-end