async-http 0.72.0 → 0.74.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b358f54acd8cf0943e35f30865d7f505025bad37a2c37e0dda5f8438efe3b25
-  data.tar.gz: a8a9eee82cc0723cf8101ef727072d4518a38ddb7e68f5f0f2d15027e92e83a9
+  metadata.gz: 5a21c7008b5509bd6f8bdffd7dad87a7679bdc9f32584cc71fa2b468518cd57c
+  data.tar.gz: 2836fc0ef066dfeb60240dce08dd88c07201250b948cfb04617ab52e9d20371c
 SHA512:
-  metadata.gz: 7f5720d8ac42c48afb19bd5c387db2da015b2d210836c6d1a7abfe3cd3a4df85587c92b9bbdee61fce397302c66c8ca303c123d9e7f9a2201b26602ea0240e58
-  data.tar.gz: 91a543963515d1375953da096781b7b9d5a161e20bafc6aa067fbf0e09ff546ae3b48e18a5d8ca06dc5173184546898d415310b6bfbded5605040bce08443010
+  metadata.gz: c249984efd9030c199c6b1199dfb4ededdd25a7db33e5156c0ecec2a5d883d703bc976216da13c33426d4814514676f80296687293c53cb4ddc33f44ff4f38a3
+  data.tar.gz: f707e1908dc79b1e16f2be6546f1781003f4d88e21307fd5172d27198b61a08f87e350a43f784445a761cda89cb674669b552e77ef1e9de4cfaeb4095040ffa9

checksums.yaml.gz.sig

@@ -1 +1,2 @@
-&���_��lB�k�M��ϟ��D��Ɋ�`��n�-��v�3��>�W��#O$�|a��S��O�n�r:ׯ�U9l�<���E��0|R�j�8z?��h��n���
@V��a��f�0�^L��sr�R�S�/��2؛�.ps)Ho��GSB����f�5G����&�Zr�
+B��[�����`x�~A PC8_�'�w�m�uQ����g��%~��{�6|��mP"+��uxwL��Vx���W�K��^�a�&��߸L�F�{OW�]pY<|�ޕCŷ&�]wM�E�RkP$ce����X\�"�MI�kbU��f�V?$J���P~t�ؒ���w~�u+���M�����s���(,%`����~,�d��K�!�StG��			���D�jۓ+^��-���~���"�\�Z�7ȽU�L�C%D3L)�q��A�6[]ʐG�=ga�^rs��6�LQ=�CL�����bQ7�g&�㑋C�?(m�N�9�IT��l@Q���
++yy�m�O.��u05T,�zTBX�{O��H��[����G�	�

data/lib/async/http/internet.rb

@@ -39,14 +39,14 @@ module Async
 			# @parameter url [String] The URL to request, e.g. `https://www.codeotaku.com`.
 			# @parameter headers [Hash | Protocol::HTTP::Headers] The headers to send with the request.
 			# @parameter body [String | Protocol::HTTP::Body] The body to send with the request.
-			def call(method, url, headers = nil, body = nil, &block)
+			def call(verb, url, *arguments, **options, &block)
 				endpoint = Endpoint[url]
 				client = self.client_for(endpoint)
 				
-				body = Body::Buffered.wrap(body)
-				headers = ::Protocol::HTTP::Headers[headers]
+				options[:authority] ||= endpoint.authority
+				options[:scheme] ||= endpoint.scheme
 				
-				request = ::Protocol::HTTP::Request.new(endpoint.scheme, endpoint.authority, method, endpoint.path, nil, headers, body)
+				request = ::Protocol::HTTP::Request[verb, endpoint.path, *arguments, **options]
 				
 				response = client.call(request)
 				
@@ -68,8 +68,8 @@ module Async
 			end
 			
 			::Protocol::HTTP::Methods.each do |name, verb|
-				define_method(verb.downcase) do |url, headers = nil, body = nil, &block|
-					self.call(verb, url, headers, body, &block)
+				define_method(verb.downcase) do |url, *arguments, **options, &block|
+					self.call(verb, url, *arguments, **options, &block)
 				end
 			end
 			

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

@@ -24,7 +24,7 @@ module Async
 						# 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 @@ module Async
 						@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

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

@@ -17,6 +17,8 @@ module Async
 							
 							if response.final?
 								return response
+							else
+								request.send_interim_response(response.status, response.headers)
 							end
 						end
 					end

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

@@ -23,6 +23,8 @@ module Async
 						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 @@ module Async
 					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 @@ module Async
 							[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 @@ module Async
 						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

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

@@ -38,18 +38,25 @@ module Async
 						
 						# 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 @@ module Async
 							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

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

@@ -51,10 +51,9 @@ module Async
 					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
 						

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

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

data/lib/async/http/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.72.0"
+		VERSION = "0.74.0"
 	end
 end

data/readme.md

@@ -12,6 +12,18 @@ Please see the [project documentation](https://socketry.github.io/async-http/) f
 
   - [Testing](https://socketry.github.io/async-http/guides/testing/index) - This guide explains how to use `Async::HTTP` clients and servers in your tests.
 
+## Releases
+
+Please see the [project releases](https://socketry.github.io/async-http/releases/index) for all releases.
+
+### v0.74.0
+
+  - [`Async::HTTP::Internet` accepts keyword arguments](https://socketry.github.io/async-http/releases/index#async::http::internet-accepts-keyword-arguments)
+
+### v0.73.0
+
+  - [Update support for `interim_response`](https://socketry.github.io/async-http/releases/index#update-support-for-interim_response)
+
 ## See Also
 
   - [benchmark-http](https://github.com/socketry/benchmark-http) — A benchmarking tool to report on web server concurrency.

data/releases.md

@@ -0,0 +1,51 @@
+# Releases
+
+## v0.74.0
+
+### `Async::HTTP::Internet` accepts keyword arguments
+
+`Async::HTTP::Internet` now accepts keyword arguments for making a request, e.g.
+
+``` ruby
+internet = Async::HTTP::Internet.instance
+
+# This will let you override the authority (HTTP/1.1 host header, HTTP/2 :authority header):
+internet.get("https://proxy.local", authority: "example.com")
+
+# This will let you override the scheme:
+internet.get("https://example.com", scheme: "http")
+```
+
+## v0.73.0
+
+### Update support for `interim_response`
+
+`Protocol::HTTP::Request` now supports an `interim_response` callback, which will be called with the interim response status and headers. This works on both the client and the server:
+
+``` ruby
+# Server side:
+def call(request)
+	if request.headers['expect'].include?('100-continue')
+		request.send_interim_response(100)
+	end
+	
+	# ...
+end
+
+# Client side:
+body = Async::HTTP::Body::Writable.new
+
+interim_repsonse = proc do |status, headers|
+	if status == 100
+		# Continue sending the body...
+		body.write("Hello, world!")
+		body.close
+	end
+end
+
+Async::HTTP::Internet.instance.post("https://example.com", body, interim_response: interim_response) do |response|
+	unless response.success?
+		body.close
+	end
+end
+```

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.72.0
+  version: 0.74.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -58,7 +58,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-08-29 00:00:00.000000000 Z
+date: 2024-08-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -122,14 +122,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.29'
+        version: '0.30'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.29'
+        version: '0.30'
 - !ruby/object:Gem::Dependency
   name: protocol-http1
   requirement: !ruby/object:Gem::Requirement
@@ -224,6 +224,7 @@ files:
 - lib/async/http/version.rb
 - license.md
 - readme.md
+- releases.md
 homepage: https://github.com/socketry/async-http
 licenses:
 - MIT