async-http 0.22.0 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9747cc8b9879031adf8d9e6086942e69955ff33ca04a598bac893f6a04588680
-  data.tar.gz: d4dca36355247bfdd1c5162493813ffc2eaf815b1a9d8c6297fed08069a3c15e
+  metadata.gz: 4977069f03e3535e44a463522d754edc6c625e24af2e520f7707f8684467145c
+  data.tar.gz: 85ec5b67a4ac4aef7c0c04c8226ebb91fd986c1174e34fe90cf65b684eed967d
 SHA512:
-  metadata.gz: d3060ef8cf5a1dc5524c8170437cfdc1a027446737ab199daed129d9d5cb8230e3df0b228c4a8259c2b2f70d0221419c1261707097d9f0a32104a13980716aef
-  data.tar.gz: 9ef10b59d8e2b27295dccc8eef3db0b60052bcf01497d124e1eae16e4d2a9d129e29acd29de71f17ffedf0ae431b2f31b1fa1ba8ec404c88663fc2aecb92982c
+  metadata.gz: ce1d3da79cb8f4ded9270f3a48bbde841a4770c43636ef0d6336b61e587c80c93ce3ebe58711c912ffbe2c158ce2ac2c7a20d50203f17d1304bb406eafb41b98
+  data.tar.gz: 8f46167cd368f92067805a9d828a3ece309c5ecde97edf4966b26a41d60eb9ee21e09ec5b01a39aea415bb48ce1f42df66bcd9f3d232b7736610b52089939967

data/async-http.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
 	spec.require_paths = ["lib"]
 	
 	spec.add_dependency("async", "~> 1.6")
-	spec.add_dependency("async-io", "~> 1.9")
+	spec.add_dependency("async-io", "~> 1.10")
 	
 	spec.add_dependency("http-2", "~> 0.9.0")
 	# spec.add_dependency("openssl")

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

@@ -42,6 +42,11 @@ module Async
 				
 				# Read the next available chunk.
 				def read
+					# I'm not sure if this is a good idea (*).
+					# if @stopped
+					# 	raise @stopped
+					# end
+					
 					return if @finished
 					
 					unless chunk = @queue.dequeue
@@ -58,6 +63,8 @@ module Async
 				
 				# Write a single chunk to the body. Signal completion by calling `#finish`.
 				def write(chunk)
+					# If the reader breaks, the writer will break.
+					# The inverse of this is less obvious (*)
 					if @stopped
 						raise @stopped
 					end

data/lib/async/http/client.rb

@@ -27,12 +27,13 @@ require_relative 'middleware'
 module Async
 	module HTTP
 		class Client
-			def initialize(endpoint, protocol = nil, authority = nil, **options)
+			def initialize(endpoint, protocol = nil, authority = nil, retries: 3, **options)
 				@endpoint = endpoint
 				
 				@protocol = protocol || endpoint.protocol
 				@authority = authority || endpoint.hostname
 				
+				@retries = retries
 				@connections = connect(**options)
 			end
 			
@@ -60,21 +61,39 @@ module Async
 			
 			def call(request)
 				request.authority ||= @authority
+				attempt = 0
 				
-				# As we cache connections, it's possible these connections go bad (e.g. closed by remote host). In this case, we need to try again. It's up to the caller to impose a timeout on this.
-				while true
+				begin
+					attempt += 1
+					
+					# As we cache connections, it's possible these connections go bad (e.g. closed by remote host). In this case, we need to try again. It's up to the caller to impose a timeout on this.
 					connection = @connections.acquire
 					
-					if 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
+					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
+				rescue Protocol::RequestFailed
+					# This is a specific case where the entire request wasn't sent before a failure occurred. So, we can even resend non-idempotent requests.
+					@connections.release(connection)
+					
+					attempt += 1
+					if attempt < @retries
+						retry
+					else
+						raise
+					end
+				rescue
+					@connections.release(connection)
+					
+					if request.idempotent? and attempt < @retries
+						retry
 					else
-						# The connection failed for some reason, we close it.
-						connection.close
+						raise
 					end
 				end
 			end

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

@@ -25,34 +25,40 @@ module Async
 		module Protocol
 			# Implements basic HTTP/1.1 request/response.
 			class HTTP10 < HTTP11
-				VERSION = "HTTP/1.0".freeze
 				KEEP_ALIVE = 'keep-alive'.freeze
 				
+				VERSION = "HTTP/1.0".freeze
+				
 				def version
 					VERSION
 				end
 				
 				def persistent?(headers)
-					headers['connection'] == KEEP_ALIVE
+					headers.delete(CONNECTION) == KEEP_ALIVE
 				end
 				
 				# Server loop.
-				def receive_requests
-					while request = Request.new(*self.read_request)
+				def receive_requests(task: Task.current)
+					while @persistent
+						request = Request.new(*self.read_request)
+						
+						unless persistent?(request.headers)
+							@persistent = false
+						end
+						
 						response = yield request
 						
 						response.version ||= request.version
 						
 						write_response(response.version, response.status, response.headers, response.body)
 						
-						unless persistent?(request.headers) && persistent?(headers)
-							@persistent = false
-							
-							break
-						end
+						# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
+						task.yield
 					end
-					
-					return false
+				end
+				
+				def write_persistent_header
+					@stream.write("Connection: keep-alive\r\n") if @persistent
 				end
 				
 				def write_body(body, chunked = false)
@@ -66,7 +72,7 @@ module Async
 					end
 					
 					# Technically, with HTTP/1.0, if no content-length is specified, we just need to read everything until the connection is closed.
-					if !persistent?(headers)
+					unless @persistent
 						return Body::Remainder.new(@stream)
 					end
 				end

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

@@ -20,6 +20,8 @@
 
 require 'async/io/protocol/line'
 
+require_relative 'request_failed'
+
 require_relative '../request'
 require_relative '../response'
 require_relative '../headers'
@@ -33,6 +35,11 @@ module Async
 			# Implements basic HTTP/1.1 request/response.
 			class HTTP11 < Async::IO::Protocol::Line
 				CRLF = "\r\n".freeze
+				CONNECTION = 'connection'.freeze
+				HOST = 'host'.freeze
+				CLOSE = 'close'.freeze
+				
+				VERSION = "HTTP/1.1".freeze
 				
 				def initialize(stream)
 					super(stream, CRLF)
@@ -49,7 +56,7 @@ module Async
 				end
 				
 				def reusable?
-					@persistent
+					@persistent && !@stream.closed?
 				end
 				
 				class << self
@@ -57,23 +64,22 @@ module Async
 					alias client new
 				end
 				
-				CLOSE = 'close'.freeze
-				
-				VERSION = "HTTP/1.1".freeze
-				
 				def version
 					VERSION
 				end
 				
 				def persistent?(headers)
-					headers['connection'] != CLOSE
+					headers.delete(CONNECTION) != CLOSE
 				end
 				
 				# Server loop.
 				def receive_requests(task: Task.current)
-					while true
+					while @persistent
 						request = Request.new(*read_request)
-						@count += 1
+						
+						unless persistent?(request.headers)
+							@persistent = false
+						end
 						
 						response = yield request
 						
@@ -83,41 +89,41 @@ module Async
 						
 						request.finish
 						
-						unless persistent?(request.headers) and persistent?(response.headers)
-							@persistent = false
-							
-							break
-						end
-						
 						# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
 						task.yield
 					end
 				end
 				
 				def call(request)
-					@count += 1
-					
 					request.version ||= self.version
 					
 					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)
+					
+					# We carefully interpret https://tools.ietf.org/html/rfc7230#section-6.3.1 to implement this correctly.
+					begin
+						write_request(request.authority, request.method, request.path, request.version, request.headers)
+					rescue
+						# If we fail to fully write the request and body, we can retry this request.
+						raise RequestFailed.new
+					end
+					
+					# Once we start writing the body, we can't recover if the request fails. That's because the body might be generated dynamically, streaming, etc.
+					write_body(request.body)
 					
 					return Response.new(*read_response)
 				rescue EOFError
-					Async.logger.debug(self) {"Connection failed with EOFError after #{@count} requests."}
-					return nil
+					# This will ensure that #reusable? returns false.
+					@stream.close
+					
+					raise
 				end
 				
-				def write_request(authority, method, path, version, headers, body)
+				def write_request(authority, method, path, version, headers)
 					@stream.write("#{method} #{path} #{version}\r\n")
 					@stream.write("Host: #{authority}\r\n")
-					
 					write_headers(headers)
-					write_body(body)
 					
 					@stream.flush
-					
-					return true
 				end
 				
 				def read_response
@@ -125,6 +131,8 @@ module Async
 					headers = read_headers
 					body = read_body(headers)
 					
+					@count += 1
+					
 					@persistent = persistent?(headers)
 					
 					return version, Integer(status), reason, headers, body
@@ -135,7 +143,9 @@ module Async
 					headers = read_headers
 					body = read_body(headers)
 					
-					return headers.delete('host'), method, path, version, headers, body
+					@count += 1
+					
+					return headers.delete(HOST), method, path, version, headers, body
 				end
 				
 				def write_response(version, status, headers, body)
@@ -144,16 +154,20 @@ module Async
 					write_body(body)
 					
 					@stream.flush
-					
-					return true
 				end
 				
 				protected
 				
+				def write_persistent_header
+					@stream.write("Connection: close\r\n") unless @persistent
+				end
+				
 				def write_headers(headers)
 					headers.each do |name, value|
 						@stream.write("#{name}: #{value}\r\n")
 					end
+					
+					write_persistent_header
 				end
 				
 				def read_headers
@@ -196,6 +210,8 @@ module Async
 							@stream.write(chunk)
 						end
 					end
+					
+					@stream.flush
 				end
 				
 				def read_body(headers)

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

@@ -66,6 +66,13 @@ module Async
 						Async.logger.debug(self) {"Received frame: #{frame.inspect}"}
 					end
 					
+					@controller.on(:goaway) do |payload|
+						Async.logger.error(self) {"goaway: #{payload.inspect}"}
+						
+						@reader.stop
+						@stream.io.close
+					end
+					
 					@count = 0
 				end
 				
@@ -77,7 +84,7 @@ module Async
 				end
 				
 				def reusable?
-					@reader.alive?
+					!@stream.closed?
 				end
 				
 				def version
@@ -102,15 +109,14 @@ module Async
 				
 				def close
 					Async.logger.debug(self) {"Closing connection"}
-					@reader.stop
+					
+					@reader.stop if @reader
 					@stream.close
 				end
 				
 				def receive_requests(task: Task.current, &block)
 					# emits new streams opened by the client
 					@controller.on(:stream) do |stream|
-						@count += 1
-						
 						request = Request.new
 						request.version = self.version
 						request.headers = Headers.new
@@ -136,33 +142,40 @@ module Async
 							body.write(chunk.to_s) unless chunk.empty?
 						end
 						
+						stream.on(:close) do |error|
+							if error
+								body.stop(EOFError.new(error))
+							end
+						end
+						
 						stream.on(:half_close) do
-							# puts "Generating response..."
-							response = yield request
-							
-							# puts "Finishing body..."
-							body.finish
-							
-							# puts "Sending response..."
-							# send response
-							headers = {STATUS => response.status.to_s}
-							headers.update(response.headers)
-							
-							# puts "Sending headers #{headers}"
-							if response.body.nil? or response.body.empty?
-								stream.headers(headers, end_stream: true)
-								response.body.read if response.body
-							else
-								stream.headers(headers, end_stream: false)
+							begin
+								# We are no longer receiving any more data frames:
+								body.finish
+								
+								# Generate the response:
+								response = yield request
 								
-								# puts "Streaming body..."
-								response.body.each do |chunk|
-									# puts "Sending chunk #{chunk.inspect}"
-									stream.data(chunk, end_stream: false)
+								headers = {STATUS => response.status.to_s}
+								headers.update(response.headers)
+								
+								if response.body.nil? or response.body.empty?
+									stream.headers(headers, end_stream: true)
+									response.body.read if response.body
+								else
+									stream.headers(headers, end_stream: false)
+									
+									response.body.each do |chunk|
+										stream.data(chunk, end_stream: false)
+									end
+									
+									stream.data("", end_stream: true)
 								end
+							rescue
+								Async.logger.error(self) {$!}
 								
-								# puts "Ending stream..."
-								stream.data("", end_stream: true)
+								# Generating the response failed.
+								stream.close(:internal_error)
 							end
 						end
 					end
@@ -172,11 +185,10 @@ module Async
 				end
 				
 				def call(request)
-					@count += 1
-					
 					request.version ||= self.version
 					
 					stream = @controller.new_stream
+					@count += 1
 					
 					headers = {
 						SCHEME => HTTPS,
@@ -187,6 +199,7 @@ module Async
 					
 					finished = Async::Notification.new
 					
+					exception = nil
 					response = Response.new
 					response.version = self.version
 					response.headers = {}
@@ -204,6 +217,16 @@ module Async
 							end
 						end
 						
+						# At this point, we are now expecting two events: data and close.
+						stream.on(:close) do |error|
+							# If we receive close after this point, it's not a request error, but a failure we need to signal to the body.
+							if error
+								body.stop(EOFError.new(error))
+							else
+								body.finish
+							end
+						end
+						
 						finished.signal
 					end
 					
@@ -211,15 +234,23 @@ module Async
 						body.write(chunk.to_s) unless chunk.empty?
 					end
 					
-					stream.on(:close) do
-						body.finish
+					stream.on(:close) do |error|
+						# The remote server has closed the connection while we were sending the request.
+						if error
+							exception = EOFError.new(error)
+							finished.signal
+						end
 					end
 					
 					if request.body.nil? or request.body.empty?
 						stream.headers(headers, end_stream: true)
 						request.body.read if request.body
 					else
-						stream.headers(headers, end_stream: false)
+						begin
+							stream.headers(headers, end_stream: false)
+						rescue
+							raise RequestFailed.new
+						end
 						
 						request.body.each do |chunk|
 							stream.data(chunk, end_stream: false)
@@ -231,10 +262,14 @@ module Async
 					start_connection
 					@stream.flush
 					
-					# Async.logger.debug(self) {"Stream flushed, waiting for signal."}
+					Async.logger.debug(self) {"Stream flushed, waiting for signal."}
 					finished.wait
 					
-					# Async.logger.debug(self) {"Stream finished: #{response.inspect}"}
+					if exception
+						raise exception
+					end
+					
+					Async.logger.debug(self) {"Stream finished: #{response.inspect}"}
 					return response
 				end
 			end

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

@@ -0,0 +1,29 @@
+# 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
+		module Protocol
+			# Failed to send the request. The request body has NOT been consumed (i.e. #read) and you should retry the request.
+			class RequestFailed < StandardError
+			end
+		end
+	end
+end

data/lib/async/http/request.rb

@@ -30,6 +30,10 @@ module Async
 				
 				self.new(nil, method, path, nil, headers, body)
 			end
+			
+			def idempotent?
+				method != 'POST' && (body.nil? || body.empty?)
+			end
 		end
 	end
 end

data/lib/async/http/server.rb

@@ -46,7 +46,7 @@ module Async
 				stream = Async::IO::Stream.new(peer)
 				protocol = @protocol_class.server(stream)
 				
-				# Async.logger.debug(self) {"Incoming connnection from #{address.inspect}"}
+				Async.logger.debug(self) {"Incoming connnection from #{address.inspect} to #{protocol}"}
 				
 				hijack = catch(:hijack) do
 					protocol.receive_requests do |request|
@@ -62,7 +62,7 @@ module Async
 					hijack.call(peer)
 				end
 			rescue EOFError, Errno::ECONNRESET, Errno::EPIPE
-				# Sometimes client will disconnect without completing a result or reading the entire buffer.
+				# Sometimes client will disconnect without completing a result or reading the entire buffer. That means we are done.
 			end
 			
 			def run

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.22.0"
+		VERSION = "0.23.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.22.0
+  version: 0.23.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-30 00:00:00.000000000 Z
+date: 2018-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.10'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.9'
+        version: '1.10'
 - !ruby/object:Gem::Dependency
   name: http-2
   requirement: !ruby/object:Gem::Requirement
@@ -146,6 +146,7 @@ files:
 - lib/async/http/protocol/http11.rb
 - lib/async/http/protocol/http2.rb
 - lib/async/http/protocol/https.rb
+- lib/async/http/protocol/request_failed.rb
 - lib/async/http/reference.rb
 - lib/async/http/relative_location.rb
 - lib/async/http/request.rb