Merge pull request #50997 from gsmet/3.29.3-backports-1

[3.29] 3.29.3 backports 1

Author: gsmet

bom/application/pom.xml

@@ -19,10 +19,10 @@
         <bouncycastle.version>1.82</bouncycastle.version>
         <bouncycastle.fips.version>2.1.2</bouncycastle.fips.version>
         <bouncycastle.tls.fips.version>2.1.22</bouncycastle.tls.fips.version>
-        <cyclonedx.version>9.0.5</cyclonedx.version>
+        <cyclonedx.version>11.0.1</cyclonedx.version>
         <expressly.version>6.0.0</expressly.version>
         <findbugs.version>3.0.2</findbugs.version>
-        <jandex.version>3.5.1</jandex.version>
+        <jandex.version>3.5.2</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>
@@ -97,7 +97,7 @@
         <classmate.version>1.7.1</classmate.version>
         <!-- See root POM for hibernate-orm.version, hibernate-reactive.version, hibernate-validator.version,
              hibernate-search.version, antlr.version, bytebuddy.version -->
-        <narayana.version>7.3.0.Final</narayana.version>
+        <narayana.version>7.3.3.Final</narayana.version>
         <narayana-lra.version>1.0.2.Final</narayana-lra.version>
         <agroal.version>2.8</agroal.version>
         <jboss-transaction-spi.version>8.0.0.Final</jboss-transaction-spi.version>
@@ -125,7 +125,7 @@
         <mysql-jdbc.version>8.3.0</mysql-jdbc.version>
         <mssql-jdbc.version>13.2.1.jre11</mssql-jdbc.version>
         <adal4j.version>1.6.7</adal4j.version>
-        <oracle-jdbc.version>23.6.0.24.10</oracle-jdbc.version>
+        <oracle-jdbc.version>23.26.0.0.0</oracle-jdbc.version>
         <derby-jdbc.version>10.16.1.1</derby-jdbc.version>
         <db2-jdbc.version>12.1.0.0</db2-jdbc.version>
         <shrinkwrap.version>1.2.6</shrinkwrap.version>

build-parent/pom.xml

@@ -30,7 +30,7 @@
         <jboss-bridger-plugin.version>1.6.Final</jboss-bridger-plugin.version>
 
         <!-- Jandex versions -->
-        <jandex.version>3.5.1</jandex.version>
+        <jandex.version>3.5.2</jandex.version>
         <jandex-gradle-plugin.version>1.0.0</jandex-gradle-plugin.version>
 
         <asciidoctorj.version>2.5.13</asciidoctorj.version>

docs/src/main/asciidoc/gradle-tooling.adoc

@@ -798,10 +798,10 @@ plugins {
 
 quarkus {
     buildForkOptions {
-        maxHeapSize = '2g'
+        maxHeapSize = "2g"
     }
     codeGenForkOptions {
-        maxHeapSize = '128m'
+        maxHeapSize = "128m"
     }
 }
 ----
@@ -933,4 +933,4 @@ The current state of compatibility is shown in the following table:
 The approach to enable Quarkus conditional and extension build time (deployment) dependencies has changed in Quarkus 3.25.1 due to a few issues with the previous implementation.
 Specifically, the previous implementation would not apply relevant dependency exclusions to enabled conditional and deployment dependencies. It would also appear to leak devmode-only dependencies into non-devmode classpaths (such as test and prod) in some cases. These issues couldn't be fixed in a reasonable way in the previous implementation, which is why the Quarkus dependency resolution had to be re-implemented based on a different approach using link:https://docs.gradle.org/current/userguide/variant_aware_resolution.html[Gradle component variants].
 
-The previous implementation still remains available for now in case the new one appears to introduce not yet detected regressions and can be enabled by setting `disableQuarkusComponentVariants` project property to `true`.
+The previous implementation still remains available for now in case the new one appears to introduce not yet detected regressions and can be enabled by setting `disableQuarkusComponentVariants` project property to `true`.

extensions/elasticsearch-rest-client-common/deployment/src/main/java/io/quarkus/elasticsearch/restclient/common/deployment/DevServicesElasticsearchProcessor.java

@@ -355,7 +355,7 @@ private DevservicesElasticsearchBuildItemsConfiguration(List<DevservicesElastics
             for (DevservicesElasticsearchBuildItem buildItem : buildItems) {
                 if (version == null) {
                     version = buildItem.getVersion();
-                } else if (!version.equals(buildItem.getVersion())) {
+                } else if (buildItem.getVersion() != null && !version.equals(buildItem.getVersion())) {
                     // safety guard but should never occur as only Hibernate Search ORM Elasticsearch configure the version
                     throw new BuildException(
                             "Multiple extensions request different versions of Elasticsearch for Dev Services.",
@@ -364,7 +364,7 @@ private DevservicesElasticsearchBuildItemsConfiguration(List<DevservicesElastics
 
                 if (distribution == null) {
                     distribution = buildItem.getDistribution();
-                } else if (!distribution.equals(buildItem.getDistribution())) {
+                } else if (buildItem.getDistribution() != null && !distribution.equals(buildItem.getDistribution())) {
                     // safety guard but should never occur as only Hibernate Search ORM Elasticsearch configure the distribution
                     throw new BuildException(
                             "Multiple extensions request different distributions of Elasticsearch for Dev Services.",

extensions/grpc/deployment/src/test/java/io/quarkus/grpc/server/interceptors/ClosingCallInInterceptorTest.java

@@ -0,0 +1,96 @@
+package io.quarkus.grpc.server.interceptors;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import java.time.Duration;
+import java.util.logging.LogRecord;
+
+import jakarta.enterprise.context.ApplicationScoped;
+
+import org.assertj.core.api.Condition;
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.grpc.Metadata;
+import io.grpc.ServerCall;
+import io.grpc.ServerCallHandler;
+import io.grpc.ServerInterceptor;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.examples.helloworld.Greeter;
+import io.grpc.examples.helloworld.GreeterBean;
+import io.grpc.examples.helloworld.GreeterGrpc;
+import io.grpc.examples.helloworld.HelloReply;
+import io.grpc.examples.helloworld.HelloRequest;
+import io.quarkus.grpc.GlobalInterceptor;
+import io.quarkus.grpc.GrpcClient;
+import io.quarkus.grpc.server.services.HelloService;
+import io.quarkus.test.QuarkusUnitTest;
+import io.smallrye.mutiny.Uni;
+
+public class ClosingCallInInterceptorTest {
+
+    private static final Metadata.Key<String> CLOSE_REASON_KEY = Metadata.Key.of("CUSTOM_CLOSE_REASON",
+            Metadata.ASCII_STRING_MARSHALLER);
+    private static final String STATED_REASON_TO_CLOSE = "Because I want to close it.";
+
+    @RegisterExtension
+    static final QuarkusUnitTest config = new QuarkusUnitTest().setArchiveProducer(
+            () -> ShrinkWrap.create(JavaArchive.class)
+                    .addPackage(GreeterGrpc.class.getPackage())
+                    .addClasses(MyClosingCallInterceptor.class, GreeterBean.class, HelloRequest.class, HelloService.class)
+                    .addAsResource(new StringAsset("quarkus.grpc.server.use-separate-server=false" + System.lineSeparator()),
+                            "application.properties"))
+            .setLogRecordPredicate(
+                    record -> record.getMessage() != null && record.getMessage().contains("Closing gRPC call due to an error"))
+            .assertLogRecords(logRecords -> {
+                if (!logRecords.isEmpty()) {
+                    for (LogRecord logRecord : logRecords) {
+                        if (logRecord.getThrown() instanceof IllegalStateException ise
+                                && ise.getMessage().contains("Already closed")) {
+                            Assertions.fail("Log contains message with 'java.lang.IllegalStateException: Already closed'");
+                        }
+                    }
+                }
+            });
+
+    @GrpcClient
+    Greeter greeter;
+
+    @Test
+    void test() {
+        Uni<HelloReply> result = greeter.sayHello(HelloRequest.newBuilder().setName("ServiceA").build());
+        assertThatThrownBy(() -> result.await().atMost(Duration.ofSeconds(4)))
+                .isInstanceOf(StatusRuntimeException.class)
+                .has(new Condition<Throwable>(t -> {
+                    if (t instanceof StatusRuntimeException statusRuntimeException) {
+                        var trailers = statusRuntimeException.getTrailers();
+                        if (trailers != null) {
+                            return STATED_REASON_TO_CLOSE.equals(trailers.get(CLOSE_REASON_KEY));
+                        }
+                    }
+                    return false;
+                }, "Checking close reason returned in metadata"))
+                .hasMessageContaining("UNAUTHENTICATED");
+    }
+
+    @ApplicationScoped
+    @GlobalInterceptor
+    public static class MyClosingCallInterceptor implements ServerInterceptor {
+
+        @Override
+        public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers,
+                ServerCallHandler<ReqT, RespT> next) {
+            var metadata = new Metadata();
+            metadata.put(CLOSE_REASON_KEY, STATED_REASON_TO_CLOSE);
+            call.close(Status.UNAUTHENTICATED, metadata);
+            return new ServerCall.Listener<>() {
+            };
+        }
+    }
+
+}

extensions/grpc/runtime/src/main/java/io/quarkus/grpc/runtime/supports/context/GrpcDuplicatedContextGrpcInterceptor.java

@@ -5,18 +5,20 @@
 import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.function.Consumer;
-import java.util.function.Supplier;
+import java.util.function.Function;
 
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.enterprise.inject.spi.Prioritized;
 import jakarta.inject.Inject;
 
 import org.jboss.logging.Logger;
 
+import io.grpc.ForwardingServerCall;
 import io.grpc.Metadata;
 import io.grpc.ServerCall;
 import io.grpc.ServerCallHandler;
 import io.grpc.ServerInterceptor;
+import io.grpc.Status;
 import io.grpc.StatusException;
 import io.quarkus.grpc.ExceptionHandlerProvider;
 import io.quarkus.grpc.GlobalInterceptor;
@@ -54,15 +56,27 @@ public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, Re
         }
     }
 
-    private <ReqT, RespT> Supplier<ServerCall.Listener<ReqT>> nextCall(ServerCall<ReqT, RespT> call,
+    private <ReqT, RespT> Function<Runnable, ServerCall.Listener<ReqT>> nextCall(ServerCall<ReqT, RespT> call,
             Metadata headers,
             ServerCallHandler<ReqT, RespT> next) {
         // Must be sure to call next.startCall on the right context
         io.grpc.Context current = io.grpc.Context.current();
-        return () -> {
+        return onClose -> {
             io.grpc.Context previous = current.attach();
             try {
-                return next.startCall(call, headers);
+                var forwardingCall = new ForwardingServerCall<ReqT, RespT>() {
+                    @Override
+                    protected ServerCall<ReqT, RespT> delegate() {
+                        return call;
+                    }
+
+                    @Override
+                    public void close(Status status, Metadata trailers) {
+                        onClose.run();
+                        super.close(status, trailers);
+                    }
+                };
+                return next.startCall(forwardingCall, headers);
             } finally {
                 current.detach(previous);
             }
@@ -77,31 +91,35 @@ public int getPriority() {
     static class ListenedOnDuplicatedContext<ReqT, RespT> extends ServerCall.Listener<ReqT> {
 
         private final Context context;
-        private final Supplier<ServerCall.Listener<ReqT>> supplier;
+        private final Function<Runnable, ServerCall.Listener<ReqT>> listenerCreator;
         private final ExceptionHandlerProvider ehp;
         private final ServerCall<ReqT, RespT> call;
-        private ServerCall.Listener<ReqT> delegate;
+        private volatile ServerCall.Listener<ReqT> delegate;
 
         private final AtomicBoolean closed = new AtomicBoolean();
 
         public ListenedOnDuplicatedContext(
                 ExceptionHandlerProvider ehp,
-                ServerCall<ReqT, RespT> call, Supplier<ServerCall.Listener<ReqT>> supplier, Context context) {
+                ServerCall<ReqT, RespT> call, Function<Runnable, ServerCall.Listener<ReqT>> listenerCreator, Context context) {
             this.ehp = ehp;
             this.context = context;
-            this.supplier = supplier;
+            this.listenerCreator = listenerCreator;
             this.call = call;
         }
 
-        private synchronized ServerCall.Listener<ReqT> getDelegate() {
-            if (delegate == null) {
-                try {
-                    delegate = supplier.get();
-                } catch (Throwable t) {
-                    // If the interceptor supplier throws an exception, catch it, and close the call.
-                    log.warn("Unable to retrieve gRPC Server call listener, see the cause below.");
-                    close(t);
-                    return null;
+        private ServerCall.Listener<ReqT> getDelegate() {
+            if (delegate == null && !closed.get()) {
+                synchronized (this) {
+                    if (delegate == null && !closed.get()) {
+                        try {
+                            delegate = listenerCreator.apply(() -> closed.set(true));
+                        } catch (Throwable t) {
+                            // If the interceptor supplier throws an exception, catch it, and close the call.
+                            log.warn("Unable to retrieve gRPC Server call listener, see the cause below.");
+                            close(t);
+                            return null;
+                        }
+                    }
                 }
             }
             return delegate;

extensions/kafka-client/runtime-dev/pom.xml

@@ -18,5 +18,10 @@
             <groupId>io.quarkus</groupId>
             <artifactId>quarkus-kafka-client</artifactId>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 </project>

extensions/kafka-client/runtime-dev/src/main/java/io/quarkus/kafka/client/runtime/dev/ui/model/converter/KafkaModelConverter.java

@@ -30,6 +30,7 @@ public KafkaMessage convert(ConsumerRecord<Bytes, Bytes> message) {
 
     private static Map<String, String> headers(ConsumerRecord<Bytes, Bytes> message) {
         return StreamSupport.stream(message.headers().spliterator(), false)
-                .collect(Collectors.toMap(Header::key, header -> new String(header.value(), StandardCharsets.UTF_8)));
+                .collect(Collectors.toMap(Header::key, header -> new String(header.value(), StandardCharsets.UTF_8),
+                        (existing, replacement) -> replacement));
     }
 }