async-http 0.27.13 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c02c5af2eb616dc015cd2897b79e5a02953e462345cb598f1b8f91bcff978cc
-  data.tar.gz: c1af0f5da029636d55a310d1cdc915a9eff057ba0b0ca5878b016ff59874e0dc
+  metadata.gz: b0902e29085dc6e9908afb45613d5a8d923f60767fb111b2a1ef5d8a549b75dd
+  data.tar.gz: ff5f7aaf1141e192d95b53a197ef12b5ad4404fad761d09201367d0f029decf5
 SHA512:
-  metadata.gz: 5409d5bb69202a4cba94af3daae5c79f12044fcaa8fb4fe4e2ab8da418ea714c452c70351e3d4386143fad92df0bbfac3cc3ac6bc1a70f251b53ebf4fc5117a5
-  data.tar.gz: 15173bb7a9bb74ceadfe73f8c2d9720ba8b195b7f39f068eb8ae5831a7554240b2a84bbab74d005ab5aefcdd129e429c0f650d779a6e62afd60d41fed888a3cc
+  metadata.gz: a70f1bb712b485d3aeae3cc374f4c430f628ac3e8db194757f4b83233e1fc91937d8b13ad04d7d22e0ee3ff8cb95d9515063211e98ff0d796beced993c52a282
+  data.tar.gz: '04821bd0c538d1df175152e3591cef5603a4ab593f57313378bb87a088a98784f40e0f5fc05ebeb988f3fd710329b0859fdec560c7b0048ab17b8efd3115f649'

data/README.md

@@ -147,11 +147,19 @@ According to these results, the cost of handling connections is quite high, whil
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
+## See Also
+
+- [benchmark-http](https://github.com/socketry/benchmark-http) — A benchmarking tool to report on web server concurrency.
+- [falcon](https://github.com/socketry/falcon) — A rack compatible server built on top of `async-http`.
+- [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`.
+
 ## License
 
 Released under the MIT license.
 
-Copyright, 2015, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
+Copyright, 2018, by [Samuel G. D. Williams](http://www.codeotaku.com/samuel-williams).
 
 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/Rakefile

@@ -6,6 +6,7 @@ RSpec::Core::RakeTask.new(:test)
 task :default => :test
 
 require 'async/http/protocol'
+require 'async/http/url_endpoint'
 require 'async/io/host_endpoint'
 
 PROTOCOL = Async::HTTP::Protocol::HTTP1
@@ -16,6 +17,31 @@ task :debug do
 	Async.logger.level = Logger::DEBUG
 end
 
+task :google do
+	require 'async'
+	require 'pry'
+	
+	Async.run do
+		endpoint = Async::HTTP::URLEndpoint.parse("https://www.google.com")
+		peer = endpoint.connect
+		stream = Async::IO::Stream.new(peer)
+		
+		framer = ::HTTP::Protocol::HTTP2::Framer.new(stream)
+		client = ::HTTP::Protocol::HTTP2::Client.new(framer)
+		
+		client.send_connection_preface([])
+		
+		stream = ::HTTP::Protocol::HTTP2::Stream.new(client)
+		
+		client.read_frame
+		client.read_frame
+		
+		stream.send_headers(nil, [[':method', 'GET'], [':authority', 'www.google.com'], [':path', '/']], ::HTTP::Protocol::HTTP2::END_STREAM)
+		
+		binding.pry
+	end
+end
+
 task :server do
 	require 'async/reactor'
 	require 'async/container/forked'

data/async-http.gemspec

@@ -13,13 +13,14 @@ Gem::Specification.new do |spec|
 	spec.files         = `git ls-files -z`.split("\x0").reject do |f|
 		f.match(%r{^(test|spec|features)/})
 	end
-	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.executables   = spec.files.grep(%r{^bin/}) {|f| File.basename(f)}
 	spec.require_paths = ["lib"]
 	
 	spec.add_dependency("async", "~> 1.6")
-	spec.add_dependency("async-io", "~> 1.13")
+	spec.add_dependency("async-io", "~> 1.14")
+	
+	spec.add_dependency("http-protocol", "~> 0.1.0")
 	
-	spec.add_dependency("http-2", "~> 0.9.0")
 	# spec.add_dependency("openssl")
 	
 	spec.add_development_dependency "async-rspec", "~> 1.10"

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

@@ -18,345 +18,34 @@
 # 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 'http11'
-
-require 'async/notification'
-
-require 'http/2'
+require_relative 'http2/client'
+require_relative 'http2/server'
 
 module Async
 	module HTTP
 		module Protocol
-			# A server that supports both HTTP1.0 and HTTP1.1 semantics by detecting the version of the request.
-			class HTTP2
-				def self.client(stream)
-					self.new(::HTTP2::Client.new, stream)
-				end
-				
-				def self.server(stream)
-					self.new(::HTTP2::Server.new, stream)
-				end
-				
-				HTTPS = 'https'.freeze
-				SCHEME = ':scheme'.freeze
-				METHOD = ':method'.freeze
-				PATH = ':path'.freeze
-				AUTHORITY = ':authority'.freeze
-				REASON = ':reason'.freeze
-				STATUS = ':status'.freeze
-				VERSION = 'HTTP/2.0'.freeze
-				
-				def initialize(controller, stream)
-					@controller = controller
-					@stream = stream
-					
-					@controller.on(:frame) do |data|
-						@stream.write(data)
-						@stream.flush
-					end
-					
-					@controller.on(:frame_sent) do |frame|
-						Async.logger.debug(self) {"Sent frame: #{frame.inspect}"}
-					end
-					
-					@controller.on(:frame_received) do |frame|
-						Async.logger.debug(self) {"Received frame: #{frame.inspect}"}
-					end
-					
-					@goaway = false
-					
-					@controller.on(:goaway) do |payload|
-						Async.logger.error(self) {"goaway: #{payload.inspect}"}
-						
-						@goaway = true
-					end
-					
-					@count = 0
-				end
-				
-				def peer
-					@stream.io
-				end
-				
-				attr :count
-				
-				# Multiple requests can be processed at the same time.
-				def multiplex
-					@controller.remote_settings[:settings_max_concurrent_streams]
-				end
-				
-				# Can we use this connection to make requests?
-				def good?
-					@stream.connected?
-				end
-				
-				def reusable?
-					!@goaway || !@stream.closed?
-				end
-				
-				def version
-					VERSION
-				end
-				
-				def start_connection
-					@reader ||= read_in_background
-				end
-				
-				def read_in_background(task: Task.current)
-					task.async do |nested_task|
-						nested_task.annotate("#{version} reading data")
-						
-						while buffer = @stream.read_partial
-							@controller << buffer
-						end
-						
-						Async.logger.debug(self) {"Connection reset by peer!"}
-					end
-				end
-				
-				def close
-					Async.logger.debug(self) {"Closing connection"}
-					
-					@reader.stop if @reader
-					@stream.close
-				end
-				
-				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)
-						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
-				end
-				
-				def receive_requests(task: Task.current, &block)
-					# emits new streams opened by the client
-					@controller.on(:stream) do |stream|
-						@count += 1
-						
-						request = Request.new(self, stream)
-						body = request.body
-						
-						stream.on(:headers) do |headers|
-							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|
-							body.write(chunk.to_s) unless chunk.empty?
-						end
-						
-						stream.on(:half_close) do
-							# We are no longer receiving any more data frames:
-							body.finish
-						end
-						
-						stream.on(:close) do |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
-					
-					start_connection
-					@reader.wait
-				end
+			module HTTP2
+				DEFAULT_SETTINGS = {
+					::HTTP::Protocol::HTTP2::Settings::ENABLE_PUSH => 0,
+					::HTTP::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 256
+				}
 				
-				# 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.headers({':status' => '500'}, end_stream: true)
-					end
-				rescue
-					Async.logger.error(request) {$!}
-				end
-				
-				class Response < Protocol::Response
-					def initialize(protocol, stream)
-						super(protocol.version, nil, nil, Headers.new, Body::Writable.new)
-						
-						@protocol = protocol
-						@stream = stream
-					end
-					
-					def assign_headers(headers)
-						headers.each do |key, value|
-							if key == STATUS
-								@status = value.to_i
-							elsif key == REASON
-								@reason = value
-							else
-								@headers[key] = value
-							end
-						end
-					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))
-							else
-								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|
-						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
-					
-					write_request(request, stream)
-					
-					Async.logger.debug(self) {"Request sent, waiting for signal."}
-					finished.wait
+				def self.client(stream, settings = DEFAULT_SETTINGS)
+					client = Client.new(stream)
 					
-					if exception
-						raise exception
-					end
+					client.send_connection_preface(settings)
+					client.start_connection
 					
-					Async.logger.debug(self) {"Stream finished: #{response.inspect}"}
-					return response
+					return client
 				end
 				
-				private def write_request(request, stream)
-					headers = Headers::Merged.new({
-						SCHEME => HTTPS,
-						METHOD => request.method,
-						PATH => request.path,
-						AUTHORITY => request.authority,
-					}, request.headers)
+				def self.server(stream, settings = DEFAULT_SETTINGS)
+					server = Server.new(stream)
 					
-					if request.body.nil? or request.body.empty?
-						stream.headers(headers, end_stream: true)
-						request.body.read if request.body
-					else
-						begin
-							stream.headers(headers)
-						rescue
-							raise RequestFailed.new
-						end
-						
-						request.body.each do |chunk|
-							stream.data(chunk, end_stream: false)
-						end
-							
-						stream.data("")
-					end
+					server.read_connection_preface(settings)
+					server.start_connection
 					
-					start_connection
-					@stream.flush
+					return server
 				end
 			end
 		end

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

@@ -0,0 +1,57 @@
+# 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.
+
+require_relative 'connection'
+require_relative 'response'
+
+require 'http/protocol/http2/client'
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP2
+				class Client < ::HTTP::Protocol::HTTP2::Client
+					include Connection
+					
+					def initialize(stream, *args)
+						@stream = stream
+						
+						framer = ::HTTP::Protocol::HTTP2::Framer.new(@stream)
+						
+						super(framer, *args)
+					end
+					
+					# Used by the client to send requests to the remote server.
+					def call(request)
+						@count += 1
+						
+						response = Response.new(self, next_stream_id)
+						
+						response.send_request(request)
+						
+						response.wait
+						
+						return response
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,94 @@
+# 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.
+
+require_relative 'stream'
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP2
+				HTTPS = 'https'.freeze
+				SCHEME = ':scheme'.freeze
+				METHOD = ':method'.freeze
+				PATH = ':path'.freeze
+				AUTHORITY = ':authority'.freeze
+				REASON = ':reason'.freeze
+				STATUS = ':status'.freeze
+				VERSION = 'HTTP/2.0'.freeze
+				
+				module Connection
+					def initialize(*)
+						super
+						
+						@count = 0
+						@reader = nil
+					end
+					
+					def start_connection
+						@reader ||= read_in_background
+					end
+					
+					def read_in_background(task: Task.current)
+						task.async do |nested_task|
+							nested_task.annotate("#{version} reading data")
+							
+							while !self.closed?
+								self.read_frame
+							end
+							
+							Async.logger.debug(self) {"Connection reset by peer!"}
+						end
+					end
+					
+					def peer
+						@stream.io
+					end
+					
+					attr :count
+					
+					# Only one simultaneous connection at a time.
+					def multiplex
+						@remote_settings.maximum_concurrent_streams
+					end
+					
+					# Can we use this connection to make requests?
+					def good?
+						@stream.connected?
+					end
+					
+					def reusable?
+						!(self.closed? || @stream.closed?)
+					end
+					
+					def version
+						VERSION
+					end
+					
+					def close
+						Async.logger.debug(self) {"Closing connection"}
+						
+						@reader.stop if @reader
+						@stream.close
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,103 @@
+# 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.
+
+require_relative '../request'
+require_relative 'connection'
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP2
+				class Request < Protocol::Request
+					def initialize(protocol, stream_id)
+						@input = Body::Writable.new
+						
+						super(nil, nil, nil, VERSION, Headers.new, @input)
+						
+						@protocol = protocol
+						@stream = Stream.new(self, protocol, stream_id)
+					end
+					
+					attr :stream
+					
+					def hijack?
+						false
+					end
+					
+					def receive_headers(stream, headers, end_stream)
+						headers.each do |key, value|
+							if key == METHOD
+								return @stream.send_failure(400, "Request method already specified") if @method
+								
+								@method = value
+							elsif key == PATH
+								return @stream.send_failure(400, "Request path already specified") if @path
+								
+								@path = value
+							elsif key == AUTHORITY
+								return @stream.send_failure(400, "Request authority already specified") if @authority
+								
+								@authority = value
+							else
+								@headers[key] = value
+							end
+						end
+						
+						# We are ready for processing:
+						@protocol.requests.enqueue self
+					end
+					
+					def receive_data(stream, data, end_stream)
+						unless data.empty?
+							@input.write(data)
+						end
+						
+						if end_stream
+							@input.finish
+						end
+					end
+					
+					def receive_reset_stream(stream, error_code)
+					end
+					
+					NO_RESPONSE = [[STATUS, '500'], [REASON, "No response generated"]]
+					
+					def send_response(response)
+						if response.nil?
+							@stream.send_headers(nil, NO_RESPONSE, ::HTTP::Protocol::HTTP2::END_STREAM)
+						else
+							headers = Headers::Merged.new({
+								STATUS => response.status,
+								REASON => response.reason,
+							}, response.headers)
+							
+							if response.body.nil?
+								@stream.send_headers(nil, headers, ::HTTP::Protocol::HTTP2::END_STREAM)
+							else
+								@stream.send_headers(nil, headers)
+								@stream.send_body(response.body)
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,111 @@
+# 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.
+
+require_relative '../response'
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP2
+				class Response < Protocol::Response
+					def initialize(protocol, stream_id)
+						@input = Body::Writable.new
+						
+						super(protocol.version, nil, nil, Headers.new, @input)
+						
+						@protocol = protocol
+						@stream = Stream.new(self, protocol, stream_id)
+						
+						@notification = Async::Notification.new
+						@exception = nil
+					end
+					
+					def wait
+						@notification.wait
+						
+						if @exception
+							raise @exception
+						end
+					end
+					
+					def receive_headers(stream, headers, end_stream)
+						headers.each do |key, value|
+							if key == STATUS
+								@status = value.to_i
+							elsif key == REASON
+								@reason = value
+							else
+								@headers[key] = value
+							end
+						end
+						
+						if end_stream
+							@input.finish
+						end
+						
+						# We are ready for processing:
+						@notification.signal
+					end
+					
+					def receive_data(stream, data, end_stream)
+						unless data.empty?
+							@input.write(data)
+						end
+						
+						if end_stream
+							@input.finish
+						end
+					rescue EOFError
+						@stream.send_reset_stream(0)
+					end
+					
+					def receive_reset_stream(stream, error_code)
+						if error_code > 0
+							@exception = EOFError.new(error_code)
+						end
+						
+						@notification.signal
+					end
+					
+					def send_request(request)
+						headers = Headers::Merged.new({
+							SCHEME => HTTPS,
+							METHOD => request.method,
+							PATH => request.path,
+							AUTHORITY => request.authority,
+						}, request.headers)
+						
+						if request.body.nil?
+							@stream.send_headers(nil, headers, ::HTTP::Protocol::HTTP2::END_STREAM)
+						else
+							begin
+								@stream.send_headers(nil, headers)
+							rescue
+								raise RequestFailed
+							end
+							
+							@stream.send_body(request.body)
+						end
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,68 @@
+# 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.
+
+require_relative 'connection'
+require_relative 'request'
+
+require 'http/protocol/http2/server'
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP2
+				class Server < ::HTTP::Protocol::HTTP2::Server
+					include Connection
+					
+					def initialize(stream, *args)
+						framer = ::HTTP::Protocol::HTTP2::Framer.new(stream)
+						
+						super(framer, *args)
+						
+						@requests = Async::Queue.new
+					end
+					
+					attr :requests
+					
+					def create_stream(stream_id)
+						request = Request.new(self, stream_id)
+						
+						return request.stream
+					end
+					
+					def receive_requests(task: Task.current)
+						while request = @requests.dequeue
+							@count += 1
+							
+							# We need to close the stream if the user code blows up while generating a response:
+							response = begin
+								response = yield(request)
+							rescue
+								request.stream.send_reset_stream(::HTTP::Protocol::HTTP2::INTERNAL_ERROR)
+								Async.logger.error(request) {$!}
+							else
+								request.send_response(response)
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+end

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

@@ -0,0 +1,121 @@
+# 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.
+
+require 'http/protocol/http2/stream'
+
+module Async
+	module HTTP
+		module Protocol
+			module HTTP2
+				class Stream < ::HTTP::Protocol::HTTP2::Stream
+					def initialize(delegate, *args)
+						super(*args)
+						
+						@delegate = delegate
+						
+						@body = body
+						@remainder = nil
+					end
+					
+					attr_accessor :delegate
+					attr :body
+					
+					def send_body(body)
+						@body = body
+						
+						window_updated
+					end
+					
+					def send_chunk
+						maximum_size = self.available_frame_size
+						
+						if maximum_size == 0
+							return false
+						end
+						
+						if @remainder
+							chunk = @remainder
+							@remainder = nil
+						elsif chunk = @body.read
+						else
+							@body = nil
+							
+							# @body.read above might take a while and a stream reset might be received in the mean time.
+							unless @state == :closed
+								send_data(nil, ::HTTP::Protocol::HTTP2::END_STREAM)
+							end
+							
+							return false
+						end
+						
+						return false if @state == :closed
+						
+						if chunk.bytesize <= maximum_size
+							send_data(chunk, maximum_size: maximum_size)
+							
+							return true
+						else
+							send_data(chunk.byteslice(0, maximum_size), padding_size: 0)
+							@remainder = chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
+							
+							return false
+						end
+					end
+					
+					def window_updated
+						return unless @body
+						
+						while send_chunk; end
+					end
+					
+					def receive_headers(frame)
+						headers = super
+						
+						delegate.receive_headers(self, headers, frame.end_stream?)
+						
+						return headers
+					end
+					
+					def receive_data(frame)
+						data = super
+						
+						if data
+							delegate.receive_data(self, data, frame.end_stream?)
+						end
+						
+						return data
+					end
+					
+					def receive_reset_stream(frame)
+						error_code = super
+						
+						if @body
+							@body.stop(EOFError.new(error_code))
+						end
+						
+						delegate.receive_reset_stream(self, error_code)
+						
+						return error_code
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/http/reference.rb

@@ -168,11 +168,11 @@ module Async
 			def encode(value, prefix = nil)
 				case value
 				when Array
-					return value.map { |v|
+					return value.map {|v|
 						encode(v, "#{prefix}[]")
 					}.join("&")
 				when Hash
-					return value.map { |k, v|
+					return value.map {|k, v|
 						encode(v, prefix ? "#{prefix}[#{escape(k.to_s)}]" : escape(k.to_s))
 					}.reject(&:empty?).join('&')
 				when nil

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.27.13"
+		VERSION = "0.28.0"
 	end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.27.13
+  version: 0.28.0
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-07-21 00:00:00.000000000 Z
+date: 2018-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -30,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '1.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.13'
+        version: '1.14'
 - !ruby/object:Gem::Dependency
-  name: http-2
+  name: http-protocol
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.9.0
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -162,6 +162,12 @@ files:
 - lib/async/http/protocol/http10.rb
 - lib/async/http/protocol/http11.rb
 - lib/async/http/protocol/http2.rb
+- lib/async/http/protocol/http2/client.rb
+- lib/async/http/protocol/http2/connection.rb
+- lib/async/http/protocol/http2/request.rb
+- lib/async/http/protocol/http2/response.rb
+- lib/async/http/protocol/http2/server.rb
+- lib/async/http/protocol/http2/stream.rb
 - lib/async/http/protocol/https.rb
 - lib/async/http/protocol/request.rb
 - lib/async/http/protocol/response.rb