protocol-http2 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5f71a68091b631d1c6a776ae1730539cf753ee6ec24d27dc3b1d739dd971426
-  data.tar.gz: ea202fecbfe30bfbe0b9facf5d507f09344a2a959822be6f22d2d082cf273477
+  metadata.gz: 49e091bc1a6d2b2bdee4176a13648d306f81042ebc6d25cf0a44a921d33d0950
+  data.tar.gz: 5ecd3a8454c2a130247c624abdd067d87b38e63c09e9ed88fe2214e52461ac6c
 SHA512:
-  metadata.gz: 9d1a0a6e6a8461e985fcb9dc83e64c622743cb3d05e52d3b72f1b8a0f48d8190ac01417070807ada1d4ee0434dd7daa775d054ca89d54ba2010d6c153d9fad91
-  data.tar.gz: a17e3d970e3a2539361f518aff2ccc5ec40ca77f9b639a0b6bd69aabab1d0ade8a2e1f7049c08f5a001acfa9eb2fca4c5f2e785475d09e0c21c8088cec050d97
+  metadata.gz: ca124b2c3232e5329b4dd19c29f1b503fb490a03d94b1501f03de0ca1f478fbed8a99c38318002eda6b7f2df484be0b8ab9b1ed0c38a4388a7e63ed2065a5d2f
+  data.tar.gz: e766f4a80429e0ddc22edc2700ce4d20054d4fc07de7d81677cb1b89351019c5bf565a5ff51ce224002d0bb3e9184cbdda97807c2d59013d34c67fab31421443

data/lib/protocol/http2/client.rb

@@ -40,7 +40,7 @@ module Protocol
 					yield if block_given?
 					
 					read_frame do |frame|
-						raise ProtocolError, "First frame must be SettingsFrame, but got #{frame.class}" unless frame.is_a? SettingsFrame
+						raise ProtocolError, "First frame must be #{SettingsFrame}, but got #{frame.class}" unless frame.is_a? SettingsFrame
 					end
 				else
 					raise ProtocolError, "Cannot send connection preface in state #{@state}"

data/lib/protocol/http2/connection.rb

@@ -29,8 +29,11 @@ module Protocol
 			include FlowControl
 			
 			def initialize(framer, local_stream_id)
+				super()
+				
 				@state = :new
 				@streams = {}
+				@children = {}
 				
 				@framer = framer
 				@local_stream_id = local_stream_id
@@ -50,6 +53,18 @@ module Protocol
 				0
 			end
 			
+			def parent
+				nil
+			end
+			
+			def [] id
+				if id.zero?
+					self
+				else
+					@streams[id]
+				end
+			end
+			
 			# The size of a frame payload is limited by the maximum size that a receiver advertises in the SETTINGS_MAX_FRAME_SIZE setting.
 			def maximum_frame_size
 				@remote_settings.maximum_frame_size
@@ -83,6 +98,7 @@ module Protocol
 			end
 			
 			def active_streams
+				# TODO inefficient
 				@streams.each_value.select(&:active?)
 			end
 			
@@ -100,7 +116,7 @@ module Protocol
 			end
 			
 			def decode_headers(data)
-				HPACK::Decompressor.new(data, @decoder).decode
+				HPACK::Decompressor.new(data, @decoder, table_size_limit: @local_settings.header_table_size).decode
 			end
 			
 			# Streams are identified with an unsigned 31-bit integer.  Streams initiated by a client MUST use odd-numbered stream identifiers; those initiated by the server MUST use even-numbered stream identifiers.  A stream identifier of zero (0x0) is used for connection control messages; the stream identifier of zero cannot be used to establish a new stream.
@@ -113,13 +129,34 @@ module Protocol
 			end
 			
 			attr :streams
+			attr :children
+			
+			def add_child(stream)
+				@children[stream.id] = stream
+			end
+			
+			def remove_child(stream)
+				@children.delete(stream.id)
+			end
+			
+			def exclusive_child(stream)
+				stream.children = @children
+				
+				@children.each do |child|
+					child.dependent_id = stream.id
+				end
+				
+				@children = {stream.id => stream}
+				
+				stream.dependent_id = 0
+			end
 			
 			# 6.8. GOAWAY
 			# There is an inherent race condition between an endpoint starting new streams and the remote sending a GOAWAY frame. To deal with this case, the GOAWAY contains the stream identifier of the last peer-initiated stream that was or might be processed on the sending endpoint in this connection. For instance, if the server sends a GOAWAY frame, the identified stream is the highest-numbered stream initiated by the client.
 			# Once sent, the sender will ignore frames sent on streams initiated by the receiver if the stream has an identifier higher than the included last stream identifier. Receivers of a GOAWAY frame MUST NOT open additional streams on the connection, although a new connection can be established for new streams.
 			def ignore_frame?(frame)
 				if self.closed?
-					puts "ignore_frame? #{frame.stream_id} -> #{valid_remote_stream_id?(frame.stream_id)} > #{@remote_stream_id}"
+					# puts "ignore_frame? #{frame.stream_id} -> #{valid_remote_stream_id?(frame.stream_id)} > #{@remote_stream_id}"
 					if valid_remote_stream_id?(frame.stream_id)
 						return frame.stream_id > @remote_stream_id
 					end
@@ -140,8 +177,6 @@ module Protocol
 				return frame
 			rescue GoawayError => error
 				# Go directly to jail. Do not pass go, do not collect $200.
-				self.close(error)
-				
 				raise
 			rescue ProtocolError => error
 				send_goaway(error.code || PROTOCOL_ERROR, error.message)
@@ -150,10 +185,6 @@ module Protocol
 			rescue HPACK::CompressionError => error
 				send_goaway(COMPRESSION_ERROR, error.message)
 				
-				raise
-			rescue
-				send_goaway(PROTOCOL_ERROR, $!.message)
-				
 				raise
 			end
 			
@@ -179,7 +210,7 @@ module Protocol
 				frame.pack @remote_stream_id, error_code, message
 				
 				write_frame(frame)
-				
+			ensure
 				self.close!
 			end
 			
@@ -217,6 +248,8 @@ module Protocol
 				@streams.each_value do |stream|
 					stream.local_window.capacity = capacity
 				end
+				
+				@decoder.table_size = @local_settings.header_table_size
 			end
 			
 			def update_remote_settings(changes)
@@ -225,6 +258,8 @@ module Protocol
 				@streams.each_value do |stream|
 					stream.remote_window.capacity = capacity
 				end
+				
+				@encoder.table_size = @remote_settings.header_table_size
 			end
 			
 			# In addition to changing the flow-control window for streams that are not yet active, a SETTINGS frame can alter the initial flow-control window size for streams with active flow-control windows (that is, streams in the "open" or "half-closed (remote)" state).  When the value of SETTINGS_INITIAL_WINDOW_SIZE changes, a receiver MUST adjust the size of all stream flow-control windows that it maintains by the difference between the new value and the old value.
@@ -304,15 +339,9 @@ module Protocol
 			# On the server side, we accept requests.
 			def accept_stream(stream_id, &block)
 				unless valid_remote_stream_id?(stream_id)
-					raise ProtocolError, "Invalid remote stream id: #{stream_id}"
+					raise ProtocolError, "Invalid stream id: #{stream_id}"
 				end
 				
-				if stream_id <= @remote_stream_id
-					raise ProtocolError, "Invalid stream id: #{stream_id} <= #{@remote_stream_id}!"
-				end
-				
-				@remote_stream_id = stream_id
-				
 				create_stream(stream_id, &block)
 			end
 			
@@ -326,17 +355,11 @@ module Protocol
 			# Create a stream, defaults to an outgoing stream.
 			# On the client side, we create requests.
 			# @return [Stream] the created stream.
-			def create_stream(stream_id = next_stream_id, &block)
+			def create_stream(id = next_stream_id, &block)
 				if block_given?
-					yield(stream_id)
+					return yield(self, id)
 				else
-					return Stream.new(self, stream_id)
-				end
-				
-				if stream = @streams[stream_id]
-					return stream
-				else
-					raise ProtocolError, "Stream creation failed!"
+					return Stream.create(self, id)
 				end
 			end
 			
@@ -346,15 +369,23 @@ module Protocol
 			
 			# On the server side, starts a new request.
 			def receive_headers(frame)
-				if frame.stream_id == 0
+				stream_id = frame.stream_id
+				
+				if stream_id.zero?
 					raise ProtocolError, "Cannot receive headers for stream 0!"
 				end
 				
-				if stream = @streams[frame.stream_id]
+				if stream = @streams[stream_id]
 					stream.receive_headers(frame)
 				else
+					if stream_id <= @remote_stream_id
+						raise ProtocolError, "Invalid stream id: #{stream_id} <= #{@remote_stream_id}!"
+					end
+					
 					if self.active_streams.count < self.maximum_concurrent_streams
-						stream = accept_stream(frame.stream_id)
+						stream = accept_stream(stream_id)
+						@remote_stream_id = stream_id
+						
 						stream.receive_headers(frame)
 					else
 						raise ProtocolError, "Exceeded maximum concurrent streams"
@@ -367,6 +398,7 @@ module Protocol
 				if stream = @streams[frame.stream_id]
 					stream.receive_priority(frame)
 				else
+					# Stream doesn't exist yet.
 					stream = accept_stream(frame.stream_id)
 					stream.receive_priority(frame)
 				end
@@ -387,6 +419,8 @@ module Protocol
 			def receive_window_update(frame)
 				if frame.connection?
 					super
+					
+					self.consume_window
 				elsif stream = @streams[frame.stream_id]
 					begin
 						stream.receive_window_update(frame)
@@ -399,13 +433,6 @@ module Protocol
 				end
 			end
 			
-			def window_updated
-				# This is very inefficient, but workable.
-				@streams.each_value do |stream|
-					stream.window_updated unless stream.closed?
-				end
-			end
-			
 			def receive_continuation(frame)
 				raise ProtocolError, "Received unexpected continuation: #{frame.class}"
 			end

data/lib/protocol/http2/continuation_frame.rb

@@ -110,6 +110,10 @@ module Protocol
 			def apply(connection)
 				connection.receive_continuation(self)
 			end
+			
+			def inspect
+				"\#<#{self.class} stream_id=#{@stream_id} flags=#{@flags} #{@length}b>"
+			end
 		end
 	end
 end

data/lib/protocol/http2/data_frame.rb

@@ -57,6 +57,10 @@ module Protocol
 			def apply(connection)
 				connection.receive_data(self)
 			end
+			
+			def inspect
+				"\#<#{self.class} stream_id=#{@stream_id} flags=#{@flags} #{@length}b>"
+			end
 		end
 	end
 end

data/lib/protocol/http2/error.rb

@@ -86,7 +86,13 @@ module Protocol
 			attr :code
 		end
 		
-		class StreamClosed < ProtocolError
+		class HeaderError < ProtocolError
+		end
+		
+		class StreamError < ProtocolError
+		end
+		
+		class StreamClosed < StreamError
 			def initialize(message)
 				super message, STREAM_CLOSED
 			end

data/lib/protocol/http2/flow_control.rb

@@ -23,9 +23,13 @@ require_relative 'window_update_frame'
 module Protocol
 	module HTTP2
 		module FlowControl
-			def available_frame_size
-				maximum_frame_size = self.maximum_frame_size
-				available_size = @remote_window.available
+			def available_size
+				@remote_window.available
+			end
+			
+			# This could be negative if the window has been overused due to a change in initial window size.
+			def available_frame_size(maximum_frame_size = self.maximum_frame_size)
+				available_size = self.available_size
 				
 				# puts "available_size=#{available_size} maximum_frame_size=#{maximum_frame_size}"
 				
@@ -71,10 +75,9 @@ module Protocol
 			end
 			
 			def receive_window_update(frame)
-				was_full = @remote_window.full?
-				
 				amount = frame.unpack
-				# puts "expand remote_window=#{@remote_window} by #{amount}"
+				
+				# puts "expanding remote_window=#{@remote_window} by #{amount}"
 				
 				if amount != 0
 					@remote_window.expand(amount)
@@ -82,10 +85,39 @@ module Protocol
 					raise ProtocolError, "Invalid window size increment: #{amount}!"
 				end
 				
-				self.window_updated if was_full
+				# puts "expanded remote_window=#{@remote_window} by #{amount}"
 			end
 			
-			def window_updated
+			# The window has been expanded by the given amount.
+			# @param size [Integer] the maximum amount of data to send.
+			# @return [Boolean] whether the window update was used or not.
+			def window_updated(size = self.available_size)
+				return false
+			end
+			
+			# Traverse active streams in order of priority and allow them to consume the available flow-control window.
+			# @param amount [Integer] the amount of data to write. Defaults to the current window capacity.
+			def consume_window(size = self.available_size)
+				# Don't consume more than the available window size:
+				size = [self.available_size, size].min
+				# puts "consume_window(#{size}) local_window=#{@local_window} remote_window=#{@remote_window}"
+				
+				# Return if there is no window to consume:
+				return unless size > 0
+				
+				# Allow the current flow-controlled instance to use up the window:
+				if !self.window_updated(size) and children = self.children
+					children = children.values.sort_by(&:weight)
+					
+					# This must always be at least >= `children.count`, since stream weight can't be 0.
+					total = children.sum(&:weight)
+					
+					children.each do |child|
+						# Compute the proportional allocation:
+						allocated = (child.weight * size) / total
+						child.consume_window(allocated)
+					end
+				end
 			end
 		end
 	end

data/lib/protocol/http2/frame.rb

@@ -200,6 +200,10 @@ module Protocol
 			def apply(connection)
 				connection.receive_frame(self)
 			end
+			
+			def inspect
+				"\#<#{self.class} stream_id=#{@stream_id} flags=#{@flags} #{self.unpack}>"
+			end
 		end
 	end
 end

data/lib/protocol/http2/framer.rb

@@ -52,6 +52,8 @@ module Protocol
 		CONNECTION_PREFACE_MAGIC = "PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n".freeze
 		
 		class Framer
+			# DEBUG = !!ENV['FRAMER_DEBUG']
+			
 			def initialize(stream, frames = FRAMES)
 				@stream = stream
 				@frames = frames
@@ -79,6 +81,8 @@ module Protocol
 				return string
 			end
 			
+			# @return [Frame] the frame that has been read from the underlying IO.
+			# @raise if the underlying IO fails for some reason.
 			def read_frame(maximum_frame_size = MAXIMUM_ALLOWED_FRAME_SIZE)
 				# Read the header:
 				length, type, flags, stream_id = read_header
@@ -86,18 +90,18 @@ module Protocol
 				
 				# Allocate the frame:
 				klass = @frames[type] || Frame
-				# puts "read_frame #{klass} id=#{stream_id} length=#{length} flags=#{flags}"
-				
 				frame = klass.new(stream_id, flags, type, length)
 				
 				# Read the payload:
 				frame.read(@stream, maximum_frame_size)
 				
+				# DEBUG and puts "read_frame: #{frame.inspect}"
+				
 				return frame
 			end
 			
 			def write_frame(frame)
-				# puts "framer: write_frame #{frame.inspect}"
+				# DEBUG and puts "write_frame: #{frame.inspect}"
 				frame.write(@stream)
 				
 				@stream.flush

data/lib/protocol/http2/headers_frame.rb

@@ -78,6 +78,10 @@ module Protocol
 			def apply(connection)
 				connection.receive_headers(self)
 			end
+			
+			def inspect
+				"\#<#{self.class} stream_id=#{@stream_id} flags=#{@flags} #{@length}b>"
+			end
 		end
 	end
 end

data/lib/protocol/http2/priority_frame.rb

@@ -22,6 +22,8 @@ require_relative 'frame'
 
 module Protocol
 	module HTTP2
+		VALID_WEIGHT = (1..256)
+		
 		# Stream Dependency:  A 31-bit stream identifier for the stream that
 		# this stream depends on (see Section 5.3).  This field is only
 		# present if the PRIORITY flag is set.
@@ -29,10 +31,16 @@ module Protocol
 			FORMAT = "NC".freeze
 			EXCLUSIVE = 1 << 31
 			
+			# All streams are initially assigned a non-exclusive dependency on stream 0x0.  Pushed streams (Section 8.2) initially depend on their associated stream.  In both cases, streams are assigned a default weight of 16.
+			def self.default(stream_dependency = 0, weight = 16)
+				self.new(false, stream_dependency, weight)
+			end
+			
 			def self.unpack(data)
 				stream_dependency, weight = data.unpack(FORMAT)
 				
-				return self.new(stream_dependency & EXCLUSIVE != 0, stream_dependency & ~EXCLUSIVE, weight)
+				# Weight:  An unsigned 8-bit integer representing a priority weight for the stream (see Section 5.3).  Add one to the value to obtain a weight between 1 and 256.  This field is only present if the PRIORITY flag is set.
+				return self.new(stream_dependency & EXCLUSIVE != 0, stream_dependency & ~EXCLUSIVE, weight + 1)
 			end
 			
 			def pack
@@ -40,7 +48,15 @@ module Protocol
 					stream_dependency = self.stream_dependency | EXCLUSIVE
 				end
 				
-				return [stream_dependency, self.weight].pack(FORMAT)
+				return [stream_dependency, self.weight - 1].pack(FORMAT)
+			end
+			
+			def weight= value
+				if VALID_WEIGHT.include?(value)
+					super
+				else
+					raise ArgumentError, "Weight #{value} must be between 1-256!"
+				end
 			end
 		end
 		

data/lib/protocol/http2/server.rb

@@ -38,7 +38,7 @@ module Protocol
 					send_settings(settings)
 					
 					read_frame do |frame|
-						raise ProtocolError, "First frame must be SettingsFrame, but got #{frame.class}" unless frame.is_a? SettingsFrame
+						raise ProtocolError, "First frame must be #{SettingsFrame}, but got #{frame.class}" unless frame.is_a? SettingsFrame
 					end
 				else
 					raise ProtocolError, "Cannot send connection preface in state #{@state}"

data/lib/protocol/http2/settings_frame.rb

@@ -231,11 +231,16 @@ module Protocol
 			end
 			
 			def unpack
-				super.scan(/....../).map{|s| s.unpack(FORMAT)}
+				if buffer = super
+					# TODO String#each_slice, or #each_unpack would be nice.
+					buffer.scan(/....../m).map{|s| s.unpack(FORMAT)}
+				else
+					[]
+				end
 			end
 			
 			def pack(settings = [])
-				super settings.map{|s| s.pack(FORMAT)}.join
+				super(settings.map{|s| s.pack(FORMAT)}.join)
 			end
 			
 			def apply(connection)

data/lib/protocol/http2/stream.rb

@@ -74,44 +74,136 @@ module Protocol
 		class Stream
 			include FlowControl
 			
-			def initialize(connection, id = connection.next_stream_id)
+			def self.create(connection, id = connection.next_stream_id)
+				local_window = Window.new(connection.local_settings.initial_window_size)
+				remote_window = Window.new(connection.remote_settings.initial_window_size)
+				
+				stream = self.new(connection, id, local_window, remote_window)
+				
+				# Create new stream:
+				connection.streams[id] = stream
+				stream.parent.add_child(stream)
+				
+				return stream
+			end
+			
+			def self.replace(stream)
+				connection = stream.connection
+				stream.parent.remove_child(stream)
+				
+				stream = self.new(
+					connection, stream.id, stream.local_window, stream.remote_window,
+					stream.state, stream.dependent_id, stream.weight, stream.children
+				)
+				
+				# Replace existing stream:
+				connection.streams[stream.id] = stream
+				stream.parent.add_child(stream)
+				
+				return stream
+			end
+			
+			def self.accept(connection, id)
+				if stream = connection.streams[id]
+					self.replace(stream)
+				else
+					self.create(connection, id)
+				end
+			end
+			
+			def initialize(connection, id, local_window, remote_window, state = :idle, dependent_id = 0, weight = 16, children = nil)
 				@connection = connection
 				@id = id
 				
-				@state = :idle
+				@local_window = local_window
+				@remote_window = remote_window
 				
-				@priority = nil
-				@local_window = Window.new(connection.local_settings.initial_window_size)
-				@remote_window = Window.new(connection.remote_settings.initial_window_size)
+				@state = state
 				
-				@headers = nil
-				@data = nil
+				# Stream priority:
+				@dependent_id = dependent_id
+				@weight = weight
 				
-				@connection.streams[@id] = self
+				# A cache of streams that have child.dependent_id = self.id
+				@children = children
 			end
 			
-			# The stream is being closed because the connection is being closed.
-			def close(error = nil)
-			end
+			# Cache of dependent children.
+			attr_accessor :children
+			
+			# The connection this stream belongs to.
+			attr :connection
 			
 			# Stream ID (odd for client initiated streams, even otherwise).
 			attr :id
 
-			# Stream state as defined by HTTP 2.0.
-			attr :state
+			# Stream state, e.g. `idle`, `closed`.
+			attr_accessor :state
+			
+			# The stream id that this stream depends on, according to the priority.
+			attr_accessor :dependent_id
 			
-			attr :headers
-			attr :data
+			# The weight of the stream relative to other siblings.
+			attr_accessor :weight
 			
 			attr :local_window
 			attr :remote_window
 			
+			def add_child(stream)
+				@children ||= {}
+				@children[stream.id] = stream
+			end
+			
+			def remove_child(stream)
+				@children.delete(stream.id)
+			end
+			
+			def exclusive_child(stream)
+				stream.children = @children
+				
+				@children.each do |child|
+					child.dependent_id = stream.id
+				end
+				
+				@children = {stream.id => stream}
+				
+				stream.dependent_id = @id
+			end
+			
+			def parent(id = @dependent_id)
+				@connection[id] || @connection.accept_stream(id)
+			end
+			
+			def parent= stream
+				self.parent&.remove_child(self)
+				
+				@dependent_id = stream.id
+				
+				stream.add_child(self)
+			end
+			
 			def priority= priority
-				if priority.stream_dependency == @id
+				dependent_id = priority.stream_dependency
+				
+				if dependent_id == @id
 					raise ProtocolError, "Stream priority for stream id #{@id} cannot depend on itself!"
 				end
 				
-				@priority = priority
+				if priority.exclusive
+					self.parent&.remove_child(self)
+					
+					self.parent(dependent_id).exclusive_child(self)
+				elsif dependent_id != @dependent_id
+					self.parent&.remove_child(self)
+					
+					@dependent_id = dependent_id
+					
+					self.parent.add_child(self)
+				end
+			end
+			
+			# The stream is being closed because the connection is being closed.
+			def close(error = nil)
 			end
 			
 			def maximum_frame_size
@@ -134,19 +226,6 @@ module Protocol
 				@state == :idle or @state == :reserved_local or @state == :open or @state == :half_closed_remote
 			end
 			
-			def send_failure(status, reason)
-				if send_headers?
-					send_headers(nil, [
-						[':status', status.to_s],
-						['reason', reason]
-					], END_STREAM)
-				else
-					send_reset_stream(PROTOCOL_ERROR)
-				end
-				
-				return nil
-			end
-			
 			private def write_headers(priority, headers, flags = 0)
 				data = @connection.encode_headers(headers)
 				
@@ -201,7 +280,6 @@ module Protocol
 				
 				# This might fail if the data payload was too big:
 				consume_remote_window(frame)
-				
 				write_frame(frame)
 				
 				return frame
@@ -226,10 +304,15 @@ module Protocol
 			end
 			
 			# Transition the stream into the closed state.
-			def close!
+			# @param error_code [Integer] the error code if the stream was closed due to a stream reset.
+			def close!(error_code = nil)
 				@state = :closed
 				
-				self.close
+				if error_code
+					error = StreamError.new("Stream closed!", error_code)
+				end
+				
+				self.close(error)
 			end
 			
 			def send_reset_stream(error_code = 0)
@@ -264,28 +347,33 @@ module Protocol
 						@state = :open
 					end
 					
-					@headers = process_headers(frame)
+					return process_headers(frame)
 				elsif @state == :reserved_remote
 					@state = :half_closed_local
 					
-					@headers = process_headers(frame)
+					return process_headers(frame)
 				elsif @state == :open
 					if frame.end_stream?
 						@state = :half_closed_remote
 					end
 					
-					@headers = process_headers(frame)
+					return process_headers(frame)
 				elsif @state == :half_closed_local
 					if frame.end_stream?
 						close!
 					end
 					
-					@headers = process_headers(frame)
+					return process_headers(frame)
 				else
 					raise ProtocolError, "Cannot receive headers in state: #{@state}"
 				end
 			end
 			
+			# @return [String] the data that was received.
+			def process_data(frame)
+				frame.unpack
+			end
+			
 			# DATA frames are subject to flow control and can only be sent when a stream is in the "open" or "half-closed (remote)" state.  The entire DATA frame payload is included in flow control, including the Pad Length and Padding fields if present.  If a DATA frame is received whose stream is not in "open" or "half-closed (local)" state, the recipient MUST respond with a stream error of type STREAM_CLOSED.
 			def receive_data(frame)
 				if @state == :open
@@ -295,15 +383,15 @@ module Protocol
 						@state = :half_closed_remote
 					end
 					
-					@data = frame.unpack
+					process_data(frame)
 				elsif @state == :half_closed_local
 					consume_local_window(frame)
 					
+					process_data(frame)
+					
 					if frame.end_stream?
 						close!
 					end
-					
-					@data = frame.unpack
 				else
 					raise ProtocolError, "Cannot receive data in state: #{@state}"
 				end
@@ -315,9 +403,11 @@ module Protocol
 			
 			def receive_reset_stream(frame)
 				if @state != :idle and @state != :closed
-					close!
+					error_code = frame.unpack
+					
+					close!(error_code)
 					
-					return frame.unpack
+					return error_code
 				else
 					raise ProtocolError, "Cannot reset stream in state: #{@state}"
 				end
@@ -383,6 +473,7 @@ module Protocol
 				headers = @connection.decode_headers(data)
 				
 				stream = self.accept_push_promise_stream(promised_stream_id, headers)
+				stream.parent = self
 				stream.reserved_remote!
 				
 				return stream, headers

data/lib/protocol/http2/version.rb

@@ -20,6 +20,6 @@
 
 module Protocol
 	module HTTP2
-		VERSION = "0.6.0"
+		VERSION = "0.7.0"
 	end
 end

data/lib/protocol/http2/window_update_frame.rb

@@ -49,6 +49,7 @@ module Protocol
 			def capacity= value
 				difference = value - @capacity
 				@available += difference
+				@capacity = value
 			end
 			
 			def consume(amount)
@@ -63,6 +64,7 @@ module Protocol
 			end
 			
 			def expand(amount)
+				# puts "expand(#{amount}) @available=#{@available}"
 				@available += amount
 				@used -= amount
 				

data/protocol-http2.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
 	spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
 	spec.require_paths = ["lib"]
 	
-	spec.add_dependency "protocol-hpack", "~> 1.0"
+	spec.add_dependency "protocol-hpack", "~> 1.2"
 	spec.add_dependency "protocol-http", "~> 0.2"
 	
 	spec.add_development_dependency "covered"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: protocol-http2
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 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: protocol-hpack
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: protocol-http
   requirement: !ruby/object:Gem::Requirement
@@ -150,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.2
 signing_key: 
 specification_version: 4
 summary: A low level implementation of the HTTP/2 protocol.