Do not fire outbound exception throught the pipeline when using Http2FrameCodec / Http2MultiplexCodec

normanmaurer · Scottmitch · commit 1df5b02fd95b · 2018-01-25T13:42:28.000-08:00
Motivation:

Usually when using netty exceptions which happen for outbound operations should not be fired through the pipeline but only the ChannelPromise should be failed.

Modifications:

- Change Http2LifecycleManager.onError(...) to take also an boolean that indicate if the error was caused by an outbound operation
- Channel Http2ConnectionHandler.on*Error(...) methods to also take this boolean
- Change Http2FrameCodec to only fire exceptions through the pipeline if these are not outbound operations related
- Add unit test.

Result:

More consistent error handling when using Http2FrameCodec and Http2MultiplexCodec.
diff --git a/codec-http2/src/main/java/io/netty/handler/codec/http2/DefaultHttp2ConnectionEncoder.java b/codec-http2/src/main/java/io/netty/handler/codec/http2/DefaultHttp2ConnectionEncoder.java
@@ -211,7 +211,7 @@ public void operationComplete(ChannelFuture future) throws Exception {
                     // other headers containing pseudo-header fields.
                     stream.headersSent(isInformational);
                 } else {
-                    lifecycleManager.onError(ctx, failureCause);
+                    lifecycleManager.onError(ctx, true, failureCause);
                 }
 
                 return future;
@@ -223,7 +223,7 @@ public void operationComplete(ChannelFuture future) throws Exception {
                 return promise;
             }
         } catch (Throwable t) {
-            lifecycleManager.onError(ctx, t);
+            lifecycleManager.onError(ctx, true, t);
             promise.tryFailure(t);
             return promise;
         }
@@ -287,11 +287,11 @@ public ChannelFuture writePushPromise(ChannelHandlerContext ctx, int streamId, i
             if (failureCause == null) {
                 stream.pushPromiseSent();
             } else {
-                lifecycleManager.onError(ctx, failureCause);
+                lifecycleManager.onError(ctx, true, failureCause);
             }
             return future;
         } catch (Throwable t) {
-            lifecycleManager.onError(ctx, t);
+            lifecycleManager.onError(ctx, true, t);
             promise.tryFailure(t);
             return promise;
         }
@@ -376,7 +376,7 @@ public void error(ChannelHandlerContext ctx, Throwable cause) {
             queue.releaseAndFailAll(cause);
             // Don't update dataSize because we need to ensure the size() method returns a consistent size even after
             // error so we don't invalidate flow control when returning bytes to flow control.
-            lifecycleManager.onError(ctx, cause);
+            lifecycleManager.onError(ctx, true, cause);
         }
 
         @Override
@@ -456,7 +456,7 @@ public int size() {
         @Override
         public void error(ChannelHandlerContext ctx, Throwable cause) {
             if (ctx != null) {
-                lifecycleManager.onError(ctx, cause);
+                lifecycleManager.onError(ctx, true, cause);
             }
             promise.tryFailure(cause);
         }
@@ -476,7 +476,7 @@ public void write(ChannelHandlerContext ctx, int allowedBytes) {
             if (failureCause == null) {
                 stream.headersSent(isInformational);
             } else {
-                lifecycleManager.onError(ctx, failureCause);
+                lifecycleManager.onError(ctx, true, failureCause);
             }
         }
 
diff --git a/codec-http2/src/main/java/io/netty/handler/codec/http2/Http2ConnectionHandler.java b/codec-http2/src/main/java/io/netty/handler/codec/http2/Http2ConnectionHandler.java
@@ -200,9 +200,9 @@ public void flush(ChannelHandlerContext ctx) {
             encoder.flowController().writePendingBytes();
             ctx.flush();
         } catch (Http2Exception e) {
-            onError(ctx, e);
+            onError(ctx, true, e);
         } catch (Throwable cause) {
-            onError(ctx, connectionError(INTERNAL_ERROR, cause, "Error flushing"));
+            onError(ctx, true, connectionError(INTERNAL_ERROR, cause, "Error flushing"));
         }
     }
 
@@ -254,7 +254,7 @@ public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) thro
                     byteDecoder.decode(ctx, in, out);
                 }
             } catch (Throwable e) {
-                onError(ctx, e);
+                onError(ctx, false, e);
             }
         }
 
@@ -389,7 +389,7 @@ public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) thro
             try {
                 decoder.decodeFrame(ctx, in, out);
             } catch (Throwable e) {
-                onError(ctx, e);
+                onError(ctx, false, e);
             }
         }
     }
@@ -538,7 +538,7 @@ void channelReadComplete0(ChannelHandlerContext ctx) throws Exception {
     public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
         if (getEmbeddedHttp2Exception(cause) != null) {
             // Some exception in the causality chain is an Http2Exception - handle it.
-            onError(ctx, cause);
+            onError(ctx, false, cause);
         } else {
             super.exceptionCaught(ctx, cause);
         }
@@ -604,17 +604,17 @@ public void operationComplete(ChannelFuture future) throws Exception {
      * Central handler for all exceptions caught during HTTP/2 processing.
      */
     @Override
-    public void onError(ChannelHandlerContext ctx, Throwable cause) {
+    public void onError(ChannelHandlerContext ctx, boolean outbound, Throwable cause) {
         Http2Exception embedded = getEmbeddedHttp2Exception(cause);
         if (isStreamError(embedded)) {
-            onStreamError(ctx, cause, (StreamException) embedded);
+            onStreamError(ctx, outbound, cause, (StreamException) embedded);
         } else if (embedded instanceof CompositeStreamException) {
             CompositeStreamException compositException = (CompositeStreamException) embedded;
             for (StreamException streamException : compositException) {
-                onStreamError(ctx, cause, streamException);
+                onStreamError(ctx, outbound, cause, streamException);
             }
         } else {
-            onConnectionError(ctx, cause, embedded);
+            onConnectionError(ctx, outbound, cause, embedded);
         }
         ctx.flush();
     }
@@ -633,11 +633,13 @@ protected boolean isGracefulShutdownComplete() {
      * streams are closed, the connection is shut down.
      *
      * @param ctx the channel context
+     * @param outbound {@code true} if the error was caused by an outbound operation.
      * @param cause the exception that was caught
      * @param http2Ex the {@link Http2Exception} that is embedded in the causality chain. This may
      *            be {@code null} if it's an unknown exception.
      */
-    protected void onConnectionError(ChannelHandlerContext ctx, Throwable cause, Http2Exception http2Ex) {
+    protected void onConnectionError(ChannelHandlerContext ctx, boolean outbound,
+                                     Throwable cause, Http2Exception http2Ex) {
         if (http2Ex == null) {
             http2Ex = new Http2Exception(INTERNAL_ERROR, cause.getMessage(), cause);
         }
@@ -659,11 +661,12 @@ protected void onConnectionError(ChannelHandlerContext ctx, Throwable cause, Htt
      * stream.
      *
      * @param ctx the channel context
+     * @param outbound {@code true} if the error was caused by an outbound operation.
      * @param cause the exception that was caught
      * @param http2Ex the {@link StreamException} that is embedded in the causality chain.
      */
-    protected void onStreamError(ChannelHandlerContext ctx, @SuppressWarnings("unused") Throwable cause,
-                                 StreamException http2Ex) {
+    protected void onStreamError(ChannelHandlerContext ctx, boolean outbound,
+                                 @SuppressWarnings("unused") Throwable cause, StreamException http2Ex) {
         final int streamId = http2Ex.streamId();
         Http2Stream stream = connection().stream(streamId);
 
@@ -692,7 +695,7 @@ protected void onStreamError(ChannelHandlerContext ctx, @SuppressWarnings("unuse
                 try {
                     handleServerHeaderDecodeSizeError(ctx, stream);
                 } catch (Throwable cause2) {
-                    onError(ctx, connectionError(INTERNAL_ERROR, cause2, "Error DecodeSizeError"));
+                    onError(ctx, outbound, connectionError(INTERNAL_ERROR, cause2, "Error DecodeSizeError"));
                 }
             }
         }
@@ -867,13 +870,13 @@ private void processRstStreamWriteResult(ChannelHandlerContext ctx, Http2Stream
             closeStream(stream, future);
         } else {
             // The connection will be closed and so no need to change the resetSent flag to false.
-            onConnectionError(ctx, future.cause(), null);
+            onConnectionError(ctx, true, future.cause(), null);
         }
     }
 
     private void closeConnectionOnError(ChannelHandlerContext ctx, ChannelFuture future) {
         if (!future.isSuccess()) {
-            onConnectionError(ctx, future.cause(), null);
+            onConnectionError(ctx, true, future.cause(), null);
         }
     }
 
diff --git a/codec-http2/src/main/java/io/netty/handler/codec/http2/Http2FrameCodec.java b/codec-http2/src/main/java/io/netty/handler/codec/http2/Http2FrameCodec.java
@@ -186,7 +186,7 @@ public boolean visit(Http2Stream stream) {
                 try {
                     return streamVisitor.visit((Http2FrameStream) stream.getProperty(streamKey));
                 } catch (Throwable cause) {
-                    onError(ctx, cause);
+                    onError(ctx, false, cause);
                     return false;
                 }
             }
@@ -431,38 +431,46 @@ public void onStreamHalfClosed(Http2Stream stream) {
     }
 
     @Override
-    protected void onConnectionError(ChannelHandlerContext ctx, Throwable cause, Http2Exception http2Ex) {
-        // allow the user to handle it first in the pipeline, and then automatically clean up.
-        // If this is not desired behavior the user can override this method.
-        ctx.fireExceptionCaught(cause);
-        super.onConnectionError(ctx, cause, http2Ex);
+    protected void onConnectionError(
+            ChannelHandlerContext ctx, boolean outbound, Throwable cause, Http2Exception http2Ex) {
+        if (!outbound) {
+            // allow the user to handle it first in the pipeline, and then automatically clean up.
+            // If this is not desired behavior the user can override this method.
+            //
+            // We only forward non outbound errors as outbound errors will already be reflected by failing the promise.
+            ctx.fireExceptionCaught(cause);
+        }
+        super.onConnectionError(ctx, outbound, cause, http2Ex);
     }
 
     /**
      * Exceptions for unknown streams, that is streams that have no {@link Http2FrameStream} object attached
      * are simply logged and replied to by sending a RST_STREAM frame.
      */
     @Override
-    protected final void onStreamError(ChannelHandlerContext ctx, Throwable cause,
+    protected final void onStreamError(ChannelHandlerContext ctx, boolean outbound, Throwable cause,
                                  Http2Exception.StreamException streamException) {
         int streamId = streamException.streamId();
         Http2Stream connectionStream = connection().stream(streamId);
         if (connectionStream == null) {
             onHttp2UnknownStreamError(ctx, cause, streamException);
             // Write a RST_STREAM
-            super.onStreamError(ctx, cause, streamException);
+            super.onStreamError(ctx, outbound, cause, streamException);
             return;
         }
 
         Http2FrameStream stream = connectionStream.getProperty(streamKey);
         if (stream == null) {
             LOG.warn("Stream exception thrown without stream object attached.", cause);
             // Write a RST_STREAM
-            super.onStreamError(ctx, cause, streamException);
+            super.onStreamError(ctx, outbound, cause, streamException);
             return;
         }
 
-        onHttp2FrameStreamException(ctx, new Http2FrameStreamException(stream, streamException.error(), cause));
+        if (!outbound) {
+            // We only forward non outbound errors as outbound errors will already be reflected by failing the promise.
+            onHttp2FrameStreamException(ctx, new Http2FrameStreamException(stream, streamException.error(), cause));
+        }
     }
 
     void onHttp2UnknownStreamError(@SuppressWarnings("unused") ChannelHandlerContext ctx, Throwable cause,
diff --git a/codec-http2/src/main/java/io/netty/handler/codec/http2/Http2LifecycleManager.java b/codec-http2/src/main/java/io/netty/handler/codec/http2/Http2LifecycleManager.java
@@ -88,6 +88,11 @@ ChannelFuture goAway(ChannelHandlerContext ctx, int lastStreamId, long errorCode
 
     /**
      * Processes the given error.
+     *
+     * @param ctx The context used for communication and buffer allocation if necessary.
+     * @param outbound {@code true} if the error was caused by an outbound operation and so the corresponding
+     * {@link ChannelPromise} was failed as well.
+     * @param cause the error.
      */
-    void onError(ChannelHandlerContext ctx, Throwable cause);
+    void onError(ChannelHandlerContext ctx, boolean outbound, Throwable cause);
 }
diff --git a/codec-http2/src/main/java/io/netty/handler/codec/http2/HttpToHttp2ConnectionHandler.java b/codec-http2/src/main/java/io/netty/handler/codec/http2/HttpToHttp2ConnectionHandler.java
@@ -112,7 +112,7 @@ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)
                 }
             }
         } catch (Throwable t) {
-            onError(ctx, t);
+            onError(ctx, true, t);
             promiseAggregator.setFailure(t);
         } finally {
             if (release) {
diff --git a/codec-http2/src/test/java/io/netty/handler/codec/http2/Http2FrameCodecTest.java b/codec-http2/src/test/java/io/netty/handler/codec/http2/Http2FrameCodecTest.java
@@ -389,14 +389,14 @@ public void goAwayLastStreamIdOverflowed() throws Exception {
     }
 
     @Test
-    public void streamErrorShouldFireException() throws Exception {
+    public void streamErrorShouldFireExceptionForInbound() throws Exception {
         frameListener.onHeadersRead(http2HandlerCtx, 3, request, 31, false);
 
         Http2Stream stream = frameCodec.connection().stream(3);
         assertNotNull(stream);
 
         StreamException streamEx = new StreamException(3, Http2Error.INTERNAL_ERROR, "foo");
-        frameCodec.onError(http2HandlerCtx, streamEx);
+        frameCodec.onError(http2HandlerCtx, false, streamEx);
 
         Http2FrameStreamEvent event = inboundHandler.readInboundMessageOrUserEvent();
         assertEquals(Http2FrameStreamEvent.Type.State, event.type());
@@ -414,6 +414,28 @@ public void streamErrorShouldFireException() throws Exception {
         assertNull(inboundHandler.readInboundMessageOrUserEvent());
     }
 
+    @Test
+    public void streamErrorShouldNotFireExceptionForOutbound() throws Exception {
+        frameListener.onHeadersRead(http2HandlerCtx, 3, request, 31, false);
+
+        Http2Stream stream = frameCodec.connection().stream(3);
+        assertNotNull(stream);
+
+        StreamException streamEx = new StreamException(3, Http2Error.INTERNAL_ERROR, "foo");
+        frameCodec.onError(http2HandlerCtx, true, streamEx);
+
+        Http2FrameStreamEvent event = inboundHandler.readInboundMessageOrUserEvent();
+        assertEquals(Http2FrameStreamEvent.Type.State, event.type());
+        assertEquals(State.OPEN, event.stream().state());
+        Http2HeadersFrame headersFrame = inboundHandler.readInboundMessageOrUserEvent();
+        assertNotNull(headersFrame);
+
+        // No exception expected
+        inboundHandler.checkException();
+
+        assertNull(inboundHandler.readInboundMessageOrUserEvent());
+    }
+
     @Test
     public void windowUpdateFrameDecrementsConsumedBytes() throws Exception {
         frameListener.onHeadersRead(http2HandlerCtx, 3, request, 31, false);

Original file line number	Diff line number	Diff line change
`@@ -211,7 +211,7 @@ public void operationComplete(ChannelFuture future) throws Exception {`
`211`	`211`	`// other headers containing pseudo-header fields.`
`212`	`212`	`stream.headersSent(isInformational);`
`213`	`213`	`} else {`
`214`		`- lifecycleManager.onError(ctx, failureCause);`
	`214`	`+ lifecycleManager.onError(ctx, true, failureCause);`
`215`	`215`	`}`
`216`	`216`
`217`	`217`	`return future;`
`@@ -223,7 +223,7 @@ public void operationComplete(ChannelFuture future) throws Exception {`
`223`	`223`	`return promise;`
`224`	`224`	`}`
`225`	`225`	`} catch (Throwable t) {`
`226`		`- lifecycleManager.onError(ctx, t);`
	`226`	`+ lifecycleManager.onError(ctx, true, t);`
`227`	`227`	`promise.tryFailure(t);`
`228`	`228`	`return promise;`
`229`	`229`	`}`
`@@ -287,11 +287,11 @@ public ChannelFuture writePushPromise(ChannelHandlerContext ctx, int streamId, i`
`287`	`287`	`if (failureCause == null) {`
`288`	`288`	`stream.pushPromiseSent();`
`289`	`289`	`} else {`
`290`		`- lifecycleManager.onError(ctx, failureCause);`
	`290`	`+ lifecycleManager.onError(ctx, true, failureCause);`
`291`	`291`	`}`
`292`	`292`	`return future;`
`293`	`293`	`} catch (Throwable t) {`
`294`		`- lifecycleManager.onError(ctx, t);`
	`294`	`+ lifecycleManager.onError(ctx, true, t);`
`295`	`295`	`promise.tryFailure(t);`
`296`	`296`	`return promise;`
`297`	`297`	`}`
`@@ -376,7 +376,7 @@ public void error(ChannelHandlerContext ctx, Throwable cause) {`
`376`	`376`	`queue.releaseAndFailAll(cause);`
`377`	`377`	`// Don't update dataSize because we need to ensure the size() method returns a consistent size even after`
`378`	`378`	`// error so we don't invalidate flow control when returning bytes to flow control.`
`379`		`- lifecycleManager.onError(ctx, cause);`
	`379`	`+ lifecycleManager.onError(ctx, true, cause);`
`380`	`380`	`}`
`381`	`381`
`382`	`382`	`@Override`
`@@ -456,7 +456,7 @@ public int size() {`
`456`	`456`	`@Override`
`457`	`457`	`public void error(ChannelHandlerContext ctx, Throwable cause) {`
`458`	`458`	`if (ctx != null) {`
`459`		`- lifecycleManager.onError(ctx, cause);`
	`459`	`+ lifecycleManager.onError(ctx, true, cause);`
`460`	`460`	`}`
`461`	`461`	`promise.tryFailure(cause);`
`462`	`462`	`}`
`@@ -476,7 +476,7 @@ public void write(ChannelHandlerContext ctx, int allowedBytes) {`
`476`	`476`	`if (failureCause == null) {`
`477`	`477`	`stream.headersSent(isInformational);`
`478`	`478`	`} else {`
`479`		`- lifecycleManager.onError(ctx, failureCause);`
	`479`	`+ lifecycleManager.onError(ctx, true, failureCause);`
`480`	`480`	`}`
`481`	`481`	`}`
`482`	`482`
Original file line number	Diff line number	Diff line change
`@@ -200,9 +200,9 @@ public void flush(ChannelHandlerContext ctx) {`
`200`	`200`	`encoder.flowController().writePendingBytes();`
`201`	`201`	`ctx.flush();`
`202`	`202`	`} catch (Http2Exception e) {`
`203`		`- onError(ctx, e);`
	`203`	`+ onError(ctx, true, e);`
`204`	`204`	`} catch (Throwable cause) {`
`205`		`- onError(ctx, connectionError(INTERNAL_ERROR, cause, "Error flushing"));`
	`205`	`+ onError(ctx, true, connectionError(INTERNAL_ERROR, cause, "Error flushing"));`
`206`	`206`	`}`
`207`	`207`	`}`
`208`	`208`
`@@ -254,7 +254,7 @@ public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) thro`
`254`	`254`	`byteDecoder.decode(ctx, in, out);`
`255`	`255`	`}`
`256`	`256`	`} catch (Throwable e) {`
`257`		`- onError(ctx, e);`
	`257`	`+ onError(ctx, false, e);`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`
`@@ -389,7 +389,7 @@ public void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) thro`
`389`	`389`	`try {`
`390`	`390`	`decoder.decodeFrame(ctx, in, out);`
`391`	`391`	`} catch (Throwable e) {`
`392`		`- onError(ctx, e);`
	`392`	`+ onError(ctx, false, e);`
`393`	`393`	`}`
`394`	`394`	`}`
`395`	`395`	`}`
`@@ -538,7 +538,7 @@ void channelReadComplete0(ChannelHandlerContext ctx) throws Exception {`
`538`	`538`	`public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {`
`539`	`539`	`if (getEmbeddedHttp2Exception(cause) != null) {`
`540`	`540`	`// Some exception in the causality chain is an Http2Exception - handle it.`
`541`		`- onError(ctx, cause);`
	`541`	`+ onError(ctx, false, cause);`
`542`	`542`	`} else {`
`543`	`543`	`super.exceptionCaught(ctx, cause);`
`544`	`544`	`}`
`@@ -604,17 +604,17 @@ public void operationComplete(ChannelFuture future) throws Exception {`
`604`	`604`	`* Central handler for all exceptions caught during HTTP/2 processing.`
`605`	`605`	`*/`
`606`	`606`	`@Override`
`607`		`- public void onError(ChannelHandlerContext ctx, Throwable cause) {`
	`607`	`+ public void onError(ChannelHandlerContext ctx, boolean outbound, Throwable cause) {`
`608`	`608`	`Http2Exception embedded = getEmbeddedHttp2Exception(cause);`
`609`	`609`	`if (isStreamError(embedded)) {`
`610`		`- onStreamError(ctx, cause, (StreamException) embedded);`
	`610`	`+ onStreamError(ctx, outbound, cause, (StreamException) embedded);`
`611`	`611`	`} else if (embedded instanceof CompositeStreamException) {`
`612`	`612`	`CompositeStreamException compositException = (CompositeStreamException) embedded;`
`613`	`613`	`for (StreamException streamException : compositException) {`
`614`		`- onStreamError(ctx, cause, streamException);`
	`614`	`+ onStreamError(ctx, outbound, cause, streamException);`
`615`	`615`	`}`
`616`	`616`	`} else {`
`617`		`- onConnectionError(ctx, cause, embedded);`
	`617`	`+ onConnectionError(ctx, outbound, cause, embedded);`
`618`	`618`	`}`
`619`	`619`	`ctx.flush();`
`620`	`620`	`}`
`@@ -633,11 +633,13 @@ protected boolean isGracefulShutdownComplete() {`
`633`	`633`	`* streams are closed, the connection is shut down.`
`634`	`634`	`*`
`635`	`635`	`* @param ctx the channel context`
	`636`	`+ * @param outbound {@code true} if the error was caused by an outbound operation.`
`636`	`637`	`* @param cause the exception that was caught`
`637`	`638`	`* @param http2Ex the {@link Http2Exception} that is embedded in the causality chain. This may`
`638`	`639`	`* be {@code null} if it's an unknown exception.`
`639`	`640`	`*/`
`640`		`- protected void onConnectionError(ChannelHandlerContext ctx, Throwable cause, Http2Exception http2Ex) {`
	`641`	`+ protected void onConnectionError(ChannelHandlerContext ctx, boolean outbound,`
	`642`	`+ Throwable cause, Http2Exception http2Ex) {`
`641`	`643`	`if (http2Ex == null) {`
`642`	`644`	`http2Ex = new Http2Exception(INTERNAL_ERROR, cause.getMessage(), cause);`
`643`	`645`	`}`
`@@ -659,11 +661,12 @@ protected void onConnectionError(ChannelHandlerContext ctx, Throwable cause, Htt`
`659`	`661`	`* stream.`
`660`	`662`	`*`
`661`	`663`	`* @param ctx the channel context`
	`664`	`+ * @param outbound {@code true} if the error was caused by an outbound operation.`
`662`	`665`	`* @param cause the exception that was caught`
`663`	`666`	`* @param http2Ex the {@link StreamException} that is embedded in the causality chain.`
`664`	`667`	`*/`
`665`		`- protected void onStreamError(ChannelHandlerContext ctx, @SuppressWarnings("unused") Throwable cause,`
`666`		`- StreamException http2Ex) {`
	`668`	`+ protected void onStreamError(ChannelHandlerContext ctx, boolean outbound,`
	`669`	`+ @SuppressWarnings("unused") Throwable cause, StreamException http2Ex) {`
`667`	`670`	`final int streamId = http2Ex.streamId();`
`668`	`671`	`Http2Stream stream = connection().stream(streamId);`
`669`	`672`
`@@ -692,7 +695,7 @@ protected void onStreamError(ChannelHandlerContext ctx, @SuppressWarnings("unuse`
`692`	`695`	`try {`
`693`	`696`	`handleServerHeaderDecodeSizeError(ctx, stream);`
`694`	`697`	`} catch (Throwable cause2) {`
`695`		`- onError(ctx, connectionError(INTERNAL_ERROR, cause2, "Error DecodeSizeError"));`
	`698`	`+ onError(ctx, outbound, connectionError(INTERNAL_ERROR, cause2, "Error DecodeSizeError"));`
`696`	`699`	`}`
`697`	`700`	`}`
`698`	`701`	`}`
`@@ -867,13 +870,13 @@ private void processRstStreamWriteResult(ChannelHandlerContext ctx, Http2Stream`
`867`	`870`	`closeStream(stream, future);`
`868`	`871`	`} else {`
`869`	`872`	`// The connection will be closed and so no need to change the resetSent flag to false.`
`870`		`- onConnectionError(ctx, future.cause(), null);`
	`873`	`+ onConnectionError(ctx, true, future.cause(), null);`
`871`	`874`	`}`
`872`	`875`	`}`
`873`	`876`
`874`	`877`	`private void closeConnectionOnError(ChannelHandlerContext ctx, ChannelFuture future) {`
`875`	`878`	`if (!future.isSuccess()) {`
`876`		`- onConnectionError(ctx, future.cause(), null);`
	`879`	`+ onConnectionError(ctx, true, future.cause(), null);`
`877`	`880`	`}`
`878`	`881`	`}`
`879`	`882`
Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise)`
`112`	`112`	`}`
`113`	`113`	`}`
`114`	`114`	`} catch (Throwable t) {`
`115`		`- onError(ctx, t);`
	`115`	`+ onError(ctx, true, t);`
`116`	`116`	`promiseAggregator.setFailure(t);`
`117`	`117`	`} finally {`
`118`	`118`	`if (release) {`