Preserve interrupt flag in H2 pool close

.changes/next-release/bugfix-NettyNIOHTTPClient-85fcf95.json

@@ -0,0 +1,5 @@
+{
+    "category": "Netty NIO HTTP Client", 
+    "type": "bugfix", 
+    "description": "Preserve interrupted flag if `Http2MultiplexedChannelPool#close()` interrupted."
+}

http-clients/netty-nio-client/src/main/java/software/amazon/awssdk/http/nio/netty/internal/http2/Http2MultiplexedChannelPool.java

@@ -180,6 +180,7 @@ public void close() {
             }
             connectionPool.close();
         } catch (InterruptedException ie) {
+            Thread.currentThread().interrupt();
             throw new RuntimeException(ie);
         }
     }

http-clients/netty-nio-client/src/test/java/software/amazon/awssdk/http/nio/netty/internal/http2/Http2MultiplexedChannelPoolTest.java

@@ -26,20 +26,17 @@
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 import org.junit.Test;
-import org.junit.runner.RunWith;
 import org.mockito.InOrder;
 import org.mockito.Mockito;
-import org.mockito.runners.MockitoJUnitRunner;
 
 import java.util.Collections;
+import java.util.concurrent.CompletableFuture;
 
 import static org.assertj.core.api.Assertions.assertThat;
 
-
 /**
  * Tests for {@link Http2MultiplexedChannelPool}.
  */
-@RunWith(MockitoJUnitRunner.class)
 public class Http2MultiplexedChannelPoolTest {
     private static EventLoopGroup loopGroup;
 
@@ -93,4 +90,45 @@ public void acquireAfterCloseFails() throws InterruptedException {
 
         assertThat(h2Pool.acquire().await().isSuccess()).isFalse();
     }
+
+    @Test(timeout = 5_000)
+    public void interruptDuringClosePreservesFlag() throws InterruptedException {
+        SocketChannel channel = new NioSocketChannel();
+        try {
+            loopGroup.register(channel).awaitUninterruptibly();
+            Promise<Channel> channelPromise = new DefaultPromise<>(loopGroup.next());
+            channelPromise.setSuccess(channel);
+
+            ChannelPool connectionPool = Mockito.mock(ChannelPool.class);
+            Promise<Void> releasePromise = Mockito.spy(new DefaultPromise<>(loopGroup.next()));
+
+            Mockito.when(connectionPool.release(Mockito.eq(channel))).thenReturn(releasePromise);
+
+            MultiplexedChannelRecord record = new MultiplexedChannelRecord(channelPromise,
+                    channel,
+                    8,
+                    (ch, rec) -> {
+                    });
+            Http2MultiplexedChannelPool h2Pool = new Http2MultiplexedChannelPool(connectionPool, loopGroup.next(), 2, Collections.singletonList(record));
+
+            CompletableFuture<Boolean> interrupteFlagPreserved = new CompletableFuture<>();
+
+            Thread t = new Thread(() -> {
+                try {
+                    h2Pool.close();
+                } catch (Exception e) {
+                    if (e.getCause() instanceof InterruptedException && Thread.currentThread().isInterrupted()) {
+                        interrupteFlagPreserved.complete(true);
+                    }
+                }
+            });
+
+            t.start();
+            t.interrupt();
+            t.join();
+            assertThat(interrupteFlagPreserved.join()).isTrue();
+        } finally {
+            channel.close().awaitUninterruptibly();
+        }
+    }
 }