This is an automated email from the ASF dual-hosted git repository.

jamesnetherton pushed a commit to branch camel-3.x
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/camel-3.x by this push:
     new 0e95129a4a2 CAMEL-18940: Add support for path & query parameters in 
vertx-websocket server consumer
0e95129a4a2 is described below

commit 0e95129a4a213a16d22c6763b1f0181e7a0969dc
Author: James Netherton <[email protected]>
AuthorDate: Thu Jan 26 10:26:13 2023 +0000

    CAMEL-18940: Add support for path & query parameters in vertx-websocket 
server consumer
---
 .../src/main/docs/vertx-websocket-component.adoc   | 22 ++++++++++
 .../vertx/websocket/VertxWebsocketConsumer.java    | 27 +++++++++---
 .../vertx/websocket/VertxWebsocketHelper.java      | 23 +++++++++++
 .../vertx/websocket/VertxWebsocketHost.java        | 19 ++++++---
 .../vertx/websocket/VertxWebsocketTest.java        | 48 ++++++++++++++++++++++
 5 files changed, 128 insertions(+), 11 deletions(-)

diff --git 
a/components/camel-vertx/camel-vertx-websocket/src/main/docs/vertx-websocket-component.adoc
 
b/components/camel-vertx/camel-vertx-websocket/src/main/docs/vertx-websocket-component.adoc
index e97ffb771fb..9d739a296c7 100644
--- 
a/components/camel-vertx/camel-vertx-websocket/src/main/docs/vertx-websocket-component.adoc
+++ 
b/components/camel-vertx/camel-vertx-websocket/src/main/docs/vertx-websocket-component.adoc
@@ -71,6 +71,28 @@ 
from("vertx-websocket:my.websocket.com:8080/chat?consumeAsClient=true")
     .log("Got WebSocket message ${body}");
 ----
 
+== Path & query parameters
+
+The WebSocket server consumer supports the configuration of parameterized 
paths. The path parameter value will be set
+as a Camel exchange header:
+
+[source,java]
+----
+from("vertx-websocket:localhost:8080/chat/{user}")
+    .log("New message from ${header.user} >>> ${body}")
+----
+
+Similarly you can retrieve any query parameter values that were used by the 
WebSocket client to connect to the server endpoint:
+
+[source,java]
+----
+from("direct:sendChatMessage")
+    .to("vertx-websocket:localhost:8080/chat/camel?role=admin");
+
+from("vertx-websocket:localhost:8080/chat/{user}")
+    .log("New message from ${header.user} (${header.role}) >>> ${body}")
+----
+
 == SSL
 
 By default, the `ws://` protocol is used, but secure connections with `wss://` 
are supported by configuring the consumer or producer
diff --git 
a/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketConsumer.java
 
b/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketConsumer.java
index 86933866748..61b4f9e4c6d 100644
--- 
a/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketConsumer.java
+++ 
b/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketConsumer.java
@@ -16,10 +16,14 @@
  */
 package org.apache.camel.component.vertx.websocket;
 
+import java.util.Map;
+
 import io.vertx.core.net.SocketAddress;
 import io.vertx.core.net.impl.ConnectionBase;
+import io.vertx.ext.web.RoutingContext;
 import org.apache.camel.AsyncCallback;
 import org.apache.camel.Exchange;
+import org.apache.camel.Message;
 import org.apache.camel.Processor;
 import org.apache.camel.support.DefaultConsumer;
 
@@ -56,27 +60,38 @@ public class VertxWebsocketConsumer extends DefaultConsumer 
{
         return endpoint.getComponent();
     }
 
-    public void onMessage(String connectionKey, Object message, SocketAddress 
remote) {
+    public void onMessage(String connectionKey, Object message, SocketAddress 
remote, RoutingContext routingContext) {
         Exchange exchange = createExchange(true);
-        
exchange.getMessage().setHeader(VertxWebsocketConstants.REMOTE_ADDRESS, remote);
-        
exchange.getMessage().setHeader(VertxWebsocketConstants.CONNECTION_KEY, 
connectionKey);
         exchange.getMessage().setBody(message);
+        populateExchangeHeaders(exchange, connectionKey, remote, 
routingContext);
 
         // use default consumer callback
         AsyncCallback cb = defaultConsumerCallback(exchange, true);
         getAsyncProcessor().process(exchange, cb);
     }
 
-    public void onException(String connectionKey, Throwable cause, 
SocketAddress remote) {
+    public void onException(String connectionKey, Throwable cause, 
SocketAddress remote, RoutingContext routingContext) {
         if (cause == ConnectionBase.CLOSED_EXCEPTION) {
             // Ignore as VertxWebsocketHost registers a closeHandler to trap 
WebSocket close events
             return;
         }
 
         Exchange exchange = createExchange(false);
-        
exchange.getMessage().setHeader(VertxWebsocketConstants.REMOTE_ADDRESS, remote);
-        
exchange.getMessage().setHeader(VertxWebsocketConstants.CONNECTION_KEY, 
connectionKey);
+        populateExchangeHeaders(exchange, connectionKey, remote, 
routingContext);
+
         getExceptionHandler().handleException("Error processing exchange", 
exchange, cause);
         releaseExchange(exchange, false);
     }
+
+    protected void populateExchangeHeaders(
+            Exchange exchange, String connectionKey, SocketAddress remote, 
RoutingContext routingContext) {
+        Message message = exchange.getMessage();
+        Map<String, Object> headers = message.getHeaders();
+        message.setHeader(VertxWebsocketConstants.REMOTE_ADDRESS, remote);
+        message.setHeader(VertxWebsocketConstants.CONNECTION_KEY, 
connectionKey);
+        routingContext.queryParams()
+                .forEach((name, value) -> 
VertxWebsocketHelper.appendHeader(headers, name, value));
+        routingContext.pathParams()
+                .forEach((name, value) -> 
VertxWebsocketHelper.appendHeader(headers, name, value));
+    }
 }
diff --git 
a/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHelper.java
 
b/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHelper.java
index 81743bd5e60..8be25ffdde1 100644
--- 
a/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHelper.java
+++ 
b/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHelper.java
@@ -17,6 +17,9 @@
 package org.apache.camel.component.vertx.websocket;
 
 import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
 
 public final class VertxWebsocketHelper {
 
@@ -30,4 +33,24 @@ public final class VertxWebsocketHelper {
     public static VertxWebsocketHostKey createHostKey(URI websockerURI) {
         return new VertxWebsocketHostKey(websockerURI.getHost(), 
websockerURI.getPort());
     }
+
+    /**
+     * Appends a header value to exchange headers, using a List if there are 
multiple items for the same key
+     */
+    @SuppressWarnings("unchecked")
+    public static void appendHeader(Map<String, Object> headers, String key, 
Object value) {
+        if (headers.containsKey(key)) {
+            Object existing = headers.get(key);
+            List<Object> list;
+            if (existing instanceof List) {
+                list = (List<Object>) existing;
+            } else {
+                list = new ArrayList<>();
+                list.add(existing);
+            }
+            list.add(value);
+            value = list;
+        }
+        headers.put(key, value);
+    }
 }
diff --git 
a/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHost.java
 
b/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHost.java
index 3da512133f6..b0e93b90936 100644
--- 
a/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHost.java
+++ 
b/components/camel-vertx/camel-vertx-websocket/src/main/java/org/apache/camel/component/vertx/websocket/VertxWebsocketHost.java
@@ -23,6 +23,7 @@ import java.util.UUID;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutionException;
+import java.util.regex.Pattern;
 
 import io.vertx.core.Vertx;
 import io.vertx.core.http.HttpHeaders;
@@ -46,6 +47,7 @@ import org.slf4j.LoggerFactory;
  */
 public class VertxWebsocketHost {
     private static final Logger LOG = 
LoggerFactory.getLogger(VertxWebsocketHost.class);
+    private static final Pattern PATH_PARAMETER_PATTERN = 
Pattern.compile("\\{([^/}]+)\\}");
 
     private final VertxWebsocketHostConfiguration hostConfiguration;
     private final VertxWebsocketHostKey hostKey;
@@ -70,9 +72,12 @@ public class VertxWebsocketHost {
         VertxWebsocketConfiguration configuration = 
endpoint.getConfiguration();
 
         URI websocketURI = configuration.getWebsocketURI();
-        LOG.info("Connected consumer for path {}", websocketURI.getPath());
+
+        // Transform from the Camel path param syntax /path/{key} to Vert.x 
web /path/:key
+        String path = 
PATH_PARAMETER_PATTERN.matcher(websocketURI.getPath()).replaceAll(":$1");
         Router router = hostConfiguration.getRouter();
-        Route route = router.route(websocketURI.getPath());
+        Route route = router.route(path);
+        LOG.info("Connected consumer for path {}", path);
 
         if (!ObjectHelper.isEmpty(configuration.getAllowedOriginPattern())) {
             CorsHandler corsHandler = 
CorsHandler.create().addRelativeOrigin(configuration.getAllowedOriginPattern());
@@ -114,10 +119,14 @@ public class VertxWebsocketHost {
                             }
                         }
 
-                        webSocket.textMessageHandler(message -> 
consumer.onMessage(connectionKey, message, remote));
+                        webSocket.textMessageHandler(
+                                message -> consumer.onMessage(connectionKey, 
message, remote, routingContext));
                         webSocket
-                                .binaryMessageHandler(message -> 
consumer.onMessage(connectionKey, message.getBytes(), remote));
-                        webSocket.exceptionHandler(exception -> 
consumer.onException(connectionKey, exception, remote));
+                                .binaryMessageHandler(
+                                        message -> 
consumer.onMessage(connectionKey, message.getBytes(), remote,
+                                                routingContext));
+                        webSocket.exceptionHandler(
+                                exception -> 
consumer.onException(connectionKey, exception, remote, routingContext));
                         webSocket.closeHandler(closeEvent -> {
                             if (LOG.isDebugEnabled()) {
                                 if (socketAddress != null) {
diff --git 
a/components/camel-vertx/camel-vertx-websocket/src/test/java/org/apache/camel/component/vertx/websocket/VertxWebsocketTest.java
 
b/components/camel-vertx/camel-vertx-websocket/src/test/java/org/apache/camel/component/vertx/websocket/VertxWebsocketTest.java
index 07ff5052e9a..95a46387204 100644
--- 
a/components/camel-vertx/camel-vertx-websocket/src/test/java/org/apache/camel/component/vertx/websocket/VertxWebsocketTest.java
+++ 
b/components/camel-vertx/camel-vertx-websocket/src/test/java/org/apache/camel/component/vertx/websocket/VertxWebsocketTest.java
@@ -277,6 +277,46 @@ public class VertxWebsocketTest extends 
VertxWebSocketTestSupport {
         mockEndpoint.assertIsSatisfied(5000);
     }
 
+    @Test
+    void testPathParams() throws InterruptedException {
+        MockEndpoint mockEndpoint = getMockEndpoint("mock:pathParamResult");
+        mockEndpoint.expectedHeaderReceived("firstParam", "Hello");
+        mockEndpoint.expectedHeaderReceived("secondParam", "World");
+        mockEndpoint.expectedBodiesReceived("Hello World");
+
+        template.sendBody("vertx-websocket:localhost:" + port + 
"/path/params/Hello/World", "null");
+
+        mockEndpoint.assertIsSatisfied(5000);
+    }
+
+    @Test
+    void testQueryParams() throws InterruptedException {
+        MockEndpoint mockEndpoint = getMockEndpoint("mock:queryParamResult");
+        mockEndpoint.expectedHeaderReceived("firstParam", "Hello");
+        mockEndpoint.expectedHeaderReceived("secondParam", "World");
+        mockEndpoint.expectedBodiesReceived("Hello World");
+
+        template.sendBody("vertx-websocket:localhost:" + port + 
"/query/params?firstParam=Hello&secondParam=World", "null");
+
+        mockEndpoint.assertIsSatisfied(5000);
+    }
+
+    @Test
+    void testOverlappingPathAndQueryParams() throws InterruptedException {
+        List<String> expectedFirstParams = new ArrayList<>();
+        expectedFirstParams.add("Goodbye");
+        expectedFirstParams.add("Hello");
+
+        MockEndpoint mockEndpoint = getMockEndpoint("mock:pathParamResult");
+        mockEndpoint.expectedHeaderReceived("firstParam", expectedFirstParams);
+        mockEndpoint.expectedHeaderReceived("secondParam", "World");
+        mockEndpoint.expectedMessageCount(1);
+
+        template.sendBody("vertx-websocket:localhost:" + port + 
"/path/params/Hello/World?firstParam=Goodbye", "null");
+
+        mockEndpoint.assertIsSatisfied(5000);
+    }
+
     @Override
     protected RoutesBuilder createRouteBuilder() {
         return new RouteBuilder() {
@@ -292,6 +332,14 @@ public class VertxWebsocketTest extends 
VertxWebSocketTestSupport {
                 fromF("vertx-websocket:localhost:%d/test-other", port)
                         .setBody(simple("Hello ${body}"));
 
+                
fromF("vertx-websocket:localhost:%d/path/params/{firstParam}/{secondParam}", 
port)
+                        .setBody(simple("${header.firstParam} 
${header.secondParam}"))
+                        .to("mock:pathParamResult");
+
+                fromF("vertx-websocket:localhost:%d/query/params", port)
+                        .setBody(simple("${header.firstParam} 
${header.secondParam}"))
+                        .to("mock:queryParamResult");
+
                 fromF("vertx-websocket:localhost:0/greeting")
                         .setBody(simple("Hello ${body}"))
                         .process(new Processor() {

Reply via email to