async-http 0.68.0 → 0.70.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 232e7394f119e448ebf2e16f2064d660ba164c852a23dc6d15c7cd7d3984d4de
-  data.tar.gz: 27bf2b400b9b4bab65cb2fee22ec75ed0ff74210fb61d53a1932ab3d8c6e9615
+  metadata.gz: f049c61bc6afdaebb893a682209ac35e761efa9a4ef6aea5759e276153a4da80
+  data.tar.gz: 0334a7f914b12caafa97e7ab00ea3e02845c8451c52c159bbd625ecc9a8f9d51
 SHA512:
-  metadata.gz: ab4cf960886ec3f8efdd0587fef2214213d09aabd8501d8c2fb212da706c78c2df73fe9dff7ce0d882945727fd7dc6635650658a5b84421b07257d94c5a2d435
-  data.tar.gz: 70aea8682c576a672afc7b0f009f03a2ed8fadfe33c5e39e668754d9c6dd3d0e875d40734447d3983d8b11f0b5e92ce275d282766844e2552431476a74837b0f
+  metadata.gz: 93188a2d18c3991ac8e1b7306dc26ea552b7094b1683c3c6434ee2b76951c4fa725a280438026cd410ccd1229efd36bbf337173241688e61552a8c9c23f5d07c
+  data.tar.gz: e0cc2b44db653d9770facff7958a512bb56da5483b07348bc12af17b76fec7cfc22e95a2d3d5fdcb608edac47591304c04e6ab558e5ae07fff816d125d3e0379

data/lib/async/http/endpoint.rb

@@ -4,6 +4,8 @@
 # Copyright, 2019-2024, by Samuel Williams.
 # Copyright, 2021-2022, by Adam Daniels.
 # Copyright, 2024, by Thomas Morgan.
+# Copyright, 2024, by Igor Sidorov.
+# Copyright, 2024, by Hal Brodigan.
 
 require 'io/endpoint'
 require 'io/endpoint/host_endpoint'
@@ -16,6 +18,13 @@ module Async
 	module HTTP
 		# Represents a way to connect to a remote HTTP server.
 		class Endpoint < ::IO::Endpoint::Generic
+			SCHEMES = {
+				'http' => URI::HTTP,
+				'https' => URI::HTTPS,
+				'ws' => URI::WS,
+				'wss' => URI::WSS,
+			}
+			
 			def self.parse(string, endpoint = nil, **options)
 				url = URI.parse(string).normalize
 				
@@ -23,9 +32,15 @@ module Async
 			end
 			
 			# Construct an endpoint with a specified scheme, hostname, optional path, and options.
+			#
+			# @parameter scheme [String] The scheme to use, e.g. "http" or "https".
+			# @parameter hostname [String] The hostname to connect to (or bind to).
+			# @parameter *options [Hash] Additional options, passed to {#initialize}.
 			def self.for(scheme, hostname, path = "/", **options)
 				# TODO: Consider using URI.for once it becomes available:
-				uri_klass = URI.scheme_list[scheme.upcase] || URI::HTTP
+				uri_klass = SCHEMES.fetch(scheme.downcase) do
+					raise ArgumentError, "Unsupported scheme: #{scheme.inspect}"
+				end
 				
 				self.new(
 					uri_klass.new(scheme, nil, hostname, nil, nil, path, nil, nil, nil).normalize,
@@ -39,7 +54,7 @@ module Async
 				if url.is_a?(Endpoint)
 					return url
 				else
-					Endpoint.parse(url.to_str)
+					Endpoint.parse(url.to_s)
 				end
 			end
 			

data/lib/async/http/internet/instance.rb

@@ -1,16 +1,27 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021-2023, by Samuel Williams.
+# Copyright, 2021-2024, by Samuel Williams.
 
 require_relative '../internet'
-require 'thread/local'
+
+::Thread.attr_accessor :async_http_internet_instance
 
 module Async
 	module HTTP
 		class Internet
-			# Provide access to a shared thread-local instance.
-			extend ::Thread::Local
+			# The global instance of the internet.
+			def self.instance
+				::Thread.current.async_http_internet_instance ||= self.new
+			end
+			
+			class << self
+				::Protocol::HTTP::Methods.each do |name, verb|
+					define_method(verb.downcase) do |url, headers = nil, body = nil, &block|
+						self.instance.call(verb, url, headers, body, &block)
+					end
+				end
+			end
 		end
 	end
 end

data/lib/async/http/internet.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2018-2024, by Samuel Williams.
+# Copyright, 2024, by Igor Sidorov.
 
 require_relative 'client'
 require_relative 'endpoint'
@@ -38,7 +39,7 @@ 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)
+			def call(method, url, headers = nil, body = nil, &block)
 				endpoint = Endpoint[url]
 				client = self.client_for(endpoint)
 				
@@ -47,7 +48,15 @@ module Async
 				
 				request = ::Protocol::HTTP::Request.new(endpoint.scheme, endpoint.authority, method, endpoint.path, nil, headers, body)
 				
-				return client.call(request)
+				response = client.call(request)
+				
+				return response unless block_given?
+				
+				begin
+					yield response
+				ensure
+					response.close
+				end
 			end
 			
 			def close
@@ -59,8 +68,8 @@ module Async
 			end
 			
 			::Protocol::HTTP::Methods.each do |name, verb|
-				define_method(verb.downcase) do |url, headers = nil, body = nil|
-					self.call(verb, url, headers, body)
+				define_method(verb.downcase) do |url, headers = nil, body = nil, &block|
+					self.call(verb, url, headers, body, &block)
 				end
 			end
 			

data/lib/async/http/middleware/location_redirector.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2018-2023, by Samuel Williams.
+# Copyright, 2019-2020, by Brian Morearty.
+
+require_relative '../reference'
+
+require 'protocol/http/middleware'
+require 'protocol/http/body/rewindable'
+
+module Async
+	module HTTP
+		module Middleware
+			# A client wrapper which transparently handles redirects to a given maximum number of hops.
+			#
+			# The default implementation will only follow relative locations (i.e. those without a scheme) and will switch to GET if the original request was not a GET.
+			#
+			# The best reference for these semantics is defined by the [Fetch specification](https://fetch.spec.whatwg.org/#http-redirect-fetch).
+			#
+			# | Redirect using GET                        | Permanent | Temporary |
+			# |:-----------------------------------------:|:---------:|:---------:|
+			# | Allowed                                   | 301       | 302       |
+			# | Preserve original method                  | 308       | 307       |
+			#
+			# For the specific details of the redirect handling, see:
+			# - <https://datatracker.ietf.org/doc/html/rfc7231#section-6-4-2> 301 Moved Permanently.
+			# - <https://datatracker.ietf.org/doc/html/rfc7231#section-6-4-3> 302 Found.
+			# - <https://datatracker.ietf.org/doc/html/rfc7538 308 Permanent Redirect.
+			# - <https://datatracker.ietf.org/doc/html/rfc7231#section-6-4-7> 307 Temporary Redirect.
+			#
+			class LocationRedirector < ::Protocol::HTTP::Middleware
+				class TooManyRedirects < StandardError
+				end
+				
+				# Header keys which should be deleted when changing a request from a POST to a GET as defined by <https://fetch.spec.whatwg.org/#request-body-header-name>.
+				PROHIBITED_GET_HEADERS = [
+					'content-encoding',
+					'content-language',
+					'content-location',
+					'content-type',
+				]
+				
+				# maximum_hops is the max number of redirects. Set to 0 to allow 1 request with no redirects.
+				def initialize(app, maximum_hops = 3)
+					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 redirect_with_get?(request, response)
+					# We only want to switch to GET if the request method is something other than get, e.g. POST.
+					if request.method != GET
+						# According to the RFC, we should only switch to GET if the response is a 301 or 302:
+						return response.status == 301 || response.status == 302
+					end
+				end
+				
+				# Handle a redirect to a relative location.
+				#
+				# @parameter request [Protocol::HTTP::Request] The original request, which you can modify if you want to handle the redirect.
+				# @parameter location [String] The relative location to redirect to.
+				# @returns [Boolean] True if the redirect was handled, false if it was not.
+				def handle_redirect(request, location)
+					uri = URI.parse(location)
+					
+					if uri.absolute?
+						return false
+					end
+					
+					# Update the path of the request:
+					request.path = Reference[request.path] + location
+					
+					# Follow the redirect:
+					return true
+				end
+				
+				def call(request)
+					# We don't want to follow redirects for HEAD requests:
+					return super if request.head?
+					
+					if body = request.body
+						if body.respond_to?(:rewind)
+							# The request body was already rewindable, so use it as is:
+							body = request.body
+						else
+							# The request body was not rewindable, and we might need to resubmit it if we get a response status of 307 or 308, so make it rewindable:
+							body = ::Protocol::HTTP::Body::Rewindable.new(body)
+							request.body = body
+						end
+					end
+					
+					hops = 0
+					
+					while hops <= @maximum_hops
+						response = super(request)
+						
+						if response.redirection?
+							hops += 1
+							
+							# Get the redirect location:
+							unless location = response.headers['location']
+								return response
+							end
+							
+							response.finish
+							
+							unless handle_redirect(request, location)
+								return response
+							end
+							
+							# Ensure the request (body) is finished and set to nil before we manipulate the request:
+							request.finish
+							
+							if request.method == GET or response.preserve_method?
+								# We (might) need to rewind the body so that it can be submitted again:
+								body&.rewind
+								request.body = body
+							else
+								# We are changing the method to GET:
+								request.method = GET
+								
+								# We will no longer be submitting the body:
+								body = nil
+								
+								# Remove any headers which are not allowed in a GET request:
+								PROHIBITED_GET_HEADERS.each do |header|
+									request.headers.delete(header)
+								end
+							end
+						else
+							return response
+						end
+					end
+					
+					raise TooManyRedirects, "Redirected #{hops} times, exceeded maximum!"
+				end
+			end
+		end
+	end
+end

data/lib/async/http/mock/endpoint.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative '../protocol'
+
+require 'async/queue'
+
+module Async
+	module HTTP
+		module Mock
+			# This is an endpoint which bridges a client with a local server.
+			class Endpoint
+				def initialize(protocol = Protocol::HTTP2, scheme = "http", authority = "localhost", queue: Queue.new)
+					@protocol = protocol
+					@scheme = scheme
+					@authority = authority
+					
+					@queue = queue
+				end
+				
+				attr :protocol
+				attr :scheme
+				attr :authority
+				
+				# Processing incoming connections
+				# @yield [::HTTP::Protocol::Request] the requests as they come in.
+				def run(parent: Task.current, &block)
+					while peer = @queue.dequeue
+						server = @protocol.server(peer)
+						
+						parent.async do
+							server.each(&block)
+						end
+					end
+				end
+				
+				def connect
+					local, remote = ::Socket.pair(Socket::AF_UNIX, Socket::SOCK_STREAM)
+					
+					@queue.enqueue(remote)
+					
+					return local
+				end
+				
+				def wrap(endpoint)
+					self.class.new(@protocol, endpoint.scheme, endpoint.authority, queue: @queue)
+				end
+			end
+		end
+	end
+end

data/lib/async/http/mock.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'mock/endpoint'

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

@@ -2,6 +2,7 @@
 
 # Released under the MIT License.
 # Copyright, 2024, by Thomas Morgan.
+# Copyright, 2024, by Samuel Williams.
 
 require_relative 'http1'
 require_relative 'http2'

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

@@ -31,7 +31,8 @@ module Async
 						@connection = connection
 						@reason = reason
 						
-						protocol = headers.delete(UPGRADE)
+						# Technically, there should never be more than one value for the upgrade header, but we'll just take the first one to avoid complexity.
+						protocol = headers.delete(UPGRADE)&.first
 						
 						super(version, status, headers, body, protocol)
 					end

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

@@ -60,9 +60,9 @@ module Async
 								# If a response was generated, send it:
 								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
@@ -89,7 +89,7 @@ module Async
 										
 										write_body(version, body, head, trailer)
 									end
-
+									
 									# We are done with the body, you shouldn't need to call close on it:
 									body = nil
 								else

data/lib/async/http/relative_location.rb

@@ -4,116 +4,15 @@
 # Copyright, 2018-2023, by Samuel Williams.
 # Copyright, 2019-2020, by Brian Morearty.
 
-require_relative 'client'
-require_relative 'endpoint'
-require_relative 'reference'
+require_relative 'middleware/location_redirector'
 
-require 'protocol/http/middleware'
-require 'protocol/http/body/rewindable'
+warn "`Async::HTTP::RelativeLocation` is deprecated and will be removed in the next release. Please use `Async::HTTP::Middleware::LocationRedirector` instead.", uplevel: 1
 
 module Async
 	module HTTP
-		class TooManyRedirects < StandardError
-		end
-		
-		# A client wrapper which transparently handles both relative and absolute redirects to a given maximum number of hops.
-		#
-		# The best reference for these semantics is defined by the [Fetch specification](https://fetch.spec.whatwg.org/#http-redirect-fetch).
-		#
-		# | Redirect using GET                        | Permanent | Temporary |
-		# |:-----------------------------------------:|:---------:|:---------:|
-		# | Allowed                                   | 301       | 302       |
-		# | Preserve original method                  | 308       | 307       |
-		#
-		# For the specific details of the redirect handling, see:
-		# - <https://datatracker.ietf.org/doc/html/rfc7231#section-6-4-2> 301 Moved Permanently.
-		# - <https://datatracker.ietf.org/doc/html/rfc7231#section-6-4-3> 302 Found.
-		# - <https://datatracker.ietf.org/doc/html/rfc7538 308 Permanent Redirect.
-		# - <https://datatracker.ietf.org/doc/html/rfc7231#section-6-4-7> 307 Temporary Redirect.
-		#
-		class RelativeLocation < ::Protocol::HTTP::Middleware
-			# Header keys which should be deleted when changing a request from a POST to a GET as defined by <https://fetch.spec.whatwg.org/#request-body-header-name>.
-			PROHIBITED_GET_HEADERS = [
-				'content-encoding',
-				'content-language',
-				'content-location',
-				'content-type',
-			]
-			
-			# maximum_hops is the max number of redirects. Set to 0 to allow 1 request with no redirects.
-			def initialize(app, maximum_hops = 3)
-				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 redirect_with_get?(request, response)
-				# We only want to switch to GET if the request method is something other than get, e.g. POST.
-				if request.method != GET
-					# According to the RFC, we should only switch to GET if the response is a 301 or 302:
-					return response.status == 301 || response.status == 302
-				end
-			end
-			
-			def call(request)
-				# We don't want to follow redirects for HEAD requests:
-				return super if request.head?
-				
-				if body = request.body
-					# We need to cache the body as it might be submitted multiple times if we get a response status of 307 or 308:
-					body = ::Protocol::HTTP::Body::Rewindable.new(body)
-					request.body = body
-				end
-				
-				hops = 0
-				
-				while hops <= @maximum_hops
-					response = super(request)
-					
-					if response.redirection?
-						hops += 1
-						
-						# Get the redirect location:
-						unless location = response.headers['location']
-							return response
-						end
-						
-						response.finish
-						
-						uri = URI.parse(location)
-						
-						if uri.absolute?
-							return response
-						else
-							request.path = Reference[request.path] + location
-						end
-						
-						if request.method == GET or response.preserve_method?
-							# We (might) need to rewind the body so that it can be submitted again:
-							body&.rewind
-						else
-							# We are changing the method to GET:
-							request.method = GET
-							
-							# Clear the request body:
-							request.finish
-							body = nil
-							
-							# Remove any headers which are not allowed in a GET request:
-							PROHIBITED_GET_HEADERS.each do |header|
-								request.headers.delete(header)
-							end
-						end
-					else
-						return response
-					end
-				end
-				
-				raise TooManyRedirects, "Redirected #{hops} times, exceeded maximum!"
-			end
+		module Middleware
+			RelativeLocation = Middleware::LocationRedirector
+			TooManyRedirects = RelativeLocation::TooManyRedirects
 		end
 	end
 end

data/lib/async/http/server.rb

@@ -64,7 +64,7 @@ module Async
 				connection&.close
 			end
 			
-			# @returns [Array(Async::Task)] The task that is running the server.
+			# @returns [Async::Task] The task that is running the server.
 			def run
 				Async do |task|
 					@endpoint.accept(&self.method(:accept))

data/lib/async/http/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.68.0"
+		VERSION = "0.70.0"
 	end
 end

data/lib/async/http.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2023, by Samuel Williams.
+# Copyright, 2017-2024, by Samuel Williams.
 
 require_relative 'http/version'
 
 require_relative 'http/client'
 require_relative 'http/server'
 
+require_relative 'http/internet'
+
 require_relative 'http/endpoint'

data/license.md

@@ -7,7 +7,7 @@ Copyright, 2019, by Denis Talakevich.
 Copyright, 2019-2020, by Brian Morearty.  
 Copyright, 2019, by Cyril Roelandt.  
 Copyright, 2020, by Stefan Wrobel.  
-Copyright, 2020, by Igor Sidorov.  
+Copyright, 2020-2024, by Igor Sidorov.  
 Copyright, 2020, by Bruno Sutic.  
 Copyright, 2020, by Sam Shadwell.  
 Copyright, 2020, by Orgad Shaneh.  
@@ -21,6 +21,7 @@ Copyright, 2023-2024, by Thomas Morgan.
 Copyright, 2023, by dependabot[bot].  
 Copyright, 2023, by Josh Huber.  
 Copyright, 2024, by Anton Zhuravsky.  
+Copyright, 2024, by Hal Brodigan.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/readme.md

@@ -4,358 +4,13 @@ An asynchronous client and server implementation of HTTP/1.0, HTTP/1.1 and HTTP/
 
 [![Development Status](https://github.com/socketry/async-http/workflows/Test/badge.svg)](https://github.com/socketry/async-http/actions?workflow=Test)
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-``` ruby
-gem 'async-http'
-```
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install async-http
-
 ## Usage
 
-Please see the [project documentation](https://socketry.github.io/async-http/) or serve it locally using `bake utopia:project:serve`.
-
-### Post JSON data
-
-Here is an example showing how to post a data structure as JSON to a remote resource:
-
-``` ruby
-#!/usr/bin/env ruby
-
-require 'json'
-require 'async'
-require 'async/http/internet'
-
-data = {'life' => 42}
-
-Async do
-	# Make a new internet:
-	internet = Async::HTTP::Internet.new
-	
-	# Prepare the request:
-	headers = [['accept', 'application/json']]
-	body = [JSON.dump(data)]
-	
-	# Issues a POST request:
-	response = internet.post("https://httpbin.org/anything", headers, body)
-	
-	# Save the response body to a local file:
-	pp JSON.parse(response.read)
-ensure
-	# The internet is closed for business:
-	internet.close
-end
-```
-
-Consider using [async-rest](https://github.com/socketry/async-rest) instead.
-
-### Multiple Requests
-
-To issue multiple requests concurrently, you should use a barrier, e.g.
-
-``` ruby
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/barrier'
-require 'async/http/internet'
-
-TOPICS = ["ruby", "python", "rust"]
-
-Async do
-	internet = Async::HTTP::Internet.new
-	barrier = Async::Barrier.new
-	
-	# Spawn an asynchronous task for each topic:
-	TOPICS.each do |topic|
-		barrier.async do
-			response = internet.get "https://www.google.com/search?q=#{topic}"
-			puts "Found #{topic}: #{response.read.scan(topic).size} times."
-		end
-	end
-	
-	# Ensure we wait for all requests to complete before continuing:
-	barrier.wait
-ensure
-	internet&.close
-end
-```
-
-#### Limiting Requests
-
-If you need to limit the number of simultaneous requests, use a semaphore.
-
-``` ruby
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/barrier'
-require 'async/semaphore'
-require 'async/http/internet'
-
-TOPICS = ["ruby", "python", "rust"]
-
-Async do
-	internet = Async::HTTP::Internet.new
-	barrier = Async::Barrier.new
-	semaphore = Async::Semaphore.new(2, parent: barrier)
-	
-	# Spawn an asynchronous task for each topic:
-	TOPICS.each do |topic|
-		semaphore.async do
-			response = internet.get "https://www.google.com/search?q=#{topic}"
-			puts "Found #{topic}: #{response.read.scan(topic).size} times."
-		end
-	end
-	
-	# Ensure we wait for all requests to complete before continuing:
-	barrier.wait
-ensure
-	internet&.close
-end
-```
-
-### Persistent Connections
-
-To keep connections alive, install the `thread-local` gem,
-require `async/http/internet/instance`, and use the `instance`, e.g.
-
-``` ruby
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/http/internet/instance'
-
-Async do
-  internet = Async::HTTP::Internet.instance
-	response = internet.get "https://www.google.com/search?q=test"
-	puts "Found #{response.read.size} results."
-end
-```
-
-### Downloading a File
-
-Here is an example showing how to download a file and save it to a local path:
-
-``` ruby
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/http/internet'
-
-Async do
-	# Make a new internet:
-	internet = Async::HTTP::Internet.new
-	
-	# Issues a GET request to Google:
-	response = internet.get("https://www.google.com/search?q=kittens")
-	
-	# Save the response body to a local file:
-	response.save("/tmp/search.html")
-ensure
-	# The internet is closed for business:
-	internet.close
-end
-```
-
-### Basic Client/Server
+Please see the [project documentation](https://socketry.github.io/async-http/) for more details.
 
-Here is a basic example of a client/server running in the same reactor:
+  - [Getting Started](https://socketry.github.io/async-http/guides/getting-started/index) - This guide explains how to get started with `Async::HTTP`.
 
-``` ruby
-#!/usr/bin/env ruby
-
-require 'async'
-require 'async/http/server'
-require 'async/http/client'
-require 'async/http/endpoint'
-require 'async/http/protocol/response'
-
-endpoint = Async::HTTP::Endpoint.parse('http://127.0.0.1:9294')
-
-app = lambda do |request|
-	Protocol::HTTP::Response[200, {}, ["Hello World"]]
-end
-
-server = Async::HTTP::Server.new(app, endpoint)
-client = Async::HTTP::Client.new(endpoint)
-	
-Async do |task|
-	server_task = task.async do
-		server.run
-	end
-	
-	response = client.get("/")
-	
-	puts response.status
-	puts response.read
-	
-	server_task.stop
-end
-```
-
-### Advanced Verification
-
-You can hook into SSL certificate verification to improve server verification.
-
-``` ruby
-require 'async'
-require 'async/http'
-
-# These are generated from the certificate chain that the server presented.
-trusted_fingerprints = {
-	"dac9024f54d8f6df94935fb1732638ca6ad77c13" => true,
-	"e6a3b45b062d509b3382282d196efe97d5956ccb" => true,
-	"07d63f4c05a03f1c306f9941b8ebf57598719ea2" => true,
-	"e8d994f44ff20dc78dbff4e59d7da93900572bbf" => true,
-}
-
-Async do
-	endpoint = Async::HTTP::Endpoint.parse("https://www.codeotaku.com/index")
-	
-	# This is a quick hack/POC:
-	ssl_context = endpoint.ssl_context
-	
-	ssl_context.verify_callback = proc do |verified, store_context|
-		certificate = store_context.current_cert
-		fingerprint = OpenSSL::Digest::SHA1.new(certificate.to_der).to_s
-		
-		if trusted_fingerprints.include? fingerprint
-			true
-		else
-			Console.logger.warn("Untrusted Certificate Fingerprint"){fingerprint}
-			false
-		end
-	end
-	
-	endpoint = endpoint.with(ssl_context: ssl_context)
-	
-	client = Async::HTTP::Client.new(endpoint)
-	
-	response = client.get(endpoint.path)
-	
-	pp response.status, response.headers.fields, response.read
-end
-```
-
-### Timeouts
-
-Here's a basic example with a timeout:
-
-``` ruby
-#!/usr/bin/env ruby
-
-require 'async/http/internet'
-
-Async do |task|
-	internet = Async::HTTP::Internet.new
-	
-	# Request will timeout after 2 seconds
-	task.with_timeout(2) do
-		response = internet.get "https://httpbin.org/delay/10"
-	end
-rescue Async::TimeoutError
-	puts "The request timed out"
-ensure
-	internet&.close
-end
-```
-
-## Performance
-
-On a 4-core 8-thread i7, running `ab` which uses discrete (non-keep-alive) connections:
-
-    $ ab -c 8 -t 10 http://127.0.0.1:9294/
-    This is ApacheBench, Version 2.3 <$Revision: 1757674 $>
-    Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
-    Licensed to The Apache Software Foundation, http://www.apache.org/
-    
-    Benchmarking 127.0.0.1 (be patient)
-    Completed 5000 requests
-    Completed 10000 requests
-    Completed 15000 requests
-    Completed 20000 requests
-    Completed 25000 requests
-    Completed 30000 requests
-    Completed 35000 requests
-    Completed 40000 requests
-    Completed 45000 requests
-    Completed 50000 requests
-    Finished 50000 requests
-    
-    
-    Server Software:        
-    Server Hostname:        127.0.0.1
-    Server Port:            9294
-    
-    Document Path:          /
-    Document Length:        13 bytes
-    
-    Concurrency Level:      8
-    Time taken for tests:   1.869 seconds
-    Complete requests:      50000
-    Failed requests:        0
-    Total transferred:      2450000 bytes
-    HTML transferred:       650000 bytes
-    Requests per second:    26755.55 [#/sec] (mean)
-    Time per request:       0.299 [ms] (mean)
-    Time per request:       0.037 [ms] (mean, across all concurrent requests)
-    Transfer rate:          1280.29 [Kbytes/sec] received
-    
-    Connection Times (ms)
-                  min  mean[+/-sd] median   max
-    Connect:        0    0   0.0      0       0
-    Processing:     0    0   0.2      0       6
-    Waiting:        0    0   0.2      0       6
-    Total:          0    0   0.2      0       6
-    
-    Percentage of the requests served within a certain time (ms)
-      50%      0
-      66%      0
-      75%      0
-      80%      0
-      90%      0
-      95%      1
-      98%      1
-      99%      1
-     100%      6 (longest request)
-
-On a 4-core 8-thread i7, running `wrk`, which uses 8 keep-alive connections:
-
-    $ wrk -c 8 -d 10 -t 8 http://127.0.0.1:9294/
-    Running 10s test @ http://127.0.0.1:9294/
-      8 threads and 8 connections
-      Thread Stats   Avg      Stdev     Max   +/- Stdev
-        Latency   217.69us    0.99ms  23.21ms   97.39%
-        Req/Sec    12.18k     1.58k   17.67k    83.21%
-      974480 requests in 10.10s, 60.41MB read
-    Requests/sec:  96485.00
-    Transfer/sec:      5.98MB
-
-According to these results, the cost of handling connections is quite high, while general throughput seems pretty decent.
-
-## Semantic Model
-
-### Scheme
-
-HTTP/1 has an implicit scheme determined by the kind of connection made to the server (either `http` or `https`), while HTTP/2 models this explicitly and the client indicates this in the request using the `:scheme` pseudo-header (typically `https`). To normalize this, `Async::HTTP::Client` and `Async::HTTP::Server` have a default scheme which is used if none is supplied.
-
-### Version
-
-HTTP/1 has an explicit version while HTTP/2 does not expose the version in any way.
-
-### Reason
-
-HTTP/1 responses contain a reason field which is largely irrelevant. HTTP/2 does not support this field.
+  - [Testing](https://socketry.github.io/async-http/guides/testing/index) - This guide explains how to use `Async::HTTP` clients and servers in your tests.
 
 ## Contributing
 
@@ -367,14 +22,6 @@ We welcome contributions to this project.
 4.  Push to the branch (`git push origin my-new-feature`).
 5.  Create new Pull Request.
 
-### Developer Certificate of Origin
-
-This project uses the [Developer Certificate of Origin](https://developercertificate.org/). All contributors to this project must agree to this document to have their contributions accepted.
-
-### Contributor Covenant
-
-This project is governed by the [Contributor Covenant](https://www.contributor-covenant.org/). All contributors and participants agree to abide by its terms.
-
 ## See Also
 
   - [benchmark-http](https://github.com/socketry/benchmark-http) — A benchmarking tool to report on web server concurrency.
@@ -382,3 +29,11 @@ This project is governed by the [Contributor Covenant](https://www.contributor-c
   - [async-websocket](https://github.com/socketry/async-websocket) — Asynchronous client and server websockets.
   - [async-rest](https://github.com/socketry/async-rest) — A RESTful resource layer built on top of `async-http`.
   - [async-http-faraday](https://github.com/socketry/async-http-faraday) — A faraday adapter to use `async-http`.
+
+### Developer Certificate of Origin
+
+In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.
+
+### Community Guidelines
+
+This project is best served by a collaborative and respectful environment. Treat each other professionally, respect differing viewpoints, and engage constructively. Harassment, discrimination, or harmful behavior is not tolerated. Communicate clearly, listen actively, and support one another. If any issues arise, please inform the project maintainers.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.68.0
+  version: 0.70.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -10,11 +10,12 @@ authors:
 - Janko Marohnić
 - Thomas Morgan
 - Adam Daniels
+- Igor Sidorov
 - Anton Zhuravsky
 - Cyril Roelandt
 - Denis Talakevich
+- Hal Brodigan
 - Ian Ker-Seymer
-- Igor Sidorov
 - Josh Huber
 - Marco Concetto Rudilosso
 - Olle Jonsson
@@ -57,7 +58,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2024-06-23 00:00:00.000000000 Z
+date: 2024-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -121,14 +122,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.28'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.26'
+        version: '0.28'
 - !ruby/object:Gem::Dependency
   name: protocol-http1
   requirement: !ruby/object:Gem::Requirement
@@ -190,6 +191,9 @@ files:
 - lib/async/http/endpoint.rb
 - lib/async/http/internet.rb
 - lib/async/http/internet/instance.rb
+- lib/async/http/middleware/location_redirector.rb
+- lib/async/http/mock.rb
+- lib/async/http/mock/endpoint.rb
 - lib/async/http/protocol.rb
 - lib/async/http/protocol/http.rb
 - lib/async/http/protocol/http1.rb