async-http 0.26.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f41c8e5613af9f0522c24461c31c8cdc410ca04f04fecd3b1e727c716e245f1c
-  data.tar.gz: 965be2b71c176eb7f11c05b182551be39bc17371997b50ea1ca3e8a9745934ec
+  metadata.gz: 46c2f19cb8438e19ef4b02d5a35dc2916c316119682cd022d3eda40f8a0acf55
+  data.tar.gz: 6d9c903d8337af465cb0ce824fada879e83e90063cf8ebf2f99445c4e330b01e
 SHA512:
-  metadata.gz: c080e937e8daf6914b9b9f0b37ef16f310fde136f9d834b4a7be11f9a13239927c8ec9e6ec51143b5b27e4f4141a0a9859c321a4d252c60caf3ea0e827537857
-  data.tar.gz: ab34e94fbd6ce5e5e73d8509dd506c3044c95f30d9f37e68491b4426c047a94cab5265c912bca6b5be662bbf2cc01c06f3d1639900d655c98360087685f5a98e
+  metadata.gz: ae20e6866313108201bcf25af615131296725836d9bc94b7d816b00abd1416d7ffe098d2614df8c9d285b3bddce965fee0b0cfe9867f1d09b8ef4f4ca517ba8c
+  data.tar.gz: 2c9087a2300ecfed16f8a7977e549511ede35fc83eb283b4f9939219bac7e5f04640bcfe0d061780c1579f5e007eb7e545ac8c2c79504af5efae98e41408b56a

data/.travis.yml

@@ -18,6 +18,7 @@ matrix:
     - rvm: 2.3
     - rvm: 2.4
     - rvm: 2.5
+    - rvm: 2.6
     - rvm: jruby-head
       env: JRUBY_OPTS="--debug -X+O"
     - rvm: ruby-head

data/Rakefile

@@ -21,7 +21,7 @@ task :server do
 	require 'async/container/forked'
 	require 'async/http/server'
 	
-	server = Async::HTTP::Server.new(Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true), PROTOCOL) do |request, peer, address|
+	server = Async::HTTP::Server.for(Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true), PROTOCOL) do |request|
 		return Async::HTTP::Response[200, {'content-type' => 'text/plain'}, ["Hello World"]]
 	end
 	
@@ -58,7 +58,7 @@ task :wrk do
 	require 'async/http/server'
 	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|
+	server = Async::HTTP::Server.for(Async::IO::Endpoint.tcp('127.0.0.1', 9294, reuse_port: true), PROTOCOL) do |request|
 		return Async::HTTP::Response[200, {'content-type' => 'text/plain'}, ["Hello World"]]
 	end
 

data/lib/async/http/accept_encoding.rb

@@ -38,7 +38,7 @@ module Async
 				@wrappers = wrappers
 			end
 			
-			def call(request, *)
+			def call(request)
 				request.headers['accept-encoding'] = @accept_encoding
 				
 				response = super

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

@@ -89,18 +89,6 @@ module Async
 				def inspect
 					"\#<#{self.class} #{@chunks.count} chunks, #{self.length} bytes>"
 				end
-				
-				module Reader
-					def read
-						self.body ? self.body.join : nil
-					end
-					
-					def finish
-						return if self.body.nil?
-						
-						self.body = self.body.close
-					end
-				end
 			end
 		end
 	end

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

@@ -24,13 +24,19 @@ module Async
 	module HTTP
 		module Body
 			class File < Readable
-				def initialize(path, range = nil, block_size: Async::IO::Stream::BLOCK_SIZE)
-					@path = path
-					@file = File.open(path)
+				BLOCK_SIZE = Async::IO::Stream::BLOCK_SIZE
+				
+				def self.open(path, *args)
+					self.new(::File.open(path), *args)
+				end
+				
+				def initialize(file, range = nil, block_size: BLOCK_SIZE)
+					@file = file
 					
 					@block_size = block_size
 					
 					if range
+						@file.seek(range.min)
 						@offset = range.min
 						@length = @remaining = range.size
 					else
@@ -39,12 +45,22 @@ module Async
 					end
 				end
 				
+				attr :offset
 				attr :length
 				
 				def empty?
 					@remaining == 0
 				end
 				
+				def rewind
+					@file.seek(@offset)
+				end
+				
+				def close
+					@file.close
+					@remaining = 0
+				end
+				
 				def read
 					if @remaining > 0
 						amount = [@remaining, @block_size].min
@@ -60,6 +76,8 @@ module Async
 				end
 				
 				def join
+					return "" if @remaining == 0
+					
 					buffer = @file.read(@remaining)
 					
 					@remaining = 0
@@ -68,7 +86,7 @@ module Async
 				end
 				
 				def inspect
-					"\#<#{self.class} path=#{@path} offset=#{@offset} remaining=#{@remaining}>"
+					"\#<#{self.class} file=#{@file.inspect} offset=#{@offset} remaining=#{@remaining}>"
 				end
 			end
 		end

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

@@ -38,7 +38,9 @@ module Async
 				end
 				
 				def stop(error)
-					@stream.close
+					if @remaining != 0
+						@stream.close
+					end
 				end
 				
 				def read
@@ -74,6 +76,7 @@ module Async
 				end
 				
 				def stop(error)
+					# We can't really do anything in this case except close the connection.
 					@stream.close
 				end
 				

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

@@ -25,7 +25,7 @@ module Async
 		module Body
 			# A generic base class for wrapping body instances. Typically you'd override `#read`.
 			class Readable
-				# Buffer any remaining body.
+				# Read all remaining chunks into a buffered body.
 				def close
 					Buffered.for(self)
 				end

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

@@ -0,0 +1,59 @@
+# 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 Body
+			module Reader
+				# Read chunks from the body.
+				def each(&block)
+					self.body.each(&block)
+				end
+				
+				# Reads the entire request/response body.
+				def read
+					if self.body
+						self.body.join
+					end
+				end
+				
+				# Immediately stop reading the body. May close the underlying connection. Discards body.
+				def stop(error = EOFError)
+					if self.body
+						self.body.stop(error)
+						self.body = nil
+					end
+				end
+				
+				# Gracefully finish reading the body. This will buffer the remainder of the body.
+				def finish
+					if self.body
+						self.body = self.body.close
+					end
+				end
+				
+				# Close the connection as quickly as possible. Discards body.
+				def close
+					self.stop
+				end
+			end
+		end
+	end
+end

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

@@ -39,6 +39,12 @@ module Async
 					@callback = callback
 				end
 				
+				def stop(*)
+					super
+					
+					@callback.call
+				end
+				
 				def read
 					unless chunk = super
 						@callback.call

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

@@ -36,13 +36,14 @@ module Async
 					@stopped = nil
 				end
 				
+				# Has the producer called #finish and has the reader consumed the nil token?
 				def empty?
 					@finished
 				end
 				
 				# Read the next available chunk.
 				def read
-					# I'm not sure if this is a good idea (*).
+					# I'm not sure if this is a good idea.
 					# if @stopped
 					# 	raise @stopped
 					# end
@@ -56,9 +57,9 @@ module Async
 					return chunk
 				end
 				
-				# Cause the next call to write to fail with the given error.
+				# Stop generating output; cause the next call to write to fail with the given error.
 				def stop(error)
-					@stopped = error
+					@stopped ||= error
 				end
 				
 				# Write a single chunk to the body. Signal completion by calling `#finish`.
@@ -77,7 +78,7 @@ module Async
 				
 				alias << write
 				
-				# Signal that output has finished.
+				# Signal that output has finished. This must be called at least once.
 				def finish
 					@queue.enqueue(nil)
 				end

data/lib/async/http/client.rb

@@ -34,13 +34,16 @@ module Async
 				@authority = authority || endpoint.hostname
 				
 				@retries = retries
-				@connections = connect(**options)
+				@pool = connect(**options)
 			end
 			
 			attr :endpoint
 			attr :protocol
 			attr :authority
 			
+			attr :retries
+			attr :pool
+			
 			def self.open(*args, &block)
 				client = self.new(*args)
 				
@@ -54,10 +57,10 @@ module Async
 			end
 			
 			def close
-				@connections.close
+				@pool.close
 			end
 			
-			include Verbs
+			include Methods
 			
 			def call(request)
 				request.authority ||= @authority
@@ -67,20 +70,20 @@ module Async
 				begin
 					attempt += 1
 					
-					# As we cache connections, it's possible these connections go bad (e.g. closed by remote host). In this case, we need to try again. It's up to the caller to impose a timeout on this. If this is the last attempt, we force a new connection.
-					connection = @connections.acquire
+					# As we cache pool, it's possible these pool go bad (e.g. closed by remote host). In this case, we need to try again. It's up to the caller to impose a timeout on this. If this is the last attempt, we force a new connection.
+					connection = @pool.acquire
 					
 					response = connection.call(request)
 					
 					# The connection won't be released until the body is completely read/released.
 					Body::Streamable.wrap(response) do
-						@connections.release(connection)
+						@pool.release(connection)
 					end
 					
 					return response
 				rescue Protocol::RequestFailed
 					# This is a specific case where the entire request wasn't sent before a failure occurred. So, we can even resend non-idempotent requests.
-					@connections.release(connection)
+					@pool.release(connection)
 					
 					attempt += 1
 					if attempt < @retries
@@ -89,7 +92,7 @@ module Async
 						raise
 					end
 				rescue
-					@connections.release(connection)
+					@pool.release(connection)
 					
 					if request.idempotent? and attempt < @retries
 						retry

data/lib/async/http/content_encoding.rb

@@ -40,7 +40,7 @@ module Async
 				@wrappers = wrappers
 			end
 			
-			def call(request, *)
+			def call(request)
 				response = super
 				
 				# TODO use http-accept and sort by priority

data/lib/async/http/middleware.rb

@@ -30,7 +30,7 @@ module Async
 		
 		VERBS = [GET, HEAD, POST, PUT, PATCH, DELETE, CONNECT].freeze
 		
-		module Verbs
+		module Methods
 			VERBS.each do |verb|
 				define_method(verb.downcase) do |location, headers = {}, body = []|
 					self.call(Request[verb, location.to_str, headers, body])
@@ -47,17 +47,17 @@ module Async
 				@app.close
 			end
 			
-			include Verbs
+			include Methods
 			
-			def call(*args)
-				@app.call(*args)
+			def call(request)
+				@app.call(request)
 			end
 			
 			module Okay
 				def self.close
 				end
 				
-				def self.call(request, *)
+				def self.call(request)
 					Response[200, {}, []]
 				end
 			end
@@ -66,7 +66,7 @@ module Async
 				def self.close
 				end
 				
-				def self.call(request, *)
+				def self.call(request)
 					Response[200, {'content-type' => 'text/plain'}, ["Hello World!"]]
 				end
 			end

data/lib/async/http/pool.rb

@@ -44,6 +44,12 @@ module Async
 				@constructor = block
 			end
 			
+			attr :available
+			
+			def empty?
+				@available.empty?
+			end
+			
 			def acquire
 				resource = wait_for_next_available
 				

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

@@ -20,12 +20,8 @@
 
 require 'async/io/protocol/line'
 
-require_relative 'request_failed'
-require_relative 'bad_request'
-
-require_relative '../request'
-require_relative '../response'
-require_relative '../headers'
+require_relative 'request'
+require_relative 'response'
 
 require_relative '../body/chunked'
 require_relative '../body/fixed'
@@ -52,6 +48,10 @@ module Async
 					@count = 0
 				end
 				
+				def peer
+					@stream.io
+				end
+				
 				attr :count
 				
 				# Only one simultaneous connection at a time.
@@ -93,15 +93,13 @@ module Async
 					return @stream.io
 				end
 				
-				class Request < HTTP::Request
+				class Request < Protocol::Request
 					def initialize(protocol)
 						super(*protocol.read_request)
 						
 						@protocol = protocol
 					end
 					
-					attr :protocol
-					
 					def hijack?
 						true
 					end
@@ -133,7 +131,7 @@ module Async
 				def receive_requests(task: Task.current)
 					while request = next_request
 						if response = yield(request, self)
-							write_response(response.version || self.version, response.status, response.headers, response.body)
+							write_response(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.
@@ -144,14 +142,21 @@ module Async
 					end
 				end
 				
+				class Response < Protocol::Response
+					def initialize(protocol, request)
+						super(*protocol.read_response(request))
+						
+						@protocol = protocol
+					end
+				end
+				
+				# Used by the client to send requests to the remote server.
 				def call(request)
-					request.version ||= self.version
-					
 					Async.logger.debug(self) {"#{request.method} #{request.path} #{request.headers.inspect}"}
 					
 					# We carefully interpret https://tools.ietf.org/html/rfc7230#section-6.3.1 to implement this correctly.
 					begin
-						write_request(request.authority, request.method, request.path, request.version, request.headers)
+						write_request(request.authority, request.method, request.path, self.version, request.headers)
 					rescue
 						# If we fail to fully write the request and body, we can retry this request.
 						raise RequestFailed.new
@@ -160,7 +165,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(request))
+					return Response.new(self, request)
 				rescue
 					# This will ensure that #reusable? returns false.
 					@stream.close

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

@@ -18,10 +18,8 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
-require_relative '../request'
-require_relative '../response'
-require_relative '../headers'
-require_relative '../body/writable'
+require_relative 'request'
+require_relative 'response'
 
 require_relative 'http11'
 
@@ -79,6 +77,10 @@ module Async
 					@count = 0
 				end
 				
+				def peer
+					@stream.io
+				end
+				
 				attr :count
 				
 				# Multiple requests can be processed at the same time.
@@ -122,13 +124,18 @@ module Async
 					@stream.close
 				end
 				
-				class Request < HTTP::Request
-					def initialize(stream)
+				class Request < Protocol::Request
+					def initialize(protocol, stream)
 						super(nil, nil, nil, VERSION, Headers.new, Body::Writable.new)
 						
+						@protocol = protocol
 						@stream = stream
 					end
 					
+					def hijack?
+						false
+					end
+					
 					attr :stream
 					
 					def assign_headers(headers)
@@ -150,16 +157,14 @@ module Async
 							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(stream)
+						@count += 1
+						
+						request = Request.new(self, stream)
 						body = request.body
 						
 						stream.on(:headers) do |headers|
@@ -188,7 +193,12 @@ module Async
 						end
 						
 						stream.on(:close) do |error|
-							body.stop(EOFError.new(error)) if error
+							if error
+								body.stop(EOFError.new(error))
+							else
+								# In theory, we should have received half_close, so there is no need to:
+								# body.finish
+							end
 						end
 					end
 					
@@ -231,41 +241,50 @@ module Async
 					Async.logger.error(request) {$!}
 				end
 				
-				def call(request)
-					request.version ||= self.version
-					
-					stream = @controller.new_stream
-					@count += 1
-					
-					headers = Headers::Merged.new({
-						SCHEME => HTTPS,
-						METHOD => request.method,
-						PATH => request.path,
-						AUTHORITY => request.authority,
-					}, request.headers)
-					
-					finished = Async::Notification.new
-					
-					exception = nil
-					response = Response.new
-					response.version = self.version
-					response.headers = Headers.new
-					body = Body::Writable.new
-					response.body = body
+				class Response < Protocol::Response
+					def initialize(protocol, stream)
+						super(self.version, nil, nil, Headers.new, Body::Writable.new)
+						
+						@protocol = protocol
+						@stream = stream
+					end
 					
-					stream.on(:headers) do |headers|
+					def assign_headers(headers)
 						headers.each do |key, value|
 							if key == STATUS
-								response.status = value.to_i
+								@status = value.to_i
 							elsif key == REASON
-								response.reason = value
+								@reason = value
 							else
-								response.headers[key] = value
+								@headers[key] = value
 							end
 						end
-						
-						# At this point, we are now expecting two events: data and close.
-						stream.on(:close) do |error|
+					end
+				end
+				
+				# Used by the client to send requests to the remote server.
+				def call(request)
+					@count += 1
+					
+					stream = @controller.new_stream
+					response = Response.new(self, stream)
+					body = response.body
+					
+					exception = nil
+					finished = Async::Notification.new
+					waiting = true
+					
+					stream.on(:close) do |error|
+						if waiting
+							if error
+								# If the stream was closed due to an error, we will raise it rather than returning normally.
+								exception = EOFError.new(error)
+							end
+							
+							waiting = false
+							finished.signal
+						else
+							# At this point, we are now expecting two events: data and close.
 							# If we receive close after this point, it's not a request error, but a failure we need to signal to the body.
 							if error
 								body.stop(EOFError.new(error))
@@ -273,22 +292,52 @@ module Async
 								body.finish
 							end
 						end
+					end
+					
+					stream.on(:headers) do |headers|
+						response.assign_headers(headers)
 						
+						# Once we receive the headers, we can return. The body will be read in the background.
+						waiting = false
 						finished.signal
 					end
 					
+					# This is a little bit tricky due to the event handlers.
+					# 1/ Caller invokes `response.stop` which causes `body.write` below to fail.
+					# 2/ We invoke `stream.close(:internal_error)` which eventually triggers `on(:close)` above.
+					# 3/ Error is set to :internal_error which causes us to call `body.stop` a 2nd time.
+					# So, we guard against that, by ensuring that `Writable#stop` only stores the first exception assigned to it.
 					stream.on(:data) do |chunk|
-						body.write(chunk.to_s) unless chunk.empty?
+						begin
+							# If the body is stopped, write will fail...
+							body.write(chunk.to_s) unless chunk.empty?
+						rescue
+							# ... so, we close the stream:
+							stream.close(:internal_error)
+						end
 					end
 					
-					stream.on(:close) do |error|
-						# The remote server has closed the connection while we were sending the request.
-						if error
-							exception = EOFError.new(error)
-							finished.signal
-						end
+					write_request(request, stream)
+					
+					Async.logger.debug(self) {"Request sent, waiting for signal."}
+					finished.wait
+					
+					if exception
+						raise exception
 					end
 					
+					Async.logger.debug(self) {"Stream finished: #{response.inspect}"}
+					return response
+				end
+				
+				private def write_request(request, stream)
+					headers = Headers::Merged.new({
+						SCHEME => HTTPS,
+						METHOD => request.method,
+						PATH => request.path,
+						AUTHORITY => request.authority,
+					}, request.headers)
+					
 					if request.body.nil? or request.body.empty?
 						stream.headers(headers, end_stream: true)
 						request.body.read if request.body
@@ -308,16 +357,6 @@ module Async
 					
 					start_connection
 					@stream.flush
-					
-					Async.logger.debug(self) {"Stream flushed, waiting for signal."}
-					finished.wait
-					
-					if exception
-						raise exception
-					end
-					
-					Async.logger.debug(self) {"Stream finished: #{response.inspect}"}
-					return response
 				end
 			end
 		end

data/lib/async/http/protocol/{bad_request.rb → request.rb}

@@ -1,4 +1,4 @@
-# Copyright, 2018, by Samuel G. D. Williams. <http://www.codeotaku.com>
+# Copyright, 2017, 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
@@ -18,12 +18,44 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative '../request'
+require_relative '../headers'
+
+require_relative '../body/writable'
+
 module Async
 	module HTTP
 		module Protocol
+			# Failed to send the request. The request body has NOT been consumed (i.e. #read) and you should retry the request.
+			class RequestFailed < StandardError
+			end
+			
 			# The request was invalid/malformed in some way.
 			class BadRequest < StandardError
 			end
+			
+			# This is generated by server protocols.
+			class Request < HTTP::Request
+				attr :protocol
+				
+				def hijack?
+					false
+				end
+				
+				def peer
+					if @protocol
+						@protocol.peer
+					end
+				end
+				
+				def remote_address
+					@remote_address ||= peer.remote_address
+				end
+				
+				def remote_address= value
+					@remote_address = value
+				end
+			end
 		end
 	end
 end

data/lib/async/http/protocol/{request_failed.rb → response.rb}

@@ -18,11 +18,35 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 
+require_relative '../response'
+require_relative '../headers'
+
+require_relative '../body/writable'
+
 module Async
 	module HTTP
 		module Protocol
-			# Failed to send the request. The request body has NOT been consumed (i.e. #read) and you should retry the request.
-			class RequestFailed < StandardError
+			# This is generated by client protocols.
+			class Response < HTTP::Response
+				attr :protocol
+				
+				def hijack?
+					false
+				end
+				
+				def peer
+					if @protocol
+						@protocol.peer
+					end
+				end
+				
+				def remote_address
+					@remote_address ||= peer.remote_address
+				end
+				
+				def remote_address= value
+					@remote_address = value
+				end
 			end
 		end
 	end

data/lib/async/http/request.rb

@@ -19,12 +19,13 @@
 # THE SOFTWARE.
 
 require_relative 'body/buffered'
+require_relative 'body/reader'
 require_relative 'middleware'
 
 module Async
 	module HTTP
 		class Request
-			prepend Body::Buffered::Reader
+			prepend Body::Reader
 			
 			def initialize(authority = nil, method = nil, path = nil, version = nil, headers = [], body = nil)
 				@authority = authority

data/lib/async/http/response.rb

@@ -19,11 +19,12 @@
 # THE SOFTWARE.
 
 require_relative 'body/buffered'
+require_relative 'body/reader'
 
 module Async
 	module HTTP
 		class Response
-			prepend Body::Buffered::Reader
+			prepend Body::Reader
 			
 			def initialize(version = nil, status = 200, reason = nil, headers = [], body = nil)
 				@version = version

data/lib/async/http/server.rb

@@ -26,18 +26,16 @@ require_relative 'response'
 
 module Async
 	module HTTP
-		class Server
-			def initialize(endpoint, protocol_class = Protocol::HTTP1, &block)
-				@endpoint = endpoint
-				@protocol_class = protocol_class || endpoint.protocol
-				
-				if block_given?
-					define_singleton_method(:handle_request, block)
-				end
+		class Server < Middleware
+			def self.for(*args, &block)
+				self.new(block, *args)
 			end
 			
-			def handle_request(request, peer, address)
-				Response[200, {}, []]
+			def initialize(app, endpoint, protocol_class = Protocol::HTTP1)
+				super(app)
+				
+				@endpoint = endpoint
+				@protocol_class = protocol_class || endpoint.protocol
 			end
 			
 			def accept(peer, address, task: Task.current)
@@ -49,10 +47,11 @@ module Async
 				Async.logger.debug(self) {"Incoming connnection from #{address.inspect} to #{protocol}"}
 				
 				protocol.receive_requests do |request|
+					request.remote_address = address
 					# Async.logger.debug(self) {"Incoming request from #{address.inspect}: #{request.method} #{request.path}"}
 					
 					# If this returns nil, we assume that the connection has been hijacked.
-					handle_request(request, peer, address)
+					self.call(request)
 				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/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.26.0"
+		VERSION = "0.27.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.27.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-26 00:00:00.000000000 Z
+date: 2018-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -146,6 +146,7 @@ files:
 - lib/async/http/body/fixed.rb
 - lib/async/http/body/inflate.rb
 - lib/async/http/body/readable.rb
+- lib/async/http/body/reader.rb
 - lib/async/http/body/rewindable.rb
 - lib/async/http/body/streamable.rb
 - lib/async/http/body/wrapper.rb
@@ -157,13 +158,13 @@ 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
 - lib/async/http/protocol/http2.rb
 - lib/async/http/protocol/https.rb
-- lib/async/http/protocol/request_failed.rb
+- lib/async/http/protocol/request.rb
+- lib/async/http/protocol/response.rb
 - lib/async/http/reference.rb
 - lib/async/http/relative_location.rb
 - lib/async/http/request.rb