You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by lb...@apache.org on 2020/03/20 09:07:20 UTC
[camel] branch master updated (aeb352e -> 1ff09b2)
This is an automated email from the ASF dual-hosted git repository.
lburgazzoli pushed a change to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git.
from aeb352e Upgrade AWS SDK v2 to version 2.10.90
new 5f831c6 CAMEL-14738: Create a camel-platform-http-vertx component
new 1ff09b2 CAMEL-14738: Create a camel-platform-http-vertx component (share vertx instance)
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
apache-camel/src/main/descriptors/common-bin.xml | 1 +
bom/camel-bom/pom.xml | 5 +
components/camel-platform-http-vertx/pom.xml | 82 +++++++
.../services/org/apache/camel/other.properties | 7 +
.../services/org/apache/camel/platform-http-engine | 2 +
.../generated/resources/platform-http-vertx.json | 12 +
.../src/main/doc/platform-http-vertx.adoc | 45 ++++
.../platform/http/vertx/VertxPlatformHttp.java | 76 ++++++
.../http/vertx/VertxPlatformHttpConsumer.java | 240 +++++++++++++++++++
.../http/vertx/VertxPlatformHttpEngine.java | 117 ++++++++++
.../http/vertx/VertxPlatformHttpServer.java | 246 ++++++++++++++++++++
.../VertxPlatformHttpServerConfiguration.java | 131 +++++++++++
.../http/vertx/VertxPlatformHttpSupport.java | 254 +++++++++++++++++++++
.../http/vertx/VertxPlatformHttpEngineTest.java | 86 +++++++
.../src/test/resources/log4j2.properties | 31 +++
.../http/PlatformHttpComponentConfigurer.java | 1 +
.../component/platform/http/platform-http.json | 3 +-
.../src/main/docs/platform-http-component.adoc | 3 +-
.../platform/http/PlatformHttpComponent.java | 55 ++++-
.../platform/http/PlatformHttpConstants.java | 3 +-
.../platform/http/PlatformHttpEndpoint.java | 18 --
.../UploadAttacher.java} | 23 +-
components/pom.xml | 1 +
core/camel-allcomponents/pom.xml | 6 +-
.../dsl/PlatformHttpComponentBuilderFactory.java | 14 ++
docs/components/modules/ROOT/pages/index.adoc | 4 +-
.../ROOT/pages/platform-http-component.adoc | 3 +-
parent/pom.xml | 5 +
28 files changed, 1439 insertions(+), 35 deletions(-)
create mode 100644 components/camel-platform-http-vertx/pom.xml
create mode 100644 components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/other.properties
create mode 100644 components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/platform-http-engine
create mode 100644 components/camel-platform-http-vertx/src/generated/resources/platform-http-vertx.json
create mode 100644 components/camel-platform-http-vertx/src/main/doc/platform-http-vertx.adoc
create mode 100644 components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttp.java
create mode 100644 components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpConsumer.java
create mode 100644 components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java
create mode 100644 components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java
create mode 100644 components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServerConfiguration.java
create mode 100644 components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpSupport.java
create mode 100644 components/camel-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java
create mode 100644 components/camel-platform-http-vertx/src/test/resources/log4j2.properties
copy components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/{PlatformHttpConstants.java => spi/UploadAttacher.java} (56%)
[camel] 02/02: CAMEL-14738: Create a camel-platform-http-vertx
component (share vertx instance)
Posted by lb...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lburgazzoli pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 1ff09b238bed5753b48a7be854233eadab80483c
Author: lburgazzoli <lb...@gmail.com>
AuthorDate: Thu Mar 19 18:00:31 2020 +0100
CAMEL-14738: Create a camel-platform-http-vertx component (share vertx instance)
---
...atformHttpRouter.java => VertxPlatformHttp.java} | 21 ++++++++++++++-------
.../http/vertx/VertxPlatformHttpEngine.java | 8 ++++----
.../http/vertx/VertxPlatformHttpServer.java | 4 ++--
.../http/vertx/VertxPlatformHttpEngineTest.java | 2 +-
4 files changed, 21 insertions(+), 14 deletions(-)
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpRouter.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttp.java
similarity index 78%
rename from components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpRouter.java
rename to components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttp.java
index 939bcd1..bdc63c0 100644
--- a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpRouter.java
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttp.java
@@ -20,6 +20,7 @@ import java.util.Collections;
import java.util.List;
import io.vertx.core.Handler;
+import io.vertx.core.Vertx;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import org.apache.camel.CamelContext;
@@ -30,21 +31,27 @@ import org.apache.camel.support.CamelContextHelper;
* This class holds an instance of a {@link Router} and an optional list of [{@link Handler<RoutingContext>} that are
* used by the {@link VertxPlatformHttpConsumer} to create and register Vert.x {@link io.vertx.ext.web.Route}].
*/
-public class VertxPlatformHttpRouter {
+public class VertxPlatformHttp {
public static final String PLATFORM_HTTP_ROUTER_NAME = PlatformHttpConstants.PLATFORM_HTTP_COMPONENT_NAME + "-router";
+ private final Vertx vertx;
private final Router router;
private final List<Handler<RoutingContext>> handlers;
- public VertxPlatformHttpRouter(Router router) {
- this(router, Collections.emptyList());
+ public VertxPlatformHttp(Vertx vertx, Router router) {
+ this(vertx, router, Collections.emptyList());
}
- public VertxPlatformHttpRouter(Router router, List<Handler<RoutingContext>> handlers) {
+ public VertxPlatformHttp(Vertx vertx, Router router, List<Handler<RoutingContext>> handlers) {
+ this.vertx = vertx;
this.router = router;
this.handlers = handlers;
}
+ public Vertx vertx() {
+ return this.vertx;
+ }
+
public Router router() {
return router;
}
@@ -59,11 +66,11 @@ public class VertxPlatformHttpRouter {
//
// **********************
- public static VertxPlatformHttpRouter lookup(CamelContext camelContext) {
+ public static VertxPlatformHttp lookup(CamelContext camelContext) {
return CamelContextHelper.mandatoryLookup(
camelContext,
- VertxPlatformHttpRouter.PLATFORM_HTTP_ROUTER_NAME,
- VertxPlatformHttpRouter.class
+ VertxPlatformHttp.PLATFORM_HTTP_ROUTER_NAME,
+ VertxPlatformHttp.class
);
}
}
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java
index cca7be7..d0769d6 100644
--- a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java
@@ -43,7 +43,7 @@ import org.apache.camel.util.ObjectHelper;
@JdkService(PlatformHttpConstants.PLATFORM_HTTP_ENGINE_FACTORY)
public class VertxPlatformHttpEngine extends ServiceSupport implements PlatformHttpEngine, CamelContextAware {
private CamelContext camelContext;
- private VertxPlatformHttpRouter router;
+ private VertxPlatformHttp router;
private List<Handler<RoutingContext>> handlers;
private UploadAttacher uploadAttacher;
@@ -51,11 +51,11 @@ public class VertxPlatformHttpEngine extends ServiceSupport implements PlatformH
this.handlers = Collections.emptyList();
}
- public VertxPlatformHttpRouter getRouter() {
+ public VertxPlatformHttp getRouter() {
return router;
}
- public void setRouter(VertxPlatformHttpRouter router) {
+ public void setRouter(VertxPlatformHttp router) {
this.router = router;
}
@@ -92,7 +92,7 @@ public class VertxPlatformHttpEngine extends ServiceSupport implements PlatformH
if (router == null) {
ObjectHelper.notNull(getCamelContext(), "Camel Context");
- router = VertxPlatformHttpRouter.lookup(getCamelContext());
+ router = VertxPlatformHttp.lookup(getCamelContext());
}
}
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java
index 300a4da..95102e6 100644
--- a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java
@@ -145,8 +145,8 @@ final class VertxPlatformHttpServer extends ServiceSupport {
router.mountSubRouter(configuration.getPath(), subRouter);
context.getRegistry().bind(
- VertxPlatformHttpRouter.PLATFORM_HTTP_ROUTER_NAME,
- new VertxPlatformHttpRouter(subRouter, Collections.singletonList(createBodyHandler()))
+ VertxPlatformHttp.PLATFORM_HTTP_ROUTER_NAME,
+ new VertxPlatformHttp(vertx, subRouter, Collections.singletonList(createBodyHandler()))
);
//HttpServerOptions options = new HttpServerOptions();
diff --git a/components/camel-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java b/components/camel-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java
index 4bcf876..84fa9a5 100644
--- a/components/camel-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java
+++ b/components/camel-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java
@@ -54,7 +54,7 @@ public class VertxPlatformHttpEngineTest {
context.start();
- assertThat(VertxPlatformHttpRouter.lookup(context)).isNotNull();
+ assertThat(VertxPlatformHttp.lookup(context)).isNotNull();
assertThat(context.getComponent("platform-http")).isInstanceOfSatisfying(PlatformHttpComponent.class, component -> {
assertThat(component.getEngine()).isInstanceOfSatisfying(VertxPlatformHttpEngine.class, e -> {
assertThat(e.getRouter().router()).isNotNull();
[camel] 01/02: CAMEL-14738: Create a camel-platform-http-vertx
component
Posted by lb...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lburgazzoli pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit 5f831c6319fd98df5e89fd8ea4d05c374fc6bbb2
Author: lburgazzoli <lb...@gmail.com>
AuthorDate: Thu Mar 19 15:47:37 2020 +0100
CAMEL-14738: Create a camel-platform-http-vertx component
---
apache-camel/src/main/descriptors/common-bin.xml | 1 +
bom/camel-bom/pom.xml | 5 +
components/camel-platform-http-vertx/pom.xml | 82 +++++++
.../services/org/apache/camel/other.properties | 7 +
.../services/org/apache/camel/platform-http-engine | 2 +
.../generated/resources/platform-http-vertx.json | 12 +
.../src/main/doc/platform-http-vertx.adoc | 45 ++++
.../http/vertx/VertxPlatformHttpConsumer.java | 240 +++++++++++++++++++
.../http/vertx/VertxPlatformHttpEngine.java | 117 ++++++++++
.../http/vertx/VertxPlatformHttpRouter.java | 69 ++++++
.../http/vertx/VertxPlatformHttpServer.java | 246 ++++++++++++++++++++
.../VertxPlatformHttpServerConfiguration.java | 131 +++++++++++
.../http/vertx/VertxPlatformHttpSupport.java | 254 +++++++++++++++++++++
.../http/vertx/VertxPlatformHttpEngineTest.java | 86 +++++++
.../src/test/resources/log4j2.properties | 31 +++
.../http/PlatformHttpComponentConfigurer.java | 1 +
.../component/platform/http/platform-http.json | 3 +-
.../src/main/docs/platform-http-component.adoc | 3 +-
.../platform/http/PlatformHttpComponent.java | 55 ++++-
.../platform/http/PlatformHttpConstants.java | 3 +-
.../platform/http/PlatformHttpEndpoint.java | 18 --
.../UploadAttacher.java} | 23 +-
components/pom.xml | 1 +
core/camel-allcomponents/pom.xml | 6 +-
.../dsl/PlatformHttpComponentBuilderFactory.java | 14 ++
docs/components/modules/ROOT/pages/index.adoc | 4 +-
.../ROOT/pages/platform-http-component.adoc | 3 +-
parent/pom.xml | 5 +
28 files changed, 1432 insertions(+), 35 deletions(-)
diff --git a/apache-camel/src/main/descriptors/common-bin.xml b/apache-camel/src/main/descriptors/common-bin.xml
index d4fea9d..fa8cf91a 100644
--- a/apache-camel/src/main/descriptors/common-bin.xml
+++ b/apache-camel/src/main/descriptors/common-bin.xml
@@ -287,6 +287,7 @@
<include>org.apache.camel:camel-pg-replication-slot</include>
<include>org.apache.camel:camel-pgevent</include>
<include>org.apache.camel:camel-platform-http</include>
+ <include>org.apache.camel:camel-platform-http-vertx</include>
<include>org.apache.camel:camel-printer</include>
<include>org.apache.camel:camel-protobuf</include>
<include>org.apache.camel:camel-pubnub</include>
diff --git a/bom/camel-bom/pom.xml b/bom/camel-bom/pom.xml
index 19a986f..830a62e 100644
--- a/bom/camel-bom/pom.xml
+++ b/bom/camel-bom/pom.xml
@@ -1370,6 +1370,11 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-platform-http-vertx</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-printer</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/components/camel-platform-http-vertx/pom.xml b/components/camel-platform-http-vertx/pom.xml
new file mode 100644
index 0000000..b92e1f2
--- /dev/null
+++ b/components/camel-platform-http-vertx/pom.xml
@@ -0,0 +1,82 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>components</artifactId>
+ <version>3.2.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>camel-platform-http-vertx</artifactId>
+ <packaging>jar</packaging>
+ <name>Camel :: Platform HTTP :: Vert.x</name>
+ <description>Implementation of the Platform HTTP Engine based on Vert.x Web</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-platform-http</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>io.vertx</groupId>
+ <artifactId>vertx-web</artifactId>
+ <version>${vertx-version}</version>
+ </dependency>
+
+
+ <!-- test dependencies -->
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-test-junit5</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>io.rest-assured</groupId>
+ <artifactId>rest-assured</artifactId>
+ <version>${rest-assured-version}</version>
+ <scope>test</scope>
+ </dependency>
+
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+</project>
diff --git a/components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/other.properties b/components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/other.properties
new file mode 100644
index 0000000..b5250a6
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/other.properties
@@ -0,0 +1,7 @@
+# Generated by camel build tools - do NOT edit this file!
+name=platform-http-vertx
+groupId=org.apache.camel
+artifactId=camel-platform-http-vertx
+version=3.2.0-SNAPSHOT
+projectName=Camel :: Platform HTTP :: Vert.x
+projectDescription=Implementation of the Platform Http Engine based on Vert.x Web
diff --git a/components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/platform-http-engine b/components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/platform-http-engine
new file mode 100644
index 0000000..814e6d9
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/generated/resources/META-INF/services/org/apache/camel/platform-http-engine
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.component.platform.http.vertx.VertxPlatformHttpEngine
diff --git a/components/camel-platform-http-vertx/src/generated/resources/platform-http-vertx.json b/components/camel-platform-http-vertx/src/generated/resources/platform-http-vertx.json
new file mode 100644
index 0000000..cd7135c
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/generated/resources/platform-http-vertx.json
@@ -0,0 +1,12 @@
+{
+ "other": {
+ "kind": "other",
+ "name": "platform-http-vertx",
+ "title": "Platform Http Vertx",
+ "description": "Implementation of the Platform Http Engine based on Vert.x Web",
+ "deprecated": false,
+ "groupId": "org.apache.camel",
+ "artifactId": "camel-platform-http-vertx",
+ "version": "3.2.0-SNAPSHOT"
+ }
+}
diff --git a/components/camel-platform-http-vertx/src/main/doc/platform-http-vertx.adoc b/components/camel-platform-http-vertx/src/main/doc/platform-http-vertx.adoc
new file mode 100644
index 0000000..26a5648
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/main/doc/platform-http-vertx.adoc
@@ -0,0 +1,45 @@
+= PlatformHttp VertX
+
+*Since Camel 3.2*
+
+The camel-platform-http-vertx is a Vert.x based implementation of the `PlatformHttp` SPI.
+
+[NOTE]
+====
+At this time this component is an experiment so use it with care.
+====
+
+== Vert.x Route
+This implementation will by default lookup an instance of `VertxPlatformHttpRouter` on the registry however you can
+configure an existing instance using the getter/setter on the `VertxPlatformHttpEngine` class.
+
+== Auto detection from classpath
+
+To use this implementation all you need to do is to add the `camel-platform-http-vertx` dependency to the classpath,
+and the platform http component should auto-detect this.
+
+== VertxPlatformHttpServer
+
+In addition to the implementation of the `PlatformHttp` SPI based on Vert.x, this module provides a Vert.x based HTTP
+server compatible with the `VertxPlatformHttpEngine`:
+
+[source,java]
+----
+final int port = AvailablePortFinder.getNextAvailable();
+final CamelContext context = new DefaultCamelContext();
+
+VertxPlatformHttpServerConfiguration conf = new VertxPlatformHttpServerConfiguration();
+conf.setBindPort(port);
+
+context.addService(new VertxPlatformHttpServer(context, conf), true, true);
+context.addRoutes(new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+ from("platform-http:/test")
+ .routeId("get")
+ .setBody().constant("Hello from Camel's PlatformHttp service");
+ }
+});
+
+context.start();
+----
\ No newline at end of file
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpConsumer.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpConsumer.java
new file mode 100644
index 0000000..fec50be
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpConsumer.java
@@ -0,0 +1,240 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http.vertx;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import io.vertx.core.Handler;
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.HttpMethod;
+import io.vertx.ext.web.FileUpload;
+import io.vertx.ext.web.Route;
+import io.vertx.ext.web.Router;
+import io.vertx.ext.web.RoutingContext;
+import org.apache.camel.Exchange;
+import org.apache.camel.Message;
+import org.apache.camel.Processor;
+import org.apache.camel.component.platform.http.PlatformHttpEndpoint;
+import org.apache.camel.component.platform.http.spi.Method;
+import org.apache.camel.component.platform.http.spi.UploadAttacher;
+import org.apache.camel.spi.HeaderFilterStrategy;
+import org.apache.camel.support.DefaultConsumer;
+import org.apache.camel.support.DefaultMessage;
+import org.apache.camel.util.FileUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.camel.component.platform.http.vertx.VertxPlatformHttpSupport.appendHeader;
+import static org.apache.camel.component.platform.http.vertx.VertxPlatformHttpSupport.populateCamelHeaders;
+import static org.apache.camel.component.platform.http.vertx.VertxPlatformHttpSupport.writeResponse;
+
+/**
+ * A {@link org.apache.camel.Consumer} for the {@link org.apache.camel.component.platform.http.spi.PlatformHttpEngine}
+ * based on Vert.x Web.
+ */
+public class VertxPlatformHttpConsumer extends DefaultConsumer {
+ private static final Logger LOGGER = LoggerFactory.getLogger(VertxPlatformHttpConsumer.class);
+ private static final Pattern PATH_PARAMETER_PATTERN = Pattern.compile("\\{([^/}]+)\\}");
+
+ private final Router router;
+ private final List<Handler<RoutingContext>> handlers;
+ private final String fileNameExtWhitelist;
+ private final UploadAttacher uploadAttacher;
+
+ private Route route;
+
+ public VertxPlatformHttpConsumer(PlatformHttpEndpoint endpoint, Processor processor, Router router,
+ List<Handler<RoutingContext>> handlers, UploadAttacher uploadAttacher) {
+ super(endpoint, processor);
+
+ this.router = router;
+ this.handlers = handlers;
+
+ String list = endpoint.getFileNameExtWhitelist();
+
+ this.fileNameExtWhitelist = list == null ? null : list.toLowerCase(Locale.US);
+ this.uploadAttacher = uploadAttacher;
+ }
+
+ @Override
+ public PlatformHttpEndpoint getEndpoint() {
+ return (PlatformHttpEndpoint) super.getEndpoint();
+ }
+
+ @Override
+ protected void doStart() throws Exception {
+ super.doStart();
+
+ final PlatformHttpEndpoint endpoint = getEndpoint();
+ final String path = endpoint.getPath();
+
+ // Transform from the Camel path param syntax /path/{key} to vert.x web's /path/:key
+ final String vertxPathParamPath = PATH_PARAMETER_PATTERN.matcher(path).replaceAll(":$1");
+ final Route newRoute = router.route(vertxPathParamPath);
+
+ final Set<Method> methods = Method.parseList(endpoint.getHttpMethodRestrict());
+ if (!methods.equals(Method.getAll())) {
+ methods.stream().forEach(m -> newRoute.method(HttpMethod.valueOf(m.name())));
+ }
+ if (endpoint.getConsumes() != null) {
+ newRoute.consumes(endpoint.getConsumes());
+ }
+ if (endpoint.getProduces() != null) {
+ newRoute.produces(endpoint.getProduces());
+ }
+
+ handlers.forEach(newRoute::handler);
+
+ newRoute.handler(
+ ctx -> {
+ Exchange exchg = null;
+ try {
+ final Exchange exchange = exchg = toExchange(ctx);
+ createUoW(exchange);
+ getAsyncProcessor().process(
+ exchange,
+ doneSync -> writeResponse(ctx, exchange, getEndpoint().getHeaderFilterStrategy()));
+ } catch (Exception e) {
+ ctx.fail(e);
+ getExceptionHandler().handleException("Failed handling platform-http endpoint " + path, exchg, e);
+ } finally {
+ if (exchg != null) {
+ doneUoW(exchg);
+ }
+ }
+ });
+
+ this.route = newRoute;
+ }
+
+ @Override
+ protected void doStop() throws Exception {
+ if (route != null) {
+ route.remove();
+ route = null;
+ }
+ super.doStop();
+ }
+
+ @Override
+ protected void doSuspend() throws Exception {
+ if (route != null) {
+ route.disable();
+ }
+ super.doSuspend();
+ }
+
+ @Override
+ protected void doResume() throws Exception {
+ if (route != null) {
+ route.enable();
+ }
+ super.doResume();
+ }
+
+ private Exchange toExchange(RoutingContext ctx) {
+ final Exchange exchange = getEndpoint().createExchange();
+ Message in = toCamelMessage(ctx, exchange);
+
+ final String charset = ctx.parsedHeaders().contentType().parameter("charset");
+ if (charset != null) {
+ exchange.setProperty(Exchange.CHARSET_NAME, charset);
+ in.setHeader(Exchange.HTTP_CHARACTER_ENCODING, charset);
+ }
+
+ exchange.setIn(in);
+ return exchange;
+ }
+
+ private Message toCamelMessage(RoutingContext ctx, Exchange exchange) {
+ final Message result = new DefaultMessage(exchange);
+
+ final HeaderFilterStrategy headerFilterStrategy = getEndpoint().getHeaderFilterStrategy();
+ populateCamelHeaders(ctx, result.getHeaders(), exchange, headerFilterStrategy);
+ final String mimeType = ctx.parsedHeaders().contentType().value();
+ final boolean isMultipartFormData = "multipart/form-data".equals(mimeType);
+ if ("application/x-www-form-urlencoded".equals(mimeType) || isMultipartFormData) {
+ final MultiMap formData = ctx.request().formAttributes();
+ final Map<String, Object> body = new HashMap<>();
+ for (String key : formData.names()) {
+ for (String value : formData.getAll(key)) {
+ if (headerFilterStrategy != null
+ && !headerFilterStrategy.applyFilterToExternalHeaders(key, value, exchange)) {
+ appendHeader(result.getHeaders(), key, value);
+ appendHeader(body, key, value);
+ }
+ }
+ }
+ result.setBody(body);
+ if (isMultipartFormData) {
+ populateAttachments(ctx.fileUploads(), result);
+ }
+ } else {
+ // extract body by myself if undertow parser didn't handle and the method is allowed to have one
+ // body is extracted as byte[] then auto TypeConverter kicks in
+ Method m = Method.valueOf(ctx.request().method().name());
+ if (m.canHaveBody()) {
+ final Buffer body = ctx.getBody();
+ if (body != null) {
+ result.setBody(body.getBytes());
+ } else {
+ result.setBody(null);
+ }
+ } else {
+ result.setBody(null);
+ }
+ }
+ return result;
+ }
+
+ private void populateAttachments(Set<FileUpload> uploads, Message message) {
+ for (FileUpload upload : uploads) {
+ final String name = upload.name();
+ final String fileName = upload.fileName();
+
+ LOGGER.trace("HTTP attachment {} = {}", name, fileName);
+
+ // is the file name accepted
+ boolean accepted = true;
+
+ if (fileNameExtWhitelist != null) {
+ String ext = FileUtil.onlyExt(fileName);
+ if (ext != null) {
+ ext = ext.toLowerCase(Locale.US);
+ if (!fileNameExtWhitelist.equals("*") && !fileNameExtWhitelist.contains(ext)) {
+ accepted = false;
+ }
+ }
+ }
+ if (accepted) {
+ final File localFile = new File(upload.uploadedFileName());
+ uploadAttacher.attachUpload(localFile, fileName, message);
+ } else {
+ LOGGER.debug(
+ "Cannot add file as attachment: {} because the file is not accepted according to fileNameExtWhitelist: {}",
+ fileName, fileNameExtWhitelist);
+ }
+ }
+ }
+}
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java
new file mode 100644
index 0000000..cca7be7
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngine.java
@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http.vertx;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import io.vertx.core.Handler;
+import io.vertx.ext.web.RoutingContext;
+import org.apache.camel.CamelContext;
+import org.apache.camel.CamelContextAware;
+import org.apache.camel.Consumer;
+import org.apache.camel.Experimental;
+import org.apache.camel.Processor;
+import org.apache.camel.component.platform.http.PlatformHttpConstants;
+import org.apache.camel.component.platform.http.PlatformHttpEndpoint;
+import org.apache.camel.component.platform.http.spi.PlatformHttpEngine;
+import org.apache.camel.component.platform.http.spi.UploadAttacher;
+import org.apache.camel.spi.annotations.JdkService;
+import org.apache.camel.support.service.ServiceSupport;
+import org.apache.camel.util.ObjectHelper;
+
+
+/**
+ * Implementation of the {@link PlatformHttpEngine} based on Vert.x Web.
+ */
+@Experimental
+@JdkService(PlatformHttpConstants.PLATFORM_HTTP_ENGINE_FACTORY)
+public class VertxPlatformHttpEngine extends ServiceSupport implements PlatformHttpEngine, CamelContextAware {
+ private CamelContext camelContext;
+ private VertxPlatformHttpRouter router;
+ private List<Handler<RoutingContext>> handlers;
+ private UploadAttacher uploadAttacher;
+
+ public VertxPlatformHttpEngine() {
+ this.handlers = Collections.emptyList();
+ }
+
+ public VertxPlatformHttpRouter getRouter() {
+ return router;
+ }
+
+ public void setRouter(VertxPlatformHttpRouter router) {
+ this.router = router;
+ }
+
+ public List<Handler<RoutingContext>> getHandlers() {
+ return Collections.unmodifiableList(handlers);
+ }
+
+ public void setHandlers(List<Handler<RoutingContext>> handlers) {
+ if (handlers == null) {
+ this.handlers = new ArrayList<>(handlers);
+ }
+ }
+
+ public UploadAttacher getUploadAttacher() {
+ return uploadAttacher;
+ }
+
+ public void setUploadAttacher(UploadAttacher uploadAttacher) {
+ this.uploadAttacher = uploadAttacher;
+ }
+
+ @Override
+ public CamelContext getCamelContext() {
+ return camelContext;
+ }
+
+ @Override
+ public void setCamelContext(CamelContext camelContext) {
+ this.camelContext = camelContext;
+ }
+
+ @Override
+ protected void doStart() throws Exception {
+ if (router == null) {
+ ObjectHelper.notNull(getCamelContext(), "Camel Context");
+
+ router = VertxPlatformHttpRouter.lookup(getCamelContext());
+ }
+ }
+
+ @Override
+ protected void doStop() throws Exception {
+ // no-op
+ }
+
+ @Override
+ public Consumer createConsumer(PlatformHttpEndpoint endpoint, Processor processor) {
+ List<Handler<RoutingContext>> handlers = new ArrayList<>(this.handlers.size() + router.handlers().size());
+ handlers.addAll(this.router.handlers());
+ handlers.addAll(this.handlers);
+
+ return new VertxPlatformHttpConsumer(
+ endpoint,
+ processor,
+ router.router(),
+ handlers,
+ uploadAttacher);
+ }
+}
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpRouter.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpRouter.java
new file mode 100644
index 0000000..939bcd1
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpRouter.java
@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http.vertx;
+
+import java.util.Collections;
+import java.util.List;
+
+import io.vertx.core.Handler;
+import io.vertx.ext.web.Router;
+import io.vertx.ext.web.RoutingContext;
+import org.apache.camel.CamelContext;
+import org.apache.camel.component.platform.http.PlatformHttpConstants;
+import org.apache.camel.support.CamelContextHelper;
+
+/**
+ * This class holds an instance of a {@link Router} and an optional list of [{@link Handler<RoutingContext>} that are
+ * used by the {@link VertxPlatformHttpConsumer} to create and register Vert.x {@link io.vertx.ext.web.Route}].
+ */
+public class VertxPlatformHttpRouter {
+ public static final String PLATFORM_HTTP_ROUTER_NAME = PlatformHttpConstants.PLATFORM_HTTP_COMPONENT_NAME + "-router";
+
+ private final Router router;
+ private final List<Handler<RoutingContext>> handlers;
+
+ public VertxPlatformHttpRouter(Router router) {
+ this(router, Collections.emptyList());
+ }
+
+ public VertxPlatformHttpRouter(Router router, List<Handler<RoutingContext>> handlers) {
+ this.router = router;
+ this.handlers = handlers;
+ }
+
+ public Router router() {
+ return router;
+ }
+
+ public List<Handler<RoutingContext>> handlers() {
+ return handlers;
+ }
+
+ // **********************
+ //
+ // Helpers
+ //
+ // **********************
+
+ public static VertxPlatformHttpRouter lookup(CamelContext camelContext) {
+ return CamelContextHelper.mandatoryLookup(
+ camelContext,
+ VertxPlatformHttpRouter.PLATFORM_HTTP_ROUTER_NAME,
+ VertxPlatformHttpRouter.class
+ );
+ }
+}
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java
new file mode 100644
index 0000000..300a4da
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServer.java
@@ -0,0 +1,246 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http.vertx;
+
+import java.util.Collections;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+
+import io.vertx.core.Handler;
+import io.vertx.core.Vertx;
+import io.vertx.core.VertxOptions;
+import io.vertx.core.http.HttpServer;
+import io.vertx.ext.web.Router;
+import io.vertx.ext.web.RoutingContext;
+import io.vertx.ext.web.handler.BodyHandler;
+import org.apache.camel.CamelContext;
+import org.apache.camel.component.platform.http.PlatformHttpConstants;
+import org.apache.camel.support.CamelContextHelper;
+import org.apache.camel.support.service.ServiceSupport;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This class implement a basic Vert.x Web based server that can be used by the {@link VertxPlatformHttpEngine} on
+ * platforms that do not provide Vert.x based http services.
+ */
+final class VertxPlatformHttpServer extends ServiceSupport {
+ private static final Logger LOGGER = LoggerFactory.getLogger(VertxPlatformHttpServer.class);
+
+ private final CamelContext context;
+ private final VertxPlatformHttpServerConfiguration configuration;
+
+ private ExecutorService executor;
+ private Vertx vertx;
+ private boolean localVertx;
+
+ private HttpServer server;
+
+ public VertxPlatformHttpServer(CamelContext context, VertxPlatformHttpServerConfiguration configuration) {
+ this(context, configuration, null);
+ }
+
+ public VertxPlatformHttpServer(CamelContext context, VertxPlatformHttpServerConfiguration configuration, Vertx vertx) {
+ this.context = context;
+ this.configuration = configuration;
+ this.vertx = vertx;
+ }
+
+ @Override
+ protected void doStart() throws Exception {
+ vertx = CamelContextHelper.findByType(context, Vertx.class);
+ executor = context.getExecutorServiceManager().newSingleThreadExecutor(this, "platform-http-service");
+
+ if (vertx != null) {
+ LOGGER.info("Found Vert.x instance in registry: {}", vertx);
+ } else {
+ VertxOptions options = CamelContextHelper.findByType(context, VertxOptions.class);
+ if (options == null) {
+ options = new VertxOptions();
+ }
+
+ LOGGER.info("Creating new Vert.x instance");
+
+ vertx = Vertx.vertx(options);
+ localVertx = true;
+ }
+
+ startAsync().toCompletableFuture().join();
+ }
+
+ @Override
+ protected void doStop() throws Exception {
+ try {
+ if (server != null) {
+ stopAsync().toCompletableFuture().join();
+ }
+ } finally {
+ this.server = null;
+ }
+
+ if (vertx != null && localVertx) {
+ Future<?> future = executor.submit(
+ () -> {
+ CountDownLatch latch = new CountDownLatch(1);
+
+ vertx.close(result -> {
+ try {
+ if (result.failed()) {
+ LOGGER.warn("Failed to close Vert.x reason: {}",
+ result.cause().getMessage()
+ );
+
+ throw new RuntimeException(result.cause());
+ }
+
+ LOGGER.info("Vert.x stopped");
+ } finally {
+ latch.countDown();
+ }
+ });
+
+ try {
+ latch.await();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ }
+ );
+
+ try {
+ future.get();
+ } finally {
+ vertx = null;
+ localVertx = false;
+ }
+ }
+
+ if (executor != null) {
+ context.getExecutorServiceManager().shutdown(executor);
+ executor = null;
+ }
+ }
+
+ private CompletionStage<Void> startAsync() {
+ final Router router = Router.router(vertx);
+ final Router subRouter = Router.router(vertx);
+
+ router.mountSubRouter(configuration.getPath(), subRouter);
+
+ context.getRegistry().bind(
+ VertxPlatformHttpRouter.PLATFORM_HTTP_ROUTER_NAME,
+ new VertxPlatformHttpRouter(subRouter, Collections.singletonList(createBodyHandler()))
+ );
+
+ //HttpServerOptions options = new HttpServerOptions();
+ if (configuration.getSslContextParameters() != null) {
+ // TODO: add ssl support
+ throw new UnsupportedOperationException("Not yet implemented");
+ }
+
+ server = vertx.createHttpServer();
+
+ return CompletableFuture.runAsync(
+ () -> {
+ CountDownLatch latch = new CountDownLatch(1);
+ server.requestHandler(router).listen(configuration.getBindPort(), configuration.getBindHost(), result -> {
+ try {
+ if (result.failed()) {
+ LOGGER.warn("Failed to start Vert.x HttpServer on {}:{}, reason: {}",
+ configuration.getBindHost(),
+ configuration.getBindPort(),
+ result.cause().getMessage()
+ );
+
+ throw new RuntimeException(result.cause());
+ }
+
+ LOGGER.info("Vert.x HttpServer started on {}:{}", configuration.getBindHost(), configuration.getBindPort());
+ } finally {
+ latch.countDown();
+ }
+ });
+
+ try {
+ latch.await();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ },
+ executor
+ );
+ }
+
+ protected CompletionStage<Void> stopAsync() {
+ return CompletableFuture.runAsync(
+ () -> {
+ CountDownLatch latch = new CountDownLatch(1);
+
+ // remove the platform-http component
+ context.removeComponent(PlatformHttpConstants.PLATFORM_HTTP_COMPONENT_NAME);
+
+ server.close(result -> {
+ try {
+ if (result.failed()) {
+ LOGGER.warn("Failed to close Vert.x HttpServer reason: {}",
+ result.cause().getMessage()
+ );
+
+ throw new RuntimeException(result.cause());
+ }
+
+ LOGGER.info("Vert.x HttpServer stopped");
+ } finally {
+ latch.countDown();
+ }
+ });
+
+ try {
+ latch.await();
+ } catch (InterruptedException e) {
+ throw new RuntimeException(e);
+ }
+ },
+ executor
+ );
+ }
+
+ private Handler<RoutingContext> createBodyHandler() {
+ BodyHandler bodyHandler = BodyHandler.create();
+
+ if (configuration.getMaxBodySize() != null) {
+ bodyHandler.setBodyLimit(configuration.getMaxBodySize().longValueExact());
+ }
+
+ bodyHandler.setHandleFileUploads(configuration.getBodyHandler().isHandleFileUploads());
+ bodyHandler.setUploadsDirectory(configuration.getBodyHandler().getUploadsDirectory());
+ bodyHandler.setDeleteUploadedFilesOnEnd(configuration.getBodyHandler().isDeleteUploadedFilesOnEnd());
+ bodyHandler.setMergeFormAttributes(configuration.getBodyHandler().isMergeFormAttributes());
+ bodyHandler.setPreallocateBodyBuffer(configuration.getBodyHandler().isPreallocateBodyBuffer());
+
+ return new Handler<RoutingContext>() {
+ @Override
+ public void handle(RoutingContext event) {
+ event.request().resume();
+ bodyHandler.handle(event);
+ }
+ };
+ }
+}
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServerConfiguration.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServerConfiguration.java
new file mode 100644
index 0000000..ff9bac7
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpServerConfiguration.java
@@ -0,0 +1,131 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http.vertx;
+
+import java.math.BigInteger;
+
+import org.apache.camel.support.jsse.SSLContextParameters;
+
+public class VertxPlatformHttpServerConfiguration {
+ public static final String DEFAULT_BIND_HOST = "0.0.0.0";
+ public static final int DEFAULT_BIND_PORT = 8080;
+ public static final String DEFAULT_PATH = "/";
+
+ private String bindHost = DEFAULT_BIND_HOST;
+ private int bindPort = DEFAULT_BIND_PORT;
+ private String path = DEFAULT_PATH;
+ private BigInteger maxBodySize;
+
+ private BodyHandler bodyHandler = new BodyHandler();
+ private SSLContextParameters sslContextParameters;
+
+ public String getBindHost() {
+ return bindHost;
+ }
+
+ public void setBindHost(String bindHost) {
+ this.bindHost = bindHost;
+ }
+
+ public int getBindPort() {
+ return bindPort;
+ }
+
+ public void setBindPort(int bindPort) {
+ this.bindPort = bindPort;
+ }
+
+ public String getPath() {
+ return path;
+ }
+
+ public void setPath(String path) {
+ this.path = path;
+ }
+
+ public BigInteger getMaxBodySize() {
+ return maxBodySize;
+ }
+
+ public void setMaxBodySize(BigInteger maxBodySize) {
+ this.maxBodySize = maxBodySize;
+ }
+
+ public BodyHandler getBodyHandler() {
+ return bodyHandler;
+ }
+
+ public void setBodyHandler(BodyHandler bodyHandler) {
+ this.bodyHandler = bodyHandler;
+ }
+
+ public SSLContextParameters getSslContextParameters() {
+ return sslContextParameters;
+ }
+
+ public void setSslContextParameters(SSLContextParameters sslContextParameters) {
+ this.sslContextParameters = sslContextParameters;
+ }
+
+ public static class BodyHandler {
+ private boolean handleFileUploads = true;
+ private String uploadsDirectory = "file-uploads";
+ private boolean mergeFormAttributes = true;
+ private boolean deleteUploadedFilesOnEnd;
+ private boolean preallocateBodyBuffer = true;
+
+ public boolean isHandleFileUploads() {
+ return handleFileUploads;
+ }
+
+ public void setHandleFileUploads(boolean handleFileUploads) {
+ this.handleFileUploads = handleFileUploads;
+ }
+
+ public String getUploadsDirectory() {
+ return uploadsDirectory;
+ }
+
+ public void setUploadsDirectory(String uploadsDirectory) {
+ this.uploadsDirectory = uploadsDirectory;
+ }
+
+ public boolean isMergeFormAttributes() {
+ return mergeFormAttributes;
+ }
+
+ public void setMergeFormAttributes(boolean mergeFormAttributes) {
+ this.mergeFormAttributes = mergeFormAttributes;
+ }
+
+ public boolean isDeleteUploadedFilesOnEnd() {
+ return deleteUploadedFilesOnEnd;
+ }
+
+ public void setDeleteUploadedFilesOnEnd(boolean deleteUploadedFilesOnEnd) {
+ this.deleteUploadedFilesOnEnd = deleteUploadedFilesOnEnd;
+ }
+
+ public boolean isPreallocateBodyBuffer() {
+ return preallocateBodyBuffer;
+ }
+
+ public void setPreallocateBodyBuffer(boolean preallocateBodyBuffer) {
+ this.preallocateBodyBuffer = preallocateBodyBuffer;
+ }
+ }
+}
diff --git a/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpSupport.java b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpSupport.java
new file mode 100644
index 0000000..ddf3760
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/main/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpSupport.java
@@ -0,0 +1,254 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http.vertx;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+import io.vertx.core.MultiMap;
+import io.vertx.core.buffer.Buffer;
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.HttpServerResponse;
+import io.vertx.ext.web.RoutingContext;
+import org.apache.camel.Exchange;
+import org.apache.camel.Message;
+import org.apache.camel.NoTypeConversionAvailableException;
+import org.apache.camel.TypeConversionException;
+import org.apache.camel.TypeConverter;
+import org.apache.camel.spi.HeaderFilterStrategy;
+import org.apache.camel.support.ExchangeHelper;
+import org.apache.camel.support.MessageHelper;
+import org.apache.camel.support.ObjectHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public final class VertxPlatformHttpSupport {
+ private static final Logger LOGGER = LoggerFactory.getLogger(VertxPlatformHttpSupport.class);
+
+ private VertxPlatformHttpSupport() {
+ }
+
+ static Object toHttpResponse(HttpServerResponse response, Message message, HeaderFilterStrategy headerFilterStrategy) {
+ final Exchange exchange = message.getExchange();
+ final TypeConverter tc = exchange.getContext().getTypeConverter();
+
+ final int code = determineResponseCode(exchange, message.getBody());
+ response.setStatusCode(code);
+
+
+ // copy headers from Message to Response
+ if (headerFilterStrategy != null) {
+ for (Map.Entry<String, Object> entry : message.getHeaders().entrySet()) {
+ final String key = entry.getKey();
+ final Object value = entry.getValue();
+ // use an iterator as there can be multiple values. (must not use a delimiter)
+ final Iterator<?> it = ObjectHelper.createIterator(value, null);
+
+ String firstValue = null;
+ List<String> values = null;
+
+ while (it.hasNext()) {
+ final String headerValue = tc.convertTo(String.class, it.next());
+ if (headerValue != null && !headerFilterStrategy.applyFilterToCamelHeaders(key, headerValue, exchange)) {
+ if (firstValue == null) {
+ firstValue = headerValue;
+ } else {
+ if (values == null) {
+ values = new ArrayList<>();
+ values.add(firstValue);
+ }
+ values.add(headerValue);
+ }
+ }
+ }
+
+ if (values != null) {
+ response.putHeader(key, values);
+ } else if (firstValue != null) {
+ response.putHeader(key, firstValue);
+ }
+ }
+ }
+
+ Object body = message.getBody();
+ final Exception exception = exchange.getException();
+
+ if (exception != null) {
+ // we failed due an exception so print it as plain text
+ final StringWriter sw = new StringWriter();
+ final PrintWriter pw = new PrintWriter(sw);
+ exception.printStackTrace(pw);
+
+ // the body should then be the stacktrace
+ body = ByteBuffer.wrap(sw.toString().getBytes(StandardCharsets.UTF_8));
+ // force content type to be text/plain as that is what the stacktrace is
+ message.setHeader(Exchange.CONTENT_TYPE, "text/plain; charset=utf-8");
+
+ // and mark the exception as failure handled, as we handled it by returning it as the response
+ ExchangeHelper.setFailureHandled(exchange);
+ }
+
+ // set the content type in the response.
+ final String contentType = MessageHelper.getContentType(message);
+ if (contentType != null) {
+ // set content-type
+ response.putHeader("Content-Type", contentType);
+ }
+ return body;
+ }
+
+ /*
+ * Copied from org.apache.camel.http.common.DefaultHttpBinding.determineResponseCode(Exchange, Object)
+ * If DefaultHttpBinding.determineResponseCode(Exchange, Object) is moved to a module without the servlet-api
+ * dependency we could eventually consume it from there.
+ */
+ static int determineResponseCode(Exchange camelExchange, Object body) {
+ boolean failed = camelExchange.isFailed();
+ int defaultCode = failed ? 500 : 200;
+
+ Message message = camelExchange.getMessage();
+ Integer currentCode = message.getHeader(Exchange.HTTP_RESPONSE_CODE, Integer.class);
+ int codeToUse = currentCode == null ? defaultCode : currentCode;
+
+ if (codeToUse != 500) {
+ if ((body == null) || (body instanceof String && ((String) body).trim().isEmpty())) {
+ // no content
+ codeToUse = currentCode == null ? 204 : currentCode;
+ }
+ }
+
+ return codeToUse;
+ }
+
+ static void writeResponse(RoutingContext ctx, Exchange camelExchange, HeaderFilterStrategy headerFilterStrategy) {
+ final Object body = toHttpResponse(ctx.response(), camelExchange.getMessage(), headerFilterStrategy);
+
+ final HttpServerResponse response = ctx.response();
+ if (body == null) {
+ LOGGER.trace("No payload to send as reply for exchange: {}", camelExchange);
+ response.end();
+ } else if (body instanceof String) {
+ response.end((String) body);
+ } else if (body instanceof InputStream) {
+ final byte[] bytes = new byte[4096];
+ try (InputStream in = (InputStream) body) {
+ int len;
+ while ((len = in.read(bytes)) >= 0) {
+ final Buffer b = Buffer.buffer(len);
+ b.appendBytes(bytes, 0, len);
+ response.write(b);
+ }
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ response.end();
+ } else {
+ final TypeConverter tc = camelExchange.getContext().getTypeConverter();
+ try {
+ final ByteBuffer bb = tc.mandatoryConvertTo(ByteBuffer.class, body);
+ final Buffer b = Buffer.buffer(bb.capacity());
+ b.setBytes(0, bb);
+ response.end(b);
+ } catch (TypeConversionException | NoTypeConversionAvailableException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ }
+
+ static void populateCamelHeaders(
+ RoutingContext ctx,
+ Map<String, Object> headersMap,
+ Exchange exchange,
+ HeaderFilterStrategy headerFilterStrategy) {
+
+ final HttpServerRequest request = ctx.request();
+ headersMap.put(Exchange.HTTP_PATH, request.path());
+
+ if (headerFilterStrategy != null) {
+ final MultiMap requestHeaders = request.headers();
+ final String authz = requestHeaders.get("authorization");
+ // store a special header that this request was authenticated using HTTP Basic
+ if (authz != null && authz.trim().startsWith("Basic")) {
+ if (!headerFilterStrategy.applyFilterToExternalHeaders(Exchange.AUTHENTICATION, "Basic", exchange)) {
+ appendHeader(headersMap, Exchange.AUTHENTICATION, "Basic");
+ }
+ }
+ for (String name : requestHeaders.names()) {
+ // add the headers one by one, and use the header filter strategy
+ for (String value : requestHeaders.getAll(name)) {
+ if (!headerFilterStrategy.applyFilterToExternalHeaders(name.toString(), value, exchange)) {
+ appendHeader(headersMap, name.toString(), value);
+ }
+ }
+ }
+
+ // process uri parameters as headers
+ final MultiMap pathParameters = ctx.queryParams();
+ // continue if the map is not empty, otherwise there are no params
+ if (!pathParameters.isEmpty()) {
+ for (String name : pathParameters.names()) {
+ for (String value : pathParameters.getAll(name)) {
+ if (!headerFilterStrategy.applyFilterToExternalHeaders(name, value, exchange)) {
+ appendHeader(headersMap, name, value);
+ }
+ }
+ }
+ }
+ }
+
+ // Path parameters
+ for (Map.Entry<String, String> en : ctx.pathParams().entrySet()) {
+ appendHeader(headersMap, en.getKey(), en.getValue());
+ }
+
+ // NOTE: these headers is applied using the same logic as camel-http/camel-jetty to be consistent
+ headersMap.put(Exchange.HTTP_METHOD, request.method().toString());
+ // strip query parameters from the uri
+ headersMap.put(Exchange.HTTP_URL, request.absoluteURI());
+ // uri is without the host and port
+ headersMap.put(Exchange.HTTP_URI, request.uri());
+ headersMap.put(Exchange.HTTP_QUERY, request.query());
+ headersMap.put(Exchange.HTTP_RAW_QUERY, request.query());
+ }
+
+ @SuppressWarnings("unchecked")
+ 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-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java b/components/camel-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java
new file mode 100644
index 0000000..4bcf876
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/test/java/org/apache/camel/component/platform/http/vertx/VertxPlatformHttpEngineTest.java
@@ -0,0 +1,86 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.platform.http.vertx;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.platform.http.PlatformHttpComponent;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.test.AvailablePortFinder;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+public class VertxPlatformHttpEngineTest {
+
+ @Test
+ public void testEngine() throws Exception {
+ final int port = AvailablePortFinder.getNextAvailable();
+ final CamelContext context = new DefaultCamelContext();
+
+ try {
+ VertxPlatformHttpServerConfiguration conf = new VertxPlatformHttpServerConfiguration();
+ conf.setBindPort(port);
+
+ context.disableJMX();
+ context.addService(new VertxPlatformHttpServer(context, conf), true, true);
+ context.addRoutes(new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+ from("platform-http:/get")
+ .routeId("get")
+ .setBody().constant("get");
+ from("platform-http:/post")
+ .routeId("post")
+ .transform().body(String.class, b -> b.toUpperCase());
+ }
+ });
+
+ context.start();
+
+ assertThat(VertxPlatformHttpRouter.lookup(context)).isNotNull();
+ assertThat(context.getComponent("platform-http")).isInstanceOfSatisfying(PlatformHttpComponent.class, component -> {
+ assertThat(component.getEngine()).isInstanceOfSatisfying(VertxPlatformHttpEngine.class, e -> {
+ assertThat(e.getRouter().router()).isNotNull();
+ assertThat(e.getRouter().handlers()).isNotEmpty();
+ });
+ });
+
+ given()
+ .port(conf.getBindPort())
+ .when()
+ .get("/get")
+ .then()
+ .statusCode(200)
+ .body(equalTo("get"));
+
+ given()
+ .port(conf.getBindPort())
+ .body("post")
+ .when()
+ .post("/post")
+ .then()
+ .statusCode(200)
+ .body(equalTo("POST"));
+
+ } finally {
+ context.stop();
+ }
+ }
+}
diff --git a/components/camel-platform-http-vertx/src/test/resources/log4j2.properties b/components/camel-platform-http-vertx/src/test/resources/log4j2.properties
new file mode 100644
index 0000000..8cde6d9
--- /dev/null
+++ b/components/camel-platform-http-vertx/src/test/resources/log4j2.properties
@@ -0,0 +1,31 @@
+## ---------------------------------------------------------------------------
+## Licensed to the Apache Software Foundation (ASF) under one or more
+## contributor license agreements. See the NOTICE file distributed with
+## this work for additional information regarding copyright ownership.
+## The ASF licenses this file to You under the Apache License, Version 2.0
+## (the "License"); you may not use this file except in compliance with
+## the License. You may obtain a copy of the License at
+##
+## http://www.apache.org/licenses/LICENSE-2.0
+##
+## Unless required by applicable law or agreed to in writing, software
+## distributed under the License is distributed on an "AS IS" BASIS,
+## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+## See the License for the specific language governing permissions and
+## limitations under the License.
+## ---------------------------------------------------------------------------
+
+appender.out.type = File
+appender.out.name = out
+appender.out.fileName = target/camel-platform-http-vertx.log
+appender.out.layout.type = PatternLayout
+appender.out.layout.pattern = %d [%-15.15t] %-5p %-30.30c{1} - %m%n
+appender.stdout.type = Console
+appender.stdout.name = stdout
+appender.stdout.layout.type = PatternLayout
+appender.stdout.layout.pattern = %d [%-15.15t] %-5p %-30.30c{1} - %m%n
+
+rootLogger.level = INFO
+
+rootLogger.appenderRef.out.ref = out
+#rootLogger.appenderRef.stdout.ref = stdout
diff --git a/components/camel-platform-http/src/generated/java/org/apache/camel/component/platform/http/PlatformHttpComponentConfigurer.java b/components/camel-platform-http/src/generated/java/org/apache/camel/component/platform/http/PlatformHttpComponentConfigurer.java
index 7d2330c..b1d09c7 100644
--- a/components/camel-platform-http/src/generated/java/org/apache/camel/component/platform/http/PlatformHttpComponentConfigurer.java
+++ b/components/camel-platform-http/src/generated/java/org/apache/camel/component/platform/http/PlatformHttpComponentConfigurer.java
@@ -19,6 +19,7 @@ public class PlatformHttpComponentConfigurer extends PropertyConfigurerSupport i
case "basicPropertyBinding": target.setBasicPropertyBinding(property(camelContext, boolean.class, value)); return true;
case "bridgeerrorhandler":
case "bridgeErrorHandler": target.setBridgeErrorHandler(property(camelContext, boolean.class, value)); return true;
+ case "engine": target.setEngine(property(camelContext, org.apache.camel.component.platform.http.spi.PlatformHttpEngine.class, value)); return true;
default: return false;
}
}
diff --git a/components/camel-platform-http/src/generated/resources/org/apache/camel/component/platform/http/platform-http.json b/components/camel-platform-http/src/generated/resources/org/apache/camel/component/platform/http/platform-http.json
index ac4eabf..da6a40b 100644
--- a/components/camel-platform-http/src/generated/resources/org/apache/camel/component/platform/http/platform-http.json
+++ b/components/camel-platform-http/src/generated/resources/org/apache/camel/component/platform/http/platform-http.json
@@ -20,7 +20,8 @@
},
"componentProperties": {
"bridgeErrorHandler": { "kind": "property", "displayName": "Bridge Error Handler", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "secret": false, "defaultValue": false, "description": "Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by [...]
- "basicPropertyBinding": { "kind": "property", "displayName": "Basic Property Binding", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "secret": false, "defaultValue": false, "description": "Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities" }
+ "basicPropertyBinding": { "kind": "property", "displayName": "Basic Property Binding", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "secret": false, "defaultValue": false, "description": "Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities" },
+ "engine": { "kind": "property", "displayName": "Engine", "group": "advanced", "label": "advanced", "required": false, "type": "object", "javaType": "org.apache.camel.component.platform.http.spi.PlatformHttpEngine", "deprecated": false, "secret": false, "description": "An HTTP Server engine implementation to serve the requests" }
},
"properties": {
"path": { "kind": "path", "displayName": "Path", "group": "consumer", "label": "", "required": true, "type": "string", "javaType": "java.lang.String", "deprecated": false, "deprecationNote": "", "secret": false, "description": "The path under which this endpoint serves the HTTP requests" },
diff --git a/components/camel-platform-http/src/main/docs/platform-http-component.adoc b/components/camel-platform-http/src/main/docs/platform-http-component.adoc
index 0de9465..8f7e43d 100644
--- a/components/camel-platform-http/src/main/docs/platform-http-component.adoc
+++ b/components/camel-platform-http/src/main/docs/platform-http-component.adoc
@@ -28,7 +28,7 @@ for this component:
== Options
// component options: START
-The Platform HTTP component supports 2 options, which are listed below.
+The Platform HTTP component supports 3 options, which are listed below.
@@ -37,6 +37,7 @@ The Platform HTTP component supports 2 options, which are listed below.
| Name | Description | Default | Type
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
+| *engine* (advanced) | An HTTP Server engine implementation to serve the requests | | PlatformHttpEngine
|===
// component options: END
diff --git a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpComponent.java b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpComponent.java
index cd37c62..f324188 100644
--- a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpComponent.java
+++ b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpComponent.java
@@ -19,10 +19,13 @@ package org.apache.camel.component.platform.http;
import java.util.Map;
import org.apache.camel.CamelContext;
+import org.apache.camel.CamelContextAware;
import org.apache.camel.Consumer;
import org.apache.camel.Endpoint;
+import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.Processor;
import org.apache.camel.component.platform.http.spi.PlatformHttpEngine;
+import org.apache.camel.spi.FactoryFinder;
import org.apache.camel.spi.Metadata;
import org.apache.camel.spi.RestApiConsumerFactory;
import org.apache.camel.spi.RestConfiguration;
@@ -31,16 +34,23 @@ import org.apache.camel.spi.annotations.Component;
import org.apache.camel.support.CamelContextHelper;
import org.apache.camel.support.DefaultComponent;
import org.apache.camel.support.RestComponentHelper;
+import org.apache.camel.support.service.ServiceHelper;
import org.apache.camel.util.FileUtil;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Exposes HTTP endpoints leveraging the given platform's (SpringBoot, WildFly, Quarkus, ...) HTTP server.
*/
@Component("platform-http")
public class PlatformHttpComponent extends DefaultComponent implements RestConsumerFactory, RestApiConsumerFactory {
+ private static final Logger LOGGER = LoggerFactory.getLogger(PlatformHttpComponent.class);
+
@Metadata(label = "advanced", description = "An HTTP Server engine implementation to serve the requests")
private PlatformHttpEngine engine;
+ private boolean localEngine;
+
public PlatformHttpComponent() {
super();
}
@@ -69,8 +79,46 @@ public class PlatformHttpComponent extends DefaultComponent implements RestConsu
String uriTemplate,
String consumes, String produces, RestConfiguration configuration, Map<String, Object> parameters)
throws Exception {
- return doCreateConsumer(camelContext, processor, verb, basePath, uriTemplate, consumes, produces, configuration,
- parameters, false);
+ return doCreateConsumer(camelContext, processor, verb, basePath, uriTemplate, consumes, produces, configuration, parameters, false);
+ }
+
+ @Override
+ protected void doStart() throws Exception {
+ if (engine == null) {
+ LOGGER.debug("Lookup platform http engine from registry");
+
+ engine = getCamelContext().getRegistry()
+ .lookupByNameAndType(PlatformHttpConstants.PLATFORM_HTTP_ENGINE_NAME, PlatformHttpEngine.class);
+
+ if (engine == null) {
+ LOGGER.debug("Lookup platform http engine from factory");
+
+ engine = getCamelContext()
+ .adapt(ExtendedCamelContext.class)
+ .getFactoryFinder(FactoryFinder.DEFAULT_PATH)
+ .newInstance(PlatformHttpConstants.PLATFORM_HTTP_ENGINE_FACTORY, PlatformHttpEngine.class)
+ .orElseThrow(() -> new IllegalStateException(
+ "PlatformHttpEngine is neither set on this endpoint neither found in Camel Registry or FactoryFinder.")
+ );
+
+ localEngine = true;
+ }
+ }
+
+ CamelContextAware.trySetCamelContext(engine, getCamelContext());
+ ServiceHelper.startService(engine);
+
+ super.doStart();
+ }
+
+ @Override
+ protected void doStop() throws Exception {
+ super.doStop();
+
+ // Stop the platform-http engine only if it has been created through factory finder
+ if (localEngine) {
+ ServiceHelper.stopService(engine);
+ }
}
public PlatformHttpEngine getEngine() {
@@ -80,9 +128,8 @@ public class PlatformHttpComponent extends DefaultComponent implements RestConsu
/**
* Sets the {@link PlatformHttpEngine} to use.
*/
- public PlatformHttpComponent setEngine(PlatformHttpEngine engine) {
+ public void setEngine(PlatformHttpEngine engine) {
this.engine = engine;
- return this;
}
private Consumer doCreateConsumer(CamelContext camelContext, Processor processor, String verb, String basePath,
diff --git a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpConstants.java b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpConstants.java
index de5a74d..9907013 100644
--- a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpConstants.java
+++ b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpConstants.java
@@ -17,11 +17,10 @@
package org.apache.camel.component.platform.http;
public final class PlatformHttpConstants {
-
public static final String PLATFORM_HTTP_COMPONENT_NAME = "platform-http";
public static final String PLATFORM_HTTP_ENGINE_NAME = "platform-http-engine";
+ public static final String PLATFORM_HTTP_ENGINE_FACTORY = "platform-http-engine";
private PlatformHttpConstants() {
}
-
}
diff --git a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpEndpoint.java b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpEndpoint.java
index d80b43f..b0ea623 100644
--- a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpEndpoint.java
+++ b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpEndpoint.java
@@ -144,22 +144,4 @@ public class PlatformHttpEndpoint extends DefaultEndpoint implements AsyncEndpoi
public void setProduces(String produces) {
this.produces = produces;
}
-
- @Override
- protected void doStart() throws Exception {
- super.doStart();
-
- if (platformHttpEngine == null) {
- LOGGER.debug("Lookup platform http engine from registry");
-
- platformHttpEngine = getCamelContext().getRegistry()
- .lookupByNameAndType(PlatformHttpConstants.PLATFORM_HTTP_ENGINE_NAME, PlatformHttpEngine.class);
-
- if (platformHttpEngine == null) {
- throw new IllegalStateException(PlatformHttpEngine.class.getSimpleName() + " neither set on this "
- + PlatformHttpEndpoint.class.getSimpleName()
- + " neither found in Camel Registry.");
- }
- }
- }
}
diff --git a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpConstants.java b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/spi/UploadAttacher.java
similarity index 56%
copy from components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpConstants.java
copy to components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/spi/UploadAttacher.java
index de5a74d..426a8d0 100644
--- a/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/PlatformHttpConstants.java
+++ b/components/camel-platform-http/src/main/java/org/apache/camel/component/platform/http/spi/UploadAttacher.java
@@ -14,14 +14,25 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package org.apache.camel.component.platform.http;
+package org.apache.camel.component.platform.http.spi;
-public final class PlatformHttpConstants {
+import java.io.File;
- public static final String PLATFORM_HTTP_COMPONENT_NAME = "platform-http";
- public static final String PLATFORM_HTTP_ENGINE_NAME = "platform-http-engine";
+import org.apache.camel.Message;
- private PlatformHttpConstants() {
- }
+/**
+ * Attaches file uploads to Camel {@link Message}s.
+ */
+public interface UploadAttacher {
+
+ /**
+ * Attach the uploaded file represented by the given {@code localFile} and {@code fileName} to the given
+ * {@code message}
+ *
+ * @param localFile the uploaded file stored locally
+ * @param fileName the name of the upload as sent by the client
+ * @param message the {@link Message} to attach the upload to
+ */
+ void attachUpload(File localFile, String fileName, Message message);
}
diff --git a/components/pom.xml b/components/pom.xml
index 2f68aca..96d6f3d 100644
--- a/components/pom.xml
+++ b/components/pom.xml
@@ -294,6 +294,7 @@
<module>camel-pg-replication-slot</module>
<module>camel-pgevent</module>
<module>camel-platform-http</module>
+ <module>camel-platform-http-vertx</module>
<module>camel-printer</module>
<module>camel-protobuf</module>
<module>camel-pubnub</module>
diff --git a/core/camel-allcomponents/pom.xml b/core/camel-allcomponents/pom.xml
index d0e3175..88ef050 100644
--- a/core/camel-allcomponents/pom.xml
+++ b/core/camel-allcomponents/pom.xml
@@ -32,7 +32,7 @@
<name>Camel :: All Components Sync point</name>
<description>Depends on all components to ensure correct build ordering</description>
-
+
<dependencies>
<dependency>
<groupId>org.apache.camel</groupId>
@@ -884,6 +884,10 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-platform-http-vertx</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-platform-http</artifactId>
</dependency>
<dependency>
diff --git a/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/PlatformHttpComponentBuilderFactory.java b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/PlatformHttpComponentBuilderFactory.java
index 2503e54..a17ba73 100644
--- a/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/PlatformHttpComponentBuilderFactory.java
+++ b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/PlatformHttpComponentBuilderFactory.java
@@ -81,6 +81,19 @@ public interface PlatformHttpComponentBuilderFactory {
doSetProperty("basicPropertyBinding", basicPropertyBinding);
return this;
}
+ /**
+ * An HTTP Server engine implementation to serve the requests.
+ *
+ * The option is a:
+ * <code>org.apache.camel.component.platform.http.spi.PlatformHttpEngine</code> type.
+ *
+ * Group: advanced
+ */
+ default PlatformHttpComponentBuilder engine(
+ org.apache.camel.component.platform.http.spi.PlatformHttpEngine engine) {
+ doSetProperty("engine", engine);
+ return this;
+ }
}
class PlatformHttpComponentBuilderImpl
@@ -100,6 +113,7 @@ public interface PlatformHttpComponentBuilderFactory {
switch (name) {
case "bridgeErrorHandler": ((PlatformHttpComponent) component).setBridgeErrorHandler((boolean) value); return true;
case "basicPropertyBinding": ((PlatformHttpComponent) component).setBasicPropertyBinding((boolean) value); return true;
+ case "engine": ((PlatformHttpComponent) component).setEngine((org.apache.camel.component.platform.http.spi.PlatformHttpEngine) value); return true;
default: return false;
}
}
diff --git a/docs/components/modules/ROOT/pages/index.adoc b/docs/components/modules/ROOT/pages/index.adoc
index f38c5c1..32acb52 100644
--- a/docs/components/modules/ROOT/pages/index.adoc
+++ b/docs/components/modules/ROOT/pages/index.adoc
@@ -832,7 +832,7 @@ Number of Languages: 17 in 11 JAR artifacts (0 deprecated)
== Miscellaneous Components
// others: START
-Number of Miscellaneous Components: 36 in 36 JAR artifacts (0 deprecated)
+Number of Miscellaneous Components: 37 in 37 JAR artifacts (0 deprecated)
[width="100%",cols="4,1,5",options="header"]
|===
@@ -868,6 +868,8 @@ Number of Miscellaneous Components: 36 in 36 JAR artifacts (0 deprecated)
| xref:osgi-activator.adoc[Osgi Activator] (camel-osgi-activator) | 3.1 | Camel OSGi Activator for running Camel routes from other bundles
+| xref:platform-http-vertx.adoc[Platform Http Vertx] (camel-platform-http-vertx) | | Implementation of the Platform Http Engine based on Vert.x Web
+
| xref:reactive-executor-vertx.adoc[Reactive Executor Vert.x] (camel-reactive-executor-vertx) | 3.0 | Reactive Executor for camel-core using Vert.x
| xref:reactor.adoc[Reactor] (camel-reactor) | 2.20 | Reactor based back-end for Camel's reactive streams component
diff --git a/docs/components/modules/ROOT/pages/platform-http-component.adoc b/docs/components/modules/ROOT/pages/platform-http-component.adoc
index 659fe89..1bb1b2b 100644
--- a/docs/components/modules/ROOT/pages/platform-http-component.adoc
+++ b/docs/components/modules/ROOT/pages/platform-http-component.adoc
@@ -29,7 +29,7 @@ for this component:
== Options
// component options: START
-The Platform HTTP component supports 2 options, which are listed below.
+The Platform HTTP component supports 3 options, which are listed below.
@@ -38,6 +38,7 @@ The Platform HTTP component supports 2 options, which are listed below.
| Name | Description | Default | Type
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
+| *engine* (advanced) | An HTTP Server engine implementation to serve the requests | | PlatformHttpEngine
|===
// component options: END
diff --git a/parent/pom.xml b/parent/pom.xml
index b7a89dd..75c86dd 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -2087,6 +2087,11 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-platform-http-vertx</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-printer</artifactId>
<version>${project.version}</version>
</dependency>