async-http 0.18.0 → 0.19.0

data/lib/async/http/reference.rb

@@ -0,0 +1,173 @@
+# 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.
+
+module Async
+	module HTTP
+		# A relative reference, excluding any authority.
+		class Reference
+			def initialize(path, query_string, fragment, parameters)
+				@path = path
+				@query_string = query_string
+				@fragment = fragment
+				@parameters = parameters
+			end
+			
+			def self.[] reference
+				if reference.is_a? self
+					return reference
+				else
+					return self.parse(reference)
+				end
+			end
+			
+			# Generate a reference from a path and user parameters. The path may contain a `#fragment` or `?query=parameters`.
+			def self.parse(path = '/', parameters = nil)
+				base, fragment = path.split('#', 2)
+				path, query_string = base.split('?', 2)
+				
+				self.new(path, query_string, fragment, parameters)
+			end
+			
+			# The path component, e.g. /foo/bar/index.html
+			attr :path
+			
+			# The un-parsed query string, e.g. 'x=10&y=20'
+			attr :query_string
+			
+			# A fragment, the part after the '#'
+			attr :fragment
+			
+			# User supplied parameters that will be appended to the query part.
+			attr :parameters
+			
+			def append(buffer)
+				if @query_string
+					buffer << escape_path(@path) << '?' << query_string
+					buffer << '&' << encode(@parameters) if @parameters
+				else
+					buffer << escape_path(@path)
+					buffer << '?' << encode(@parameters) if @parameters
+				end
+				
+				if @fragment
+					buffer << '#' << escape(@fragment)
+				end
+				
+				return buffer
+			end
+			
+			def to_str
+				append(String.new)
+			end
+			
+			alias to_s to_str
+			
+			def + other
+				other = self.class[other]
+				
+				self.class.new(
+					expand_path(self.path, other.path),
+					other.query_string,
+					other.fragment,
+					other.parameters,
+				)
+			end
+			
+			def [] parameters
+				self.dup(nil, parameters)
+			end
+			
+			def dup(path = nil, parameters = nil)
+				if parameters and @parameters
+					parameters = @parameters.merge(parameters)
+				else
+					parameters = @parameters
+				end
+				
+				if path
+					path = @path + '/' + path
+				else
+					path = @path
+				end
+				
+				self.class.new(path, @query_string, @fragment, parameters)
+			end
+			
+			private
+			
+			def expand_path(base, relative)
+				if relative.start_with? '/'
+					return relative
+				else
+					path = base.split('/')
+					parts = relative.split('/')
+					
+					parts.each do |part|
+						if part == '..'
+							path.pop
+						else
+							path << part
+						end
+					end
+					
+					return path.join('/')
+				end
+			end
+			
+			# Escapes a generic string, using percent encoding.
+			def escape(string)
+				encoding = string.encoding
+				string.b.gsub(/([^a-zA-Z0-9_.\-]+)/) do |m|
+					'%' + m.unpack('H2' * m.bytesize).join('%').upcase
+				end.force_encoding(encoding)
+			end
+			
+			# According to https://tools.ietf.org/html/rfc3986#section-3.3, we escape non-pchar.
+			NON_PCHAR = /([^a-zA-Z0-9_\-\.~!$&'()*+,;=:@\/]+)/.freeze
+			
+			# Escapes a path
+			def escape_path(path)
+				encoding = path.encoding
+				path.b.gsub(NON_PCHAR) do |m|
+					'%' + m.unpack('H2' * m.bytesize).join('%').upcase
+				end.force_encoding(encoding)
+			end
+			
+			# Encodes a hash or array into a query string
+			def encode(value, prefix = nil)
+				case value
+				when Array
+					value.map { |v|
+						encode(v, "#{prefix}[]")
+					}.join("&")
+				when Hash
+					value.map { |k, v|
+						encode(v, prefix ? "#{prefix}[#{escape(k.to_s)}]" : escape(k.to_s))
+					}.reject(&:empty?).join('&')
+				when nil
+					prefix
+				else
+					raise ArgumentError, "value must be a Hash" if prefix.nil?
+					"#{prefix}=#{escape(value.to_s)}"
+				end
+			end
+		end
+	end
+end

data/lib/async/http/relative_location.rb

@@ -0,0 +1,75 @@
+# 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 'client'
+require_relative 'url_endpoint'
+
+require_relative 'reference'
+
+module Async
+	module HTTP
+		# A client wrapper which transparently handles both relative and absolute redirects to a given maximum number of hops.
+		class RelativeLocation < Middleware
+			DEFAULT_METHOD = 'GET'.freeze
+			
+			def initialize(app, maximum_hops = 4)
+				super(app)
+				
+				@maximum_hops = maximum_hops
+			end
+			
+			# The maximum number of hops which will limit the number of redirects until an error is thrown.
+			attr :maximum_hops
+			
+			def call(request)
+				hops = 0
+				
+				# We need to cache the body as it might be submitted multiple times.
+				request.finish
+				
+				while hops < @maximum_hops
+					response = super(request)
+					hops += 1
+						
+					if response.redirection?
+						response.finish
+						
+						location = response.headers['location']
+						uri = URI.parse(location)
+						
+						if uri.absolute?
+							return response
+						else
+							request.path = Reference[request.path] + location
+						end
+						
+						unless response.preserve_method?
+							request.method = DEFAULT_METHOD
+						end
+					else
+						return response
+					end
+				end
+				
+				raise ArgumentError, "Redirected #{hops} times, exceeded maximum!"
+			end
+		end
+	end
+end

data/lib/async/http/request.rb

@@ -18,12 +18,18 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'body'
+require_relative 'body/buffered'
 
 module Async
 	module HTTP
 		class Request < Struct.new(:authority, :method, :path, :version, :headers, :body)
-			include BufferedBody::Reader
+			prepend Body::Buffered::Reader
+			
+			def self.[](method, path, headers, body)
+				body = Body::Buffered.wrap(body)
+				
+				self.new(nil, method, path, nil, headers, body)
+			end
 		end
 	end
 end

data/lib/async/http/response.rb

@@ -18,11 +18,13 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative 'body'
+require_relative 'body/buffered'
 
 module Async
 	module HTTP
 		class Response < Struct.new(:version, :status, :reason, :headers, :body)
+			prepend Body::Buffered::Reader
+			
 			def continue?
 				status == 100
 			end
@@ -43,7 +45,15 @@ module Async
 				status >= 400 && status < 600
 			end
 			
-			include BufferedBody::Reader
+			def self.[](status, headers = {}, body = [])
+				body = Body::Buffered.wrap(body)
+				
+				self.new(nil, status, nil, headers, body)
+			end
+			
+			def self.for_exception(exception)
+				Async::HTTP::Response[500, {'content-type' => 'text/plain'}, ["#{exception.class}: #{exception.message}"]]
+			end
 		end
 	end
 end

data/lib/async/http/server.rb

@@ -21,6 +21,8 @@
 require 'async/io/endpoint'
 
 require_relative 'protocol'
+require_relative 'response'
+
 
 module Async
 	module HTTP
@@ -30,12 +32,12 @@ module Async
 				@protocol_class = protocol_class || endpoint.protocol
 				
 				if block_given?
-					self.define_singleton_method(:handle_request, block)
+					define_singleton_method(:handle_request, block)
 				end
 			end
 			
 			def handle_request(request, peer, address)
-				[200, {"Content-Type" => "text/plain"}, ["Hello World"]]
+				Response[200, {}, []]
 			end
 			
 			def accept(peer, address, task: Task.current)

data/lib/async/http/statistics.rb

@@ -0,0 +1,131 @@
+# 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_relative 'body/wrapper'
+
+require 'async/clock'
+
+module Async
+	module HTTP
+		class Statistics
+			def self.start
+				self.new(Clock.now)
+			end
+			
+			def initialize(start_time)
+				@start_time = start_time
+			end
+			
+			def wrap(response, &block)
+				response.body = Body::Statistics.new(@start_time, response.body, block)
+			end
+		end
+		
+		module Body
+			# Invokes a callback once the body has finished reading.
+			class Statistics < Wrapper
+				def initialize(start_time, body, callback)
+					super(body)
+					
+					@bytesize = 0
+					
+					@start_time = start_time
+					@first_chunk_time = nil
+					@end_time = nil
+					
+					@callback = callback
+				end
+				
+				attr :start_time
+				attr :first_chunk_time
+				attr :end_time
+				
+				attr :bytesize
+				
+				def total_duration
+					if @end_time
+						@end_time - @start_time
+					end
+				end
+				
+				def first_chunk_duration
+					if @first_chunk_time
+						@first_chunk_time - @start_time
+					end
+				end
+				
+				def stop(error)
+					complete_statistics(error)
+					
+					super
+				end
+				
+				def read
+					chunk = super
+					
+					@first_chunk_time ||= Clock.now
+					
+					if chunk
+						@bytesize += chunk.bytesize
+					else
+						complete_statistics
+					end
+					
+					return chunk
+				end
+				
+				def to_s
+					parts = ["sent #{@bytesize} bytes"]
+					
+					if duration = self.total_duration
+						parts << "took #{format_duration(duration)} in total"
+					end
+					
+					if duration = self.first_chunk_duration
+						parts << "took #{format_duration(duration)} until first chunk"
+					end
+					
+					return parts.join('; ')
+				end
+				
+				def inspect
+					"#{super} | \#<#{self.class} #{self.to_s}>"
+				end
+				
+				private
+				
+				def complete_statistics(error = nil)
+					@end_time = Clock.now
+					
+					@callback.call(self, error) if @callback
+				end
+				
+				def format_duration(seconds)
+					if seconds < 1.0
+						seconds * 1000.0
+						return "#{(seconds * 1000.0).round(2)}ms"
+					else
+						return "#{seconds.round(1)}s"
+					end
+				end
+			end
+		end
+	end
+end