async-http 0.24.3 → 0.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 570eb9bb6a0b2a283e9149bb2e158e1f72caedae249e872622c335ef2676bba2
-  data.tar.gz: 93049e1d6687cdc102725553a48e9401ebc8ef743c3a54343b5de3b41ef8c0b7
+  metadata.gz: 232e1b617ad6dea60e2b7d5ccbd1838bd1a507d6896292dab3345cb439ee7638
+  data.tar.gz: 51877e29175a10fabe6bd36b10d675b09eb90447b16a4e59ba3a8c128f4b9940
 SHA512:
-  metadata.gz: 8694e40e0e0eb6f1a1bebeef6b41385bc05ecd87549feb2943306828037e6a24c11113c0271ce26b3ab9a4f2e8512d1cf19c22d03fb59c61b5606cc253d60798
-  data.tar.gz: f785ab8a1e9f71bdfd2a24f12f30de4474cbefcd08745a8ec4976a94b84c702f94319ef5c30b31fc898506c24df1206e41cec25b929bf7d8faf2229f2989ceac
+  metadata.gz: 61215be764f44c9b46378c7eb6582850936f3cbf0d424f8967fa38141ee109469c3cde72f343807919fb0a5a9fc31a191a6441c15832c6370279a395da8e1a16
+  data.tar.gz: 63f6fdd40cfc107ef03234615ed92d8a9a7f76305e48bbb6638a177d148a38f626650aa3d83671d0438ac0a2652f301e722d08f9626db5886288028359fbf682

data/Rakefile

@@ -56,30 +56,23 @@ end
 task :wrk do
 	require 'async/reactor'
 	require 'async/http/server'
-	
-	app = lambda do |env|
-		[200, {}, ["Hello World"]]
+	require 'async/container/forked'
+
+	server = Async::HTTP::Server.new(Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true), PROTOCOL) do |request, peer, address|
+		return Async::HTTP::Response[200, {'content-type' => 'text/plain'}, ["Hello World"]]
 	end
+
+	concurrency = 1
 	
-	server = Async::HTTP::Server.new(Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true), app)
-	
-	process_count = Etc.nprocessors
-	
-	pids = process_count.times.collect do
-		fork do
-			Async::Reactor.run do
-				server.run
-			end
-		end
+	container = Async::Container::Forked.new(concurrency: concurrency) do
+		server.run
 	end
 
 	url = "http://127.0.0.1:9294/"
 	
-	connections = process_count
-	system("wrk", "-c", connections.to_s, "-d", "2", "-t", connections.to_s, url)
-
-	pids.each do |pid|
-		Process.kill(:KILL, pid)
-		Process.wait pid
+	5.times do
+		system("wrk", "-c", concurrency.to_s, "-d", "10", "-t", concurrency.to_s, url)
 	end
+
+	container.stop
 end

data/lib/async/http/body/buffered.rb

@@ -48,13 +48,13 @@ module Async
 				
 				def initialize(chunks)
 					@chunks = chunks
-					@bytesize = nil
+					@length = nil
 					
 					@index = 0
 				end
 				
-				def bytesize
-					@bytesize ||= @chunks.inject(0) {|sum, chunk| sum + chunk.bytesize}
+				def length
+					@length ||= @chunks.inject(0) {|sum, chunk| sum + chunk.bytesize}
 				end
 				
 				def empty?

data/lib/async/http/body/chunked.rb

@@ -28,7 +28,7 @@ module Async
 					@protocol = protocol
 					@finished = false
 					
-					@bytesize = 0
+					@length = 0
 					@count = 0
 				end
 				
@@ -36,30 +36,34 @@ module Async
 					@finished
 				end
 				
+				def stop(error)
+					@protocol.close
+					@finished = true
+				end
+				
 				def read
 					return nil if @finished
 					
-					size = @protocol.read_line.to_i(16)
+					length = @protocol.read_line.to_i(16)
 					
-					if size == 0
-						@protocol.read_line
-						
+					if length == 0
 						@finished = true
+						@protocol.read_line
 						
 						return nil
 					end
 					
-					chunk = @protocol.stream.read(size)
+					chunk = @protocol.stream.read(length)
 					@protocol.read_line # Consume the trailing CRLF
 					
-					@bytesize += size
+					@length += length
 					@count += 1
 					
 					return chunk
 				end
 				
 				def inspect
-					"\#<#{self.class} #{@bytesize} bytes read in #{@count} chunks>"
+					"\#<#{self.class} #{@length} bytes read in #{@count} chunks>"
 				end
 			end
 		end

data/lib/async/http/body/deflate.rb

@@ -51,15 +51,24 @@ module Async
 					
 					@stream = stream
 					
-					@input_size = 0
-					@output_size = 0
+					@input_length = 0
+					@output_length = 0
 				end
 				
-				attr :input_size
-				attr :output_size
+				def length
+					# We don't know the length of the output until after it's been compressed.
+					nil
+				end
+				
+				attr :input_length
+				attr :output_length
 				
 				def ratio
-					@output_size.to_f / @input_size.to_f
+					if @input_length != 0
+						@output_length.to_f / @input_length.to_f
+					else
+						1.0
+					end
 				end
 				
 				def stop(error)
@@ -83,17 +92,17 @@ module Async
 					return if @stream.closed?
 					
 					if chunk = super
-						@input_size += chunk.bytesize
+						@input_length += chunk.bytesize
 						
 						chunk = @stream.deflate(chunk, Zlib::SYNC_FLUSH)
 						
-						@output_size += chunk.bytesize
+						@output_length += chunk.bytesize
 						
 						return chunk
 					else
 						chunk = @stream.finish
 						
-						@output_size += chunk.bytesize
+						@output_length += chunk.bytesize
 						
 						@stream.close
 						

data/lib/async/http/body/fixed.rb

@@ -37,6 +37,10 @@ module Async
 					@remaining == 0
 				end
 				
+				def stop(error)
+					@stream.close
+				end
+				
 				def read
 					if @remaining > 0
 						if chunk = @stream.read_partial(@remaining)
@@ -69,8 +73,12 @@ module Async
 					@stream.closed?
 				end
 				
+				def stop(error)
+					@stream.close
+				end
+				
 				def read
-					@stream.read unless @stream.closed?
+					@stream.read_partial
 				end
 				
 				def join

data/lib/async/http/body/inflate.rb

@@ -34,15 +34,15 @@ module Async
 					return if @stream.closed?
 					
 					if chunk = super
-						@input_size += chunk.bytesize
+						@input_length += chunk.bytesize
 						
 						chunk = @stream.inflate(chunk)
 						
-						@output_size += chunk.bytesize
+						@output_length += chunk.bytesize
 					else
 						chunk = @stream.finish
 						
-						@output_size += chunk.bytesize
+						@output_length += chunk.bytesize
 						
 						@stream.close
 					end

data/lib/async/http/body/wrapper.rb

@@ -33,6 +33,10 @@ module Async
 					@body.empty?
 				end
 				
+				def length
+					@body.length
+				end
+				
 				# Buffer any remaining body.
 				def close
 					@body = @body.close

data/lib/async/http/headers.rb

@@ -156,6 +156,8 @@ module Async
 						hash[key] = policy.new(value)
 					end
 				else
+					raise ArgumentError, "Header #{key} can only be set once!" if hash.include?(key)
+					
 					# We can't merge these, we only expose the last one set.
 					hash[key] = value
 				end

data/lib/async/http/middleware.rb

@@ -20,7 +20,15 @@
 
 module Async
 	module HTTP
-		VERBS = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE']
+		GET = 'GET'.freeze
+		HEAD = 'HEAD'.freeze
+		POST = 'POST'.freeze
+		PUT = 'PUT'.freeze
+		PATCH = 'PATCH'.freeze
+		DELETE = 'DELETE'.freeze
+		CONNECT = 'CONNECT'.freeze
+		
+		VERBS = [GET, HEAD, POST, PUT, PATCH, DELETE, CONNECT].freeze
 		
 		module Verbs
 			VERBS.each do |verb|

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

@@ -0,0 +1,29 @@
+# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+module Async
+	module HTTP
+		module Protocol
+			# The request was invalid/malformed in some way.
+			class BadRequest < StandardError
+			end
+		end
+	end
+end

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

@@ -41,45 +41,14 @@ module Async
 					end
 				end
 				
-				# Server loop.
-				def receive_requests(task: Task.current)
-					while @persistent
-						request = Request.new(*self.read_request)
-						
-						unless persistent?(request.headers)
-							@persistent = false
-						end
-						
-						response = yield request
-						
-						response.version ||= request.version
-						
-						write_response(response.version, response.status, response.headers, response.body)
-						
-						# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
-						task.yield
-					end
-				end
-				
 				def write_persistent_header
-					@stream.write("Connection: keep-alive\r\n") if @persistent
+					@stream.write("connection: keep-alive\r\n") if @persistent
 				end
 				
 				def write_body(body, chunked = false)
 					# We don't support chunked encoding.
 					super(body, chunked)
 				end
-				
-				def read_body(headers)
-					if body = super
-						return body
-					end
-					
-					# Technically, with HTTP/1.0, if no content-length is specified, we just need to read everything until the connection is closed.
-					unless @persistent
-						return Body::Remainder.new(@stream)
-					end
-				end
 			end
 		end
 	end

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

@@ -21,6 +21,7 @@
 require 'async/io/protocol/line'
 
 require_relative 'request_failed'
+require_relative 'bad_request'
 
 require_relative '../request'
 require_relative '../response'
@@ -32,6 +33,10 @@ require_relative '../body/fixed'
 module Async
 	module HTTP
 		module Protocol
+			TRANSFER_ENCODING = 'transfer-encoding'.freeze
+			CONTENT_LENGTH = 'content-length'.freeze
+			CHUNKED = 'chunked'.freeze
+			
 			# Implements basic HTTP/1.1 request/response.
 			class HTTP11 < Async::IO::Protocol::Line
 				CRLF = "\r\n".freeze
@@ -80,25 +85,62 @@ module Async
 					end
 				end
 				
+				def hijack
+					@persistent = false
+					
+					@stream.flush
+					
+					return @stream.io
+				end
+				
+				class Request < HTTP::Request
+					def initialize(protocol)
+						super(*protocol.read_request)
+						
+						@protocol = protocol
+					end
+					
+					attr :protocol
+					
+					def hijack?
+						true
+					end
+					
+					def hijack
+						@protocol.hijack
+					end
+				end
+				
+				def next_request
+					# The default is true.
+					return nil unless @persistent
+					
+					request = Request.new(self)
+					
+					unless persistent?(request.headers)
+						@persistent = false
+					end
+					
+					return request
+				rescue
+					# Bad Request
+					write_response(self.version, 400, {}, nil)
+					
+					raise
+				end
+				
 				# Server loop.
 				def receive_requests(task: Task.current)
-					while @persistent
-						request = Request.new(*read_request)
-						
-						unless persistent?(request.headers)
-							@persistent = false
+					while request = next_request
+						if response = yield(request, self)
+							write_response(response.version || self.version, response.status, response.headers, response.body)
+							request.finish
+							
+							# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
+							task.yield
+						else
+							break
 						end
-						
-						response = yield request
-						
-						response.version ||= request.version
-						
-						write_response(response.version, response.status, response.headers, response.body)
-						
-						request.finish
-						
-						# This ensures we yield at least once every iteration of the loop and allow other fibers to execute.
-						task.yield
 					end
 				end
 				
@@ -118,7 +160,7 @@ module Async
 					# 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(request.body)
 					
-					return Response.new(*read_response)
+					return Response.new(*read_response(request))
 				rescue
 					# This will ensure that #reusable? returns false.
 					@stream.close
@@ -128,28 +170,34 @@ module Async
 				
 				def write_request(authority, method, path, version, headers)
 					@stream.write("#{method} #{path} #{version}\r\n")
-					@stream.write("Host: #{authority}\r\n")
+					@stream.write("host: #{authority}\r\n")
 					write_headers(headers)
 					
 					@stream.flush
 				end
 				
-				def read_response
+				def read_response(request)
 					version, status, reason = read_line.split(/\s+/, 3)
-					headers = read_headers
-					body = read_body(headers)
+					Async.logger.debug(self) {"#{version} #{status} #{reason}"}
 					
-					@count += 1
+					headers = read_headers
 					
 					@persistent = persistent?(headers)
 					
+					body = read_response_body(request, status, headers)
+					
+					@count += 1
+					
 					return version, Integer(status), reason, headers, body
 				end
 				
 				def read_request
 					method, path, version = read_line.split(/\s+/, 3)
 					headers = read_headers
-					body = read_body(headers)
+					
+					@persistent = persistent?(headers)
+					
+					body = read_request_body(headers)
 					
 					@count += 1
 					
@@ -167,15 +215,13 @@ module Async
 				protected
 				
 				def write_persistent_header
-					@stream.write("Connection: close\r\n") unless @persistent
+					@stream.write("connection: close\r\n") unless @persistent
 				end
 				
 				def write_headers(headers)
 					headers.each do |name, value|
 						@stream.write("#{name}: #{value}\r\n")
 					end
-					
-					write_persistent_header
 				end
 				
 				def read_headers
@@ -192,60 +238,154 @@ module Async
 					return Headers.new(fields)
 				end
 				
+				def write_empty_body(body)
+					# Write empty body:
+					write_persistent_header
+					@stream.write("content-length: 0\r\n\r\n")
+					
+					body.read if body
+					
+					@stream.flush
+				end
+				
+				def write_fixed_length_body(body, length)
+					write_persistent_header
+					@stream.write("content-length: #{length}\r\n\r\n")
+					
+					body.each do |chunk|
+						@stream.write(chunk)
+					end
+					
+					@stream.flush
+				end
+				
+				def write_chunked_body(body)
+					write_persistent_header
+					@stream.write("transfer-encoding: chunked\r\n\r\n")
+					
+					body.each do |chunk|
+						next if chunk.size == 0
+						
+						@stream.write("#{chunk.bytesize.to_s(16).upcase}\r\n")
+						@stream.write(chunk)
+						@stream.write(CRLF)
+						@stream.flush
+					end
+					
+					@stream.write("0\r\n\r\n")
+					@stream.flush
+				end
+				
+				def write_body_and_close(body)
+					# We can't be persistent because we don't know the data length:
+					@persistent = false
+					write_persistent_header
+					
+					@stream.write("\r\n")
+					
+					body.each do |chunk|
+						@stream.write(chunk)
+						@stream.flush
+					end
+					
+					@stream.io.close_write
+				end
+				
 				def write_body(body, chunked = true)
 					if body.nil? or body.empty?
-						@stream.write("Content-Length: 0\r\n\r\n")
-						body.read if body
+						write_empty_body(body)
 					elsif length = body.length
-						@stream.write("Content-Length: #{length}\r\n\r\n")
-						
-						body.each do |chunk|
-							@stream.write(chunk)
-						end
+						write_fixed_length_body(body, length)
 					elsif chunked
-						@stream.write("Transfer-Encoding: chunked\r\n\r\n")
-						
-						body.each do |chunk|
-							next if chunk.size == 0
-							
-							@stream.write("#{chunk.bytesize.to_s(16).upcase}\r\n")
-							@stream.write(chunk)
-							@stream.write(CRLF)
-							@stream.flush
-						end
-						
-						@stream.write("0\r\n\r\n")
+						write_chunked_body(body)
 					else
-						body = Body::Buffered.for(body)
-						
-						@stream.write("Content-Length: #{body.bytesize}\r\n\r\n")
-						
-						body.each do |chunk|
-							@stream.write(chunk)
-						end
+						write_body_and_close(body)
 					end
-					
-					@stream.flush
 				end
 				
-				TRANSFER_ENCODING = 'transfer-encoding'.freeze
-				CONTENT_LENGTH = 'content-length'.freeze
-				CHUNKED = 'chunked'.freeze
+				def read_response_body(request, status, headers)
+					# RFC 7230 3.3.3
+					# 1.  Any response to a HEAD request and any response with a 1xx
+					# (Informational), 204 (No Content), or 304 (Not Modified) status
+					# code is always terminated by the first empty line after the
+					# header fields, regardless of the header fields present in the
+					# message, and thus cannot contain a message body.
+					if request.head? or status == 204 or status == 304
+						return nil
+					end
+					
+					# 2.  Any 2xx (Successful) response to a CONNECT request implies that
+					# the connection will become a tunnel immediately after the empty
+					# line that concludes the header fields.  A client MUST ignore any
+					# Content-Length or Transfer-Encoding header fields received in
+					# such a message.
+					if request.connect? and status == 200
+						return Body::Remainder.new(@stream)
+					end
+					
+					if body = read_body(headers)
+						return body
+					else
+						# 7.  Otherwise, this is a response message without a declared message
+						# body length, so the message body length is determined by the
+						# number of octets received prior to the server closing the
+						# connection.
+						return Body::Remainder.new(@stream)
+					end
+				end
 				
-				def chunked?(headers)
-					if transfer_encoding = headers[TRANSFER_ENCODING]
-						if transfer_encoding.count == 1
-							return transfer_encoding.first == CHUNKED
-						end
+				def read_request_body(headers)
+					# 6.  If this is a request message and none of the above are true, then
+					# the message body length is zero (no message body is present).
+					if body = read_body(headers)
+						return body
 					end
 				end
 				
 				def read_body(headers)
-					if chunked?(headers)
-						return Body::Chunked.new(self)
-					elsif content_length = headers[CONTENT_LENGTH]
-						if content_length != 0
-							return Body::Fixed.new(@stream, Integer(content_length))
+					# 3.  If a Transfer-Encoding header field is present and the chunked
+					# transfer coding (Section 4.1) is the final encoding, the message
+					# body length is determined by reading and decoding the chunked
+					# data until the transfer coding indicates the data is complete.
+					if transfer_encoding = headers[TRANSFER_ENCODING]
+						# If a message is received with both a Transfer-Encoding and a
+						# Content-Length header field, the Transfer-Encoding overrides the
+						# Content-Length.  Such a message might indicate an attempt to
+						# perform request smuggling (Section 9.5) or response splitting
+						# (Section 9.4) and ought to be handled as an error.  A sender MUST
+						# remove the received Content-Length field prior to forwarding such
+						# a message downstream.
+						if headers[CONTENT_LENGTH]
+							raise BadRequest, "Message contains both transfer encoding and content length!"
+						end
+						
+						if transfer_encoding.last == CHUNKED
+							return Body::Chunked.new(self)
+						else
+							# If a Transfer-Encoding header field is present in a response and
+							# the chunked transfer coding is not the final encoding, the
+							# message body length is determined by reading the connection until
+							# it is closed by the server.  If a Transfer-Encoding header field
+							# is present in a request and the chunked transfer coding is not
+							# the final encoding, the message body length cannot be determined
+							# reliably; the server MUST respond with the 400 (Bad Request)
+							# status code and then close the connection.
+							return Body::Remainder.new(@stream)
+						end
+					end
+
+					# 5.  If a valid Content-Length header field is present without
+					# Transfer-Encoding, its decimal value defines the expected message
+					# body length in octets.  If the sender closes the connection or
+					# the recipient times out before the indicated number of octets are
+					# received, the recipient MUST consider the message to be
+					# incomplete and close the connection.
+					if content_length = headers[CONTENT_LENGTH]
+						length = Integer(content_length)
+						if length >= 0
+							return Body::Fixed.new(@stream, length)
+						else
+							raise BadRequest, "Invalid content length: #{content_length}"
 						end
 					end
 				end

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

@@ -23,6 +23,8 @@ require_relative '../response'
 require_relative '../headers'
 require_relative '../body/writable'
 
+require_relative 'http11'
+
 require 'async/notification'
 
 require 'http/2'
@@ -120,71 +122,73 @@ module Async
 					@stream.close
 				end
 				
+				class Request < HTTP::Request
+					def initialize(stream)
+						super(nil, nil, nil, VERSION, Headers.new, Body::Writable.new)
+						
+						@stream = stream
+					end
+					
+					attr :stream
+					
+					def assign_headers(headers)
+						headers.each do |key, value|
+							if key == METHOD
+								raise BadRequest, "Request method already specified" if @method
+								
+								@method = value
+							elsif key == PATH
+								raise BadRequest, "Request path already specified" if @path
+								
+								@path = value
+							elsif key == AUTHORITY
+								raise BadRequest, "Request authority already specified" if @authority
+								
+								@authority = value
+							else
+								@headers[key] = value
+							end
+						end
+					end
+					
+					def hijack?
+						false
+					end
+				end
+				
 				def receive_requests(task: Task.current, &block)
 					# emits new streams opened by the client
 					@controller.on(:stream) do |stream|
-						request = Request.new
-						request.version = self.version
-						request.headers = Headers.new
-						body = Body::Writable.new
-						request.body = body
+						request = Request.new(stream)
+						body = request.body
 						
 						stream.on(:headers) do |headers|
-							headers.each do |key, value|
-								if key == METHOD
-									request.method = value
-								elsif key == PATH
-									request.path = value
-								elsif key == AUTHORITY
-									request.authority = value
-								else
-									request.headers[key] = value
+							begin
+								request.assign_headers(headers)
+							rescue
+								Async.logger.error(self) {$!}
+								
+								stream.headers({
+									STATUS => "400"
+								}, end_stream: true)
+							else
+								task.async do
+									generate_response(request, stream, &block)
 								end
 							end
 						end
 						
 						stream.on(:data) do |chunk|
-							# puts "Got request data: #{chunk.inspect}"
 							body.write(chunk.to_s) unless chunk.empty?
 						end
 						
-						stream.on(:close) do |error|
-							if error
-								body.stop(EOFError.new(error))
-							end
+						stream.on(:half_close) do
+							# We are no longer receiving any more data frames:
+							body.finish
 						end
 						
-						stream.on(:half_close) do
-							# The requirements for this to be in lock-step with other opertaions is minimal.
-							# TODO consider putting this in it's own async task.
-							begin
-								# We are no longer receiving any more data frames:
-								body.finish
-								
-								# Generate the response:
-								response = yield request
-								
-								headers = {STATUS => response.status.to_s}
-								headers.update(response.headers)
-								
-								if response.body.nil? or response.body.empty?
-									stream.headers(headers, end_stream: true)
-									response.body.read if response.body
-								else
-									stream.headers(headers, end_stream: false)
-									
-									response.body.each do |chunk|
-										stream.data(chunk, end_stream: false)
-									end
-									
-									stream.data("", end_stream: true)
-								end
-							rescue
-								Async.logger.error(self) {$!}
-								
-								# Generating the response failed.
-								stream.close(:internal_error)
-							end
+						stream.on(:close) do |error|
+							body.stop(EOFError.new(error)) if error
 						end
 					end
 					
@@ -192,6 +196,41 @@ module Async
 					@reader.wait
 				end
 				
+				# Generate a response to the request. If this fails, the stream is terminated and the error is reported.
+				private def generate_response(request, stream, &block)
+					# We need to close the stream if the user code blows up while generating a response:
+					response = begin
+						yield(request, stream)
+					rescue
+						stream.close(:internal_error)
+						
+						raise
+					end
+					
+					if response
+						headers = Headers::Merged.new({
+							STATUS => response.status,
+						}, response.headers)
+						
+						if response.body.nil? or response.body.empty?
+							stream.headers(headers, end_stream: true)
+							response.body.read if response.body
+						else
+							stream.headers(headers, end_stream: false)
+							
+							response.body.each do |chunk|
+								stream.data(chunk, end_stream: false)
+							end
+							
+							stream.data("", end_stream: true)
+						end
+					else
+						stream.close(:internal_error) unless stream.state == :closed
+					end
+				rescue
+					Async.logger.error(request) {$!}
+				end
+				
 				def call(request)
 					request.version ||= self.version
 					

data/lib/async/http/request.rb

@@ -19,12 +19,37 @@
 # THE SOFTWARE.
 
 require_relative 'body/buffered'
+require_relative 'middleware'
 
 module Async
 	module HTTP
-		class Request < Struct.new(:authority, :method, :path, :version, :headers, :body)
+		class Request
 			prepend Body::Buffered::Reader
 			
+			def initialize(authority = nil, method = nil, path = nil, version = nil, headers = [], body = nil)
+				@authority = authority
+				@method = method
+				@path = path
+				@version = version
+				@headers = headers
+				@body = body
+			end
+			
+			attr_accessor :authority
+			attr_accessor :method
+			attr_accessor :path
+			attr_accessor :version
+			attr_accessor :headers
+			attr_accessor :body
+			
+			def head?
+				self.method == HEAD
+			end
+			
+			def connect?
+				self.method == CONNECT
+			end
+			
 			def self.[](method, path, headers, body)
 				body = Body::Buffered.wrap(body)
 				
@@ -32,7 +57,11 @@ module Async
 			end
 			
 			def idempotent?
-				method != 'POST' && (body.nil? || body.empty?)
+				method != POST && (body.nil? || body.empty?)
+			end
+			
+			def to_s
+				"#{@method} #{@path} #{@version}"
 			end
 		end
 	end

data/lib/async/http/response.rb

@@ -22,9 +22,23 @@ require_relative 'body/buffered'
 
 module Async
 	module HTTP
-		class Response < Struct.new(:version, :status, :reason, :headers, :body)
+		class Response
 			prepend Body::Buffered::Reader
 			
+			def initialize(version = nil, status = 200, reason = nil, headers = [], body = nil)
+				@version = version
+				@status = status
+				@reason = reason
+				@headers = headers
+				@body = body
+			end
+			
+			attr_accessor :version
+			attr_accessor :status
+			attr_accessor :reason
+			attr_accessor :headers
+			attr_accessor :body
+			
 			def continue?
 				status == 100
 			end
@@ -45,6 +59,10 @@ module Async
 				status >= 400 && status < 600
 			end
 			
+			def bad_request?
+				status == 400
+			end
+			
 			def self.[](status, headers = {}, body = [])
 				body = Body::Buffered.wrap(body)
 				
@@ -54,6 +72,10 @@ module Async
 			def self.for_exception(exception)
 				Async::HTTP::Response[500, {'content-type' => 'text/plain'}, ["#{exception.class}: #{exception.message}"]]
 			end
+			
+			def to_s
+				"#{@status} #{@reason} #{@version}"
+			end
 		end
 	end
 end

data/lib/async/http/server.rb

@@ -48,18 +48,11 @@ module Async
 				
 				Async.logger.debug(self) {"Incoming connnection from #{address.inspect} to #{protocol}"}
 				
-				hijack = catch(:hijack) do
-					protocol.receive_requests do |request|
-						# Async.logger.debug(self) {"Incoming request from #{address.inspect}: #{request.method} #{request.path}"}
-						handle_request(request, peer, address)
-					end
+				protocol.receive_requests do |request|
+					# Async.logger.debug(self) {"Incoming request from #{address.inspect}: #{request.method} #{request.path}"}
 					
-					# hijack should be false by default.
-					false
-				end
-				
-				if hijack
-					hijack.call(peer)
+					# If this returns nil, we assume that the connection has been hijacked.
+					handle_request(request, peer, address)
 				end
 			rescue EOFError, Errno::ECONNRESET, Errno::EPIPE
 				# Sometimes client will disconnect without completing a result or reading the entire buffer. That means we are done.

data/lib/async/http/statistics.rb

@@ -46,7 +46,7 @@ module Async
 				def initialize(start_time, body, callback)
 					super(body)
 					
-					@bytesize = 0
+					@length = 0
 					
 					@start_time = start_time
 					@first_chunk_time = nil
@@ -59,7 +59,7 @@ module Async
 				attr :first_chunk_time
 				attr :end_time
 				
-				attr :bytesize
+				attr :length
 				
 				def total_duration
 					if @end_time
@@ -85,7 +85,7 @@ module Async
 					@first_chunk_time ||= Clock.now
 					
 					if chunk
-						@bytesize += chunk.bytesize
+						@length += chunk.length
 					else
 						complete_statistics
 					end
@@ -94,7 +94,7 @@ module Async
 				end
 				
 				def to_s
-					parts = ["sent #{@bytesize} bytes"]
+					parts = ["sent #{@length} bytes"]
 					
 					if duration = self.total_duration
 						parts << "took #{format_duration(duration)} in total"

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.24.3"
+		VERSION = "0.25.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.24.3
+  version: 0.25.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-22 00:00:00.000000000 Z
+date: 2018-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -156,6 +156,7 @@ files:
 - lib/async/http/middleware/builder.rb
 - lib/async/http/pool.rb
 - lib/async/http/protocol.rb
+- lib/async/http/protocol/bad_request.rb
 - lib/async/http/protocol/http1.rb
 - lib/async/http/protocol/http10.rb
 - lib/async/http/protocol/http11.rb