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

davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/main by this push:
     new a7c336c7b68e CAMEL-27391: camel-jbang - camel-cxf-platform-http only 
for an integration with a cxf consumer (#30606)
a7c336c7b68e is described below

commit a7c336c7b68e7b4f59f0c4377b825e6eacbfd06b
Author: Claus Ibsen <[email protected]>
AuthorDate: Sun Nov 22 19:50:46 2026 +0100

    CAMEL-27391: camel-jbang - camel-cxf-platform-http only for an integration 
with a cxf consumer (#30606)
    
    camel export to Camel Main now adds camel-cxf-platform-http and 
camel-platform-http-main (and turns on the HTTP
    server) only for an integration with a cxf consumer, not for one with only 
cxf producers.
    
    Camel JBang (camel-kamelet-main) decides from the routes: 
DependencyDownloaderCxf, a ModelLifecycleStrategy like
    DependencyDownloaderKamelet, downloads camel-cxf-platform-http as a 
dependency of the integration when the first
    route with a cxf: consumer is added (also from a template or a Kamelet), 
binds its transport and sets the starter of
    the platform-http server. The auto-configure script camel-cxf-soap.java is 
removed. Spring Boot and Quarkus exports
    drop the module and use their CXF starter / extension, as before. Upgrade 
guide entry updated.
    
    Signed-off-by: Claus Ibsen <[email protected]>
    Co-Authored-By: Claude Opus 5.5 <[email protected]>
---
 .../ROOT/pages/camel-4x-upgrade-guide-4_24.adoc    |   7 +-
 .../dsl/jbang/run/export/CamelMainExporter.java    |  11 +-
 .../dsl/jbang/run/export/QuarkusExporter.java      |   3 +
 .../dsl/jbang/run/export/SpringBootExporter.java   |   3 +
 .../dsl/jbang/run/export/ProjectExporterTest.java  |  31 ++++
 .../java/org/apache/camel/main/KameletMain.java    |   3 +
 .../main/download/DependencyDownloaderCxf.java     | 144 ++++++++++++++++
 .../resources/auto-configure/camel-cxf-soap.java   |  50 ------
 .../main/download/DependencyDownloaderCxfTest.java | 188 +++++++++++++++++++++
 9 files changed, 382 insertions(+), 58 deletions(-)

diff --git 
a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc 
b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
index 5ead09afc66d..b25a539dad26 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
@@ -1308,9 +1308,10 @@ service is then at 
`\http://localhost:8080/services/orders` (with `camel.server.
 scheme and a host fails when the route starts. The `cxf` producer (a SOAP 
client) is not changed and still takes a full
 URL.
 
-`camel export` to Camel Main adds `camel-cxf-platform-http` and 
`camel-platform-http-main` for an integration with
-`camel-cxf-soap`, and turns on the HTTP server. The export to Spring Boot and 
Quarkus uses their CXF starter and
-extension, as before, with `camel.cxf.path` mapped to `cxf.path` and 
`quarkus.cxf.path`.
+`camel export` to Camel Main adds `camel-cxf-platform-http` and 
`camel-platform-http-main` for an integration with a
+`cxf` consumer, and turns on the HTTP server. An integration with only `cxf` 
producers gets neither. The export to
+Spring Boot and Quarkus uses their CXF starter and extension, as before, with 
`camel.cxf.path` mapped to `cxf.path` and
+`quarkus.cxf.path`.
 
 A Camel Main application is not changed: it serves a cxf consumer with the 
transport it brings (Jetty or Undertow),
 unless it adds `camel-cxf-platform-http`.
diff --git 
a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/CamelMainExporter.java
 
b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/CamelMainExporter.java
index 6c434510c1ac..56ea4c7c6ab8 100644
--- 
a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/CamelMainExporter.java
+++ 
b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/CamelMainExporter.java
@@ -342,11 +342,12 @@ class CamelMainExporter extends Exporter {
             answer.add("mvn:org.apache.camel:camel-platform-http-jolokia");
         }
 
-        // a cxf consumer is served on the platform-http server, as in camel 
run (since 4.24)
-        if (hasCamelArtifact(answer, "camel-cxf-soap") && 
!hasCamelArtifact(answer, "camel-cxf-platform-http")
-                && (request.camelVersion == null || 
VersionHelper.isGE(request.camelVersion, "4.24.0"))) {
-            answer.add("mvn:org.apache.camel:camel-cxf-platform-http");
-            if (!hasCamelArtifact(answer, "camel-platform-http-main")) {
+        // a cxf consumer is served on the platform-http server, as in camel 
run, which adds camel-cxf-platform-http
+        // (since 4.24) for an integration with a cxf consumer, not for cxf 
producers only
+        if (hasCamelArtifact(answer, "camel-cxf-platform-http")) {
+            if (request.camelVersion != null && 
!VersionHelper.isGE(request.camelVersion, "4.24.0")) {
+                removeCamelArtifact(answer, "camel-cxf-platform-http");
+            } else if (!hasCamelArtifact(answer, "camel-platform-http-main")) {
                 answer.add("mvn:org.apache.camel:camel-platform-http-main");
             }
         }
diff --git 
a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/QuarkusExporter.java
 
b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/QuarkusExporter.java
index 8530ad181e5d..555d7b0b5d63 100644
--- 
a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/QuarkusExporter.java
+++ 
b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/QuarkusExporter.java
@@ -587,6 +587,9 @@ class QuarkusExporter extends Exporter {
 
         // remove out of the box dependencies
         answer.removeIf(s -> s.contains("camel-core"));
+        // camel run serves a cxf consumer with camel-cxf-platform-http 
(camel-main); the runtime serves it with its
+        // CXF starter or extension
+        removeCamelArtifact(answer, "camel-cxf-platform-http");
 
         if (request.hawtio) {
             answer.add("mvn:org.apache.camel:camel-management");
diff --git 
a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/SpringBootExporter.java
 
b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/SpringBootExporter.java
index 5d2875d4533d..a9515c23abd5 100644
--- 
a/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/SpringBootExporter.java
+++ 
b/dsl/camel-jbang/camel-jbang-run/src/main/java/org/apache/camel/dsl/jbang/run/export/SpringBootExporter.java
@@ -515,6 +515,9 @@ class SpringBootExporter extends Exporter {
 
         // remove out of the box dependencies
         answer.removeIf(s -> s.contains("camel-core"));
+        // camel run serves a cxf consumer with camel-cxf-platform-http 
(camel-main); the runtime serves it with its
+        // CXF starter or extension
+        removeCamelArtifact(answer, "camel-cxf-platform-http");
 
         boolean http = hasCamelArtifact(answer, "camel-platform-http")
                 || hasCamelArtifact(answer, "camel-platform-http-vertx");
diff --git 
a/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/export/ProjectExporterTest.java
 
b/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/export/ProjectExporterTest.java
index 2e78f94c0fbc..51d1d3b8bfe6 100644
--- 
a/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/export/ProjectExporterTest.java
+++ 
b/dsl/camel-jbang/camel-jbang-run/src/test/java/org/apache/camel/dsl/jbang/run/export/ProjectExporterTest.java
@@ -478,12 +478,14 @@ class ProjectExporterTest {
     @EnumSource(value = RuntimeType.class, names = { "main", "springBoot", 
"quarkus" })
     void cxfConsumerIsServedOnTheHttpServerOfTheRuntime(RuntimeType runtime) 
throws Exception {
         Path route = writeRoute("soap");
+        // camel run adds camel-cxf-platform-http for a route with a cxf 
consumer
         DependencyResolver cxf = r -> {
             Path settings = r.workDir.resolve(ExportHelper.RUN_SETTINGS_FILE);
             Files.createDirectories(settings.getParent());
             Files.writeString(settings, """
                     camel.main.routesIncludePattern=file:%s
                     dependency=camel:cxf-soap
+                    dependency=camel:cxf-platform-http
                     """.formatted(route));
             return 0;
         };
@@ -523,6 +525,35 @@ class ProjectExporterTest {
         }
     }
 
+    @Test
+    void cxfProducersOnlyNeedNoHttpServer() throws Exception {
+        // CAMEL-27391: camel run adds camel-cxf-platform-http only for a cxf 
consumer
+        Path route = writeRoute("soap");
+        DependencyResolver cxf = r -> {
+            Path settings = r.workDir.resolve(ExportHelper.RUN_SETTINGS_FILE);
+            Files.createDirectories(settings.getParent());
+            Files.writeString(settings, """
+                    camel.main.routesIncludePattern=file:%s
+                    dependency=camel:cxf-soap
+                    """.formatted(route));
+            return 0;
+        };
+        Path exportDir = dir.resolve("export");
+        ExportRequest request = request(route, exportDir);
+        request.runtime = RuntimeType.main;
+
+        StringPrinter printer = new StringPrinter();
+        int exit = new ProjectExporter(new 
ExportContext().withPrinter(printer).withDependencyResolver(cxf))
+                .export(request);
+
+        assertThat(exit).as(printer.getOutput()).isZero();
+        String pom = Files.readString(exportDir.resolve("pom.xml"));
+        assertThat(pom).contains("<artifactId>camel-cxf-soap</artifactId>")
+                .doesNotContain("camel-cxf-platform-http", 
"camel-platform-http-main");
+        
assertThat(exportDir.resolve("src/main/resources/application.properties")).content()
+                .doesNotContain("camel.server.enabled");
+    }
+
     @ParameterizedTest
     @EnumSource(value = RuntimeType.class, names = { "main", "springBoot", 
"quarkus" })
     void localJarsAreInTheLibDirectoryAsThePomRefersToThem(RuntimeType 
runtime) throws Exception {
diff --git 
a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java 
b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java
index b62d1648b4e3..849151eefc2a 100644
--- 
a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java
+++ 
b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/KameletMain.java
@@ -49,6 +49,7 @@ import 
org.apache.camel.main.download.DependencyDownloadFactoryFinderResolver;
 import org.apache.camel.main.download.DependencyDownloaderClassLoader;
 import org.apache.camel.main.download.DependencyDownloaderClassResolver;
 import org.apache.camel.main.download.DependencyDownloaderComponentResolver;
+import org.apache.camel.main.download.DependencyDownloaderCxf;
 import org.apache.camel.main.download.DependencyDownloaderDataFormatResolver;
 import org.apache.camel.main.download.DependencyDownloaderKamelet;
 import org.apache.camel.main.download.DependencyDownloaderLanguageResolver;
@@ -769,6 +770,8 @@ public class KameletMain extends MainCommandLineSupport {
             Object kameletsVersion = 
getInitialProperties().get(getInstanceType() + ".kameletsVersion");
             answer.addService(new DependencyDownloaderKamelet(
                     answer, kameletsVersion != null ? 
kameletsVersion.toString() : null));
+            // a cxf consumer is served on the platform-http server
+            answer.addService(new DependencyDownloaderCxf(answer, silent));
             answer.addService(new 
DependencyDownloaderPropertiesComponent(answer, knownDeps, silent));
 
             // reloader
diff --git 
a/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/download/DependencyDownloaderCxf.java
 
b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/download/DependencyDownloaderCxf.java
new file mode 100644
index 000000000000..7af9f1192ef0
--- /dev/null
+++ 
b/dsl/camel-kamelet-main/src/main/java/org/apache/camel/main/download/DependencyDownloaderCxf.java
@@ -0,0 +1,144 @@
+/*
+ * 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.main.download;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.CamelContextAware;
+import org.apache.camel.RuntimeCamelException;
+import org.apache.camel.model.ModelCamelContext;
+import org.apache.camel.model.ModelLifecycleStrategy;
+import org.apache.camel.model.RouteDefinition;
+import org.apache.camel.model.RouteTemplateDefinition;
+import org.apache.camel.support.service.ServiceSupport;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Serves the cxf consumers on the platform-http server 
(camel-cxf-platform-http), as the CXF extension of Quarkus does
+ * on the Vert.x server of Quarkus.
+ * <p>
+ * When the first route with a cxf consumer is added (a route of the 
integration or of a Kamelet),
+ * camel-cxf-platform-http is downloaded, as a dependency of the integration, 
so camel export includes it, and its
+ * transport is bound with a starter of the platform-http server, which starts 
when the first cxf consumer starts. An
+ * integration with only cxf producers (SOAP clients) needs neither.
+ */
+public final class DependencyDownloaderCxf extends ServiceSupport
+        implements CamelContextAware, ModelLifecycleStrategy {
+
+    static final String TRANSPORT_BEAN_NAME = "camelCxfPlatformHttpTransport";
+    private static final String TRANSPORT_CLASS
+            = 
"org.apache.camel.component.cxf.platform.http.CxfPlatformHttpTransport";
+    private static final Logger LOG = 
LoggerFactory.getLogger(DependencyDownloaderCxf.class);
+
+    private CamelContext camelContext;
+    private final boolean silent;
+    private final AtomicBoolean done = new AtomicBoolean();
+
+    public DependencyDownloaderCxf(CamelContext camelContext, boolean silent) {
+        this.camelContext = camelContext;
+        this.silent = silent;
+    }
+
+    @Override
+    public CamelContext getCamelContext() {
+        return camelContext;
+    }
+
+    @Override
+    public void setCamelContext(CamelContext camelContext) {
+        this.camelContext = camelContext;
+    }
+
+    @Override
+    protected void doBuild() throws Exception {
+        if (camelContext instanceof ModelCamelContext mcc) {
+            mcc.addModelLifecycleStrategy(this);
+            // the routes that are added already
+            for (RouteDefinition route : mcc.getRouteDefinitions()) {
+                onAddRouteDefinition(route);
+            }
+        }
+    }
+
+    @Override
+    public void onAddRouteDefinition(RouteDefinition routeDefinition) {
+        if (!done.get() && routeDefinition.getInput() != null
+                && isCxfConsumer(camelContext, 
routeDefinition.getInput().getEndpointUri())
+                && done.compareAndSet(false, true)) {
+            LOG.debug("Route: {} has a cxf consumer, which is served on the 
platform-http server",
+                    routeDefinition.getRouteId());
+            servePlatformHttp();
+        }
+    }
+
+    @Override
+    public void onRemoveRouteDefinition(RouteDefinition routeDefinition) {
+        // noop
+    }
+
+    @Override
+    public void onAddRouteTemplateDefinition(RouteTemplateDefinition 
routeTemplateDefinition) {
+        // noop
+    }
+
+    @Override
+    public void onRemoveRouteTemplateDefinition(RouteTemplateDefinition 
routeTemplateDefinition) {
+        // noop
+    }
+
+    /**
+     * Whether the endpoint uri of the input of a route is cxf (a SOAP 
service); not cxfrs, which is another component.
+     */
+    static boolean isCxfConsumer(CamelContext camelContext, String uri) {
+        if (uri != null && uri.startsWith("{{")) {
+            // the uri is a property placeholder
+            try {
+                uri = camelContext.resolvePropertyPlaceholders(uri);
+            } catch (Exception e) {
+                return false;
+            }
+        }
+        return uri != null && uri.startsWith("cxf:");
+    }
+
+    private void servePlatformHttp() {
+        DependencyDownloader downloader = 
camelContext.hasService(DependencyDownloader.class);
+        if (downloader != null) {
+            downloader.downloadDependency("org.apache.camel", 
"camel-cxf-platform-http", camelContext.getVersion());
+        }
+        try {
+            Object transport = 
camelContext.getRegistry().lookupByName(TRANSPORT_BEAN_NAME);
+            if (transport == null) {
+                Class<?> type = 
camelContext.getClassResolver().resolveMandatoryClass(TRANSPORT_CLASS);
+                transport = type.getConstructor().newInstance();
+                CamelContextAware.trySetCamelContext(transport, camelContext);
+                camelContext.getRegistry().bind(TRANSPORT_BEAN_NAME, 
transport);
+            }
+            // start the platform-http server when the first cxf consumer 
starts
+            Runnable starter = () -> 
MainHttpServerFactory.setupHttpServer(camelContext, false);
+            transport.getClass().getMethod("setHttpServerStarter", 
Runnable.class).invoke(transport, starter);
+            if (!silent) {
+                LOG.info("Camel CLI serves cxf consumers on the platform-http 
server under {}",
+                        
camelContext.resolvePropertyPlaceholders("{{camel.cxf.path:/services}}"));
+            }
+        } catch (Exception e) {
+            throw RuntimeCamelException.wrapRuntimeException(e);
+        }
+    }
+}
diff --git 
a/dsl/camel-kamelet-main/src/main/resources/auto-configure/camel-cxf-soap.java 
b/dsl/camel-kamelet-main/src/main/resources/auto-configure/camel-cxf-soap.java
deleted file mode 100644
index 6563c5baffa1..000000000000
--- 
a/dsl/camel-kamelet-main/src/main/resources/auto-configure/camel-cxf-soap.java
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * 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.
- */
-
-// a cxf consumer is served on the platform-http server 
(camel-cxf-platform-http), as the CXF extension of Quarkus does
-// on the Vert.x server of Quarkus; the address of a consumer is a path, 
served under /services (camel.cxf.path)
-//
-// only the Camel API is used directly: the classes of the Camel CLI are not 
visible to the compiler of this script
-// when it runs from the launcher, so they are called by reflection
-var resolver = context.getClassResolver();
-Class downloaderType = 
resolver.resolveMandatoryClass("org.apache.camel.main.download.DependencyDownloader");
-Object downloader = context.hasService(downloaderType);
-downloaderType.getMethod("downloadHiddenDependency", String.class, 
String.class, String.class)
-        .invoke(downloader, "org.apache.camel", "camel-cxf-platform-http", 
context.getVersion());
-
-Class transportType = 
resolver.resolveMandatoryClass("org.apache.camel.component.cxf.platform.http.CxfPlatformHttpTransport");
-Object transport = 
context.getRegistry().lookupByName("camelCxfPlatformHttpTransport");
-if (transport == null) {
-    transport = transportType.getConstructor().newInstance();
-    transportType.getMethod("setCamelContext", 
org.apache.camel.CamelContext.class).invoke(transport, context);
-    context.getRegistry().bind("camelCxfPlatformHttpTransport", transport);
-}
-
-// start the platform-http server when the first cxf consumer starts (not for 
a cxf producer only)
-java.lang.reflect.Method setup = 
resolver.resolveMandatoryClass("org.apache.camel.main.download.MainHttpServerFactory")
-        .getMethod("setupHttpServer", org.apache.camel.CamelContext.class, 
boolean.class);
-Runnable starter = () -> {
-    try {
-        setup.invoke(null, context, false);
-    } catch (Exception e) {
-        throw new IllegalStateException("Cannot start the platform-http server 
for the cxf consumers", e);
-    }
-};
-transportType.getMethod("setHttpServerStarter", 
Runnable.class).invoke(transport, starter);
-
-return "Camel CLI serves cxf consumers on the platform-http server under "
-       + context.resolvePropertyPlaceholders("{{camel.cxf.path:/services}}");
diff --git 
a/dsl/camel-kamelet-main/src/test/java/org/apache/camel/main/download/DependencyDownloaderCxfTest.java
 
b/dsl/camel-kamelet-main/src/test/java/org/apache/camel/main/download/DependencyDownloaderCxfTest.java
new file mode 100644
index 000000000000..b1dcc1c891bc
--- /dev/null
+++ 
b/dsl/camel-kamelet-main/src/test/java/org/apache/camel/main/download/DependencyDownloaderCxfTest.java
@@ -0,0 +1,188 @@
+/*
+ * 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.main.download;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class DependencyDownloaderCxfTest {
+
+    private static final String MODULE = 
"org.apache.camel:camel-cxf-platform-http";
+
+    @Test
+    void 
aRouteWithACxfConsumerDownloadsTheModuleAndSetsTheStarterOfTheHttpServer() 
throws Exception {
+        RecordingDownloader downloader = new RecordingDownloader();
+        FakeTransport transport = new FakeTransport();
+        try (CamelContext context = context(downloader, transport)) {
+            context.addService(new DependencyDownloaderCxf(context, true));
+            context.addRoutes(new RouteBuilder() {
+                @Override
+                public void configure() {
+                    
from("cxf:/orders?serviceClass=org.example.Orders").to("log:orders");
+                    
from("cxf:/invoices?serviceClass=org.example.Invoices").to("log:invoices");
+                }
+            });
+
+            // a dependency of the integration (so camel export has it), 
downloaded once
+            assertEquals(List.of(MODULE), downloader.downloaded);
+            assertNotNull(transport.starter);
+        }
+    }
+
+    @Test
+    void cxfProducersOnlyNeedNeitherTheModuleNorTheHttpServer() throws 
Exception {
+        RecordingDownloader downloader = new RecordingDownloader();
+        FakeTransport transport = new FakeTransport();
+        try (CamelContext context = context(downloader, transport)) {
+            context.addService(new DependencyDownloaderCxf(context, true));
+            context.addRoutes(new RouteBuilder() {
+                @Override
+                public void configure() {
+                    
from("direct:start").to("cxf:http://localhost:9000/orders?serviceClass=org.example.Orders";);
+                    // cxfrs is another component (camel-cxf-rest)
+                    
from("cxfrs:/customers?resourceClasses=org.example.Customers").to("log:customers");
+                }
+            });
+
+            assertTrue(downloader.downloaded.isEmpty(), 
downloader.downloaded.toString());
+            assertNull(transport.starter);
+        }
+    }
+
+    @Test
+    void theRoutesThatAreAddedBeforeAreChecked() throws Exception {
+        RecordingDownloader downloader = new RecordingDownloader();
+        FakeTransport transport = new FakeTransport();
+        try (CamelContext context = context(downloader, transport)) {
+            context.addRoutes(new RouteBuilder() {
+                @Override
+                public void configure() {
+                    
from("cxf:/orders?serviceClass=org.example.Orders").to("log:orders");
+                }
+            });
+            context.addService(new DependencyDownloaderCxf(context, true));
+
+            assertEquals(List.of(MODULE), downloader.downloaded);
+            assertNotNull(transport.starter);
+        }
+    }
+
+    @Test
+    void aRouteFromATemplateWithACxfConsumer() throws Exception {
+        // such as the route of a Kamelet, which is created from its template
+        RecordingDownloader downloader = new RecordingDownloader();
+        FakeTransport transport = new FakeTransport();
+        try (CamelContext context = context(downloader, transport)) {
+            context.addService(new DependencyDownloaderCxf(context, true));
+            context.addRoutes(new RouteBuilder() {
+                @Override
+                public void configure() {
+                    routeTemplate("soap").templateParameter("address")
+                            
.from("cxf:{{address}}?serviceClass=org.example.Orders").to("log:orders");
+                }
+            });
+            assertTrue(downloader.downloaded.isEmpty(), 
downloader.downloaded.toString());
+
+            context.addRouteFromTemplate("orders", "soap", Map.of("address", 
"/orders"));
+
+            assertEquals(List.of(MODULE), downloader.downloaded);
+            assertNotNull(transport.starter);
+        }
+    }
+
+    @Test
+    void isCxfConsumer() throws Exception {
+        try (CamelContext context = new DefaultCamelContext()) {
+            Properties props = new Properties();
+            props.setProperty("soap.uri", "cxf:/orders");
+            props.setProperty("timer.uri", "timer:tick");
+            context.getPropertiesComponent().setInitialProperties(props);
+
+            assertTrue(DependencyDownloaderCxf.isCxfConsumer(context, 
"cxf:/orders"));
+            assertTrue(DependencyDownloaderCxf.isCxfConsumer(context, 
"cxf://http://0.0.0.0:9000/orders";));
+            assertTrue(DependencyDownloaderCxf.isCxfConsumer(context, 
"cxf:bean:ordersEndpoint"));
+            assertTrue(DependencyDownloaderCxf.isCxfConsumer(context, 
"{{soap.uri}}"));
+            assertFalse(DependencyDownloaderCxf.isCxfConsumer(context, 
"{{timer.uri}}"));
+            assertFalse(DependencyDownloaderCxf.isCxfConsumer(context, 
"{{not.there}}"));
+            assertFalse(DependencyDownloaderCxf.isCxfConsumer(context, 
"cxfrs:/customers"));
+            assertFalse(DependencyDownloaderCxf.isCxfConsumer(context, 
"direct:start"));
+            assertFalse(DependencyDownloaderCxf.isCxfConsumer(context, null));
+        }
+    }
+
+    private static CamelContext context(RecordingDownloader downloader, 
FakeTransport transport) throws Exception {
+        CamelContext context = new DefaultCamelContext();
+        context.addService(downloader);
+        // camel-cxf-platform-http is not on the classpath of the test: its 
transport is bound already
+        
context.getRegistry().bind(DependencyDownloaderCxf.TRANSPORT_BEAN_NAME, 
transport);
+        return context;
+    }
+
+    /** The setter of CxfPlatformHttpTransport that the downloader calls. */
+    public static class FakeTransport {
+
+        private Runnable starter;
+
+        public void setHttpServerStarter(Runnable starter) {
+            this.starter = starter;
+        }
+    }
+
+    /** Records the downloads and downloads nothing. */
+    private static class RecordingDownloader extends MavenDependencyDownloader 
{
+
+        private final List<String> downloaded = new CopyOnWriteArrayList<>();
+
+        @Override
+        protected void doBuild() {
+            // noop
+        }
+
+        @Override
+        protected void doInit() {
+            // noop
+        }
+
+        @Override
+        protected void doStart() {
+            // noop
+        }
+
+        @Override
+        protected void doStop() {
+            // noop
+        }
+
+        @Override
+        public void downloadDependency(String groupId, String artifactId, 
String version) {
+            downloaded.add(groupId + ":" + artifactId);
+        }
+    }
+}

Reply via email to