interrup catcher

Author: aloubyansky

core/deployment/src/main/java/io/quarkus/deployment/pkg/steps/JarTreeShakeInput.java

@@ -708,9 +708,19 @@ static class BytecodeSupplier implements Supplier<byte[]> {
 
         @Override
         public byte[] get() {
+            if (Thread.currentThread().isInterrupted()) {
+                log.warnf(new Exception("interrupt stack trace"),
+                        "Thread %s is interrupted BEFORE ZipFS read of %s",
+                        Thread.currentThread().getName(), path);
+            }
             try (InputStream is = Files.newInputStream(path)) {
                 return is.readAllBytes();
             } catch (IOException e) {
+                log.warnf(new Exception("read failure stack trace"),
+                        "Failed to read %s on thread %s (fileSystem.isOpen=%s, interrupted=%s)",
+                        path, Thread.currentThread().getName(),
+                        path.getFileSystem().isOpen(),
+                        Thread.currentThread().isInterrupted());
                 throw new UncheckedIOException("Failed to read bytecode " + path
                         + " (fileSystem.isOpen=" + path.getFileSystem().isOpen() + ")", e);
             }

independent-projects/bootstrap/app-model/src/test/java/io/quarkus/paths/SharedArchivePathTreeTest.java

@@ -40,20 +40,114 @@ void closedFileSystemException() throws IOException, InterruptedException, Execu
         });
     }
 
-    static void stress(Consumer<OpenPathTree> consumer) throws IOException {
-        /* Find assertj-core jar in the class path */
+    @Test
+    void untrackedWalkDoesNotBreakSharedFs() throws IOException {
+        /*
+         * Tests that calling walk() on a SharedArchivePathTree (which inherits
+         * ArchivePathTree.walk() and opens/closes a temporary ZipFS) does not
+         * corrupt the shared ZipFS obtained via open().
+         */
+        final Path jar = copyAssertjCoreJar();
+        final ArchivePathTree tree = SharedArchivePathTree.forPath(jar);
+
+        // Step 1: open a shared ZipFS
+        try (OpenPathTree shared = tree.open()) {
+            // Step 2: call inherited walk() — opens and closes a temp ZipFS
+            tree.walk(visit -> {
+                // just iterate, don't need to do anything
+            });
+
+            // Step 3: read from the shared ZipFS — should still work
+            Path p = shared.getPath("org/assertj/core/api/Assertions.class");
+            Assertions.assertThat(p).isNotNull();
+            byte[] bytes = Files.readAllBytes(p);
+            Assertions.assertThat(bytes).isNotEmpty();
+        }
+    }
+
+    @Test
+    void untrackedWalkRawDoesNotBreakSharedFs() throws IOException {
+        final Path jar = copyAssertjCoreJar();
+        final ArchivePathTree tree = SharedArchivePathTree.forPath(jar);
+
+        try (OpenPathTree shared = tree.open()) {
+            tree.walkRaw(visit -> {
+            });
+
+            Path p = shared.getPath("org/assertj/core/api/Assertions.class");
+            Assertions.assertThat(p).isNotNull();
+            byte[] bytes = Files.readAllBytes(p);
+            Assertions.assertThat(bytes).isNotEmpty();
+        }
+    }
+
+    @Test
+    void multipleUntrackedWalksDoNotBreakSharedFs() throws IOException {
+        final Path jar = copyAssertjCoreJar();
+        final ArchivePathTree tree = SharedArchivePathTree.forPath(jar);
+
+        try (OpenPathTree shared = tree.open()) {
+            // Multiple untracked walks
+            for (int i = 0; i < 5; i++) {
+                tree.walk(visit -> {
+                });
+            }
+
+            Path p = shared.getPath("org/assertj/core/api/Assertions.class");
+            Assertions.assertThat(p).isNotNull();
+            byte[] bytes = Files.readAllBytes(p);
+            Assertions.assertThat(bytes).isNotEmpty();
+        }
+    }
+
+    @Test
+    void concurrentUntrackedWalkDoesNotBreakSharedFs() throws IOException, InterruptedException, ExecutionException {
+        final Path jar = copyAssertjCoreJar();
+        final ArchivePathTree tree = SharedArchivePathTree.forPath(jar);
+
+        try (OpenPathTree shared = tree.open()) {
+            // Concurrently walk (untracked) while holding the shared ZipFS open
+            final ExecutorService executor = Executors.newFixedThreadPool(8);
+            final List<Future<Void>> futures = new ArrayList<>(8);
+            try {
+                for (int i = 0; i < 8; i++) {
+                    futures.add(executor.submit(() -> {
+                        tree.walk(visit -> {
+                        });
+                        return null;
+                    }));
+                }
+                for (Future<Void> f : futures) {
+                    Assertions.assertThat(f).succeedsWithin(30, TimeUnit.SECONDS);
+                }
+            } finally {
+                executor.shutdown();
+            }
+
+            // The shared ZipFS should still be usable
+            Path p = shared.getPath("org/assertj/core/api/Assertions.class");
+            Assertions.assertThat(p).isNotNull();
+            byte[] bytes = Files.readAllBytes(p);
+            Assertions.assertThat(bytes).isNotEmpty();
+        }
+    }
+
+    private static Path copyAssertjCoreJar() throws IOException {
         final String rawCp = System.getProperty("java.class.path");
         final String assertjCoreJarPath = Stream.of(rawCp.split(System.getProperty("path.separator")))
                 .filter(p -> p.contains("assertj-core"))
                 .findFirst()
-                .orElseThrow(() -> new AssertionError("Could not find assertj-core  in " + rawCp));
-
-        /* Create a copy of assertj-core jar in target directory */
-        final Path assertjCoreJarPathCopy = Path.of("target/assertj-core-" + UUID.randomUUID() + ".jar");
-        if (!Files.exists(assertjCoreJarPathCopy.getParent())) {
-            Files.createDirectories(assertjCoreJarPathCopy.getParent());
+                .orElseThrow(() -> new AssertionError("Could not find assertj-core in " + rawCp));
+        final Path copy = Path.of("target/assertj-core-" + UUID.randomUUID() + ".jar");
+        if (!Files.exists(copy.getParent())) {
+            Files.createDirectories(copy.getParent());
         }
-        Files.copy(Path.of(assertjCoreJarPath), assertjCoreJarPathCopy);
+        Files.copy(Path.of(assertjCoreJarPath), copy);
+        return copy;
+    }
+
+    static void stress(Consumer<OpenPathTree> consumer) throws IOException {
+        final Path assertjCoreJarPathCopy = copyAssertjCoreJar();
 
         /* Now do some concurrent opening and closing of the SharedArchivePathTree instance */
         final ArchivePathTree archivePathTree = SharedArchivePathTree.forPath(assertjCoreJarPathCopy);