Use RefusedError directly in stream close! transition.

Author: samuel-williams-shopify

lib/protocol/http2/connection.rb

@@ -238,7 +238,7 @@ def receive_goaway(frame)
 				self.close!
 
 				# Streams above the last stream ID were not processed by the remote peer and are safe to retry (RFC 9113 §6.8).
-				error = ::Protocol::HTTP::RequestRefusedError.new("GOAWAY: request not processed.")
+				error = ::Protocol::HTTP::RefusedError.new("GOAWAY: request not processed.")
 
 				@streams.each_value do |stream|
 					if stream.id > @remote_stream_id

lib/protocol/http2/stream.rb

@@ -250,7 +250,11 @@ def close!(error_code = nil)
 				@connection.delete(@id)
 
 				if error_code
-					error = StreamError.new("Stream closed!", error_code)
+					if error_code == REFUSED_STREAM
+						error = ::Protocol::HTTP::RefusedError.new("Stream refused.")
+					else
+						error = StreamError.new("Stream closed!", error_code)
+					end
 				end
 
 				self.closed(error)

protocol-http2.gemspec

@@ -25,5 +25,5 @@ Gem::Specification.new do |spec|
 	spec.required_ruby_version = ">= 3.3"
 
 	spec.add_dependency "protocol-hpack", "~> 1.4"
-	spec.add_dependency "protocol-http", "~> 0.61"
+	spec.add_dependency "protocol-http", "~> 0.62"
 end

releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## Unreleased
+
+  - On RST_STREAM with REFUSED_STREAM, close the stream with `Protocol::HTTP::RefusedError` instead of `StreamError`.
+
 ## v0.25.0
 
   - On GOAWAY, proactively close unprocessed streams (ID above `last_stream_id`) with `Protocol::HTTP::RequestRefusedError`, enabling safe retry of non-idempotent requests.

test/protocol/http2/connection.rb

@@ -402,7 +402,25 @@ def closed(error)
 			end
 		end
 
-		it "closes unprocessed streams with RequestRefusedError on graceful GOAWAY" do
+		it "closes stream with RefusedError on REFUSED_STREAM" do
+			stream = client.create_stream do |connection, id|
+				stream_class.create(connection, id)
+			end
+			stream.send_headers(request_headers, Protocol::HTTP2::END_STREAM)
+			
+			# Establish request stream on server:
+			server.read_frame
+			
+			# Server refuses the stream:
+			server.streams[stream.id].send_reset_stream(Protocol::HTTP2::REFUSED_STREAM)
+			
+			client.read_frame
+			
+			expect(stream.state).to be == :closed
+			expect(stream.error).to be_a(Protocol::HTTP::RefusedError)
+		end
+		
+		it "closes unprocessed streams with RefusedError on graceful GOAWAY" do
 			stream.send_headers(request_headers, Protocol::HTTP2::END_STREAM)
 
 			# Establish request stream on server:
@@ -418,15 +436,15 @@ def closed(error)
 
 			client.read_frame
 
-			# The unprocessed stream (id=3) should be closed with RequestRefusedError:
+			# The unprocessed stream (id=3) should be closed with RefusedError:
 			expect(another_stream.state).to be == :closed
-			expect(another_stream.error).to be_a(Protocol::HTTP::RequestRefusedError)
+			expect(another_stream.error).to be_a(Protocol::HTTP::RefusedError)
 
 			# The processed stream (id=1) should still be open:
 			expect(stream.state).not.to be == :closed
 		end
 
-		it "closes all streams with RequestRefusedError on GOAWAY with last_stream_id=0" do
+		it "closes all streams with RefusedError on GOAWAY with last_stream_id=0" do
 			another_stream = client.create_stream do |connection, id|
 				stream_class.create(connection, id)
 			end
@@ -438,10 +456,10 @@ def closed(error)
 			client.read_frame
 
 			expect(another_stream.state).to be == :closed
-			expect(another_stream.error).to be_a(Protocol::HTTP::RequestRefusedError)
+			expect(another_stream.error).to be_a(Protocol::HTTP::RefusedError)
 		end
 
-		it "closes unprocessed streams with RequestRefusedError on non-graceful GOAWAY" do
+		it "closes unprocessed streams with RefusedError on non-graceful GOAWAY" do
 			stream.send_headers(request_headers, Protocol::HTTP2::END_STREAM)
 
 			# Establish request stream on server:
@@ -459,9 +477,9 @@ def closed(error)
 				client.read_frame
 			end.to raise_exception(Protocol::HTTP2::GoawayError)
 
-			# The unprocessed stream should still have been closed with RequestRefusedError:
+			# The unprocessed stream should still have been closed with RefusedError:
 			expect(another_stream.state).to be == :closed
-			expect(another_stream.error).to be_a(Protocol::HTTP::RequestRefusedError)
+			expect(another_stream.error).to be_a(Protocol::HTTP::RefusedError)
 		end
 
 		it "client can handle non-graceful shutdown" do