async-http 0.73.0 → 0.75.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01cf4d909911a28f4f386982504e5865d9053210af1cb121a4acc8e0812a63bd
-  data.tar.gz: 20b913990be812792c72f5e68649ee8084310112287e316c438c6a220cee9982
+  metadata.gz: 946e45fa80db4dc1a3416f91a6533d58e7e4c5b8e7db9a687b922e9161f84dcf
+  data.tar.gz: 7810dfb04b6c120e91660c4cabec884ef531bb4b4078c149558a6190314f88cb
 SHA512:
-  metadata.gz: 6b1eefc4c6f0d1a631c1b6f0365ae36a7fe4067e1b372f334473b99f379f0755d29d53a5a04183f5eef46a9c0cf6504a2a56b7c5741757700b44d5c2283fb129
-  data.tar.gz: 1ed32dc7b17b30ddd2d842e688e89df28a0cc51a0610398ea567191c6158c5adde2ebdd337035450fca499b0c312e2d9b3bed616f9cf1058c1d136bbdd10acd4
+  metadata.gz: 456325793d94251a8b8b117000361e512c23aad9ce03dd2df6c387a35405ac83a7cae1b0de270bf0264485ab98ff5fff3778d720845fe26753950bedd1066b38
+  data.tar.gz: de2cb3749808740c03bd0d0d6cfe5facb3282d26f8465ddeb734158389cfdd70b2bf5610a01bf1d4f0af44fdc1d6c15249f912942038778e9f38217e96ad9c84

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/client.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 require_relative 'connection'
 
@@ -33,22 +33,16 @@ module Async
 							
 							if protocol = request.protocol
 								# This is a very tricky apect of handling HTTP/1 upgrade connections. In theory, this approach is a bit inefficient, because we spin up a task just to handle writing to the underlying stream when we could be writing to the stream directly. But we need to maintain some level of compatibility with HTTP/2. Additionally, we don't know if the upgrade request will be accepted, so starting to write the body at this point needs to be handled with care.
-								task.async do |subtask|
-									subtask.annotate("Upgrading request.")
-									
+								task.async(annotation: "Upgrading request...") do
 									# If this fails, this connection will be closed.
 									write_upgrade_body(protocol, body)
 								end
 							elsif request.connect?
-								task.async do |subtask|
-									subtask.annotate("Tunnelling body.")
-									
+								task.async(annotation: "Tunnneling request...") do
 									write_tunnel_body(@version, body)
 								end
 							else
-								task.async do |subtask|
-									subtask.annotate("Streaming body.")
-									
+								task.async(annotation: "Streaming request...") do
 									# 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(@version, body, false, trailer)
 								end

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

@@ -59,33 +59,42 @@ module Async
 								if response
 									trailer = response.headers.trailer!
 									
-									write_response(@version, response.status, response.headers)
-									
 									# Some operations in this method are long running, that is, it's expected that `body.call(stream)` could literally run indefinitely. In order to facilitate garbage collection, we want to nullify as many local variables before calling the streaming body. This ensures that the garbage collection can clean up as much state as possible during the long running operation, so we don't retain objects that are no longer needed.
-
+									
 									if body and protocol = response.protocol
+										# We force a 101 response if the protocol is upgraded - HTTP/2 CONNECT will return 200 for success, but this won't be understood by HTTP/1 clients:
+										write_response(@version, 101, response.headers)
+										
 										stream = write_upgrade_body(protocol)
 										
 										# At this point, the request body is hijacked, so we don't want to call #finish below.
-										request = response = nil
-										
-										body.call(stream)
-									elsif request.connect? and response.success?
-										stream = write_tunnel_body(request.version)
-										
-										# Same as above:
-										request = response = nil
-										
-										body.call(stream)
-									else
-										head = request.head?
-										version = request.version
-										
-										# Same as above:
 										request = nil unless request.body
 										response = nil
 										
-										write_body(version, body, head, trailer)
+										# We must return here as no further request processing can be done:
+										return body.call(stream)
+									else
+										write_response(@version, response.status, response.headers)
+										
+										if request.connect? and response.success?
+											stream = write_tunnel_body(request.version)
+											
+											# Same as above:
+											request = nil unless request.body
+											response = nil
+											
+											# We must return here as no further request processing can be done:
+											return body.call(stream)
+										else
+											head = request.head?
+											version = request.version
+											
+											# Same as above:
+											request = nil unless request.body
+											response = nil
+											
+											write_body(version, body, head, trailer)
+										end
 									end
 									
 									# We are done with the body, you shouldn't need to call close on it:

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

@@ -66,14 +66,14 @@ module Async
 					end
 					
 					def close(error = nil)
-						super
-						
 						# Ensure the reader task is stopped.
 						if @reader
 							reader = @reader
 							@reader = nil
 							reader.stop
 						end
+						
+						super
 					end
 					
 					def read_in_background(parent: Task.current)
@@ -101,6 +101,8 @@ module Async
 							ensure
 								# Don't call #close twice.
 								if @reader
+									@reader = nil
+									
 									self.close(error)
 								end
 							end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 require_relative '../request'
 require_relative 'stream'

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
 
 require_relative '../response'
 require_relative 'stream'
@@ -54,6 +54,11 @@ module Async
 							@response.status = status
 							@headers = ::Protocol::HTTP::Headers.new
 							
+							# If the protocol request was successful, ensure the response protocol matches:
+							if status == 200 and protocol = @response.request.protocol
+								@response.protocol = Array(protocol).first
+							end
+							
 							headers.each do |key, value|
 								# It's guaranteed that this should be the first header:
 								if key == CONTENT_LENGTH
@@ -118,7 +123,7 @@ module Async
 							
 							@exception = error
 							
-							notify!
+							self.notify!
 						end
 					end
 					

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2023, by Samuel Williams.
+# Copyright, 2017-2024, by Samuel Williams.
 
 require 'protocol/http/request'
 require 'protocol/http/headers'

data/lib/async/http/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.73.0"
+		VERSION = "0.75.0"
 	end
 end

data/readme.md

@@ -12,6 +12,22 @@ 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.75.0
+
+  - Better handling of HTTP/1 \<-\> HTTP/2 proxying, specifically upgrade/CONNECT requests.
+
+### 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,55 @@
+# Releases
+
+## v0.75.0
+
+  - Better handling of HTTP/1 \<-\> HTTP/2 proxying, specifically upgrade/CONNECT requests.
+
+## 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.73.0
+  version: 0.75.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -58,7 +58,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-08-31 00:00:00.000000000 Z
+date: 2024-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -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