async-http 0.87.0 → 0.88.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fb9ca49f85d321261c3a3ee9cccf0459841fc09e5df5981289c6d4a6dc6a973
-  data.tar.gz: 2a8310e595b65f51001f0b871de5992476153cd0de3eb175d1060e7743ffe6d2
+  metadata.gz: 605cb4a26c37dbfdaa3225fb306b3c2bc9e01da814094babb8e46cdb05594999
+  data.tar.gz: 40c28864c03492bc20d8aa02947210841ca5f2c75b841e222c90d8f3a36102af
 SHA512:
-  metadata.gz: 5b2c843acae23369e6fcffffea81ee443bac6caa2bb21acd80a72af00a831326700e0b0c6e57128f300b11bcbaf435f03e59a84c3de17c59b170241a0dce0cfb
-  data.tar.gz: b851a56d637736f82cc48b68c00ca4562daa9756548792d4f41c21771150e6b1bd1385eb429cfa43937936454d4719e3535f9273254dc81e26880ce30aa3eeb6
+  metadata.gz: 95eb6bb5d079d59b9ed9698d648bd709a7f60ae1a5833547cadd9a11def31e6e8d99b929650df676c0ed215a0719bd604ffc7c57c6e047cdefaa0ac11ff2d71b
+  data.tar.gz: 0cdbfe53cbcf3acb1529536ddac851c09e53dd9b7c40fb1d1059abc073138f67cda426a5825966052d52a2d35f39170047c814f7ca6168b25f149fb2baf1e7e0

data/bake/async/http/h2spec.rb

@@ -30,7 +30,7 @@ def server
 	
 	container = Async::Container.new
 	
-	Console.logger.info(self){"Starting server..."}
+	Console.info(self){"Starting server..."}
 	
 	container.run(count: 1) do
 		server = Async::HTTP::Server.for(endpoint, protocol: Async::HTTP::Protocol::HTTP2, scheme: "https") do |request|

data/lib/async/http/client.rb

@@ -81,7 +81,7 @@ module Async
 			
 			def close
 				while @pool.busy?
-					Console.logger.warn(self) {"Waiting for #{@protocol} pool to drain: #{@pool}"}
+					Console.warn(self) {"Waiting for #{@protocol} pool to drain: #{@pool}"}
 					@pool.wait
 				end
 				
@@ -164,7 +164,7 @@ module Async
 				self.assign_default_tags(options[:tags] ||= {})
 				
 				Async::Pool::Controller.wrap(**options) do
-					Console.logger.debug(self) {"Making connection to #{@endpoint.inspect}"}
+					Console.debug(self) {"Making connection to #{@endpoint.inspect}"}
 					
 					@protocol.client(@endpoint.connect)
 				end

data/lib/async/http/endpoint.rb

@@ -40,7 +40,7 @@ module Async
 			#
 			# @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}.
+			# @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 = SCHEMES.fetch(scheme.downcase) do

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Async
+	module HTTP
+		module Protocol
+			class Configured
+				def initialize(protocol, **options)
+					@protocol = protocol
+					@options = options
+				end
+				
+				# @attribute [Protocol] The underlying protocol.
+				attr :protocol
+				
+				# @attribute [Hash] The options to pass to the protocol.
+				attr :options
+				
+				def client(peer, **options)
+					options = @options.merge(options)
+					@protocol.client(peer, **options)
+				end
+				
+				def server(peer, **options)
+					options = @options.merge(options)
+					@protocol.server(peer, **options)
+				end
+				
+				def names
+					@protocol.names
+				end
+			end
+			
+			module Configurable
+				def new(**options)
+					Configured.new(self, **options)
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+module Async
+	module HTTP
+		module Protocol
+			# This module provides a default instance of the protocol, which can be used to create clients and servers. The name is a play on "Default" + "Singleton".
+			module Defaulton
+				def self.extended(base)
+					base.instance_variable_set(:@default, base.new)
+				end
+				
+				attr_accessor :default
+				
+				# Create a client for an outbound connection, using the default instance.
+				def client(peer, **options)
+					default.client(peer, **options)
+				end
+				
+				# Create a server for an inbound connection, using the default instance.
+				def server(peer, **options)
+					default.server(peer, **options)
+				end
+				
+				# @returns [Array] The names of the supported protocol, used for Application Layer Protocol Negotiation (ALPN), using the default instance.
+				def names
+					default.names
+				end
+			end
+			
+			private_constant :Defaulton
+		end
+	end
+end

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

@@ -4,19 +4,33 @@
 # Copyright, 2024, by Thomas Morgan.
 # Copyright, 2024, by Samuel Williams.
 
+require_relative "defaulton"
+
 require_relative "http1"
 require_relative "http2"
 
 module Async
 	module HTTP
 		module Protocol
-			# HTTP is an http:// server that auto-selects HTTP/1.1 or HTTP/2 by detecting the HTTP/2
-			# connection preface.
-			module HTTP
+			# HTTP is an http:// server that auto-selects HTTP/1.1 or HTTP/2 by detecting the HTTP/2 connection preface.
+			class HTTP
 				HTTP2_PREFACE = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n"
 				HTTP2_PREFACE_SIZE = HTTP2_PREFACE.bytesize
 				
-				def self.protocol_for(stream)
+				# Create a new HTTP protocol instance.
+				#
+				# @parameter http1 [HTTP1] The HTTP/1 protocol instance.
+				# @parameter http2 [HTTP2] The HTTP/2 protocol instance.
+				def initialize(http1: HTTP1, http2: HTTP2)
+					@http1 = http1
+					@http2 = http2
+				end
+				
+				# Determine if the inbound connection is HTTP/1 or HTTP/2.
+				#
+				# @parameter stream [IO::Stream] The stream to detect the protocol for.
+				# @returns [Class] The protocol class to use.
+				def protocol_for(stream)
 					# Detect HTTP/2 connection preface
 					# https://www.rfc-editor.org/rfc/rfc9113.html#section-3.4
 					preface = stream.peek do |read_buffer|
@@ -29,27 +43,35 @@ module Async
 					end
 					
 					if preface == HTTP2_PREFACE
-						HTTP2
+						@http2
 					else
-						HTTP1
+						@http1
 					end
 				end
 				
-				# Only inbound connections can detect HTTP1 vs HTTP2 for http://.
-				# Outbound connections default to HTTP1.
-				def self.client(peer, **options)
-					HTTP1.client(peer, **options)
+				# Create a client for an outbound connection. Defaults to HTTP/1 for plaintext connections.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the protocol, keyed by protocol class.
+				def client(peer, **options)
+					options = options[@http1] || {}
+					
+					return @http1.client(peer, **options)
 				end
 				
-				def self.server(peer, **options)
-					stream = ::IO::Stream(peer)
+				# Create a server for an inbound connection. Able to detect HTTP1 and HTTP2.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the protocol, keyed by protocol class.
+				def server(peer, **options)
+					stream = IO::Stream(peer)
+					protocol = protocol_for(stream)
+					options = options[protocol] || {}
 					
-					return protocol_for(stream).server(stream, **options)
+					return protocol.server(stream, **options)
 				end
 				
-				def self.names
-					["h2", "http/1.1", "http/1.0"]
-				end
+				extend Defaulton
 			end
 		end
 	end

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

@@ -32,8 +32,6 @@ module Async
 					
 					# Used by the client to send requests to the remote server.
 					def call(request, task: Task.current)
-						Console.logger.debug(self) {"#{request.method} #{request.path} #{request.headers.inspect}"}
-						
 						# Mark the start of the trailers:
 						trailer = request.headers.trailer!
 						

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

@@ -14,9 +14,10 @@ module Async
 		module Protocol
 			module HTTP1
 				class Connection < ::Protocol::HTTP1::Connection
-					def initialize(stream, version)
-						super(stream)
+					def initialize(stream, version, **options)
+						super(stream, **options)
 						
+						# On the client side, we need to send the HTTP version with the initial request. On the server side, there are some scenarios (bad request) where we don't know the request version. In those cases, we use this value, which is either hard coded based on the protocol being used, OR could be negotiated during the connection setup (e.g. ALPN).
 						@version = version
 					end
 					

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

@@ -34,7 +34,7 @@ module Async
 						write_body(@version, nil)
 					rescue => error
 						# At this point, there is very little we can do to recover:
-						Console::Event::Failure.for(error).emit(self, "Failed to write failure response!", severity: :debug)
+						Console.debug(self, "Failed to write failure response!", error)
 					end
 					
 					def next_request

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

@@ -4,6 +4,8 @@
 # Copyright, 2017-2024, by Samuel Williams.
 # Copyright, 2024, by Thomas Morgan.
 
+require_relative "configurable"
+
 require_relative "http1/client"
 require_relative "http1/server"
 
@@ -13,28 +15,41 @@ module Async
 	module HTTP
 		module Protocol
 			module HTTP1
+				extend Configurable
+				
 				VERSION = "HTTP/1.1"
 				
+				# @returns [Boolean] Whether the protocol supports bidirectional communication.
 				def self.bidirectional?
 					true
 				end
 				
+				# @returns [Boolean] Whether the protocol supports trailers.
 				def self.trailer?
 					true
 				end
 				
-				def self.client(peer)
+				# Create a client for an outbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the client instance.
+				def self.client(peer, **options)
 					stream = ::IO::Stream(peer)
 					
-					return HTTP1::Client.new(stream, VERSION)
+					return HTTP1::Client.new(stream, VERSION, **options)
 				end
 				
-				def self.server(peer)
+				# Create a server for an inbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the server instance.
+				def self.server(peer, **options)
 					stream = ::IO::Stream(peer)
 					
-					return HTTP1::Server.new(stream, VERSION)
+					return HTTP1::Server.new(stream, VERSION, **options)
 				end
 				
+				# @returns [Array] The names of the supported protocol.
 				def self.names
 					["http/1.1", "http/1.0"]
 				end

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

@@ -10,28 +10,41 @@ module Async
 	module HTTP
 		module Protocol
 			module HTTP10
+				extend Configurable
+				
 				VERSION = "HTTP/1.0"
 				
+				# @returns [Boolean] Whether the protocol supports bidirectional communication.
 				def self.bidirectional?
 					false
 				end
 				
+				# @returns [Boolean] Whether the protocol supports trailers.
 				def self.trailer?
 					false
 				end
 				
-				def self.client(peer)
+				# Create a client for an outbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the client instance.
+				def self.client(peer, **options)
 					stream = ::IO::Stream(peer)
 					
-					return HTTP1::Client.new(stream, VERSION)
+					return HTTP1::Client.new(stream, VERSION, **options)
 				end
 				
-				def self.server(peer)
+				# Create a server for an inbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the server instance.
+				def self.server(peer, **options)
 					stream = ::IO::Stream(peer)
 					
-					return HTTP1::Server.new(stream, VERSION)
+					return HTTP1::Server.new(stream, VERSION, **options)
 				end
 				
+				# @returns [Array] The names of the supported protocol.
 				def self.names
 					["http/1.0"]
 				end

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

@@ -11,28 +11,41 @@ module Async
 	module HTTP
 		module Protocol
 			module HTTP11
+				extend Configurable
+				
 				VERSION = "HTTP/1.1"
 				
+				# @returns [Boolean] Whether the protocol supports bidirectional communication.
 				def self.bidirectional?
 					true
 				end
 				
+				# @returns [Boolean] Whether the protocol supports trailers.
 				def self.trailer?
 					true
 				end
 				
-				def self.client(peer)
+				# Create a client for an outbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the client instance.
+				def self.client(peer, **options)
 					stream = ::IO::Stream(peer)
 					
-					return HTTP1::Client.new(stream, VERSION)
+					return HTTP1::Client.new(stream, VERSION, **options)
 				end
 				
-				def self.server(peer)
+				# Create a server for an inbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the server instance.
+				def self.server(peer, **options)
 					stream = ::IO::Stream(peer)
 					
-					return HTTP1::Server.new(stream, VERSION)
+					return HTTP1::Server.new(stream, VERSION, **options)
 				end
 				
+				# @returns [Array] The names of the supported protocol.
 				def self.names
 					["http/1.1"]
 				end

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

@@ -32,8 +32,6 @@ module Async
 					def call(request)
 						raise ::Protocol::HTTP2::Error, "Connection closed!" if self.closed?
 						
-						@count += 1
-						
 						response = create_response
 						write_request(response, request)
 						read_response(response)

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

@@ -26,10 +26,9 @@ module Async
 				TRAILER = "trailer".freeze
 				
 				module Connection
-					def initialize(*)
+					def initialize(...)
 						super
 						
-						@count = 0
 						@reader = nil
 						
 						# Writing multiple frames at the same time can cause odd problems if frames are only partially written. So we use a semaphore to ensure frames are written in their entirety.
@@ -41,7 +40,7 @@ module Async
 					end
 					
 					def to_s
-						"\#<#{self.class} #{@count} requests, #{@streams.count} active streams>"
+						"\#<#{self.class} #{@streams.count} active streams>"
 					end
 					
 					def as_json(...)

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

@@ -51,8 +51,6 @@ module Async
 						@requests&.async do |task, request|
 							task.annotate("Incoming request: #{request.method} #{request.path.inspect}.")
 							
-							@count += 1
-							
 							task.defer_stop do
 								response = yield(request)
 							rescue

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

@@ -65,7 +65,7 @@ module Async
 							@input.close_write
 						end
 					rescue ::Protocol::HTTP2::HeaderError => error
-						Console.logger.debug(self, error)
+						Console.debug(self, "Error while processing headers!", error)
 						
 						send_reset_stream(error.code)
 					end

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

@@ -4,6 +4,8 @@
 # Copyright, 2018-2024, by Samuel Williams.
 # Copyright, 2024, by Thomas Morgan.
 
+require_relative "configurable"
+
 require_relative "http2/client"
 require_relative "http2/server"
 
@@ -13,16 +15,21 @@ module Async
 	module HTTP
 		module Protocol
 			module HTTP2
+				extend Configurable
+				
 				VERSION = "HTTP/2"
 				
+				# @returns [Boolean] Whether the protocol supports bidirectional communication.
 				def self.bidirectional?
 					true
 				end
 				
+				# @returns [Boolean] Whether the protocol supports trailers.
 				def self.trailer?
 					true
 				end
 				
+				# The default settings for the client.
 				CLIENT_SETTINGS = {
 					::Protocol::HTTP2::Settings::ENABLE_PUSH => 0,
 					::Protocol::HTTP2::Settings::MAXIMUM_FRAME_SIZE => 0x100000,
@@ -30,6 +37,7 @@ module Async
 					::Protocol::HTTP2::Settings::NO_RFC7540_PRIORITIES => 1,
 				}
 				
+				# The default settings for the server.
 				SERVER_SETTINGS = {
 					# We choose a lower maximum concurrent streams to avoid overloading a single connection/thread.
 					::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 128,
@@ -39,7 +47,11 @@ module Async
 					::Protocol::HTTP2::Settings::NO_RFC7540_PRIORITIES => 1,
 				}
 				
-				def self.client(peer, settings = CLIENT_SETTINGS)
+				# Create a client for an outbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the client instance.
+				def self.client(peer, settings: CLIENT_SETTINGS)
 					stream = ::IO::Stream(peer)
 					client = Client.new(stream)
 					
@@ -49,7 +61,11 @@ module Async
 					return client
 				end
 				
-				def self.server(peer, settings = SERVER_SETTINGS)
+				# Create a server for an inbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the server instance.
+				def self.server(peer, settings: SERVER_SETTINGS)
 					stream = ::IO::Stream(peer)
 					server = Server.new(stream)
 					
@@ -59,6 +75,7 @@ module Async
 					return server
 				end
 				
+				# @returns [Array] The names of the supported protocol.
 				def self.names
 					["h2"]
 				end

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

@@ -4,16 +4,18 @@
 # Copyright, 2018-2024, by Samuel Williams.
 # Copyright, 2019, by Brian Morearty.
 
+require_relative "defaulton"
+
 require_relative "http10"
 require_relative "http11"
-
 require_relative "http2"
 
 module Async
 	module HTTP
 		module Protocol
 			# A server that supports both HTTP1.0 and HTTP1.1 semantics by detecting the version of the request.
-			module HTTPS
+			class HTTPS
+				# The protocol classes for each supported protocol.
 				HANDLERS = {
 					"h2" => HTTP2,
 					"http/1.1" => HTTP11,
@@ -21,11 +23,27 @@ module Async
 					nil => HTTP11,
 				}
 				
-				def self.protocol_for(peer)
+				def initialize(handlers = HANDLERS, **options)
+					@handlers = handlers
+					@options = options
+				end
+				
+				def add(name, protocol, **options)
+					@handlers[name] = protocol
+					@options[protocol] = options
+				end
+				
+				# Determine the protocol of the peer and return the appropriate protocol class.
+				#
+				# Use TLS Application Layer Protocol Negotiation (ALPN) to determine the protocol.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @returns [Class] The protocol class to use.
+				def protocol_for(peer)
 					# alpn_protocol is only available if openssl v1.0.2+
 					name = peer.alpn_protocol
 					
-					Console.logger.debug(self) {"Negotiating protocol #{name.inspect}..."}
+					Console.debug(self) {"Negotiating protocol #{name.inspect}..."}
 					
 					if protocol = HANDLERS[name]
 						return protocol
@@ -34,18 +52,34 @@ module Async
 					end
 				end
 				
-				def self.client(peer)
-					protocol_for(peer).client(peer)
+				# Create a client for an outbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the client instance.
+				def client(peer, **options)
+					protocol = protocol_for(peer)
+					options = options[protocol] || {}
+					
+					protocol.client(peer, **options)
 				end
 				
-				def self.server(peer)
-					protocol_for(peer).server(peer)
+				# Create a server for an inbound connection.
+				#
+				# @parameter peer [IO] The peer to communicate with.
+				# @parameter options [Hash] Options to pass to the server instance.
+				def server(peer, **options)
+					protocol = protocol_for(peer)
+					options = options[protocol] || {}
+					
+					protocol.server(peer, **options)
 				end
 				
-				# Supported Application Layer Protocol Negotiation names:
-				def self.names
-					HANDLERS.keys.compact
+				# @returns [Array] The names of the supported protocol, used for Application Layer Protocol Negotiation (ALPN).
+				def names
+					@handlers.keys.compact
 				end
+				
+				extend Defaulton
 			end
 		end
 	end

data/lib/async/http/server.rb

@@ -45,14 +45,14 @@ module Async
 			def accept(peer, address, task: Task.current)
 				connection = @protocol.server(peer)
 				
-				Console.logger.debug(self) {"Incoming connnection from #{address.inspect} to #{@protocol}"}
+				Console.debug(self) {"Incoming connnection from #{address.inspect} to #{@protocol}"}
 				
 				connection.each do |request|
 					# We set the default scheme unless it was otherwise specified.
 					# https://tools.ietf.org/html/rfc7230#section-5.5
 					request.scheme ||= self.scheme
 					
-					# Console.logger.debug(self) {"Incoming request from #{address.inspect}: #{request.method} #{request.path}"}
+					# Console.debug(self) {"Incoming request from #{address.inspect}: #{request.method} #{request.path}"}
 					
 					# If this returns nil, we assume that the connection has been hijacked.
 					self.call(request)

data/lib/async/http/version.rb

@@ -5,6 +5,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.87.0"
+		VERSION = "0.88.0"
 	end
 end

data/readme.md

@@ -16,6 +16,10 @@ Please see the [project documentation](https://socketry.github.io/async-http/) f
 
 Please see the [project releases](https://socketry.github.io/async-http/releases/index) for all releases.
 
+### v0.88.0
+
+  - [Support custom protocols with options](https://socketry.github.io/async-http/releases/index#support-custom-protocols-with-options)
+
 ### v0.87.0
 
   - [Unify HTTP/1 and HTTP/2 `CONNECT` semantics](https://socketry.github.io/async-http/releases/index#unify-http/1-and-http/2-connect-semantics)
@@ -55,10 +59,6 @@ Please see the [project releases](https://socketry.github.io/async-http/releases
 
   - [`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

@@ -1,5 +1,62 @@
 # Releases
 
+## v0.88.0
+
+### Support custom protocols with options
+
+{ruby Async::HTTP::Protocol} contains classes for specific protocols, e.g. {ruby Async::HTTP::Protocol::HTTP1} and {ruby Async::HTTP::Protocol::HTTP2}. It also contains classes for aggregating protocols, e.g. {ruby Async::HTTP::Protocol::HTTP} and {ruby Async::HTTP::Protocol::HTTPS}. They serve as factories for creating client and server instances.
+
+These classes are now configurable with various options, which are passed as keyword arguments to the relevant connection classes. For example, to configure an HTTP/1.1 protocol without keep-alive:
+
+``` ruby
+protocol = Async::HTTP::Protocol::HTTP1.new(persistent: false, maximum_line_length: 32)
+endpoint = Async::HTTP::Endpoint.parse("http://localhost:9292", protocol: protocol)
+server = Async::HTTP::Server.for(endpoint) do |request|
+	Protocol::HTTP::Response[200, {}, ["Hello, world"]]
+end.run
+```
+
+Making a request to the server will now close the connection after the response is received:
+
+    > curl -v http://localhost:9292
+    * Host localhost:9292 was resolved.
+    * IPv6: ::1
+    * IPv4: 127.0.0.1
+    *   Trying [::1]:9292...
+    * Connected to localhost (::1) port 9292
+    * using HTTP/1.x
+    > GET / HTTP/1.1
+    > Host: localhost:9292
+    > User-Agent: curl/8.12.1
+    > Accept: */*
+    > 
+    * Request completely sent off
+    < HTTP/1.1 200 OK
+    < connection: close
+    < content-length: 12
+    < 
+    * shutting down connection #0
+    Hello, world
+
+In addition, any line longer than 32 bytes will be rejected:
+
+    curl -v http://localhost:9292/012345678901234567890123456789012
+    * Host localhost:9292 was resolved.
+    * IPv6: ::1
+    * IPv4: 127.0.0.1
+    *   Trying [::1]:9292...
+    * Connected to localhost (::1) port 9292
+    * using HTTP/1.x
+    > GET /012345678901234567890123456789012 HTTP/1.1
+    > Host: localhost:9292
+    > User-Agent: curl/8.12.1
+    > Accept: */*
+    > 
+    * Request completely sent off
+    * Empty reply from server
+    * shutting down connection #0
+    curl: (52) Empty reply from server
+
 ## v0.87.0
 
 ### Unify HTTP/1 and HTTP/2 `CONNECT` semantics

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.87.0
+  version: 0.88.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -57,7 +57,7 @@ cert_chain:
   Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
   voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
   -----END CERTIFICATE-----
-date: 2025-01-29 00:00:00.000000000 Z
+date: 2025-03-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -204,6 +204,8 @@ files:
 - lib/async/http/mock.rb
 - lib/async/http/mock/endpoint.rb
 - lib/async/http/protocol.rb
+- lib/async/http/protocol/configurable.rb
+- lib/async/http/protocol/defaulton.rb
 - lib/async/http/protocol/http.rb
 - lib/async/http/protocol/http1.rb
 - lib/async/http/protocol/http1/client.rb