Updated (client) support for interim responses.

Author: ioquatix

async-http.gemspec

@@ -28,7 +28,7 @@ Gem::Specification.new do |spec|
 	spec.add_dependency "async-pool", "~> 0.7"
 	spec.add_dependency "io-endpoint", "~> 0.11"
 	spec.add_dependency "io-stream", "~> 0.4"
-	spec.add_dependency "protocol-http", "~> 0.29"
+	spec.add_dependency "protocol-http", "~> 0.30"
 	spec.add_dependency "protocol-http1", "~> 0.20"
 	spec.add_dependency "protocol-http2", "~> 0.18"
 	spec.add_dependency "traces", ">= 0.10"

fixtures/async/http/a_protocol.rb

@@ -44,18 +44,28 @@ module HTTP
 			with "interim response" do
 				let(:app) do
 					::Protocol::HTTP::Middleware.for do |request|
-						request.write_interim_response(
-							::Protocol::HTTP::Response[103, [["link", "</style.css>; rel=preload; as=style"]]]
-						)
+						request.send_interim_response(103, [["link", "</style.css>; rel=preload; as=style"]])
 
 						::Protocol::HTTP::Response[200, {}, ["Hello World"]]
 					end
 				end
 
 				it "can read informational response" do
-					response = client.get("/")
+					called = false
+					
+					callback = proc do |status, headers|
+						called = true
+						expect(status).to be == 103
+						expect(headers).to have_keys(
+							"link" => be == ["</style.css>; rel=preload; as=style"]
+						)
+					end
+					
+					response = client.get("/", interim_response: callback)
 					expect(response).to be(:success?)
 					expect(response.read).to be == "Hello World"
+					
+					expect(called).to be == true
 				end
 			end
 

lib/async/http/protocol/http1/request.rb

@@ -24,7 +24,7 @@ def initialize(connection, authority, method, path, version, headers, body)
 						# HTTP/1 requests with an upgrade header (which can contain zero or more values) are extracted into the protocol field of the request, and we expect a response to select one of those protocols with a status code of 101 Switching Protocols.
 						protocol = headers.delete('upgrade')
 
-						super(nil, authority, method, path, version, headers, body, protocol)
+						super(nil, authority, method, path, version, headers, body, protocol, self.public_method(:write_interim_response))
 					end
 
 					def connection
@@ -39,8 +39,8 @@ def hijack!
 						@connection.hijack!
 					end
 
-					def write_interim_response(response)
-						@connection.write_interim_response(response.version, response.status, response.headers)
+					def write_interim_response(status, headers = nil)
+						@connection.write_interim_response(@version, status, headers)
 					end
 				end
 			end

lib/async/http/protocol/http1/response.rb

@@ -17,6 +17,8 @@ def self.read(connection, request)
 
 							if response.final?
 								return response
+							else
+								request.send_interim_response(response.status, response.headers)
 							end
 						end
 					end

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

@@ -23,6 +23,8 @@ def initialize(*)
 						attr :request
 
 						def receive_initial_headers(headers, end_stream)
+							@headers = ::Protocol::HTTP::Headers.new
+							
 							headers.each do |key, value|
 								if key == SCHEME
 									raise ::Protocol::HTTP2::HeaderError, "Request scheme already specified!" if @request.scheme
@@ -85,7 +87,7 @@ def closed(error)
 					end
 
 					def initialize(stream)
-						super(nil, nil, nil, nil, VERSION, nil)
+						super(nil, nil, nil, nil, VERSION, nil, nil, nil, self.public_method(:write_interim_response))
 
 						@stream = stream
 					end
@@ -117,10 +119,6 @@ def send_response(response)
 							[STATUS, response.status],
 						]
 
-						if protocol = response.protocol
-							protocol_headers << [PROTOCOL, protocol]
-						end
-						
 						if length = response.body&.length
 							protocol_headers << [CONTENT_LENGTH, length]
 						end
@@ -142,14 +140,16 @@ def send_response(response)
 						end
 					end
 
-					def write_interim_response(response)
-						protocol_headers = [
-							[STATUS, response.status]
+					def write_interim_response(status, headers = nil)
+						interim_response_headers = [
+							[STATUS, status]
 						]
 
-						headers = ::Protocol::HTTP::Headers::Merged.new(protocol_headers, response.headers)
+						if headers
+							interim_response_headers = ::Protocol::HTTP::Headers::Merged.new(interim_response_headers, headers)
+						end
 
-						@stream.send_headers(nil, headers)
+						@stream.send_headers(nil, interim_response_headers)
 					end
 				end
 			end

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

@@ -38,18 +38,25 @@ def accept_push_promise_stream(promised_stream_id, headers)
 
 						# This should be invoked from the background reader, and notifies the task waiting for the headers that we are done.
 						def receive_initial_headers(headers, end_stream)
+							# While in theory, the response pseudo-headers may be extended in the future, currently they only response pseudo-header is :status, so we can assume it is always the first header.
+							status_header = headers.shift
+							
+							if status_header.first != ':status'
+								raise ProtocolError, "Invalid response headers: #{headers.inspect}"
+							end
+							
+							status = Integer(status_header.last)
+							
+							if status >= 100 && status < 200
+								return receive_interim_headers(status, headers)
+							end
+							
+							@response.status = status
+							@headers = ::Protocol::HTTP::Headers.new
+							
 							headers.each do |key, value|
 								# It's guaranteed that this should be the first header:
-								if key == STATUS
-									status = Integer(value)
-									
-									# Ignore informational headers:
-									return if status >= 100 && status < 200
-									
-									@response.status = Integer(value)
-								elsif key == PROTOCOL
-									@response.protocol = value
-								elsif key == CONTENT_LENGTH
+								if key == CONTENT_LENGTH
 									@length = Integer(value)
 								else
 									add_header(key, value)
@@ -74,6 +81,16 @@ def receive_initial_headers(headers, end_stream)
 							return headers
 						end
 
+						def receive_interim_headers(status, headers)
+							if headers.any?
+								headers = ::Protocol::HTTP::Headers[headers]
+							else
+								headers = nil
+							end
+							
+							@response.request.send_interim_response(status, headers)
+						end
+						
 						# Notify anyone waiting on the response headers to be received (or failure).
 						def notify!
 							if notification = @notification

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

@@ -51,10 +51,9 @@ def receive_trailing_headers(headers, end_stream)
 					end
 
 					def process_headers(frame)
-						if frame.end_stream? && @headers
+						if @headers and frame.end_stream?
 							self.receive_trailing_headers(super, frame.end_stream?)
 						else
-							@headers ||= ::Protocol::HTTP::Headers.new
 							self.receive_initial_headers(super, frame.end_stream?)
 						end
 

lib/async/http/protocol/request.rb

@@ -25,7 +25,7 @@ def hijack?
 					false
 				end
 
-				def write_interim_response(response)
+				def write_interim_response(status, headers = nil)
 				end
 
 				def peer