async-http 0.45.4 → 0.45.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af620d4e3e885af7b094634cd875459b5613999af8b80464dc52fbc92108d7cb
-  data.tar.gz: a56bea4149a58c74f2830d31f62ef308720a51887574aab81087ebfb095502f6
+  metadata.gz: f10ee1ffdafaf1d8b663c53dcb8d4be3d9462206024a6415214a081e2574bee3
+  data.tar.gz: ee48372568c7563d0e273447299f1701d4dde0872136614a42df34ce26bb830b
 SHA512:
-  metadata.gz: 16bd6f0a463a8fe62e14054fc9918df817a7937f7a172b9c4d5266e588143db6c86ea3d34b83e89dbf77bfe3fc0be3e76cb1b0e0a60e73f6620a251e5768caca
-  data.tar.gz: bdce788539eab5560fb489b7ff9d631218f5fdbaf0c0602d8b054b9bbc43cea6743897c73ff332abd8138fb5e41e711539f96308291d9da6885dc3b291d14cfb
+  metadata.gz: d2fbfbd18899d1d773795afd014e8b1508564c6dc670c7290fd6b9cecd109fd0b2a3612e304352c353435320fcf703e99477ff9ece909baa0734c1e33e0a3f97
+  data.tar.gz: da9ca8b00e9fea4866c9e1806b0c24611f52be3dab459c2df424c00640f63db894f9b5e98e70720b9f244ade1155cb9b96776ccc6812e10272b42d29f01b5439

data/.gitignore

@@ -12,3 +12,4 @@
 
 .rspec_status
 .covered.db
+/h2spec

data/.travis.yml

@@ -29,3 +29,6 @@ matrix:
     - rvm: ruby-head
     - rvm: jruby-head
     - rvm: truffleruby
+
+# after_success:
+#   - bundle exec rake h2spec:all

data/Gemfile

@@ -3,6 +3,9 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in async-io.gemspec
 gemspec
 
+# gem "protocol-http2", path: "../protocol-http2"
+# gem "protocol-hpack", path: "../protocol-hpack"
+
 group :development do
 	gem 'pry'
 end

data/async-http.gemspec

@@ -16,12 +16,12 @@ Gem::Specification.new do |spec|
 	spec.executables   = spec.files.grep(%r{^bin/}) {|f| File.basename(f)}
 	spec.require_paths = ["lib"]
 	
-	spec.add_dependency("async", "~> 1.18")
+	spec.add_dependency("async", "~> 1.19")
 	spec.add_dependency("async-io", "~> 1.18")
 	
 	spec.add_dependency("protocol-http", "~> 0.8.0")
 	spec.add_dependency("protocol-http1", "~> 0.8.0")
-	spec.add_dependency("protocol-http2", "~> 0.6.0")
+	spec.add_dependency("protocol-http2", "~> 0.7.0")
 	
 	# spec.add_dependency("openssl")
 	

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

@@ -33,15 +33,13 @@ module Async
 				
 				CLIENT_SETTINGS = {
 					::Protocol::HTTP2::Settings::ENABLE_PUSH => 0,
-					::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 256,
 					::Protocol::HTTP2::Settings::MAXIMUM_FRAME_SIZE => 0x100000,
 					::Protocol::HTTP2::Settings::INITIAL_WINDOW_SIZE => 0x7FFFFFFF,
-					::Protocol::HTTP2::Settings::ENABLE_CONNECT_PROTOCOL => 1,
 				}
 				
 				SERVER_SETTINGS = {
 					# We choose a lower maximum concurrent streams to avoid overloading a single connection/thread.
-					::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 32,
+					::Protocol::HTTP2::Settings::MAXIMUM_CONCURRENT_STREAMS => 10,
 					::Protocol::HTTP2::Settings::MAXIMUM_FRAME_SIZE => 0x100000,
 					::Protocol::HTTP2::Settings::INITIAL_WINDOW_SIZE => 0x7FFFFFFF,
 					::Protocol::HTTP2::Settings::ENABLE_CONNECT_PROTOCOL => 1,

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

@@ -39,7 +39,7 @@ module Async
 					end
 					
 					def create_response
-						Response.new(self, self.next_stream_id)
+						Response::Stream.create(self, self.next_stream_id).response
 					end
 					
 					# Used by the client to send requests to the remote server.

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

@@ -34,7 +34,9 @@ module Async
 				STATUS = ':status'.freeze
 				PROTOCOL = ':protocol'.freeze
 				
-				CONTENT_LENGTH = 'content-length'
+				CONTENT_LENGTH = 'content-length'.freeze
+				CONNECTION = 'connection'.freeze
+				TRAILERS = 'trailers'.freeze
 				
 				module Connection
 					def initialize(*)
@@ -80,9 +82,10 @@ module Async
 							
 							begin
 								while !self.closed?
+									self.consume_window
 									self.read_frame
 								end
-							rescue EOFError, Async::Wrapper::Cancelled
+							rescue EOFError, Errno::ECONNRESET, Errno::EPIPE, Async::Wrapper::Cancelled
 								# Ignore.
 							ensure
 								close($!)
@@ -99,7 +102,7 @@ module Async
 					attr :count
 					
 					def multiplex
-						@remote_settings.maximum_concurrent_streams
+						self.maximum_concurrent_streams
 					end
 					
 					# Can we use this connection to make requests?

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

@@ -19,59 +19,123 @@
 # THE SOFTWARE.
 
 require_relative '../request'
-require_relative 'connection'
+require_relative 'stream'
 
 module Async
 	module HTTP
 		module Protocol
 			module HTTP2
+				# Typically used on the server side to represent an incoming request, and write the response.
 				class Request < Protocol::Request
-					def initialize(connection, stream_id)
-						super(nil, nil, nil, nil, VERSION, ::Protocol::HTTP::Headers.new)
+					class Stream < HTTP2::Stream
+						def initialize(*)
+							super
+							
+							@enqueued = false
+							@request = Request.new(self)
+						end
 						
-						@input = nil
-						@length = nil
+						attr :request
+						
+						# Create a fake request on the server, with the given headers.
+						def create_push_promise_stream(headers)
+							stream = @connection.create_push_promise_stream(&Stream.method(:create))
+							
+							stream.headers = ::Protocol::HTTP::Headers.new
+							
+							# This will ultimately enqueue the request to be processed by the server:
+							stream.receive_initial_headers(headers, false)
+							
+							return stream
+						end
 						
-						@connection = connection
-						@stream = Stream.new(self, connection, stream_id)
+						def receive_initial_headers(headers, end_stream)
+							headers.each do |key, value|
+								if key == SCHEME
+									raise ::Protocol::HTTP2::HeaderError, "Request scheme already specified!" if @request.scheme
+									
+									@request.scheme = value
+								elsif key == AUTHORITY
+									raise ::Protocol::HTTP2::HeaderError, "Request authority already specified!" if @request.authority
+									
+									@request.authority = value
+								elsif key == METHOD
+									raise ::Protocol::HTTP2::HeaderError, "Request method already specified!" if @request.method
+									
+									@request.method = value
+								elsif key == PATH
+									raise ::Protocol::HTTP2::HeaderError, "Request path is empty!" if value.empty?
+									raise ::Protocol::HTTP2::HeaderError, "Request path already specified!" if @request.path
+									
+									@request.path = value
+								elsif key == PROTOCOL
+									raise ::Protocol::HTTP2::HeaderError, "Request protocol already specified!" if @request.protocol
+									
+									@request.protocol = value
+								elsif key == CONTENT_LENGTH
+									raise ::Protocol::HTTP2::HeaderError, "Request content length already specified!" if @length
+									
+									@length = Integer(value)
+								elsif key == CONNECTION
+									raise ::Protocol::HTTP2::HeaderError, "Connection header is not allowed!"
+								elsif key.start_with? ':'
+									raise ::Protocol::HTTP2::HeaderError, "Invalid pseudo-header #{key}!"
+								elsif key =~ /[A-Z]/
+									raise ::Protocol::HTTP2::HeaderError, "Invalid characters in header #{key}!"
+								else
+									add_header(key, value)
+								end
+							end
+							
+							@request.headers = @headers
+							
+							unless @request.valid?
+								raise ::Protocol::HTTP2::HeaderError, "Request is missing required headers!"
+							else
+								# We only construct the input/body if data is coming.
+								unless end_stream
+									@input = Body::Writable.new(@length)
+									@request.body = @input
+								end
+								
+								# We are ready for processing:
+								@connection.requests.enqueue(@request)
+							end
+							
+							return headers
+						end
 					end
 					
-					attr :stream
-					
-					def hijack?
-						false
+					def initialize(stream)
+						super(nil, nil, nil, nil, VERSION, nil)
+						
+						@stream = stream
 					end
 					
-					def push?
-						@connection.enable_push?
-					end
+					attr :stream
 					
-					def create_push_promise_stream(headers)
-						@connection.create_push_promise_stream do |stream_id|
-							request = self.class.new(@connection, stream_id)
-							
-							request.receive_headers(self, headers, false)
-						end
+					def valid?
+						@scheme and @method and @path
 					end
 					
-					# Stream state transition into `:closed`.
-					def close!
+					def hijack?
+						false
 					end
 					
-					def stream_closed(error)
-						if @input
-							@input.close(error)
-							@input = nil
-						end
+					def push?
+						@stream.connection.enable_push?
 					end
 					
 					# @return [Stream] the promised stream, on which to send data.
-					def push(path, headers = nil)
+					def push(path, headers = nil, scheme = @scheme, authority = @authority)
+						raise ArgumentError, "Missing scheme!" unless scheme
+						raise ArgumentError, "Missing authority!" unless authority
+						
 						push_headers = [
-							[SCHEME, @scheme],
+							[SCHEME, scheme],
 							[METHOD, ::Protocol::HTTP::Methods::GET],
 							[PATH, path],
-							[AUTHORITY, @authority]
+							[AUTHORITY, authority]
 						]
 						
 						if headers
@@ -84,63 +148,6 @@ module Async
 						@stream.send_push_promise(push_headers)
 					end
 					
-					def receive_headers(stream, headers, end_stream)
-						headers.each do |key, value|
-							if key == SCHEME
-								return @stream.send_failure(400, "Request scheme already specified") if @scheme
-								
-								@scheme = value
-							elsif key == AUTHORITY
-								return @stream.send_failure(400, "Request authority already specified") if @authority
-								
-								@authority = value
-							elsif 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 == PROTOCOL
-								return @stream.send_failure(400, "Request protocol already specified") if @protocol
-								
-								@protocol = value
-							elsif key == CONTENT_LENGTH
-								return @stream.send_failure(400, "Request protocol already content length") if @length
-								
-								@length = Integer(value)
-							else
-								@headers[key] = value
-							end
-						end
-						
-						unless @scheme and @method and @path
-							send_reset_stream(PROTOCOL_ERROR)
-						else
-							# We only construct the input/body if data is coming.
-							unless end_stream
-								@body = @input = Body::Writable.new(@length)
-							end
-							
-							# We are ready for processing:
-							@connection.requests.enqueue(self)
-						end
-					end
-					
-					def receive_data(stream, data, end_stream)
-						unless data.empty?
-							@input.write(data)
-						end
-						
-						if end_stream
-							@input.close
-						end
-					end
-					
-					def receive_reset_stream(stream, error_code)
-					end
-					
 					NO_RESPONSE = [
 						[STATUS, '500'],
 					]

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

@@ -19,119 +19,156 @@
 # THE SOFTWARE.
 
 require_relative '../response'
+require_relative 'stream'
 
 module Async
 	module HTTP
 		module Protocol
 			module HTTP2
+				# Typically used on the client side to represent a request and the incoming response.
 				class Response < Protocol::Response
-					def initialize(connection, stream_id)
-						@input = nil
-						@length = nil
+					class Stream < HTTP2::Stream
+						def initialize(*)
+							super
+							
+							@response = Response.new(self)
+							
+							@notification = Async::Notification.new
+							@exception = nil
+						end
+						
+						attr :response
+						
+						def accept_push_promise_stream(promised_stream_id, headers)
+							stream = @connection.accept_push_promise_stream(promised_stream_id, &Stream.method(:accept))
+							
+							stream.response.build_request(headers)
+							
+							@response.promises.enqueue(stream.response)
+							
+							return stream
+						end
+						
+						# This should be invoked from the background reader, and notifies the task waiting for the headers that we are done.
+						def receive_initial_headers(headers, end_stream)
+							headers.each do |key, value|
+								if key == STATUS
+									@response.status = Integer(value)
+								elsif key == PROTOCOL
+									@response.protocol = value
+								elsif key == CONTENT_LENGTH
+									@length = Integer(value)
+								else
+									add_header(key, value)
+								end
+							end
+							
+							@response.headers = @headers
+							
+							unless @response.valid?
+								send_reset_stream(::Protocol::HTTP2::Error::PROTOCOL_ERROR)
+							else
+								# We only construct the input/body if data is coming.
+								unless end_stream
+									@input = Body::Writable.new(@length)
+									@response.body = @input
+								end
+							end
+							
+							self.notify!
+							
+							return headers
+						end
 						
-						super(connection.version, nil, ::Protocol::HTTP::Headers.new)
+						# Notify anyone waiting on the response headers to be received (or failure).
+						def notify!
+							if @notification
+								@notification.signal
+								@notification = nil
+							end
+						end
 						
-						@connection = connection
-						@stream = Stream.new(self, connection, stream_id)
+						# Wait for the headers to be received or for stream reset.
+						def wait
+							# If you call wait after the headers were already received, it should return immediately:
+							@notification&.wait
+							
+							if @exception
+								raise @exception
+							end
+						end
 						
-						@notification = Async::Notification.new
-						@exception = nil
+						def close(error)
+							super
+							
+							@response.promises.enqueue nil
+							
+							@exception = error
+							
+							notify!
+						end
+					end
+					
+					def initialize(stream)
+						super(stream.connection.version, nil, nil)
 						
+						@stream = stream
+						@request = nil
 						@promises = nil
 					end
 					
 					attr :stream
 					
-					def promises
-						@promises ||= Async::Queue.new
-					end
+					attr :request
 					
-					def accept_push_promise_stream(promised_stream_id, headers)
-						@connection.accept_push_promise_stream(promised_stream_id) do
-							promise = Promise.new(@connection, headers, promised_stream_id)
-							
-							self.promises.enqueue(promise)
-						end
+					def wait
+						@stream.wait
 					end
 					
-					# Stream state transition into `:closed`.
-					def close!
-						self.promises.enqueue(nil)
+					def valid?
+						!!@status
 					end
 					
-					# Notify anyone waiting on the response headers to be received (or failure).
-					protected def notify!
-						if @notification
-							@notification.signal
-							@notification = nil
-						end
-						
-						# if @input
-						# 	@input.close(@exception)
-						# end
+					def promises
+						@promises ||= Async::Queue.new
 					end
 					
-					# Wait for the headers to be received or for stream reset.
-					def wait
-						# If you call wait after the headers were already received, it should return immediately.
-						if @notification
-							@notification.wait
-						end
+					def build_request(headers)
+						request = ::Protocol::HTTP::Request.new
+						request.headers = ::Protocol::HTTP::Headers.new
 						
-						if @exception
-							raise @exception
-						end
-					end
-					
-					# This should be invoked from the background reader, and notifies the task waiting for the headers that we are done.
-					def receive_headers(stream, headers, end_stream)
 						headers.each do |key, value|
-							if key == STATUS
-								@status = Integer(value)
-							elsif key == CONTENT_LENGTH
-								@length = Integer(value)
-							elsif key == PROTOCOL
-								@protocol = value
+							if key == SCHEME
+								raise ::Protocol::HTTP2::HeaderError, "Request scheme already specified!" if request.scheme
+								
+								request.scheme = value
+							elsif key == AUTHORITY
+								raise ::Protocol::HTTP2::HeaderError, "Request authority already specified!" if request.authority
+								
+								request.authority = value
+							elsif key == METHOD
+								raise ::Protocol::HTTP2::HeaderError, "Request method already specified!" if request.method
+								
+								request.method = value
+							elsif key == PATH
+								raise ::Protocol::HTTP2::HeaderError, "Request path is empty!" if value.empty?
+								raise ::Protocol::HTTP2::HeaderError, "Request path already specified!" if request.path
+								
+								request.path = value
+							elsif key.start_with? ':'
+								raise ::Protocol::HTTP2::HeaderError, "Invalid pseudo-header #{key}!"
 							else
-								@headers[key] = value
+								request.headers[key] = value
 							end
 						end
 						
-						unless end_stream
-							@body = @input = Body::Writable.new(@length)
-						end
-						
-						notify!
-					end
-					
-					def receive_data(stream, data, end_stream)
-						unless data.empty?
-							@input.write(data)
-						end
-						
-						if end_stream
-							@input.close
-						end
-					rescue
-						@stream.send_reset_stream(0)
-					end
-					
-					def receive_reset_stream(stream, error_code)
-						if error_code > 0
-							@exception = EOFError.new("Stream reset: error_code=#{error_code}")
-						end
-						
-						notify!
-					end
-					
-					def stream_closed(error)
-						@exception = error
-						
-						notify!
+						@request = request
 					end
 					
 					# Send a request and read it into this response.
-					def send_request(request)
+					def send_request(request, task: Async::Task.current)
+						@request = request
+						
 						# https://http2.github.io/http2-spec/#rfc.section.8.1.2.3
 						# All HTTP/2 requests MUST include exactly one valid value for the :method, :scheme, and :path pseudo-header fields, unless it is a CONNECT request (Section 8.3). An HTTP request that omits mandatory pseudo-header fields is malformed (Section 8.1.2.6).
 						pseudo_headers = [

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

@@ -20,7 +20,6 @@
 
 require_relative 'connection'
 require_relative 'request'
-require_relative 'promise'
 
 require 'protocol/http2/server'
 
@@ -32,6 +31,7 @@ module Async
 					include Connection
 					
 					def initialize(stream)
+						# Used by some generic methods in Connetion:
 						@stream = stream
 						
 						framer = ::Protocol::HTTP2::Framer.new(stream)
@@ -43,21 +43,23 @@ module Async
 					
 					attr :requests
 					
-					# A new request has come in:
 					def accept_stream(stream_id)
 						super do
-							Request.new(self, stream_id)
+							Request::Stream.create(self, stream_id)
 						end
 					end
 					
 					def close(error = nil)
 						super
 						
+						# Stop the request loop:
 						@requests.enqueue nil
+						@requests = nil
 					end
 					
 					def each
-						@requests.async do |task, request|
+						# It's possible the connection has died before we get here...
+						@requests&.async do |task, request|
 							@count += 1
 							
 							begin

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

@@ -25,136 +25,190 @@ module Async
 		module Protocol
 			module HTTP2
 				class Stream < ::Protocol::HTTP2::Stream
-					def initialize(delegate, *args)
-						super(*args)
+					class Buffer
+						def initialize(stream, body, task: Task.current)
+							@stream = stream
+							
+							@body = body
+							@remainder = nil
+							
+							@window_updated = Async::Condition.new
+							
+							@task = task.async(&self.method(:passthrough))
+						end
 						
-						@delegate = delegate
+						def passthrough(task)
+							while chunk = self.read
+								maximum_size = @stream.available_frame_size
+								
+								while maximum_size <= 0
+									@window_updated.wait
+									
+									maximum_size = @stream.available_frame_size
+								end
+								
+								self.send_data(chunk, maximum_size)
+							end
+							
+							self.end_stream
+						rescue Async::Stop
+							# Ignore.
+						ensure
+							@body&.close($!)
+							@body = nil
+						end
 						
-						# This is the body that is being sent.
-						@body = nil
+						def read
+							if @remainder
+								remainder = @remainder
+								@remainder = nil
+								
+								return remainder
+							else
+								@body.read
+							end
+						end
 						
-						# The remainder of the current chunk being sent.
-						@remainder = nil
+						def push(chunk)
+							@remainder = chunk
+						end
 						
-						# The task that is handling sending the body.
-						@task = nil
-					end
-					
-					attr_accessor :delegate
-					attr :body
-					
-					def create_push_promise_stream(headers)
-						@delegate.create_push_promise_stream(headers)
-					end
-					
-					def accept_push_promise_stream(headers, stream_id)
-						@delegate.accept_push_promise_stream(headers, stream_id)
-					end
-					
-					def send_body(body, task: Async::Task.current)
-						# TODO Might need to stop this task when body is cancelled.
-						@task = task.async do |subtask|
-							subtask.annotate "Sending body: #{body.class}"
-							
-							@body = body
-							
-							window_updated
+						# Send `maximum_size` bytes of data using the specified `stream`. If the buffer has no more chunks, `END_STREAM` will be sent on the final chunk.
+						# @param maximum_size [Integer] send up to this many bytes of data.
+						# @param stream [Stream] the stream to use for sending data frames.
+						def send_data(chunk, maximum_size)
+							if chunk.bytesize <= maximum_size
+								@stream.send_data(chunk, maximum_size: maximum_size)
+							else
+								@stream.send_data(chunk.byteslice(0, maximum_size), maximum_size: maximum_size)
+								
+								# The window was not big enough to send all the data, so we save it for next time:
+								self.push(
+									chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
+								)
+							end
 						end
-					end
-					
-					def send_chunk
-						maximum_size = self.available_frame_size
 						
-						if maximum_size == 0
-							return false
+						def end_stream
+							@stream.send_data(nil, ::Protocol::HTTP2::END_STREAM)
 						end
 						
-						if @remainder
-							chunk = @remainder
-							@remainder = nil
-						elsif chunk = @body.read
-							# There was a new chunk of data to send
-						else
+						def window_updated(size)
+							@window_updated.signal
+						end
+						
+						def close(error)
 							if @body
-								@body.close
+								@body.close(error)
 								@body = nil
 							end
 							
-							# @body.read above might take a while and a stream reset might be received in the mean time.
-							unless closed? or @connection.closed?
-								send_data(nil, ::Protocol::HTTP2::END_STREAM)
-							end
-							
-							return false
+							@task&.stop
 						end
+					end
+					
+					def initialize(*)
+						super
 						
-						return false if closed?
+						@headers = nil
+						@trailers = nil
 						
-						if chunk.bytesize <= maximum_size
-							send_data(chunk, maximum_size: maximum_size)
+						# Input buffer (receive_data):
+						@length = nil
+						@input = nil
+						
+						# Output buffer (window_updated):
+						@output = nil
+					end
+					
+					attr_accessor :headers
+					
+					def add_header(key, value)
+						if key == CONNECTION
+							raise ::Protocol::HTTP2::HeaderError, "Connection header is not allowed!"
+						elsif key.start_with? ':'
+							raise ::Protocol::HTTP2::HeaderError, "Invalid pseudo-header #{key}!"
+						elsif key =~ /[A-Z]/
+							raise ::Protocol::HTTP2::HeaderError, "Invalid upper-case characters in header #{key}!"
 						else
-							send_data(chunk.byteslice(0, maximum_size), maximum_size: maximum_size)
-							
-							@remainder = chunk.byteslice(maximum_size, chunk.bytesize - maximum_size)
+							@headers.add(key, value)
 						end
-						
-						return true
 					end
 					
-					def window_updated
-						return unless @body
-						
-						while send_chunk
-							# There could be more data to send...
+					def add_trailer(key, value)
+						if @trailers.include(key)
+							add_header(key, value)
+						else
+							raise ::Protocol::HTTP2::HeaderError, "Cannot add trailer #{key} as it was not specified in trailers!"
+						end
+					end
+					
+					def receive_trailing_headers(headers, end_stream)
+						headers.each do |key, value|
+							add_trailer(key, value)
 						end
 					end
 					
 					def receive_headers(frame)
-						headers = super
-						
-						@delegate.receive_headers(self, headers, frame.end_stream?)
+						if @headers.nil?
+							@headers = ::Protocol::HTTP::Headers.new
+							self.receive_initial_headers(super, frame.end_stream?)
+							@trailers = @headers[TRAILERS]
+						elsif @trailers and frame.end_stream?
+							self.receive_trailing_headers(super, frame.end_stream?)
+						else
+							raise ::Protocol::HTTP2::HeaderError, "Unable to process headers!"
+						end
+					rescue ::Protocol::HTTP2::HeaderError => error
+						Async.logger.error(self, error)
 						
-						return headers
+						send_reset_stream(error.code)
 					end
 					
-					def receive_data(frame)
-						data = super
+					def process_data(frame)
+						data = frame.unpack
 						
-						if data
-							@delegate.receive_data(self, data, frame.end_stream?)
+						if @input
+							unless data.empty?
+								@input.write(data)
+							end
+							
+							if frame.end_stream?
+								@input.close
+								@input = nil
+							end
 						end
 						
 						return data
+					rescue ::Protocol::HTTP2::ProtocolError
+						raise
+					rescue # Anything else...
+						send_reset_stream(::Protocol::HTTP2::Error::INTERNAL_ERROR)
 					end
 					
-					def receive_reset_stream(frame)
-						error_code = super
-						
-						if @body
-							@body.close(EOFError.new(error_code))
-							@body = nil
-						end
-						
-						@delegate.receive_reset_stream(self, error_code)
-						
-						return error_code
+					# Set the body and begin sending it.
+					def send_body(body)
+						@output = Buffer.new(self, body)
 					end
 					
-					def close!
-						@delegate.close!
-						
+					def window_updated(size)
 						super
+						
+						@output&.window_updated(size)
 					end
 					
 					def close(error = nil)
 						super
 						
-						if @body
-							@body.close(error)
-							@body = nil
+						if @input
+							@input.close(error)
+							@input = nil
 						end
 						
-						@delegate.stream_closed(error)
+						if @output
+							@output.close(error)
+							@output = nil
+						end
 					end
 				end
 			end

data/lib/async/http/version.rb

@@ -20,6 +20,6 @@
 
 module Async
 	module HTTP
-		VERSION = "0.45.4"
+		VERSION = "0.45.6"
 	end
 end

data/tasks/h2spec.rake

@@ -0,0 +1,45 @@
+
+namespace :h2spec do
+	task :build do
+		# Fetch the code:
+		sh "go get github.com/spf13/cobra"
+		sh "go get github.com/summerwind/h2spec"
+		
+		# This builds `h2spec` into the current directory
+		sh "go build ~/go/src/github.com/summerwind/h2spec/cmd/h2spec/h2spec.go"
+	end
+	
+	task :server do
+		require 'async/reactor'
+		require 'async/container'
+		require 'async/http/server'
+		require 'async/io/host_endpoint'
+		
+		endpoint = Async::IO::Endpoint.tcp('127.0.0.1', 7272)
+		
+		server = Async::HTTP::Server.for(endpoint, Async::HTTP::Protocol::HTTP2, "https") do |request|
+			Protocol::HTTP::Response[200, {'content-type' => 'text/plain'}, ["Hello World"]]
+		end
+		
+		@container = Async::Container.new
+		
+		Async.logger.info(self){"Starting server..."}
+		@container.run(count: 1) do
+			server.run
+		end
+	end
+	
+	task :test => :server do
+		begin
+			if test = ENV['TEST']
+				sh("./h2spec", test, "-p", "7272")
+			else
+				sh("./h2spec", "-p", "7272")
+			end
+		ensure
+			@container.stop(false)
+		end
+	end
+	
+	task :all => [:build, :test]
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-http
 version: !ruby/object:Gem::Version
-  version: 0.45.4
+  version: 0.45.6
 platform: ruby
 authors:
 - Samuel Williams
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-13 00:00:00.000000000 Z
+date: 2019-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.19'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.18'
+        version: '1.19'
 - !ruby/object:Gem::Dependency
   name: async-io
   requirement: !ruby/object:Gem::Requirement
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.0
 - !ruby/object:Gem::Dependency
   name: async-rspec
   requirement: !ruby/object:Gem::Requirement
@@ -215,7 +215,6 @@ files:
 - 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/promise.rb
 - lib/async/http/protocol/http2/request.rb
 - lib/async/http/protocol/http2/response.rb
 - lib/async/http/protocol/http2/server.rb
@@ -228,6 +227,7 @@ files:
 - lib/async/http/server.rb
 - lib/async/http/statistics.rb
 - lib/async/http/version.rb
+- tasks/h2spec.rake
 - tasks/server.rake
 homepage: https://github.com/socketry/async-http
 licenses: []

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

@@ -1,71 +0,0 @@
-# Copyright, 2019, 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 Promise < Response
-					def initialize(protocol, headers, stream_id)
-						super(protocol, stream_id)
-						
-						@request = build_request(headers)
-					end
-					
-					attr :stream
-					attr :request
-					
-					private def build_request(headers)
-						request = ::Protocol::HTTP::Request.new
-						request.headers = ::Protocol::HTTP::Headers.new
-						
-						headers.each do |key, value|
-							if key == SCHEME
-								return @stream.send_failure(400, "Request scheme already specified") if request.scheme
-								
-								request.scheme = value
-							elsif key == AUTHORITY
-								return @stream.send_failure(400, "Request authority already specified") if request.authority
-								
-								request.authority = value
-							elsif key == METHOD
-								return @stream.send_failure(400, "Request method already specified") if request.method
-								
-								request.method = value
-							elsif key == PATH
-								return @stream.send_failure(400, "Request path already specified") if request.path
-								
-								request.path = value
-							else
-								request.headers[key] = value
-							end
-						end
-						
-						return request
-					end
-					
-					undef send_request
-				end
-			end
-		end
-	end
-end