Merge pull request #47837 from gsmet/3.22.3-backports-1

[3.22] 3.22.3 backports 1

Author: gsmet

adr/0004-using-the-tls-registry-for-clients.adoc

@@ -26,7 +26,7 @@ The TLS registry is an extension processing the `quarkus.tls` configuration and
 Note that the configuration and the runtime API are different.
 The configuration is used to define the TLS settings, while the runtime API is used to access these pre-processed settings.
 
-hen using the options directly under `quarkus.tls.`, one configures the default (_unamed_) configuration, while using options under `quarkus.tls.<name>.` configures a _named_ configuration.
+When using the options directly under `quarkus.tls.`, one configures the default (_unnamed_) configuration, while using options under `quarkus.tls.<name>.` configures a _named_ configuration.
 For each configuration, trust stores and key stores can be defined, as well as the default protocol, cipher suites, etc.
 More details can be found in the https://quarkus.io/version/main/guides/tls-registry-reference[documentation] and in the https://github.com/quarkusio/quarkus/blob/main/extensions/tls-registry/runtime/src/main/java/io/quarkus/tls/runtime/config/TlsBucketConfig.java[code].
 

bom/application/pom.xml

@@ -22,7 +22,7 @@
         <cyclonedx.version>9.0.5</cyclonedx.version>
         <expressly.version>5.0.0</expressly.version>
         <findbugs.version>3.0.2</findbugs.version>
-        <jandex.version>3.3.0</jandex.version>
+        <jandex.version>3.3.1</jandex.version>
         <javax.annotation-api.version>1.3.2</javax.annotation-api.version>
         <javax.inject.version>1</javax.inject.version>
         <parsson.version>1.1.7</parsson.version>
@@ -32,7 +32,7 @@
         <opentelemetry-instrumentation.version>2.10.0-alpha</opentelemetry-instrumentation.version>
         <opentelemetry-semconv.version>1.29.0-alpha</opentelemetry-semconv.version>
         <quarkus-http.version>5.3.4</quarkus-http.version>
-        <micrometer.version>1.14.6</micrometer.version><!-- keep in sync with hdrhistogram: https://central.sonatype.com/artifact/io.micrometer/micrometer-core -->
+        <micrometer.version>1.14.7</micrometer.version><!-- keep in sync with hdrhistogram: https://central.sonatype.com/artifact/io.micrometer/micrometer-core -->
         <hdrhistogram.version>2.2.2</hdrhistogram.version><!-- keep in sync with micrometer -->
         <google-auth.version>0.22.0</google-auth.version>
         <graphql-java.version>22.2</graphql-java.version> <!-- keep in sync with smallrye-graphql -->
@@ -96,7 +96,7 @@
         <classmate.version>1.7.0</classmate.version>
         <!-- See root POM for hibernate-orm.version, hibernate-reactive.version, hibernate-validator.version,
              hibernate-search.version, antlr.version, bytebuddy.version, hibernate-commons-annotations.version -->
-        <narayana.version>7.2.1.Final</narayana.version>
+        <narayana.version>7.2.2.Final</narayana.version>
         <narayana-lra.version>1.0.0.Final</narayana-lra.version>
         <agroal.version>2.6</agroal.version>
         <jboss-transaction-spi.version>8.0.0.Final</jboss-transaction-spi.version>
@@ -108,7 +108,7 @@
         <slf4j-jboss-logmanager.version>2.0.0.Final</slf4j-jboss-logmanager.version>
         <wildfly-common.version>2.0.1</wildfly-common.version>
         <wildfly-client-config.version>1.0.1.Final</wildfly-client-config.version>
-        <wildfly-elytron.version>2.6.3.Final</wildfly-elytron.version>
+        <wildfly-elytron.version>2.6.4.Final</wildfly-elytron.version>
         <jboss-marshalling.version>2.2.3.Final</jboss-marshalling.version>
         <jboss-threads.version>3.8.0.Final</jboss-threads.version>
         <vertx.version>4.5.14</vertx.version>

build-parent/pom.xml

@@ -29,7 +29,7 @@
         <jboss-bridger-plugin.version>1.6.Final</jboss-bridger-plugin.version>
 
         <!-- Jandex versions -->
-        <jandex.version>3.3.0</jandex.version>
+        <jandex.version>3.3.1</jandex.version>
         <jandex-gradle-plugin.version>1.0.0</jandex-gradle-plugin.version>
 
         <asciidoctorj.version>2.5.13</asciidoctorj.version>

core/deployment/src/main/java/io/quarkus/deployment/dev/testing/CurrentTestApplication.java

@@ -158,7 +158,6 @@ public Runnable prepare() {
             LogCapturingOutputFilter logHandler = new LogCapturingOutputFilter(testApplication, true, true,
                     TestSupport.instance()
                             .get()::isDisplayTestOutput);
-            // TODO do we want to do this setting of the TCCL? I think it just makes problems?
             Thread.currentThread().setContextClassLoader(tcl);
 
             Set<UniqueId> allDiscoveredIds = new HashSet<>();
@@ -570,21 +569,23 @@ private DiscoveryResult discoverTestClasses() {
         //for now this is out of scope, we are just going to do annotation based discovery
         //we will need to fix this sooner rather than later though
 
+        if (moduleInfo.getTest().isEmpty()) {
+            return DiscoveryResult.EMPTY;
+        }
+
         //we also only run tests from the current module, which we can also revisit later
         Indexer indexer = new Indexer();
-        moduleInfo.getTest().ifPresent(test -> {
-            try (Stream<Path> files = Files.walk(Paths.get(test.getClassesPath()))) {
-                files.filter(s -> s.getFileName().toString().endsWith(".class")).forEach(s -> {
-                    try (InputStream in = Files.newInputStream(s)) {
-                        indexer.index(in);
-                    } catch (IOException e) {
-                        throw new RuntimeException(e);
-                    }
-                });
-            } catch (IOException e) {
-                throw new RuntimeException(e);
-            }
-        });
+        try (Stream<Path> files = Files.walk(Paths.get(moduleInfo.getTest().get().getClassesPath()))) {
+            files.filter(s -> s.getFileName().toString().endsWith(".class")).forEach(s -> {
+                try (InputStream in = Files.newInputStream(s)) {
+                    indexer.index(in);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
 
         Index index = indexer.complete();
         //we now have all the classes by name
@@ -617,18 +618,16 @@ private DiscoveryResult discoverTestClasses() {
         // Most logic in the JUnitRunner counts main tests as quarkus tests, so do a (mildly irritating) special pass to get the ones which are strictly @QuarkusTest
 
         Set<String> quarkusTestClassesForFacadeClassLoader = new HashSet<>();
-        for (var a : Arrays.asList(QUARKUS_TEST)) {
-            for (AnnotationInstance i : index.getAnnotations(a)) {
-                DotName name = i.target()
-                        .asClass()
-                        .name();
-                quarkusTestClassesForFacadeClassLoader.add(name.toString());
-                for (ClassInfo clazz : index.getAllKnownSubclasses(name)) {
-                    if (!integrationTestClasses.contains(clazz.name()
-                            .toString())) {
-                        quarkusTestClassesForFacadeClassLoader.add(clazz.name()
-                                .toString());
-                    }
+        for (AnnotationInstance i : index.getAnnotations(QUARKUS_TEST)) {
+            DotName name = i.target()
+                    .asClass()
+                    .name();
+            quarkusTestClassesForFacadeClassLoader.add(name.toString());
+            for (ClassInfo clazz : index.getAllKnownSubclasses(name)) {
+                if (!integrationTestClasses.contains(clazz.name()
+                        .toString())) {
+                    quarkusTestClassesForFacadeClassLoader.add(clazz.name()
+                            .toString());
                 }
             }
         }
@@ -681,10 +680,16 @@ private DiscoveryResult discoverTestClasses() {
             }
             var enclosing = enclosingClasses.get(testClass);
             if (enclosing != null) {
-                if (integrationTestClasses.contains(enclosing.toString())) {
+                String enclosingString = enclosing.toString();
+                if (quarkusTestClassesForFacadeClassLoader.contains(enclosingString)) {
+                    quarkusTestClassesForFacadeClassLoader.add(name);
+                }
+
+                // No else here, this is an 'also do'
+                if (integrationTestClasses.contains(enclosingString)) {
                     integrationTestClasses.add(name);
                     continue;
-                } else if (quarkusTestClasses.contains(enclosing.toString())) {
+                } else if (quarkusTestClasses.contains(enclosingString)) {
                     quarkusTestClasses.add(name);
                     continue;
                 }
@@ -696,6 +701,20 @@ private DiscoveryResult discoverTestClasses() {
             unitTestClasses.add(name);
         }
 
+        // if we didn't find any test classes, let's return early
+        // Make sure you also update the logic for the non-empty case above if you adjust this part
+        if (testType == TestType.ALL) {
+            if (unitTestClasses.isEmpty() && quarkusTestClasses.isEmpty()) {
+                return DiscoveryResult.EMPTY;
+            }
+        } else if (testType == TestType.UNIT) {
+            if (unitTestClasses.isEmpty()) {
+                return DiscoveryResult.EMPTY;
+            }
+        } else if (quarkusTestClasses.isEmpty()) {
+            return DiscoveryResult.EMPTY;
+        }
+
         List<Class<?>> itClasses = new ArrayList<>();
         List<Class<?>> utClasses = new ArrayList<>();
 
@@ -745,8 +764,6 @@ private DiscoveryResult discoverTestClasses() {
                 log.warnf(
                         "Failed to load test class %s (possibly as it was added after the test run started), it will not be executed this run.",
                         i);
-            } finally {
-                // TODO should we do this?  Thread.currentThread().setContextClassLoader(old);
             }
         }
         itClasses.sort(Comparator.comparing(new Function<Class<?>, String>() {
@@ -808,6 +825,7 @@ public String apply(Class<?> aClass) {
             }
         }
 
+        // Make sure you also update the logic for the empty case above if you adjust this part
         if (testType == TestType.ALL) {
             //run unit style tests first
             //before the quarkus tests have started
@@ -1270,6 +1288,8 @@ public FilterResult apply(TestDescriptor testDescriptor) {
 
     static class DiscoveryResult implements AutoCloseable {
 
+        private final static DiscoveryResult EMPTY = new DiscoveryResult(null, List.of());
+
         final QuarkusClassLoader classLoader;
         final List<Class<?>> testClasses;
 

core/deployment/src/main/java/io/quarkus/deployment/dev/testing/JunitTestRunner.java

@@ -0,0 +1,164 @@
+package io.quarkus.deployment.pkg;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Enumeration;
+import java.util.Map;
+import java.util.function.Predicate;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+
+import org.jboss.logging.Logger;
+
+/**
+ * JarUnsigner is used to remove the signature from a jar file.
+ */
+public final class JarUnsigner {
+
+    private static final Logger log = Logger.getLogger(JarUnsigner.class);
+
+    private JarUnsigner() {
+        // utility class
+    }
+
+    /**
+     * Unsigns a jar file by removing the signature entries.
+     * If the JAR is not signed, it will simply copy the original JAR to the target path.
+     *
+     * @param jarPath the path to the jar file to unsign
+     * @param targetPath the path to the target jar file
+     * @throws IOException if an I/O error occurs
+     */
+    public static void unsignJar(Path jarPath, Path targetPath) throws IOException {
+        try (JarFile in = new JarFile(jarPath.toFile(), false)) {
+            Manifest manifest = in.getManifest();
+            boolean signed;
+            if (manifest != null) {
+                Map<String, Attributes> entries = manifest.getEntries();
+                signed = !entries.isEmpty();
+                // Remove signature entries
+                entries.clear();
+            } else {
+                signed = false;
+                manifest = new Manifest();
+            }
+            if (!signed) {
+                in.close();
+                log.debugf("JAR %s is not signed, skipping unsigning", jarPath);
+                Files.copy(jarPath, targetPath, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
+            } else {
+                log.debugf("JAR %s is signed, removing signature", jarPath);
+                // Reusing buffer for performance reasons
+                byte[] buffer = new byte[10000];
+                try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(targetPath))) {
+                    JarEntry manifestEntry = new JarEntry(JarFile.MANIFEST_NAME);
+                    // Set manifest time to epoch to always make the same jar
+                    manifestEntry.setTime(0);
+                    out.putNextEntry(manifestEntry);
+                    manifest.write(out);
+                    out.closeEntry();
+                    Enumeration<JarEntry> entries = in.entries();
+                    while (entries.hasMoreElements()) {
+                        JarEntry entry = entries.nextElement();
+                        String entryName = entry.getName();
+                        if (!entryName.equals(JarFile.MANIFEST_NAME)
+                                && !entryName.equals("META-INF/INDEX.LIST")
+                                && !isSignatureFile(entryName)) {
+                            entry.setCompressedSize(-1);
+                            out.putNextEntry(entry);
+                            try (InputStream inStream = in.getInputStream(entry)) {
+                                int r;
+                                while ((r = inStream.read(buffer)) > 0) {
+                                    out.write(buffer, 0, r);
+                                }
+                            } finally {
+                                out.closeEntry();
+                            }
+                        } else {
+                            log.debugf("Removed %s from %s", entryName, jarPath);
+                        }
+                    }
+                }
+            }
+            // let's make sure we keep the original timestamp
+            Files.setLastModifiedTime(targetPath, Files.getLastModifiedTime(jarPath));
+        }
+    }
+
+    /**
+     * Unsigns a jar file by removing the signature entries.
+     *
+     * @param jarPath the path to the jar file to unsign
+     * @param targetPath the path to the target jar file
+     * @param includePredicate a predicate to determine which entries to include in the target jar
+     * @throws IOException if an I/O error occurs
+     */
+    public static void unsignJar(Path jarPath, Path targetPath, Predicate<String> includePredicate) throws IOException {
+        // Reusing buffer for performance reasons
+        byte[] buffer = new byte[10000];
+        try (JarFile in = new JarFile(jarPath.toFile(), false)) {
+            Manifest manifest = in.getManifest();
+            boolean signed;
+            if (manifest != null) {
+                Map<String, Attributes> entries = manifest.getEntries();
+                signed = !entries.isEmpty();
+                // Remove signature entries
+                entries.clear();
+            } else {
+                signed = false;
+                manifest = new Manifest();
+            }
+            if (signed) {
+                log.debugf("JAR %s is signed, removing signature", jarPath);
+            }
+            try (JarOutputStream out = new JarOutputStream(Files.newOutputStream(targetPath))) {
+                JarEntry manifestEntry = new JarEntry(JarFile.MANIFEST_NAME);
+                // Set manifest time to epoch to always make the same jar
+                manifestEntry.setTime(0);
+                out.putNextEntry(manifestEntry);
+                manifest.write(out);
+                out.closeEntry();
+                Enumeration<JarEntry> entries = in.entries();
+                while (entries.hasMoreElements()) {
+                    JarEntry entry = entries.nextElement();
+                    String entryName = entry.getName();
+                    if (includePredicate.test(entryName)
+                            && !entryName.equals(JarFile.MANIFEST_NAME)
+                            && !entryName.equals("META-INF/INDEX.LIST")
+                            && !isSignatureFile(entryName)) {
+                        entry.setCompressedSize(-1);
+                        out.putNextEntry(entry);
+                        try (InputStream inStream = in.getInputStream(entry)) {
+                            int r;
+                            while ((r = inStream.read(buffer)) > 0) {
+                                out.write(buffer, 0, r);
+                            }
+                        } finally {
+                            out.closeEntry();
+                        }
+                    } else {
+                        log.debugf("Removed %s from %s", entryName, jarPath);
+                    }
+                }
+            }
+            // let's make sure we keep the original timestamp
+            Files.setLastModifiedTime(targetPath, Files.getLastModifiedTime(jarPath));
+        }
+    }
+
+    private static boolean isSignatureFile(String entry) {
+        entry = entry.toUpperCase();
+        if (entry.startsWith("META-INF/") && entry.indexOf('/', "META-INF/".length()) == -1) {
+            return entry.endsWith(".SF")
+                    || entry.endsWith(".DSA")
+                    || entry.endsWith(".RSA")
+                    || entry.endsWith(".EC");
+        }
+        return false;
+    }
+}