getAll() {
return Collections.unmodifiableMap(properties);
}
+ /**
+ * Set the property
+ *
+ * @param name property name
+ * @param value property value
+ * @return this OidcRequestContextProperties instance
+ */
+ public OidcRequestContextProperties put(String name, Object value) {
+ properties.put(name, value);
+ return this;
+ }
}
diff --git a/extensions/panache/mongodb-panache/runtime/src/main/java/io/quarkus/mongodb/panache/package-info.java b/extensions/panache/mongodb-panache/runtime/src/main/java/io/quarkus/mongodb/panache/package-info.java
index 0340f0bbc54c6..0deec3af70317 100644
--- a/extensions/panache/mongodb-panache/runtime/src/main/java/io/quarkus/mongodb/panache/package-info.java
+++ b/extensions/panache/mongodb-panache/runtime/src/main/java/io/quarkus/mongodb/panache/package-info.java
@@ -56,8 +56,10 @@
* otherwise it will be the name of your entity.
*
*
- * The Mongo PojoCodec is used to serialize your entity to Bson Document, you can find more information on it's
- * documentation page: https://mongodb.github.io/mongo-java-driver/3.10/bson/pojos/
+ * The Mongo PojoCodec is used to serialize your entity to a Bson Document, you can find more information on its
+ * documentation page:
+ * https://www.mongodb.com/docs/drivers/java/sync/current/fundamentals/data-formats/document-data-format-pojo.
+ * This codec also supports Java records.
* You can use the MongoDB annotations to control the mapping to the database : @BsonId,
* @BsonProperty("fieldName"), @BsonIgnore.
*
diff --git a/extensions/quartz/runtime/src/main/java/io/quarkus/quartz/runtime/QuartzRuntimeConfig.java b/extensions/quartz/runtime/src/main/java/io/quarkus/quartz/runtime/QuartzRuntimeConfig.java
index 12bb568c727d1..a2589605d5e6a 100644
--- a/extensions/quartz/runtime/src/main/java/io/quarkus/quartz/runtime/QuartzRuntimeConfig.java
+++ b/extensions/quartz/runtime/src/main/java/io/quarkus/quartz/runtime/QuartzRuntimeConfig.java
@@ -42,8 +42,11 @@ public class QuartzRuntimeConfig {
public int batchTriggerAcquisitionMaxCount;
/**
* The size of scheduler thread pool. This will initialize the number of worker threads in the pool.
+ *
+ * It's important to bear in mind that Quartz threads are not used to execute scheduled methods, instead the regular Quarkus
+ * thread pool is used by default. See also {@code quarkus.quartz.run-blocking-scheduled-method-on-quartz-thread}.
*/
- @ConfigItem(defaultValue = "25")
+ @ConfigItem(defaultValue = "10")
public int threadCount;
/**
diff --git a/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonDeserializerFactory.java b/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonDeserializerFactory.java
index 73d843f80d00a..fa1fdb002bf0a 100644
--- a/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonDeserializerFactory.java
+++ b/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonDeserializerFactory.java
@@ -156,6 +156,9 @@
* Map.Entry entry = (Map.iterator) var3.next();
* String field = (String) entry.getKey();
* JsonNode jsonNode = (JsonNode) entry.getValue();
+ * if (jsonNode.isNull()) {
+ * continue;
+ * }
* switch (field) {
* case "content":
* dataItem.setContent(context.readTreeAsValue(jsonNode, this.valueTypes[0]));
@@ -240,10 +243,13 @@ private boolean deserializeObject(ClassInfo classInfo, ResultHandle objHandle, C
.invokeInterfaceMethod(ofMethod(Map.Entry.class, "getKey", Object.class), mapEntry);
ResultHandle fieldValue = loopCreator.checkCast(loopCreator
.invokeInterfaceMethod(ofMethod(Map.Entry.class, "getValue", Object.class), mapEntry), JsonNode.class);
- Switch.StringSwitch strSwitch = loopCreator.stringSwitch(fieldName);
+
+ loopCreator.ifTrue(loopCreator.invokeVirtualMethod(ofMethod(JsonNode.class, "isNull", boolean.class), fieldValue))
+ .trueBranch().continueScope(loopCreator);
Set deserializedFields = new HashSet<>();
ResultHandle deserializationContext = deserialize.getMethodParam(1);
+ Switch.StringSwitch strSwitch = loopCreator.stringSwitch(fieldName);
return deserializeFields(classCreator, classInfo, deserializationContext, objHandle, fieldValue, deserializedFields,
strSwitch, parseTypeParameters(classInfo, classCreator));
}
diff --git a/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonSerializerFactory.java b/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonSerializerFactory.java
index 6ca5109cd4e21..457977f1f4064 100644
--- a/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonSerializerFactory.java
+++ b/extensions/resteasy-reactive/rest-jackson/deployment/src/main/java/io/quarkus/resteasy/reactive/jackson/deployment/processor/JacksonSerializerFactory.java
@@ -190,13 +190,13 @@ protected boolean createSerializationMethod(ClassInfo classInfo, ClassCreator cl
private boolean serializeObject(ClassInfo classInfo, ClassCreator classCreator, String beanClassName,
MethodCreator serialize) {
- Set serializedFields = new HashSet<>();
SerializationContext ctx = new SerializationContext(serialize, beanClassName);
// jsonGenerator.writeStartObject();
MethodDescriptor writeStartObject = MethodDescriptor.ofMethod(JSON_GEN_CLASS_NAME, "writeStartObject", "void");
serialize.invokeVirtualMethod(writeStartObject, ctx.jsonGenerator);
+ Set serializedFields = new HashSet<>();
boolean valid = serializeObjectData(classInfo, classCreator, serialize, ctx, serializedFields);
// jsonGenerator.writeEndObject();
@@ -222,7 +222,7 @@ private boolean serializeFields(ClassInfo classInfo, ClassCreator classCreator,
SerializationContext ctx, Set serializedFields) {
for (FieldInfo fieldInfo : classFields(classInfo)) {
FieldSpecs fieldSpecs = fieldSpecsFromField(classInfo, fieldInfo);
- if (fieldSpecs != null && serializedFields.add(fieldSpecs.fieldName)) {
+ if (fieldSpecs != null && serializedFields.add(fieldSpecs.jsonName)) {
if (fieldSpecs.hasUnknownAnnotation()) {
return false;
}
@@ -236,7 +236,7 @@ private boolean serializeMethods(ClassInfo classInfo, ClassCreator classCreator,
SerializationContext ctx, Set serializedFields) {
for (MethodInfo methodInfo : classMethods(classInfo)) {
FieldSpecs fieldSpecs = fieldSpecsFromMethod(methodInfo);
- if (fieldSpecs != null && serializedFields.add(fieldSpecs.fieldName)) {
+ if (fieldSpecs != null && serializedFields.add(fieldSpecs.jsonName)) {
if (fieldSpecs.hasUnknownAnnotation()) {
return false;
}
diff --git a/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonResource.java b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonResource.java
index 05f12b8e9ebf4..855c43625c09e 100644
--- a/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonResource.java
+++ b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonResource.java
@@ -116,6 +116,13 @@ public Dog echoDog(Dog dog) {
return dog;
}
+ @POST
+ @Path("/record-echo")
+ @Consumes(MediaType.APPLICATION_JSON)
+ public StateRecord echoDog(StateRecord stateRecord) {
+ return stateRecord;
+ }
+
@EnableSecureSerialization
@GET
@Path("/abstract-cat")
diff --git a/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonTest.java b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonTest.java
index 8aa2a009e8418..d2f22569f9a7a 100644
--- a/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonTest.java
+++ b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonTest.java
@@ -6,6 +6,7 @@
import static org.hamcrest.Matchers.notNullValue;
import static org.hamcrest.Matchers.nullValue;
import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.function.Supplier;
@@ -35,7 +36,7 @@ public JavaArchive get() {
AbstractPet.class, Dog.class, Cat.class, Veterinarian.class, AbstractNamedPet.class,
AbstractUnsecuredPet.class, UnsecuredPet.class, SecuredPersonInterface.class, Frog.class,
Pond.class, FrogBodyParts.class, FrogBodyParts.BodyPart.class, ContainerDTO.class,
- NestedInterface.class)
+ NestedInterface.class, StateRecord.class)
.addAsResource(new StringAsset("admin-expression=admin\n" +
"user-expression=user\n" +
"birth-date-roles=alice,bob\n"), "application.properties");
@@ -675,6 +676,24 @@ public void testEcho() {
.body("veterinarian.title", Matchers.nullValue());
}
+ @Test
+ public void testEchoWithNullString() {
+ RestAssured
+ .with()
+ .body("{\"publicName\":null,\"veterinarian\":{\"name\":\"Dolittle\"},\"age\":5,\"vaccinated\":true}")
+ .contentType("application/json; charset=utf-8")
+ .post("/simple/dog-echo")
+ .then()
+ .statusCode(200)
+ .contentType("application/json")
+ .body("publicName", Matchers.nullValue())
+ .body("privateName", Matchers.nullValue())
+ .body("age", Matchers.is(5))
+ .body("vaccinated", Matchers.is(true))
+ .body("veterinarian.name", Matchers.is("Dolittle"))
+ .body("veterinarian.title", Matchers.nullValue());
+ }
+
@Test
public void testEchoWithMissingPrimitive() {
RestAssured
@@ -691,4 +710,27 @@ public void testEchoWithMissingPrimitive() {
.body("veterinarian.name", Matchers.is("Dolittle"))
.body("veterinarian.title", Matchers.nullValue());
}
+
+ @Test
+ public void testRecordEcho() {
+ String response = RestAssured
+ .with()
+ .body("{\"code\":\"AL\",\"is_enabled\":true,\"name\":\"Alabama\"}")
+ .contentType("application/json; charset=utf-8")
+ .post("/simple/record-echo")
+ .then()
+ .statusCode(200)
+ .contentType("application/json")
+ .body("name", Matchers.is("Alabama"))
+ .body("code", Matchers.is("AL"))
+ .body("is_enabled", Matchers.is(true))
+ .extract()
+ .asString();
+
+ int first = response.indexOf("is_enabled");
+ int last = response.lastIndexOf("is_enabled");
+ // assert that the "is_enabled" field is present only once in the response
+ assertTrue(first >= 0);
+ assertEquals(first, last);
+ }
}
diff --git a/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonWithReflectionFreeSerializersTest.java b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonWithReflectionFreeSerializersTest.java
index 0254e48598fe8..65dec05aa59a4 100644
--- a/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonWithReflectionFreeSerializersTest.java
+++ b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/SimpleJsonWithReflectionFreeSerializersTest.java
@@ -25,7 +25,7 @@ public JavaArchive get() {
AbstractPet.class, Dog.class, Cat.class, Veterinarian.class, AbstractNamedPet.class,
AbstractUnsecuredPet.class, UnsecuredPet.class, SecuredPersonInterface.class, Frog.class,
Pond.class, FrogBodyParts.class, FrogBodyParts.BodyPart.class, ContainerDTO.class,
- NestedInterface.class)
+ NestedInterface.class, StateRecord.class)
.addAsResource(new StringAsset("admin-expression=admin\n" +
"user-expression=user\n" +
"birth-date-roles=alice,bob\n" +
diff --git a/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/StateRecord.java b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/StateRecord.java
new file mode 100644
index 0000000000000..1e7aed0af9943
--- /dev/null
+++ b/extensions/resteasy-reactive/rest-jackson/deployment/src/test/java/io/quarkus/resteasy/reactive/jackson/deployment/test/StateRecord.java
@@ -0,0 +1,8 @@
+package io.quarkus.resteasy.reactive.jackson.deployment.test;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonProperty;
+
+@JsonIgnoreProperties(ignoreUnknown = true)
+public record StateRecord(String name, String code, @JsonProperty("is_enabled") boolean isEnabled) {
+}
\ No newline at end of file
diff --git a/extensions/resteasy-reactive/rest/deployment/src/main/java/io/quarkus/resteasy/reactive/server/deployment/ResteasyReactiveProcessor.java b/extensions/resteasy-reactive/rest/deployment/src/main/java/io/quarkus/resteasy/reactive/server/deployment/ResteasyReactiveProcessor.java
index d9fe9f478b498..67adec4015f7f 100644
--- a/extensions/resteasy-reactive/rest/deployment/src/main/java/io/quarkus/resteasy/reactive/server/deployment/ResteasyReactiveProcessor.java
+++ b/extensions/resteasy-reactive/rest/deployment/src/main/java/io/quarkus/resteasy/reactive/server/deployment/ResteasyReactiveProcessor.java
@@ -245,6 +245,8 @@ public class ResteasyReactiveProcessor {
private static final int SECURITY_EXCEPTION_MAPPERS_PRIORITY = Priorities.USER + 1;
private static final String[] EMPTY_STRING_ARRAY = new String[0];
+ private static final DotName QUARKUS_TEST_MOCK = DotName.createSimple("io.quarkus.test.Mock");
+
@BuildStep
public FeatureBuildItem buildSetup() {
return new FeatureBuildItem(Feature.REST);
@@ -697,21 +699,23 @@ public Supplier apply(ClassInfo classInfo) {
generatedClassBuildItemBuildProducer, applicationClassPredicate, reflectiveClassBuildItemBuildProducer));
serverEndpointIndexer = serverEndpointIndexerBuilder.build();
- Map> allMethods = new HashMap<>();
- for (ClassInfo i : scannedResources.values()) {
- Optional endpoints = serverEndpointIndexer.createEndpoints(i, true);
+ Map> allServerMethods = new HashMap<>();
+ for (ClassInfo ci : scannedResources.values()) {
+ Optional endpoints = serverEndpointIndexer.createEndpoints(ci, true);
if (endpoints.isPresent()) {
- if (singletonClasses.contains(i.name().toString())) {
- endpoints.get().setFactory(new SingletonBeanFactory<>(i.name().toString()));
+ if (singletonClasses.contains(ci.name().toString())) {
+ endpoints.get().setFactory(new SingletonBeanFactory<>(ci.name().toString()));
}
resourceClasses.add(endpoints.get());
- for (ResourceMethod rm : endpoints.get().getMethods()) {
- addResourceMethodByPath(allMethods, endpoints.get().getPath(), i, rm);
+ if (!ignoreResourceForDuplicateDetection(ci)) {
+ for (ResourceMethod rm : endpoints.get().getMethods()) {
+ addResourceMethodByPath(allServerMethods, endpoints.get().getPath(), ci, rm);
+ }
}
}
}
- checkForDuplicateEndpoint(config, allMethods);
+ checkForDuplicateEndpoint(config, allServerMethods);
//now index possible sub resources. These are all classes that have method annotations
//that are not annotated @Path
@@ -782,6 +786,14 @@ public Supplier apply(ClassInfo classInfo) {
handleDateFormatReflection(reflectiveClassBuildItemBuildProducer, index);
}
+ // TODO: this is really just a hackish way of allowing the use of @Mock so we might need something better
+ private boolean ignoreResourceForDuplicateDetection(ClassInfo ci) {
+ if (ci.hasAnnotation(QUARKUS_TEST_MOCK)) {
+ return true;
+ }
+ return false;
+ }
+
private boolean filtersAccessResourceMethod(ResourceInterceptors resourceInterceptors) {
AtomicBoolean ab = new AtomicBoolean(false);
ResourceInterceptors.FiltersVisitor visitor = new ResourceInterceptors.FiltersVisitor() {
diff --git a/extensions/resteasy-reactive/rest/deployment/src/test/java/io/quarkus/resteasy/reactive/server/test/duplicate/DuplicateResourceAndClientTest.java b/extensions/resteasy-reactive/rest/deployment/src/test/java/io/quarkus/resteasy/reactive/server/test/duplicate/DuplicateResourceAndClientTest.java
new file mode 100644
index 0000000000000..69fdd14033620
--- /dev/null
+++ b/extensions/resteasy-reactive/rest/deployment/src/test/java/io/quarkus/resteasy/reactive/server/test/duplicate/DuplicateResourceAndClientTest.java
@@ -0,0 +1,59 @@
+package io.quarkus.resteasy.reactive.server.test.duplicate;
+
+import static io.restassured.RestAssured.when;
+
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.MediaType;
+
+import org.jboss.shrinkwrap.api.ShrinkWrap;
+import org.jboss.shrinkwrap.api.spec.JavaArchive;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.Mock;
+import io.quarkus.test.QuarkusUnitTest;
+
+public class DuplicateResourceAndClientTest {
+
+ @RegisterExtension
+ static QuarkusUnitTest runner = new QuarkusUnitTest()
+ .setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
+ .addClasses(Client.class, Resource.class));
+
+ @Test
+ public void dummy() {
+ when()
+ .get("/hello")
+ .then()
+ .statusCode(200);
+ }
+
+ @Path("/hello")
+ public interface Client {
+
+ @GET
+ @Produces(MediaType.TEXT_PLAIN)
+ String hello();
+ }
+
+ @Mock
+ public static class ClientMock implements Client {
+
+ @Override
+ public String hello() {
+ return "";
+ }
+ }
+
+ @Path("/hello")
+ public static class Resource {
+
+ @GET
+ @Produces(MediaType.TEXT_PLAIN)
+ public String hello() {
+ return "hello";
+ }
+ }
+}
diff --git a/extensions/resteasy-reactive/rest/deployment/src/test/java/io/quarkus/resteasy/reactive/server/test/security/RepeatedPermissionsAllowedTest.java b/extensions/resteasy-reactive/rest/deployment/src/test/java/io/quarkus/resteasy/reactive/server/test/security/RepeatedPermissionsAllowedTest.java
new file mode 100644
index 0000000000000..19e41ddfa6652
--- /dev/null
+++ b/extensions/resteasy-reactive/rest/deployment/src/test/java/io/quarkus/resteasy/reactive/server/test/security/RepeatedPermissionsAllowedTest.java
@@ -0,0 +1,113 @@
+package io.quarkus.resteasy.reactive.server.test.security;
+
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.security.PermissionsAllowed;
+import io.quarkus.security.StringPermission;
+import io.quarkus.security.test.utils.TestIdentityController;
+import io.quarkus.security.test.utils.TestIdentityProvider;
+import io.quarkus.test.QuarkusUnitTest;
+import io.restassured.RestAssured;
+import io.vertx.core.json.JsonObject;
+
+public class RepeatedPermissionsAllowedTest {
+
+ @RegisterExtension
+ static QuarkusUnitTest runner = new QuarkusUnitTest()
+ .withApplicationRoot((jar) -> jar
+ .addClasses(TestIdentityProvider.class, TestIdentityController.class, HelloResource.class)
+ .addAsResource(
+ new StringAsset(
+ "quarkus.log.category.\"io.quarkus.vertx.http.runtime.QuarkusErrorHandler\".level=OFF"
+ + System.lineSeparator()),
+ "application.properties"));
+
+ @BeforeAll
+ public static void setupUsers() {
+ TestIdentityController.resetRoles()
+ .add("user", "user", new StringPermission("read"))
+ .add("admin", "admin", new StringPermission("read"), new StringPermission("write"));
+ }
+
+ @Test
+ public void testRepeatedPermissionsAllowedOnClass() {
+ // anonymous user
+ RestAssured.given()
+ .body("{%$$#!#@") // assures checks are eager
+ .post("/hello")
+ .then()
+ .statusCode(401);
+ // authenticated user, insufficient rights
+ RestAssured.given()
+ .auth().preemptive().basic("user", "user")
+ .body("{%$$#!#@") // assures checks are eager
+ .post("/hello")
+ .then()
+ .statusCode(403);
+ // authorized user, invalid payload
+ RestAssured.given()
+ .auth().preemptive().basic("admin", "admin")
+ .body("{%$$#!#@") // assures checks are eager
+ .post("/hello")
+ .then()
+ .statusCode(500);
+ }
+
+ @Test
+ public void testRepeatedPermissionsAllowedOnInterface() {
+ // anonymous user
+ RestAssured.given()
+ .body("{%$$#!#@") // assures checks are eager
+ .post("/hello-interface")
+ .then()
+ .statusCode(401);
+ // authenticated user, insufficient rights
+ RestAssured.given()
+ .auth().preemptive().basic("user", "user")
+ .body("{%$$#!#@") // assures checks are eager
+ .post("/hello-interface")
+ .then()
+ .statusCode(403);
+ // authorized user, invalid payload
+ RestAssured.given()
+ .auth().preemptive().basic("admin", "admin")
+ .body("{%$$#!#@") // assures checks are eager
+ .post("/hello-interface")
+ .then()
+ .statusCode(500);
+ }
+
+ @Path("/hello")
+ public static class HelloResource {
+
+ @PermissionsAllowed(value = "write")
+ @PermissionsAllowed(value = "read")
+ @POST
+ public String sayHello(JsonObject entity) {
+ return "ignored";
+ }
+ }
+
+ @Path("/hello-interface")
+ public interface HelloInterface {
+
+ @PermissionsAllowed(value = "write")
+ @PermissionsAllowed(value = "read")
+ @POST
+ String sayHello(JsonObject entity);
+ }
+
+ public static class HelloInterfaceImpl implements HelloInterface {
+
+ @Override
+ public String sayHello(JsonObject entity) {
+ return "ignored";
+ }
+ }
+}
diff --git a/extensions/security/spi/src/main/java/io/quarkus/security/spi/SecurityTransformerUtils.java b/extensions/security/spi/src/main/java/io/quarkus/security/spi/SecurityTransformerUtils.java
index c85c497a3db9b..39ab0bf50c575 100644
--- a/extensions/security/spi/src/main/java/io/quarkus/security/spi/SecurityTransformerUtils.java
+++ b/extensions/security/spi/src/main/java/io/quarkus/security/spi/SecurityTransformerUtils.java
@@ -23,6 +23,7 @@ public final class SecurityTransformerUtils {
public static final DotName DENY_ALL = DotName.createSimple(DenyAll.class.getName());
private static final Set SECURITY_ANNOTATIONS = Set.of(DotName.createSimple(RolesAllowed.class.getName()),
DotName.createSimple(PermissionsAllowed.class.getName()),
+ DotName.createSimple(PermissionsAllowed.List.class.getName()),
DotName.createSimple(Authenticated.class.getName()),
DotName.createSimple(DenyAll.class.getName()),
DotName.createSimple(PermitAll.class.getName()));
diff --git a/extensions/vertx-http/deployment/src/main/java/io/quarkus/devui/deployment/ide/IdeProcessor.java b/extensions/vertx-http/deployment/src/main/java/io/quarkus/devui/deployment/ide/IdeProcessor.java
index ffee04566e460..368c57ec0a632 100644
--- a/extensions/vertx-http/deployment/src/main/java/io/quarkus/devui/deployment/ide/IdeProcessor.java
+++ b/extensions/vertx-http/deployment/src/main/java/io/quarkus/devui/deployment/ide/IdeProcessor.java
@@ -8,8 +8,6 @@
import java.util.Optional;
import java.util.concurrent.TimeUnit;
-import org.eclipse.microprofile.config.Config;
-import org.eclipse.microprofile.config.ConfigProvider;
import org.jboss.logging.Logger;
import io.quarkus.deployment.IsDevelopment;
@@ -126,7 +124,6 @@ public static void openBrowser(HttpRootPathBuildItem rp, NonApplicationRootPathB
}
StringBuilder sb = new StringBuilder("http://");
- Config c = ConfigProvider.getConfig();
sb.append(host);
sb.append(":");
sb.append(port);
diff --git a/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHandlerInitializer.java b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHandlerInitializer.java
index ad8200b875184..429afe2aa5d6e 100644
--- a/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHandlerInitializer.java
+++ b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHandlerInitializer.java
@@ -19,6 +19,17 @@ public void register(@Observes Router router) {
+ "|" + rc.request().remoteAddress().toString()
+ "|" + rc.request().uri()
+ "|" + rc.request().absoluteURI()));
+ router.route("/trusted-proxy").handler(rc -> rc.response()
+ .end(rc.request().scheme() + "|" + rc.request().getHeader(HttpHeaders.HOST) + "|"
+ + rc.request().remoteAddress().toString()
+ + "|" + rc.request().getHeader("X-Forwarded-Trusted-Proxy")));
+ router.route("/path-trusted-proxy").handler(rc -> rc.response()
+ .end(rc.request().scheme()
+ + "|" + rc.request().getHeader(HttpHeaders.HOST)
+ + "|" + rc.request().remoteAddress().toString()
+ + "|" + rc.request().uri()
+ + "|" + rc.request().absoluteURI()
+ + "|" + rc.request().getHeader("X-Forwarded-Trusted-Proxy")));
}
}
diff --git a/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHeaderTest.java b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHeaderTest.java
index 9fc8a8b841d73..bbf1e0af0d4f3 100644
--- a/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHeaderTest.java
+++ b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/ForwardedHeaderTest.java
@@ -30,6 +30,41 @@ public void test() {
.body(Matchers.equalTo("https|somehost|backend:4444"));
}
+ @Test
+ public void testWithoutTrustedProxyHeader() {
+ assertThat(RestAssured.get("/forward").asString()).startsWith("http|");
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+ }
+
+ @Test
+ public void testThatTrustedProxyHeaderCannotBeForged() {
+ assertThat(RestAssured.get("/forward").asString()).startsWith("http|");
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "true")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "hello")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "false")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+ }
+
@Test
public void testForwardedForWithSequenceOfProxies() {
assertThat(RestAssured.get("/forward").asString()).startsWith("http|");
diff --git a/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/proxy/TrustedForwarderProxyTest.java b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/proxy/TrustedForwarderProxyTest.java
index d267b617b99d2..206dd9b192e6d 100644
--- a/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/proxy/TrustedForwarderProxyTest.java
+++ b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/proxy/TrustedForwarderProxyTest.java
@@ -1,5 +1,7 @@
package io.quarkus.vertx.http.proxy;
+import static org.assertj.core.api.Assertions.assertThat;
+
import org.hamcrest.Matchers;
import org.jboss.shrinkwrap.api.asset.StringAsset;
import org.junit.jupiter.api.Test;
@@ -31,6 +33,51 @@ public void testHeadersAreUsed() {
.body(Matchers.equalTo("http|somehost2|backend2:5555|/path|http://somehost2/path"));
}
+ @Test
+ public void testHeadersAreUsedWithTrustedProxyHeader() {
+ RestAssured.given()
+ .header("Forwarded", "proto=http;for=backend2:5555;host=somehost2")
+ .get("/path-trusted-proxy")
+ .then()
+ .body(Matchers
+ .equalTo("http|somehost2|backend2:5555|/path-trusted-proxy|http://somehost2/path-trusted-proxy|null"));
+ }
+
+ @Test
+ public void testWithoutTrustedProxyHeader() {
+ assertThat(RestAssured.get("/forward").asString()).startsWith("http|");
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+ }
+
+ @Test
+ public void testThatTrustedProxyHeaderCannotBeForged() {
+ assertThat(RestAssured.get("/forward").asString()).startsWith("http|");
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "true")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "hello")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "false")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|null"));
+ }
+
/**
* As described on https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Forwarded,
diff --git a/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/proxy/TrustedProxyHeaderTest.java b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/proxy/TrustedProxyHeaderTest.java
new file mode 100644
index 0000000000000..3193855e8de7e
--- /dev/null
+++ b/extensions/vertx-http/deployment/src/test/java/io/quarkus/vertx/http/proxy/TrustedProxyHeaderTest.java
@@ -0,0 +1,95 @@
+package io.quarkus.vertx.http.proxy;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.hamcrest.Matchers;
+import org.jboss.shrinkwrap.api.asset.StringAsset;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.QuarkusUnitTest;
+import io.quarkus.vertx.http.ForwardedHandlerInitializer;
+import io.restassured.RestAssured;
+
+/**
+ * Test the trusted-proxy header
+ */
+public class TrustedProxyHeaderTest {
+
+ @RegisterExtension
+ static final QuarkusUnitTest config = new QuarkusUnitTest()
+ .withApplicationRoot((jar) -> jar
+ .addClasses(ForwardedHandlerInitializer.class)
+ .addAsResource(new StringAsset("""
+ quarkus.http.proxy.proxy-address-forwarding=true
+ quarkus.http.proxy.allow-forwarded=true
+ quarkus.http.proxy.enable-forwarded-host=true
+ quarkus.http.proxy.enable-forwarded-prefix=true
+ quarkus.http.proxy.allow-forwarded=true
+ quarkus.http.proxy.enable-trusted-proxy-header=true
+ quarkus.http.proxy.trusted-proxies=localhost
+ """),
+ "application.properties"));
+
+ @Test
+ public void testHeadersAreUsed() {
+ RestAssured.given()
+ .header("Forwarded", "proto=http;for=backend2:5555;host=somehost2")
+ .get("/path-trusted-proxy")
+ .then()
+ .body(Matchers
+ .equalTo("http|somehost2|backend2:5555|/path-trusted-proxy|http://somehost2/path-trusted-proxy|true"));
+ }
+
+ @Test
+ public void testTrustedProxyHeader() {
+ assertThat(RestAssured.get("/forward").asString()).startsWith("http|");
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|true"));
+ }
+
+ @Test
+ public void testThatTrustedProxyHeaderCannotBeForged() {
+ assertThat(RestAssured.get("/forward").asString()).startsWith("http|");
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "true")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|true"));
+
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "hello")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|true"));
+
+ RestAssured.given()
+ .header("Forwarded", "by=proxy;for=backend:4444;host=somehost;proto=https")
+ .header("X-Forwarded-Trusted-Proxy", "false")
+ .get("/trusted-proxy")
+ .then()
+ .body(Matchers.equalTo("https|somehost|backend:4444|true"));
+ }
+
+ /**
+ * As described on https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Forwarded,
+ * the syntax should be case-insensitive.
+ *
+ * Kong, for example, uses `Proto` instead of `proto` and `For` instead of `for`.
+ */
+ @Test
+ public void testHeadersAreUsedWhenUsingCasedCharacters() {
+ RestAssured.given()
+ .header("Forwarded", "Proto=http;For=backend2:5555;Host=somehost2")
+ .get("/path-trusted-proxy")
+ .then()
+ .body(Matchers
+ .equalTo("http|somehost2|backend2:5555|/path-trusted-proxy|http://somehost2/path-trusted-proxy|true"));
+ }
+}
diff --git a/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-continuous-testing.js b/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-continuous-testing.js
index e255967f68e0e..a9a34fa93ca8e 100644
--- a/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-continuous-testing.js
+++ b/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-continuous-testing.js
@@ -293,7 +293,7 @@ export class QwcContinuousTesting extends QwcHotReloadElement {
_renderStacktrace(stackTraces){
return html`${stackTraces.map((stackTrace) =>
html`
${stackTrace.className}#${stackTrace.methodName}(${stackTrace.fileName}:${stackTrace.lineNumber})`
+ lineNumber='${stackTrace.lineNumber}'>${stackTrace.className}#${stackTrace.methodName}(${stackTrace.fileName}:${stackTrace.lineNumber})`
)}`;
}
@@ -329,8 +329,8 @@ export class QwcContinuousTesting extends QwcHotReloadElement {
_testRenderer(testLine){
let level = testLine.testExecutionResult.status.toLowerCase();
- return html`
+ return html`
+
${testLine.testClass}
`;
@@ -463,4 +463,4 @@ export class QwcContinuousTesting extends QwcHotReloadElement {
this._displayTags = !this._displayTags;
}
}
-customElements.define('qwc-continuous-testing', QwcContinuousTesting);
\ No newline at end of file
+customElements.define('qwc-continuous-testing', QwcContinuousTesting);
diff --git a/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-server-log.js b/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-server-log.js
index 5a3b9e8fcb2bc..c364e755d3be4 100644
--- a/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-server-log.js
+++ b/extensions/vertx-http/dev-ui-resources/src/main/resources/dev-ui/qwc/qwc-server-log.js
@@ -332,7 +332,7 @@ export class QwcServerLog extends QwcAbstractLogElement {
return html`[${sourceClassNameFull}]`;
+ lineNumber='${sourceLineNumber}'>[${sourceClassNameFull}]`;
}
}
@@ -341,7 +341,7 @@ export class QwcServerLog extends QwcAbstractLogElement {
return html`[${sourceClassNameFullShort}]`;
+ lineNumber='${sourceLineNumber}'>[${sourceClassNameFullShort}]`;
}
}
@@ -350,7 +350,7 @@ export class QwcServerLog extends QwcAbstractLogElement {
return html`[${sourceClassName}]`;
+ lineNumber='${sourceLineNumber}'>[${sourceClassName}]`;
}
}
@@ -365,7 +365,7 @@ export class QwcServerLog extends QwcAbstractLogElement {
return html`${sourceFileName}`;
+ lineNumber='${sourceLineNumber}'>${sourceFileName}`;
}
}
diff --git a/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardedParser.java b/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardedParser.java
index 95be0431ee84e..a8ead2e5b6e35 100644
--- a/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardedParser.java
+++ b/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardedParser.java
@@ -40,6 +40,7 @@ class ForwardedParser {
private static final AsciiString X_FORWARDED_PROTO = AsciiString.cached("X-Forwarded-Proto");
private static final AsciiString X_FORWARDED_PORT = AsciiString.cached("X-Forwarded-Port");
private static final AsciiString X_FORWARDED_FOR = AsciiString.cached("X-Forwarded-For");
+ private static final AsciiString X_FORWARDED_TRUSTED_PROXY = AsciiString.cached("X-Forwarded-Trusted-Proxy");
private static final Pattern FORWARDED_HOST_PATTERN = Pattern.compile("host=\"?([^;,\"]+)\"?", Pattern.CASE_INSENSITIVE);
private static final Pattern FORWARDED_PROTO_PATTERN = Pattern.compile("proto=\"?([^;,\"]+)\"?", Pattern.CASE_INSENSITIVE);
@@ -128,7 +129,8 @@ private void calculate() {
setHostAndPort(delegate.host(), port);
uri = delegate.uri();
- if (trustedProxyCheck.isProxyAllowed()) {
+ boolean isProxyAllowed = trustedProxyCheck.isProxyAllowed();
+ if (isProxyAllowed) {
String forwarded = delegate.getHeader(FORWARDED);
if (forwardingProxyOptions.allowForwarded && forwarded != null) {
Matcher matcher = FORWARDED_PROTO_PATTERN.matcher(forwarded);
@@ -193,6 +195,21 @@ private void calculate() {
authority = HostAndPort.create(host, port >= 0 ? port : -1);
host = host + (port >= 0 ? ":" + port : "");
delegate.headers().set(HOST_HEADER, host);
+ // TODO Add a test
+ if (forwardingProxyOptions.enableTrustedProxyHeader) {
+ // Verify that the header was not already set.
+ if (delegate.headers().contains(X_FORWARDED_TRUSTED_PROXY)) {
+ log.warn("The header " + X_FORWARDED_TRUSTED_PROXY + " was already set. Overwriting it.");
+ }
+ delegate.headers().set(X_FORWARDED_TRUSTED_PROXY, Boolean.toString(isProxyAllowed));
+ } else {
+ // Verify that the header was not already set - to avoid forgery.
+ if (delegate.headers().contains(X_FORWARDED_TRUSTED_PROXY)) {
+ log.warn("The header " + X_FORWARDED_TRUSTED_PROXY + " was already set. Removing it.");
+ delegate.headers().remove(X_FORWARDED_TRUSTED_PROXY);
+ }
+ }
+
absoluteURI = scheme + "://" + host + uri;
log.debug("Recalculated absoluteURI to " + absoluteURI);
}
diff --git a/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardingProxyOptions.java b/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardingProxyOptions.java
index e7c0cf032a6fb..23aafa044f1f7 100644
--- a/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardingProxyOptions.java
+++ b/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ForwardingProxyOptions.java
@@ -15,14 +15,16 @@ public class ForwardingProxyOptions {
final AsciiString forwardedHostHeader;
final AsciiString forwardedPrefixHeader;
public final TrustedProxyCheckBuilder trustedProxyCheckBuilder;
+ final boolean enableTrustedProxyHeader;
public ForwardingProxyOptions(final boolean proxyAddressForwarding,
- final boolean allowForwarded,
- final boolean allowXForwarded,
- final boolean enableForwardedHost,
- final AsciiString forwardedHostHeader,
- final boolean enableForwardedPrefix,
- final AsciiString forwardedPrefixHeader,
+ boolean allowForwarded,
+ boolean allowXForwarded,
+ boolean enableForwardedHost,
+ boolean enableTrustedProxyHeader,
+ AsciiString forwardedHostHeader,
+ boolean enableForwardedPrefix,
+ AsciiString forwardedPrefixHeader,
TrustedProxyCheckBuilder trustedProxyCheckBuilder) {
this.proxyAddressForwarding = proxyAddressForwarding;
this.allowForwarded = allowForwarded;
@@ -32,15 +34,16 @@ public ForwardingProxyOptions(final boolean proxyAddressForwarding,
this.forwardedHostHeader = forwardedHostHeader;
this.forwardedPrefixHeader = forwardedPrefixHeader;
this.trustedProxyCheckBuilder = trustedProxyCheckBuilder;
+ this.enableTrustedProxyHeader = enableTrustedProxyHeader;
}
public static ForwardingProxyOptions from(ProxyConfig proxy) {
final boolean proxyAddressForwarding = proxy.proxyAddressForwarding;
final boolean allowForwarded = proxy.allowForwarded;
final boolean allowXForwarded = proxy.allowXForwarded.orElse(!allowForwarded);
-
final boolean enableForwardedHost = proxy.enableForwardedHost;
final boolean enableForwardedPrefix = proxy.enableForwardedPrefix;
+ final boolean enableTrustedProxyHeader = proxy.enableTrustedProxyHeader;
final AsciiString forwardedPrefixHeader = AsciiString.cached(proxy.forwardedPrefixHeader);
final AsciiString forwardedHostHeader = AsciiString.cached(proxy.forwardedHostHeader);
@@ -50,6 +53,7 @@ public static ForwardingProxyOptions from(ProxyConfig proxy) {
|| parts.isEmpty() ? null : TrustedProxyCheckBuilder.builder(parts);
return new ForwardingProxyOptions(proxyAddressForwarding, allowForwarded, allowXForwarded, enableForwardedHost,
- forwardedHostHeader, enableForwardedPrefix, forwardedPrefixHeader, proxyCheckBuilder);
+ enableTrustedProxyHeader, forwardedHostHeader, enableForwardedPrefix, forwardedPrefixHeader,
+ proxyCheckBuilder);
}
}
diff --git a/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ProxyConfig.java b/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ProxyConfig.java
index f4a2f557c796b..210fe6ddfb1ba 100644
--- a/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ProxyConfig.java
+++ b/extensions/vertx-http/runtime/src/main/java/io/quarkus/vertx/http/runtime/ProxyConfig.java
@@ -76,6 +76,18 @@ public class ProxyConfig {
@ConfigItem(defaultValue = "X-Forwarded-Prefix")
public String forwardedPrefixHeader;
+ /**
+ * Adds the header `X-Forwarded-Trusted-Proxy` if the request is forwarded by a trusted proxy.
+ * The value is `true` if the request is forwarded by a trusted proxy, otherwise `null`.
+ *
+ * The forwarded parser detects forgery attempts and if the incoming request contains this header, it will be removed
+ * from the request.
+ *
+ * The `X-Forwarded-Trusted-Proxy` header is a custom header, not part of the standard `Forwarded` header.
+ */
+ @ConfigItem(defaultValue = "false")
+ public boolean enableTrustedProxyHeader;
+
/**
* Configure the list of trusted proxy addresses.
* Received `Forwarded`, `X-Forwarded` or `X-Forwarded-*` headers from any other proxy address will be ignored.
diff --git a/extensions/websockets-next/deployment/src/test/java/io/quarkus/websockets/next/test/client/BasicConnectorContextTest.java b/extensions/websockets-next/deployment/src/test/java/io/quarkus/websockets/next/test/client/BasicConnectorContextTest.java
new file mode 100644
index 0000000000000..fcddf32bf6ffa
--- /dev/null
+++ b/extensions/websockets-next/deployment/src/test/java/io/quarkus/websockets/next/test/client/BasicConnectorContextTest.java
@@ -0,0 +1,89 @@
+package io.quarkus.websockets.next.test.client;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.net.URI;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.QuarkusUnitTest;
+import io.quarkus.test.common.http.TestHTTPResource;
+import io.quarkus.websockets.next.BasicWebSocketConnector;
+import io.quarkus.websockets.next.OnClose;
+import io.quarkus.websockets.next.OnOpen;
+import io.quarkus.websockets.next.WebSocket;
+import io.quarkus.websockets.next.WebSocketClientConnection;
+
+public class BasicConnectorContextTest {
+
+ @RegisterExtension
+ public static final QuarkusUnitTest test = new QuarkusUnitTest()
+ .withApplicationRoot(root -> {
+ root.addClasses(ServerEndpoint.class);
+ });
+
+ @TestHTTPResource("/end")
+ URI uri;
+
+ static final CountDownLatch MESSAGE_LATCH = new CountDownLatch(2);
+
+ static final Set THREADS = ConcurrentHashMap.newKeySet();
+
+ static final CountDownLatch CLOSED_LATCH = new CountDownLatch(2);
+
+ @Test
+ void testClient() throws InterruptedException {
+ BasicWebSocketConnector connector = BasicWebSocketConnector.create();
+ connector
+ .executionModel(BasicWebSocketConnector.ExecutionModel.NON_BLOCKING)
+ .onTextMessage((c, m) -> {
+ String thread = Thread.currentThread().getName();
+ THREADS.add(thread);
+ MESSAGE_LATCH.countDown();
+ })
+ .onClose((c, cr) -> {
+ CLOSED_LATCH.countDown();
+ })
+ .baseUri(uri);
+ WebSocketClientConnection conn1 = connector.connectAndAwait();
+ WebSocketClientConnection conn2 = connector.connectAndAwait();
+ assertTrue(MESSAGE_LATCH.await(10, TimeUnit.SECONDS));
+ if (Runtime.getRuntime().availableProcessors() > 1) {
+ // Each client should be executed on a dedicated event loop thread
+ assertEquals(2, THREADS.size());
+ } else {
+ // Single core - the event pool is shared
+ // Due to some CI weirdness it might happen that the system incorrectly reports single core
+ // Therefore, the assert checks if the number of threads used is >= 1
+ assertTrue(THREADS.size() >= 1);
+ }
+ conn1.closeAndAwait();
+ conn2.closeAndAwait();
+ assertTrue(ServerEndpoint.CLOSED_LATCH.await(5, TimeUnit.SECONDS));
+ assertTrue(CLOSED_LATCH.await(5, TimeUnit.SECONDS));
+ }
+
+ @WebSocket(path = "/end")
+ public static class ServerEndpoint {
+
+ static final CountDownLatch CLOSED_LATCH = new CountDownLatch(1);
+
+ @OnOpen
+ String open() {
+ return "Hello!";
+ }
+
+ @OnClose
+ void close() {
+ CLOSED_LATCH.countDown();
+ }
+
+ }
+
+}
diff --git a/extensions/websockets-next/deployment/src/test/java/io/quarkus/websockets/next/test/client/ClientContextTest.java b/extensions/websockets-next/deployment/src/test/java/io/quarkus/websockets/next/test/client/ClientContextTest.java
new file mode 100644
index 0000000000000..0ea1a055434e5
--- /dev/null
+++ b/extensions/websockets-next/deployment/src/test/java/io/quarkus/websockets/next/test/client/ClientContextTest.java
@@ -0,0 +1,104 @@
+package io.quarkus.websockets.next.test.client;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.net.URI;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import jakarta.inject.Inject;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+import io.quarkus.test.QuarkusUnitTest;
+import io.quarkus.test.common.http.TestHTTPResource;
+import io.quarkus.websockets.next.OnClose;
+import io.quarkus.websockets.next.OnOpen;
+import io.quarkus.websockets.next.OnTextMessage;
+import io.quarkus.websockets.next.WebSocket;
+import io.quarkus.websockets.next.WebSocketClient;
+import io.quarkus.websockets.next.WebSocketClientConnection;
+import io.quarkus.websockets.next.WebSocketConnector;
+import io.smallrye.mutiny.Uni;
+
+public class ClientContextTest {
+
+ @RegisterExtension
+ public static final QuarkusUnitTest test = new QuarkusUnitTest()
+ .withApplicationRoot(root -> {
+ root.addClasses(ServerEndpoint.class, ClientEndpoint.class);
+ });
+
+ @Inject
+ WebSocketConnector connector;
+
+ @TestHTTPResource("/")
+ URI uri;
+
+ @Test
+ void testClient() throws InterruptedException {
+ connector.baseUri(uri);
+ WebSocketClientConnection conn1 = connector.connectAndAwait();
+ WebSocketClientConnection conn2 = connector.connectAndAwait();
+ assertTrue(ClientEndpoint.MESSAGE_LATCH.await(10, TimeUnit.SECONDS));
+ if (Runtime.getRuntime().availableProcessors() > 1) {
+ // Each client should be executed on a dedicated event loop thread
+ assertEquals(2, ClientEndpoint.THREADS.size());
+ } else {
+ // Single core - the event pool is shared
+ // Due to some CI weirdness it might happen that the system incorrectly reports single core
+ // Therefore, the assert checks if the number of threads used is >= 1
+ assertTrue(ClientEndpoint.THREADS.size() >= 1);
+ }
+ conn1.closeAndAwait();
+ conn2.closeAndAwait();
+ assertTrue(ClientEndpoint.CLOSED_LATCH.await(5, TimeUnit.SECONDS));
+ assertTrue(ServerEndpoint.CLOSED_LATCH.await(5, TimeUnit.SECONDS));
+ }
+
+ @WebSocket(path = "/end")
+ public static class ServerEndpoint {
+
+ static final CountDownLatch CLOSED_LATCH = new CountDownLatch(1);
+
+ @OnOpen
+ String open() {
+ return "Hello!";
+ }
+
+ @OnClose
+ void close() {
+ CLOSED_LATCH.countDown();
+ }
+
+ }
+
+ @WebSocketClient(path = "/end")
+ public static class ClientEndpoint {
+
+ static final CountDownLatch MESSAGE_LATCH = new CountDownLatch(2);
+
+ static final Set THREADS = ConcurrentHashMap.newKeySet();
+
+ static final CountDownLatch CLOSED_LATCH = new CountDownLatch(2);
+
+ @OnTextMessage
+ Uni onMessage(String message) {
+ String thread = Thread.currentThread().getName();
+ THREADS.add(thread);
+ MESSAGE_LATCH.countDown();
+ return Uni.createFrom().voidItem();
+ }
+
+ @OnClose
+ void close() {
+ CLOSED_LATCH.countDown();
+ }
+
+ }
+
+}
diff --git a/extensions/websockets-next/pom.xml b/extensions/websockets-next/pom.xml
index 1e149d244734f..623739b4ed3c7 100644
--- a/extensions/websockets-next/pom.xml
+++ b/extensions/websockets-next/pom.xml
@@ -12,6 +12,8 @@
quarkus-websockets-next-parent
Quarkus - WebSockets Next
+ Use a modern declarative API to define WebSocket server and client endpoints
+
pom
deployment
diff --git a/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/BasicWebSocketConnectorImpl.java b/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/BasicWebSocketConnectorImpl.java
index b9e3af7e7395f..bf6dd1044e0bf 100644
--- a/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/BasicWebSocketConnectorImpl.java
+++ b/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/BasicWebSocketConnectorImpl.java
@@ -6,6 +6,7 @@
import java.util.Map.Entry;
import java.util.Objects;
import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
@@ -22,12 +23,16 @@
import io.quarkus.websockets.next.WebSocketClientException;
import io.quarkus.websockets.next.WebSocketsClientRuntimeConfig;
import io.smallrye.mutiny.Uni;
+import io.vertx.core.AsyncResult;
import io.vertx.core.Context;
import io.vertx.core.Handler;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.WebSocket;
import io.vertx.core.http.WebSocketClient;
import io.vertx.core.http.WebSocketConnectOptions;
+import io.vertx.core.impl.ContextImpl;
+import io.vertx.core.impl.VertxImpl;
@Typed(BasicWebSocketConnector.class)
@Dependent
@@ -111,10 +116,10 @@ public Uni connect() {
throw new WebSocketClientException("Endpoint URI not set!");
}
- // Currently we create a new client for each connection
+ // A new client is created for each connection
+ // The client is created when the returned Uni is subscribed
// The client is closed when the connection is closed
- // TODO would it make sense to share clients?
- WebSocketClient client = vertx.createWebSocketClient(populateClientOptions());
+ AtomicReference client = new AtomicReference<>();
WebSocketConnectOptions connectOptions = newConnectOptions(baseUri);
StringBuilder requestUri = new StringBuilder();
@@ -140,87 +145,110 @@ public Uni connect() {
throw new WebSocketClientException(e);
}
- return Uni.createFrom().completionStage(() -> client.connect(connectOptions).toCompletionStage())
- .map(ws -> {
- String clientId = BasicWebSocketConnector.class.getName();
- TrafficLogger trafficLogger = TrafficLogger.forClient(config);
- WebSocketClientConnectionImpl connection = new WebSocketClientConnectionImpl(clientId, ws,
- codecs,
- pathParams,
- serverEndpointUri,
- headers, trafficLogger);
- if (trafficLogger != null) {
- trafficLogger.connectionOpened(connection);
- }
- connectionManager.add(BasicWebSocketConnectorImpl.class.getName(), connection);
+ Uni websocket = Uni.createFrom(). emitter(e -> {
+ // Create a new event loop context for each client, otherwise the current context is used
+ // We want to avoid a situation where if multiple clients/connections are created in a row,
+ // the same event loop is used and so writing/receiving messages is de-facto serialized
+ // Get rid of this workaround once https://github.com/eclipse-vertx/vert.x/issues/5366 is resolved
+ ContextImpl context = ((VertxImpl) vertx).createEventLoopContext();
+ context.dispatch(new Handler() {
+ @Override
+ public void handle(Void event) {
+ WebSocketClient c = vertx.createWebSocketClient(populateClientOptions());
+ client.setPlain(c);
+ c.connect(connectOptions, new Handler>() {
+ @Override
+ public void handle(AsyncResult r) {
+ if (r.succeeded()) {
+ e.complete(r.result());
+ } else {
+ e.fail(r.cause());
+ }
+ }
+ });
+ }
+ });
+ });
+ return websocket.map(ws -> {
+ String clientId = BasicWebSocketConnector.class.getName();
+ TrafficLogger trafficLogger = TrafficLogger.forClient(config);
+ WebSocketClientConnectionImpl connection = new WebSocketClientConnectionImpl(clientId, ws,
+ codecs,
+ pathParams,
+ serverEndpointUri,
+ headers, trafficLogger);
+ if (trafficLogger != null) {
+ trafficLogger.connectionOpened(connection);
+ }
+ connectionManager.add(BasicWebSocketConnectorImpl.class.getName(), connection);
- if (openHandler != null) {
- doExecute(connection, null, (c, ignored) -> openHandler.accept(c));
- }
+ if (openHandler != null) {
+ doExecute(connection, null, (c, ignored) -> openHandler.accept(c));
+ }
- if (textMessageHandler != null) {
- ws.textMessageHandler(new Handler() {
- @Override
- public void handle(String message) {
- if (trafficLogger != null) {
- trafficLogger.textMessageReceived(connection, message);
- }
- doExecute(connection, message, textMessageHandler);
- }
- });
+ if (textMessageHandler != null) {
+ ws.textMessageHandler(new Handler() {
+ @Override
+ public void handle(String message) {
+ if (trafficLogger != null) {
+ trafficLogger.textMessageReceived(connection, message);
+ }
+ doExecute(connection, message, textMessageHandler);
}
+ });
+ }
- if (binaryMessageHandler != null) {
- ws.binaryMessageHandler(new Handler() {
+ if (binaryMessageHandler != null) {
+ ws.binaryMessageHandler(new Handler() {
- @Override
- public void handle(Buffer message) {
- if (trafficLogger != null) {
- trafficLogger.binaryMessageReceived(connection, message);
- }
- doExecute(connection, message, binaryMessageHandler);
- }
- });
+ @Override
+ public void handle(Buffer message) {
+ if (trafficLogger != null) {
+ trafficLogger.binaryMessageReceived(connection, message);
+ }
+ doExecute(connection, message, binaryMessageHandler);
}
+ });
+ }
- if (pongMessageHandler != null) {
- ws.pongHandler(new Handler() {
+ if (pongMessageHandler != null) {
+ ws.pongHandler(new Handler() {
- @Override
- public void handle(Buffer event) {
- doExecute(connection, event, pongMessageHandler);
- }
- });
+ @Override
+ public void handle(Buffer event) {
+ doExecute(connection, event, pongMessageHandler);
}
+ });
+ }
- if (errorHandler != null) {
- ws.exceptionHandler(new Handler() {
+ if (errorHandler != null) {
+ ws.exceptionHandler(new Handler() {
- @Override
- public void handle(Throwable event) {
- doExecute(connection, event, errorHandler);
- }
- });
+ @Override
+ public void handle(Throwable event) {
+ doExecute(connection, event, errorHandler);
}
+ });
+ }
- ws.closeHandler(new Handler() {
+ ws.closeHandler(new Handler() {
- @Override
- public void handle(Void event) {
- if (trafficLogger != null) {
- trafficLogger.connectionClosed(connection);
- }
- if (closeHandler != null) {
- doExecute(connection, new CloseReason(ws.closeStatusCode(), ws.closeReason()), closeHandler);
- }
- connectionManager.remove(BasicWebSocketConnectorImpl.class.getName(), connection);
- client.close();
- }
+ @Override
+ public void handle(Void event) {
+ if (trafficLogger != null) {
+ trafficLogger.connectionClosed(connection);
+ }
+ if (closeHandler != null) {
+ doExecute(connection, new CloseReason(ws.closeStatusCode(), ws.closeReason()), closeHandler);
+ }
+ connectionManager.remove(BasicWebSocketConnectorImpl.class.getName(), connection);
+ client.get().close();
+ }
- });
+ });
- return connection;
- });
+ return connection;
+ });
}
private void doExecute(WebSocketClientConnectionImpl connection, MESSAGE message,
diff --git a/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/WebSocketConnectorImpl.java b/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/WebSocketConnectorImpl.java
index 686f132c71038..185c47fbcd59c 100644
--- a/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/WebSocketConnectorImpl.java
+++ b/extensions/websockets-next/runtime/src/main/java/io/quarkus/websockets/next/runtime/WebSocketConnectorImpl.java
@@ -7,6 +7,7 @@
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
import jakarta.enterprise.context.Dependent;
import jakarta.enterprise.inject.Typed;
@@ -23,9 +24,14 @@
import io.quarkus.websockets.next.runtime.WebSocketClientRecorder.ClientEndpoint;
import io.quarkus.websockets.next.runtime.WebSocketClientRecorder.ClientEndpointsContext;
import io.smallrye.mutiny.Uni;
+import io.vertx.core.AsyncResult;
+import io.vertx.core.Handler;
import io.vertx.core.Vertx;
+import io.vertx.core.http.WebSocket;
import io.vertx.core.http.WebSocketClient;
import io.vertx.core.http.WebSocketConnectOptions;
+import io.vertx.core.impl.ContextImpl;
+import io.vertx.core.impl.VertxImpl;
@Typed(WebSocketConnector.class)
@Dependent
@@ -46,10 +52,10 @@ public class WebSocketConnectorImpl extends WebSocketConnectorBase connect() {
- // Currently we create a new client for each connection
+ // A new client is created for each connection
+ // The client is created when the returned Uni is subscribed
// The client is closed when the connection is closed
- // TODO would it make sense to share clients?
- WebSocketClient client = vertx.createWebSocketClient(populateClientOptions());
+ AtomicReference client = new AtomicReference<>();
StringBuilder serverEndpoint = new StringBuilder();
if (baseUri != null) {
@@ -88,28 +94,51 @@ public Uni connect() {
}
subprotocols.forEach(connectOptions::addSubProtocol);
- return Uni.createFrom().completionStage(() -> client.connect(connectOptions).toCompletionStage())
- .map(ws -> {
- TrafficLogger trafficLogger = TrafficLogger.forClient(config);
- WebSocketClientConnectionImpl connection = new WebSocketClientConnectionImpl(clientEndpoint.clientId, ws,
- codecs,
- pathParams,
- serverEndpointUri, headers, trafficLogger);
- if (trafficLogger != null) {
- trafficLogger.connectionOpened(connection);
- }
- connectionManager.add(clientEndpoint.generatedEndpointClass, connection);
-
- Endpoints.initialize(vertx, Arc.container(), codecs, connection, ws,
- clientEndpoint.generatedEndpointClass, config.autoPingInterval(), SecuritySupport.NOOP,
- config.unhandledFailureStrategy(), trafficLogger,
- () -> {
- connectionManager.remove(clientEndpoint.generatedEndpointClass, connection);
- client.close();
- });
-
- return connection;
- });
+ Uni websocket = Uni.createFrom(). emitter(e -> {
+ // Create a new event loop context for each client, otherwise the current context is used
+ // We want to avoid a situation where if multiple clients/connections are created in a row,
+ // the same event loop is used and so writing/receiving messages is de-facto serialized
+ // Get rid of this workaround once https://github.com/eclipse-vertx/vert.x/issues/5366 is resolved
+ ContextImpl context = ((VertxImpl) vertx).createEventLoopContext();
+ context.dispatch(new Handler() {
+ @Override
+ public void handle(Void event) {
+ WebSocketClient c = vertx.createWebSocketClient(populateClientOptions());
+ client.setPlain(c);
+ c.connect(connectOptions, new Handler>() {
+ @Override
+ public void handle(AsyncResult r) {
+ if (r.succeeded()) {
+ e.complete(r.result());
+ } else {
+ e.fail(r.cause());
+ }
+ }
+ });
+ }
+ });
+ });
+ return websocket.map(ws -> {
+ TrafficLogger trafficLogger = TrafficLogger.forClient(config);
+ WebSocketClientConnectionImpl connection = new WebSocketClientConnectionImpl(clientEndpoint.clientId, ws,
+ codecs,
+ pathParams,
+ serverEndpointUri, headers, trafficLogger);
+ if (trafficLogger != null) {
+ trafficLogger.connectionOpened(connection);
+ }
+ connectionManager.add(clientEndpoint.generatedEndpointClass, connection);
+
+ Endpoints.initialize(vertx, Arc.container(), codecs, connection, ws,
+ clientEndpoint.generatedEndpointClass, config.autoPingInterval(), SecuritySupport.NOOP,
+ config.unhandledFailureStrategy(), trafficLogger,
+ () -> {
+ connectionManager.remove(clientEndpoint.generatedEndpointClass, connection);
+ client.get().close();
+ });
+
+ return connection;
+ });
}
String getEndpointClass(InjectionPoint injectionPoint) {
diff --git a/independent-projects/extension-maven-plugin/pom.xml b/independent-projects/extension-maven-plugin/pom.xml
index a4593cf828fc8..07c4e4ec89003 100644
--- a/independent-projects/extension-maven-plugin/pom.xml
+++ b/independent-projects/extension-maven-plugin/pom.xml
@@ -38,7 +38,7 @@
11
11
3.9.9
- 2.18.0
+ 2.18.1
1.5.2
5.10.5