protocol-http2 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 868932fdb503f3fb6cc3fed243af7019b56e24bb1ac56a42e69132e0dad1af41
-  data.tar.gz: fb965bc65c34b0ad14f10985c0f21676e1b9a9ceab1052d7482635d5542f461b
+  metadata.gz: b5f71a68091b631d1c6a776ae1730539cf753ee6ec24d27dc3b1d739dd971426
+  data.tar.gz: ea202fecbfe30bfbe0b9facf5d507f09344a2a959822be6f22d2d082cf273477
 SHA512:
-  metadata.gz: d3f8197a22080d609c376e48fd4019aa751b9cf2b845c7d5c9d5f3917e349a09a3ea14d256cac36e815d7126ad72c95a268f754884db200eed006e2f6400d450
-  data.tar.gz: a9cf712bc5eee80c7d77f3628e7df163b3c253a5910358534d52910f13064b5c197ca815eb248483be429544f2cff0af0ce8a540172143eb44bea2f53223a6f3
+  metadata.gz: 9d1a0a6e6a8461e985fcb9dc83e64c622743cb3d05e52d3b72f1b8a0f48d8190ac01417070807ada1d4ee0434dd7daa775d054ca89d54ba2010d6c153d9fad91
+  data.tar.gz: a17e3d970e3a2539361f518aff2ccc5ec40ca77f9b639a0b6bd69aabab1d0ade8a2e1f7049c08f5a001acfa9eb2fca4c5f2e785475d09e0c21c8088cec050d97

data/lib/protocol/http2/connection.rb

@@ -31,7 +31,6 @@ module Protocol
 			def initialize(framer, local_stream_id)
 				@state = :new
 				@streams = {}
-				@closed = 0
 				
 				@framer = framer
 				@local_stream_id = local_stream_id
@@ -76,28 +75,22 @@ module Protocol
 			# Our window for sending data. When we send data, it reduces this window.
 			attr :remote_window
 			
+			# The highest stream_id that has been successfully accepted by this connection.
+			attr :remote_stream_id
+			
 			def closed?
 				@state == :closed
 			end
 			
-			def stream_closed(stream)
-				@closed += 1
-			end
-			
-			def active_stream_count
-				@streams.size - @closed
+			def active_streams
+				@streams.each_value.select(&:active?)
 			end
 			
-			def connection_error!(error, message)
-				return if @framer.closed?
-				
-				send_goaway(error, message)
-				
-				self.close
-			end
-			
-			def close
+			# Close the underlying framer and all streams.
+			def close(error = nil)
 				@framer.close
+				
+				@streams.each_value{|stream| stream.close(error)}
 			end
 			
 			def encode_headers(headers, buffer = String.new.b)
@@ -121,31 +114,45 @@ module Protocol
 			
 			attr :streams
 			
+			# 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}"
+					if valid_remote_stream_id?(frame.stream_id)
+						return frame.stream_id > @remote_stream_id
+					end
+				end
+			end
+			
+			# Reads one frame from the network and processes. Processing the frame updates the state of the connection and related streams. If the frame triggers an error, e.g. a protocol error, the connection will typically emit a goaway frame and re-raise the exception. You should continue processing frames until the underlying connection is closed.
 			def read_frame
 				frame = @framer.read_frame(@local_settings.maximum_frame_size)
-				# puts "#{self.class} #{@state} read_frame: class=#{frame.class} flags=#{frame.flags} length=#{frame.length}"
+				# puts "#{self.class} #{@state} read_frame: class=#{frame.class} stream_id=#{frame.stream_id} flags=#{frame.flags} length=#{frame.length} (remote_stream_id=#{@remote_stream_id})"
 				# puts "Windows: local_window=#{@local_window.inspect}; remote_window=#{@remote_window.inspect}"
 				
-				yield frame if block_given?
+				return if ignore_frame?(frame)
 				
+				yield frame if block_given?
 				frame.apply(self)
 				
 				return frame
-			rescue GoawayError
-				# This is not a connection error. We are done.
-				self.close
+			rescue GoawayError => error
+				# Go directly to jail. Do not pass go, do not collect $200.
+				self.close(error)
 				
 				raise
 			rescue ProtocolError => error
-				connection_error!(error.code || PROTOCOL_ERROR, error.message)
+				send_goaway(error.code || PROTOCOL_ERROR, error.message)
 				
 				raise
 			rescue HPACK::CompressionError => error
-				connection_error!(COMPRESSION_ERROR, error.message)
+				send_goaway(COMPRESSION_ERROR, error.message)
 				
 				raise
 			rescue
-				connection_error!(PROTOCOL_ERROR, $!.message)
+				send_goaway(PROTOCOL_ERROR, $!.message)
 				
 				raise
 			end
@@ -159,21 +166,31 @@ module Protocol
 				write_frame(frame)
 			end
 			
+			# Transition the connection into the closed state.
+			def close!
+				@state = :closed
+				
+				return self
+			end
+			
+			# Tell the remote end that the connection is being shut down. If the `error_code` is 0, this is a graceful shutdown. The other end of the connection should not make any new streams, but existing streams may be completed.
 			def send_goaway(error_code = 0, message = "")
 				frame = GoawayFrame.new
 				frame.pack @remote_stream_id, error_code, message
 				
 				write_frame(frame)
 				
-				@state = :closed
+				self.close!
 			end
 			
 			def receive_goaway(frame)
-				@state = :closed
+				# We capture the last stream that was processed.
+				@remote_stream_id, error_code, message = frame.unpack
 				
-				last_stream_id, error_code, message = frame.unpack
+				self.close!
 				
 				if error_code != 0
+					# Shut down immediately.
 					raise GoawayError.new(message, error_code)
 				end
 			end
@@ -336,7 +353,7 @@ module Protocol
 				if stream = @streams[frame.stream_id]
 					stream.receive_headers(frame)
 				else
-					if self.active_stream_count < self.maximum_concurrent_streams
+					if self.active_streams.count < self.maximum_concurrent_streams
 						stream = accept_stream(frame.stream_id)
 						stream.receive_headers(frame)
 					else

data/lib/protocol/http2/stream.rb

@@ -90,6 +90,10 @@ module Protocol
 				@connection.streams[@id] = self
 			end
 			
+			# The stream is being closed because the connection is being closed.
+			def close(error = nil)
+			end
+			
 			# Stream ID (odd for client initiated streams, even otherwise).
 			attr :id
 
@@ -118,6 +122,10 @@ module Protocol
 				@connection.write_frame(frame)
 			end
 			
+			def active?
+				@state != :closed && @state != :idle
+			end
+			
 			def closed?
 				@state == :closed
 			end
@@ -217,11 +225,11 @@ module Protocol
 				end
 			end
 			
-			# This is not the same as a `close` method. If you are looking for that, use `send_stream_reset`.
+			# Transition the stream into the closed state.
 			def close!
 				@state = :closed
 				
-				@connection.stream_closed(self)
+				self.close
 			end
 			
 			def send_reset_stream(error_code = 0)

data/lib/protocol/http2/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: protocol-http2
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Samuel Williams