async-http 0.18.0 → 0.19.0

data/lib/async/http/client.rb

@@ -21,6 +21,8 @@
 require 'async/io/endpoint'
 
 require_relative 'protocol'
+require_relative 'body/streamable'
+require_relative 'middleware'
 
 module Async
 	module HTTP
@@ -54,27 +56,20 @@ module Async
 				@connections.close
 			end
 			
-			VERBS = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE']
+			include Verbs
 			
-			VERBS.each do |verb|
-				define_method(verb.downcase) do |reference, *args, &block|
-					self.request(verb, reference.to_str, *args, &block)
-				end
-			end
-			
-			def request(*args, &block)
-				@connections.acquire do |connection|
-					response = connection.send_request(@authority, *args)
-					
-					begin
-						return yield response if block_given?
-					ensure
-						# This forces the stream to complete reading.
-						response.finish
-					end
-					
-					return response
+			def call(request)
+				connection = @connections.acquire
+				
+				request.authority ||= @authority
+				response = connection.call(request)
+				
+				# The connection won't be released until the body is completely read/released.
+				Body::Streamable.wrap(response) do
+					@connections.release(connection)
 				end
+				
+				return response
 			end
 			
 			protected

data/lib/async/http/content_encoding.rb

@@ -0,0 +1,71 @@
+# 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.
+
+require_relative 'middleware'
+
+require_relative 'body/buffered'
+require_relative 'body/deflate'
+
+module Async
+	module HTTP
+		# Encode a response according the the request's acceptable encodings.
+		class ContentEncoding < Middleware
+			DEFAULT_WRAPPERS = {
+				'gzip' => Body::Deflate.method(:for)
+			}
+			
+			DEFAULT_CONTENT_TYPES = %r{^(text/.*?)|(.*?/json)|(.*?/javascript)$}
+			
+			def initialize(app, content_types = DEFAULT_CONTENT_TYPES, wrappers = DEFAULT_WRAPPERS)
+				super(app)
+				
+				@content_types = content_types
+				@wrappers = wrappers
+			end
+			
+			def call(request, *)
+				response = super
+				
+				if !response.body.empty? and accept_encoding = request.headers['accept-encoding']
+					if content_type = response.headers['content-type'] and @content_types.match?(content_type)
+						# TODO use http-accept and sort by priority
+						encodings = accept_encoding.split(/\s*,\s*/)
+						
+						body = response.body
+						
+						encodings.each do |name|
+							if wrapper = @wrappers[name]
+								response.headers['content-encoding'] = name
+								
+								body = wrapper.call(body)
+								
+								break
+							end
+						end
+						
+						response.body = body
+					end
+				end
+				
+				return response
+			end
+		end
+	end
+end

data/lib/async/http/middleware.rb

@@ -0,0 +1,55 @@
+# 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
+		VERBS = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE']
+		
+		module Verbs
+			VERBS.each do |verb|
+				define_method(verb.downcase) do |location, headers = {}, body = []|
+					self.call(Request[verb, location.to_str, headers, body])
+				end
+			end
+		end
+		
+		class Middleware
+			def initialize(app)
+				@app = app
+			end
+			
+			def close
+				@app.close
+			end
+			
+			include Verbs
+			
+			def call(*args)
+				@app.call(*args)
+			end
+			
+			module Okay
+				def self.call
+					Response.local(200, {}, [])
+				end
+			end
+		end
+	end
+end

data/lib/async/http/middleware/builder.rb

@@ -0,0 +1,50 @@
+# 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 Middleware
+			class Builder
+				def initialize(default_app = nil, &block)
+					@use = []
+					@run = default_app
+					
+					instance_eval(&block) if block_given?
+				end
+				
+				def use(middleware, *args, &block)
+					@use << proc {|app| middleware.new(app, *args, &block)}
+				end
+				
+				def run(app)
+					@app = app
+				end
+				
+				def to_app
+					app = @use.reverse.inject(app) {|app, use| use.call(app).freeze}
+				end
+			end
+			
+			def self.build(&block)
+				Builder.new(&block).to_app
+			end
+		end
+	end
+end

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

@@ -38,9 +38,11 @@ module Async
 				# Server loop.
 				def receive_requests
 					while request = Request.new(*self.read_request)
-						status, headers, body = yield request
+						response = yield request
 						
-						write_response(request.version, status, headers, body)
+						response.version ||= request.version
+						
+						write_response(response.version, response.status, response.headers, response.body)
 						
 						unless keep_alive?(request.headers) && keep_alive?(headers)
 							@keep_alive = false
@@ -53,18 +55,18 @@ module Async
 				end
 				
 				def write_body(body, chunked = true)
-					buffer = String.new
-					body.each{|chunk| buffer << chunk}
-						
-					@stream.write("Content-Length: #{buffer.bytesize}\r\n\r\n")
-					@stream.write(buffer)
+					# We don't support chunked encoding.
+					super(body, false)
 				end
 				
 				def read_body(headers)
-					if content_length = headers['content-length']
-						return @stream.read(Integer(content_length))
-					# elsif !keep_alive?(headers)
-					# 	return @stream.read
+					if body = super
+						return body
+					end
+					
+					# Technically, with HTTP/1.0, if no content-length is specified, we just need to read everything until the connection is closed.
+					if !keep_alive?(headers)
+						return Body::Remainder.new(@stream)
 					end
 				end
 			end

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

@@ -23,6 +23,9 @@ require 'async/io/protocol/line'
 require_relative '../request'
 require_relative '../response'
 
+require_relative '../body/chunked'
+require_relative '../body/fixed'
+
 module Async
 	module HTTP
 		module Protocol
@@ -68,13 +71,15 @@ module Async
 					while true
 						request = Request.new(*read_request)
 						
-						status, headers, body = yield request
+						response = yield request
+						
+						response.version ||= request.version
 						
-						write_response(request.version, status, headers, body)
+						write_response(response.version, response.status, response.headers, response.body)
 						
 						request.finish
 						
-						unless keep_alive?(request.headers) and keep_alive?(headers)
+						unless keep_alive?(request.headers) and keep_alive?(response.headers)
 							@keep_alive = false
 							
 							break
@@ -85,11 +90,11 @@ module Async
 					end
 				end
 				
-				# Client request.
-				def send_request(authority, method, path, headers = {}, body = [])
-					Async.logger.debug(self) {"#{method} #{path} #{headers.inspect}"}
+				def call(request)
+					request.version ||= self.version
 					
-					write_request(authority, method, path, version, headers, body)
+					Async.logger.debug(self) {"#{request.method} #{request.path} #{request.headers.inspect}"}
+					write_request(request.authority, request.method, request.path, request.version, request.headers, request.body)
 					
 					return Response.new(*read_response)
 				rescue EOFError
@@ -158,7 +163,10 @@ module Async
 				end
 				
 				def write_body(body, chunked = true)
-					if chunked
+					if body.empty?
+						@stream.write("Content-Length: 0\r\n\r\n")
+						body.read
+					elsif chunked
 						@stream.write("Transfer-Encoding: chunked\r\n\r\n")
 						
 						body.each do |chunk|
@@ -172,19 +180,21 @@ module Async
 						
 						@stream.write("0\r\n\r\n")
 					else
-						buffer = String.new
-						body.each{|chunk| buffer << chunk}
+						body = Body::Buffered.for(body)
+						
+						@stream.write("Content-Length: #{body.bytesize}\r\n\r\n")
 						
-						@stream.write("Content-Length: #{buffer.bytesize}\r\n\r\n")
-						@stream.write(buffer)
+						body.each do |chunk|
+							@stream.write(chunk)
+						end
 					end
 				end
 				
 				def read_body(headers)
 					if headers['transfer-encoding'] == 'chunked'
-						return ChunkedBody.new(self)
+						return Body::Chunked.new(self)
 					elsif content_length = headers['content-length']
-						return FixedBody.new(Integer(content_length), @stream)
+						return Body::Fixed.new(@stream, Integer(content_length))
 					end
 				end
 			end

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

@@ -20,6 +20,7 @@
 
 require_relative '../request'
 require_relative '../response'
+require_relative '../body/writable'
 
 require 'async/notification'
 
@@ -63,12 +64,6 @@ module Async
 					@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
-					end
-					
-					@reader = read_in_background
 				end
 				
 				# Multiple requests can be processed at the same time.
@@ -80,6 +75,14 @@ module Async
 					@reader.alive?
 				end
 				
+				def version
+					VERSION
+				end
+				
+				def start_connection
+					@reader ||= read_in_background
+				end
+				
 				def read_in_background(task: Task.current)
 					task.async do |nested_task|
 						buffer = Async::IO::BinaryString.new
@@ -102,11 +105,13 @@ module Async
 					# emits new streams opened by the client
 					@controller.on(:stream) do |stream|
 						request = Request.new
-						request.version = VERSION
+						request.version = self.version
 						request.headers = {}
-						request.body = Body.new
+						body = Body::Writable.new
+						request.body = body
 						
 						stream.on(:headers) do |headers|
+							# puts "Got request headers: #{headers.inspect}"
 							headers.each do |key, value|
 								if key == METHOD
 									request.method = value
@@ -121,63 +126,66 @@ module Async
 						end
 						
 						stream.on(:data) do |chunk|
-							request.body.write(chunk.to_s) unless chunk.empty?
+							# puts "Got request data: #{chunk.inspect}"
+							body.write(chunk.to_s) unless chunk.empty?
 						end
 						
 						stream.on(:half_close) do
+							# puts "Generating response..."
 							response = yield request
 							
-							request.body.finish
+							# puts "Finishing body..."
+							body.finish
 							
+							# puts "Sending response..."
 							# send response
-							headers = {STATUS => response[0].to_s}
-							headers.update(response[1])
+							headers = {STATUS => response.status.to_s}
+							headers.update(response.headers)
 							
-							stream.headers(headers, end_stream: false)
-							
-							response[2].each do |chunk|
-								stream.data(chunk, end_stream: false)
+							# puts "Sending headers #{headers}"
+							if response.body.empty?
+								stream.headers(headers, end_stream: true)
+								response.body.read
+							else
+								stream.headers(headers, end_stream: false)
+								
+								# puts "Streaming body..."
+								response.body.each do |chunk|
+									# puts "Sending chunk #{chunk.inspect}"
+									stream.data(chunk, end_stream: false)
+								end
+								
+								# puts "Ending stream..."
+								stream.data("", end_stream: true)
 							end
-							
-							stream.data("", end_stream: true)
 						end
 					end
 					
+					start_connection
 					@reader.wait
 				end
 				
-				RESPONSE_VERSION = 'HTTP/2'.freeze
-				
-				def send_request(authority, method, path, headers = {}, body = nil)
+				def call(request)
+					request.version ||= self.version
+					
 					stream = @controller.new_stream
 					
-					internal_headers = {
+					headers = {
 						SCHEME => HTTPS,
-						METHOD => method,
-						PATH => path,
-						AUTHORITY => authority,
-					}.merge(headers)
-					
-					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
+						METHOD => request.method.to_s,
+						PATH => request.path.to_s,
+						AUTHORITY => request.authority.to_s,
+					}.merge(request.headers)
 					
 					finished = Async::Notification.new
 					
 					response = Response.new
-					response.version = RESPONSE_VERSION
+					response.version = self.version
 					response.headers = {}
-					response.body = Body.new
+					body = Body::Writable.new
+					response.body = body
 					
 					stream.on(:headers) do |headers|
-						# Async.logger.debug(self) {"Stream headers: #{headers.inspect}"}
-						
 						headers.each do |key, value|
 							if key == STATUS
 								response.status = value.to_i
@@ -192,20 +200,26 @@ module Async
 					end
 					
 					stream.on(:data) do |chunk|
-						Async.logger.debug(self) {"Stream data: #{chunk.inspect}"}
-						response.body.write(chunk.to_s) unless chunk.empty?
+						body.write(chunk.to_s) unless chunk.empty?
 					end
 					
-					stream.on(:half_close) do
-						Async.logger.debug(self) {"Stream half-closed."}
+					stream.on(:close) do
+						body.finish
 					end
 					
-					stream.on(:close) do
-						Async.logger.debug(self) {"Stream closed, sending signal."}
-						# TODO should we prefer `response.finish`?
-						response.body.finish
+					if request.body.empty?
+						stream.headers(headers, end_stream: true)
+					else
+						stream.headers(headers, end_stream: false)
+						
+						request.body.each do |chunk|
+							stream.data(chunk, end_stream: false)
+						end
+							
+						stream.data("", end_stream: true)
 					end
 					
+					start_connection
 					@stream.flush
 					
 					# Async.logger.debug(self) {"Stream flushed, waiting for signal."}