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 2021/01/27 07:53:21 UTC
[camel] branch master updated: CAMEL-16080: Migrate camel-kamelet
component from camel-k-runtime to camel
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
The following commit(s) were added to refs/heads/master by this push:
new 16767a7 CAMEL-16080: Migrate camel-kamelet component from camel-k-runtime to camel
16767a7 is described below
commit 16767a74b0b5f9f7bf3d2e3db594baa4d066106b
Author: Luca Burgazzoli <lb...@gmail.com>
AuthorDate: Tue Jan 26 14:20:57 2021 +0100
CAMEL-16080: Migrate camel-kamelet component from camel-k-runtime to camel
---
bom/camel-bom/pom.xml | 5 +
.../org/apache/camel/catalog/components.properties | 1 +
.../apache/camel/catalog/components/kamelet.json | 44 +++
.../org/apache/camel/catalog/docs.properties | 1 +
.../camel/catalog/docs/kamelet-component.adoc | 144 +++++++
.../apache/camel/catalog/schemas/camel-spring.xsd | 8 +
components/camel-kamelet/pom.xml | 89 +++++
.../kamelet/KameletComponentConfigurer.java | 90 +++++
.../kamelet/KameletEndpointConfigurer.java | 79 ++++
.../kamelet/KameletEndpointUriFactory.java | 70 ++++
.../services/org/apache/camel/component.properties | 7 +
.../services/org/apache/camel/component/kamelet | 2 +
.../org/apache/camel/configurer/kamelet-component | 2 +
.../org/apache/camel/configurer/kamelet-endpoint | 2 +
.../org/apache/camel/urifactory/kamelet-endpoint | 2 +
.../apache/camel/component/kamelet/kamelet.json | 44 +++
.../src/main/docs/kamelet-component.adoc | 144 +++++++
.../apache/camel/component/kamelet/Kamelet.java | 132 +++++++
.../camel/component/kamelet/KameletComponent.java | 382 ++++++++++++++++++
.../camel/component/kamelet/KameletConsumer.java | 83 ++++
.../KameletConsumerNotAvailableException.java | 27 ++
.../camel/component/kamelet/KameletEndpoint.java | 162 ++++++++
.../camel/component/kamelet/KameletProducer.java | 90 +++++
.../camel/component/kamelet/KameletBasicTest.java | 89 +++++
.../component/kamelet/KameletComponentTest.java | 52 +++
.../component/kamelet/KameletPropertiesTest.java | 170 ++++++++
.../camel/component/kamelet/KameletRouteTest.java | 73 ++++
.../component/kamelet/KameletValidationTest.java | 49 +++
.../src/test/resources/log4j2.properties | 34 ++
components/pom.xml | 1 +
core/camel-allcomponents/pom.xml | 4 +
.../component/ComponentsBuilderFactory.java | 14 +
.../dsl/KameletComponentBuilderFactory.java | 214 ++++++++++
.../src/generated/resources/metadata.json | 22 ++
.../builder/endpoint/EndpointBuilderFactory.java | 1 +
.../camel/builder/endpoint/EndpointBuilders.java | 1 +
.../builder/endpoint/StaticEndpointBuilders.java | 53 +++
.../dsl/KameletEndpointBuilderFactory.java | 430 +++++++++++++++++++++
.../org/apache/camel/util/PropertiesHelper.java | 24 ++
docs/components/modules/ROOT/nav.adoc | 1 +
.../modules/ROOT/pages/kamelet-component.adoc | 146 +++++++
parent/pom.xml | 5 +
42 files changed, 2993 insertions(+)
diff --git a/bom/camel-bom/pom.xml b/bom/camel-bom/pom.xml
index 2bf41c7..1f183b5 100644
--- a/bom/camel-bom/pom.xml
+++ b/bom/camel-bom/pom.xml
@@ -1184,6 +1184,11 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-kamelet</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-kubernetes</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components.properties b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components.properties
index 6e9c853..c0ef9a1 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components.properties
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components.properties
@@ -203,6 +203,7 @@ json-validator
jsonata
jt400
kafka
+kamelet
kubernetes-config-maps
kubernetes-custom-resources
kubernetes-deployments
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/kamelet.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/kamelet.json
new file mode 100644
index 0000000..bd9d1db
--- /dev/null
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/components/kamelet.json
@@ -0,0 +1,44 @@
+{
+ "component": {
+ "kind": "component",
+ "name": "kamelet",
+ "title": "Kamelet",
+ "description": "The Kamelet Component provides support for interacting with the Camel Route Template engine",
+ "deprecated": false,
+ "firstVersion": "3.8.0",
+ "label": "core",
+ "javaType": "org.apache.camel.component.kamelet.KameletComponent",
+ "supportLevel": "Preview",
+ "groupId": "org.apache.camel",
+ "artifactId": "camel-kamelet",
+ "version": "3.8.0-SNAPSHOT",
+ "scheme": "kamelet",
+ "extendsScheme": "",
+ "syntax": "kamelet:templateId\/routeId",
+ "async": false,
+ "api": false,
+ "consumerOnly": false,
+ "producerOnly": false,
+ "lenientProperties": true
+ },
+ "componentProperties": {
+ "routeProperties": { "kind": "property", "displayName": "Route Properties", "group": "common", "label": "", "required": false, "type": "object", "javaType": "java.util.Map<java.lang.String, java.util.Properties>", "deprecated": false, "autowired": false, "secret": false, "description": "Set route local parameters." },
+ "templateProperties": { "kind": "property", "displayName": "Template Properties", "group": "common", "label": "", "required": false, "type": "object", "javaType": "java.util.Map<java.lang.String, java.util.Properties>", "deprecated": false, "autowired": false, "secret": false, "description": "Set template local parameters." },
+ "bridgeErrorHandler": { "kind": "property", "displayName": "Bridge Error Handler", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": 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 me [...]
+ "block": { "kind": "property", "displayName": "Block", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "If sending a message to a kamelet endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active." },
+ "lazyStartProducer": { "kind": "property", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during star [...]
+ "timeout": { "kind": "property", "displayName": "Timeout", "group": "producer", "label": "producer", "required": false, "type": "integer", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 30000, "description": "The timeout value to use if block is enabled." },
+ "autowiredEnabled": { "kind": "property", "displayName": "Autowired Enabled", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which t [...]
+ },
+ "properties": {
+ "templateId": { "kind": "path", "displayName": "Template Id", "group": "common", "label": "", "required": true, "type": "string", "javaType": "java.lang.String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "The Route Template ID" },
+ "routeId": { "kind": "path", "displayName": "Route Id", "group": "common", "label": "", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "The Route ID. Default value notice: The ID will be auto-generated if not provided" },
+ "bridgeErrorHandler": { "kind": "parameter", "displayName": "Bridge Error Handler", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": 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 m [...]
+ "exceptionHandler": { "kind": "parameter", "displayName": "Exception Handler", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.apache.camel.spi.ExceptionHandler", "optionalPrefix": "consumer.", "deprecated": false, "autowired": false, "secret": false, "description": "To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the con [...]
+ "exchangePattern": { "kind": "parameter", "displayName": "Exchange Pattern", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.apache.camel.ExchangePattern", "enum": [ "InOnly", "InOut", "InOptionalOut" ], "deprecated": false, "autowired": false, "secret": false, "description": "Sets the exchange pattern when the consumer creates an exchange." },
+ "block": { "kind": "parameter", "displayName": "Block", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active." },
+ "failIfNoConsumers": { "kind": "parameter", "displayName": "Fail If No Consumers", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether the producer should fail by throwing an exception, when sending to a kamelet endpoint with no active consumers." },
+ "lazyStartProducer": { "kind": "parameter", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during sta [...]
+ "timeout": { "kind": "parameter", "displayName": "Timeout", "group": "producer", "label": "producer", "required": false, "type": "integer", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 30000, "description": "The timeout value to use if block is enabled." }
+ }
+}
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs.properties b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs.properties
index 76df481..86272f3 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs.properties
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs.properties
@@ -285,6 +285,7 @@ jsonpath-language
jt400-component
jta
kafka-component
+kamelet-component
kubernetes-config-maps-component
kubernetes-custom-resources-component
kubernetes-deployments-component
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/kamelet-component.adoc b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/kamelet-component.adoc
new file mode 100644
index 0000000..ae93369
--- /dev/null
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/docs/kamelet-component.adoc
@@ -0,0 +1,144 @@
+[[kamelet-component]]
+= Kamelet Component
+:docTitle: Kamelet
+:artifactId: camel-kamelet
+:description: The Kamelet Component provides support for interacting with the Camel Route Template engine
+:since: 3.8
+:supportLevel: Preview
+:component-header: Both producer and consumer are supported
+:core:
+include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kamelet.adoc[opts=optional]
+
+*Since Camel {since}*
+
+*{component-header}*
+
+The Kamelet Component provides support for interacting with the xref:manual::route-template.adoc[Camel Route Template] engine using Endpoint semantic.
+
+== URI format
+
+[source]
+----
+kamelet:templateId/routeId[?options]
+----
+
+== Options
+
+
+
+// component options: START
+The Kamelet component supports 7 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *routeProperties* (common) | Set route local parameters. | | Map
+| *templateProperties* (common) | Set template local parameters. | | Map
+| *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
+| *block* (producer) | If sending a message to a kamelet endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
+| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
+| *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | boolean
+|===
+// component options: END
+
+
+
+
+// endpoint options: START
+The Kamelet endpoint is configured using URI syntax:
+
+----
+kamelet:templateId/routeId
+----
+
+with the following path and query parameters:
+
+=== Path Parameters (2 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *templateId* | *Required* The Route Template ID | | String
+| *routeId* | The Route ID. Default value notice: The ID will be auto-generated if not provided | | String
+|===
+
+
+=== Query Parameters (7 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| 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
+| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. | | ExceptionHandler
+| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
+| *block* (producer) | If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
+| *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a kamelet endpoint with no active consumers. | true | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
+| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
+|===
+// endpoint options: END
+
+[NOTE]
+====
+The *kamelet* endpoint is *lenient*, which means that the endpoint accepts additional parameters that are passed to the ROute Templkate engine and consumed upon route materialization.
+====
+
+== Samples
+
+
+Kamelets can be used as if they were standard Camel components.
+For example, suppose that we have created a Route Template as follows:
+
+[source,java]
+----
+routeTemplate("setMyBody")
+ .templateParameter("bodyValue")
+ .from("kamelet:source")
+ .setBody().constant("{{bodyValue}}");
+----
+
+[IMPORTANT]
+====
+To let the *Kamelet* component wiring the materialized route to the caller processor, we need to be able to identify the input and output endpoint of the route and this is done by using `kamele:source` to mark the input endpoint and `kamelet:sink` for the output endpoint.
+====
+
+Then the template can be instantiated and invoked as shown below:
+
+[source,java]
+----
+from("direct:setMyBody")
+ .to("kamelet:setMyBody?bodyValue=myKamelet");
+----
+
+
+Behind the scenes, the *Kamelet* component does the following things:
+
+1. it instantiates a route out of the Route Template identified by the given `templateId` path parameter (in this case `setBody`)
+2. it will act like the `direct` component and connect the current route to the materialized one.
+
+If you had to do it programmatically, it would have been something like:
+
+[source,java]
+----
+routeTemplate("setMyBody")
+ .templateParameter("bodyValue")
+ .from("direct:{{foo}}")
+ .setBody().constant("{{bodyValue}}");
+
+TemplatedRouteBuilder.builder(context, "setMyBody")
+ .parameter("foo", "bar")
+ .parameter("bodyValue", "myKamelet")
+ .add();
+
+from("direct:template")
+ .to("direct:bar");
+
+----
+
+
+//include::camel-spring-boot::page$kamelet-starter.adoc[]
diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
index 2167e5e..efd3087 100644
--- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
+++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/schemas/camel-spring.xsd
@@ -2609,6 +2609,14 @@ this and can report the Camel application as DOWN. Default value: false
]]></xs:documentation>
</xs:annotation>
</xs:attribute>
+ <xs:attribute name="loggingLevel" type="xs:string">
+ <xs:annotation>
+ <xs:documentation xml:lang="en"><![CDATA[
+Sets the logging level used for logging route activity (such as starting and
+stopping routes). The default logging level is DEBUG. Default value: DEBUG
+ ]]></xs:documentation>
+ </xs:annotation>
+ </xs:attribute>
</xs:extension>
</xs:complexContent>
</xs:complexType>
diff --git a/components/camel-kamelet/pom.xml b/components/camel-kamelet/pom.xml
new file mode 100644
index 0000000..6faed33
--- /dev/null
+++ b/components/camel-kamelet/pom.xml
@@ -0,0 +1,89 @@
+<?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/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>components</artifactId>
+ <version>3.8.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>camel-kamelet</artifactId>
+ <packaging>jar</packaging>
+
+ <name>Camel :: Kamelet</name>
+ <description>The Kamelet Component provides support for interacting with the Camel Route Template engine</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-support</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-core-model</artifactId>
+ </dependency>
+
+ <!-- TESTS -->
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-timer</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-log</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-mock</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-direct</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-test-junit5</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-http</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.assertj</groupId>
+ <artifactId>assertj-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-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletComponentConfigurer.java b/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletComponentConfigurer.java
new file mode 100644
index 0000000..238976e
--- /dev/null
+++ b/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletComponentConfigurer.java
@@ -0,0 +1,90 @@
+/* Generated by camel build tools - do NOT edit this file! */
+package org.apache.camel.component.kamelet;
+
+import java.util.Map;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.spi.ExtendedPropertyConfigurerGetter;
+import org.apache.camel.spi.PropertyConfigurerGetter;
+import org.apache.camel.spi.ConfigurerStrategy;
+import org.apache.camel.spi.GeneratedPropertyConfigurer;
+import org.apache.camel.util.CaseInsensitiveMap;
+import org.apache.camel.support.component.PropertyConfigurerSupport;
+
+/**
+ * Generated by camel build tools - do NOT edit this file!
+ */
+@SuppressWarnings("unchecked")
+public class KameletComponentConfigurer extends PropertyConfigurerSupport implements GeneratedPropertyConfigurer, PropertyConfigurerGetter {
+
+ @Override
+ public boolean configure(CamelContext camelContext, Object obj, String name, Object value, boolean ignoreCase) {
+ KameletComponent target = (KameletComponent) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "autowiredenabled":
+ case "autowiredEnabled": target.setAutowiredEnabled(property(camelContext, boolean.class, value)); return true;
+ case "block": target.setBlock(property(camelContext, boolean.class, value)); return true;
+ case "bridgeerrorhandler":
+ case "bridgeErrorHandler": target.setBridgeErrorHandler(property(camelContext, boolean.class, value)); return true;
+ case "lazystartproducer":
+ case "lazyStartProducer": target.setLazyStartProducer(property(camelContext, boolean.class, value)); return true;
+ case "routeproperties":
+ case "routeProperties": target.setRouteProperties(property(camelContext, java.util.Map.class, value)); return true;
+ case "templateproperties":
+ case "templateProperties": target.setTemplateProperties(property(camelContext, java.util.Map.class, value)); return true;
+ case "timeout": target.setTimeout(property(camelContext, long.class, value)); return true;
+ default: return false;
+ }
+ }
+
+ @Override
+ public Class<?> getOptionType(String name, boolean ignoreCase) {
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "autowiredenabled":
+ case "autowiredEnabled": return boolean.class;
+ case "block": return boolean.class;
+ case "bridgeerrorhandler":
+ case "bridgeErrorHandler": return boolean.class;
+ case "lazystartproducer":
+ case "lazyStartProducer": return boolean.class;
+ case "routeproperties":
+ case "routeProperties": return java.util.Map.class;
+ case "templateproperties":
+ case "templateProperties": return java.util.Map.class;
+ case "timeout": return long.class;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object getOptionValue(Object obj, String name, boolean ignoreCase) {
+ KameletComponent target = (KameletComponent) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "autowiredenabled":
+ case "autowiredEnabled": return target.isAutowiredEnabled();
+ case "block": return target.isBlock();
+ case "bridgeerrorhandler":
+ case "bridgeErrorHandler": return target.isBridgeErrorHandler();
+ case "lazystartproducer":
+ case "lazyStartProducer": return target.isLazyStartProducer();
+ case "routeproperties":
+ case "routeProperties": return target.getRouteProperties();
+ case "templateproperties":
+ case "templateProperties": return target.getTemplateProperties();
+ case "timeout": return target.getTimeout();
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object getCollectionValueType(Object target, String name, boolean ignoreCase) {
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "routeproperties":
+ case "routeProperties": return java.util.Properties.class;
+ case "templateproperties":
+ case "templateProperties": return java.util.Properties.class;
+ default: return null;
+ }
+ }
+}
+
diff --git a/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletEndpointConfigurer.java b/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletEndpointConfigurer.java
new file mode 100644
index 0000000..19bd60f
--- /dev/null
+++ b/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletEndpointConfigurer.java
@@ -0,0 +1,79 @@
+/* Generated by camel build tools - do NOT edit this file! */
+package org.apache.camel.component.kamelet;
+
+import java.util.Map;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.spi.ExtendedPropertyConfigurerGetter;
+import org.apache.camel.spi.PropertyConfigurerGetter;
+import org.apache.camel.spi.ConfigurerStrategy;
+import org.apache.camel.spi.GeneratedPropertyConfigurer;
+import org.apache.camel.util.CaseInsensitiveMap;
+import org.apache.camel.support.component.PropertyConfigurerSupport;
+
+/**
+ * Generated by camel build tools - do NOT edit this file!
+ */
+@SuppressWarnings("unchecked")
+public class KameletEndpointConfigurer extends PropertyConfigurerSupport implements GeneratedPropertyConfigurer, PropertyConfigurerGetter {
+
+ @Override
+ public boolean configure(CamelContext camelContext, Object obj, String name, Object value, boolean ignoreCase) {
+ KameletEndpoint target = (KameletEndpoint) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "block": target.setBlock(property(camelContext, boolean.class, value)); return true;
+ case "bridgeerrorhandler":
+ case "bridgeErrorHandler": target.setBridgeErrorHandler(property(camelContext, boolean.class, value)); return true;
+ case "exceptionhandler":
+ case "exceptionHandler": target.setExceptionHandler(property(camelContext, org.apache.camel.spi.ExceptionHandler.class, value)); return true;
+ case "exchangepattern":
+ case "exchangePattern": target.setExchangePattern(property(camelContext, org.apache.camel.ExchangePattern.class, value)); return true;
+ case "failifnoconsumers":
+ case "failIfNoConsumers": target.setFailIfNoConsumers(property(camelContext, boolean.class, value)); return true;
+ case "lazystartproducer":
+ case "lazyStartProducer": target.setLazyStartProducer(property(camelContext, boolean.class, value)); return true;
+ case "timeout": target.setTimeout(property(camelContext, long.class, value)); return true;
+ default: return false;
+ }
+ }
+
+ @Override
+ public Class<?> getOptionType(String name, boolean ignoreCase) {
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "block": return boolean.class;
+ case "bridgeerrorhandler":
+ case "bridgeErrorHandler": return boolean.class;
+ case "exceptionhandler":
+ case "exceptionHandler": return org.apache.camel.spi.ExceptionHandler.class;
+ case "exchangepattern":
+ case "exchangePattern": return org.apache.camel.ExchangePattern.class;
+ case "failifnoconsumers":
+ case "failIfNoConsumers": return boolean.class;
+ case "lazystartproducer":
+ case "lazyStartProducer": return boolean.class;
+ case "timeout": return long.class;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object getOptionValue(Object obj, String name, boolean ignoreCase) {
+ KameletEndpoint target = (KameletEndpoint) obj;
+ switch (ignoreCase ? name.toLowerCase() : name) {
+ case "block": return target.isBlock();
+ case "bridgeerrorhandler":
+ case "bridgeErrorHandler": return target.isBridgeErrorHandler();
+ case "exceptionhandler":
+ case "exceptionHandler": return target.getExceptionHandler();
+ case "exchangepattern":
+ case "exchangePattern": return target.getExchangePattern();
+ case "failifnoconsumers":
+ case "failIfNoConsumers": return target.isFailIfNoConsumers();
+ case "lazystartproducer":
+ case "lazyStartProducer": return target.isLazyStartProducer();
+ case "timeout": return target.getTimeout();
+ default: return null;
+ }
+ }
+}
+
diff --git a/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletEndpointUriFactory.java b/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletEndpointUriFactory.java
new file mode 100644
index 0000000..779ede4
--- /dev/null
+++ b/components/camel-kamelet/src/generated/java/org/apache/camel/component/kamelet/KameletEndpointUriFactory.java
@@ -0,0 +1,70 @@
+/* Generated by camel build tools - do NOT edit this file! */
+package org.apache.camel.component.kamelet;
+
+import java.net.URISyntaxException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.apache.camel.spi.EndpointUriFactory;
+
+/**
+ * Generated by camel build tools - do NOT edit this file!
+ */
+public class KameletEndpointUriFactory extends org.apache.camel.support.component.EndpointUriFactorySupport implements EndpointUriFactory {
+
+ private static final String BASE = ":templateId/routeId";
+
+ private static final Set<String> PROPERTY_NAMES;
+ private static final Set<String> SECRET_PROPERTY_NAMES;
+ static {
+ Set<String> props = new HashSet<>(9);
+ props.add("lazyStartProducer");
+ props.add("routeId");
+ props.add("bridgeErrorHandler");
+ props.add("exchangePattern");
+ props.add("failIfNoConsumers");
+ props.add("block");
+ props.add("templateId");
+ props.add("exceptionHandler");
+ props.add("timeout");
+ PROPERTY_NAMES = Collections.unmodifiableSet(props);
+ SECRET_PROPERTY_NAMES = Collections.emptySet();
+ }
+
+ @Override
+ public boolean isEnabled(String scheme) {
+ return "kamelet".equals(scheme);
+ }
+
+ @Override
+ public String buildUri(String scheme, Map<String, Object> properties, boolean encode) throws URISyntaxException {
+ String syntax = scheme + BASE;
+ String uri = syntax;
+
+ Map<String, Object> copy = new HashMap<>(properties);
+
+ uri = buildPathParameter(syntax, uri, "templateId", null, true, copy);
+ uri = buildPathParameter(syntax, uri, "routeId", null, false, copy);
+ uri = buildQueryParameters(uri, copy, encode);
+ return uri;
+ }
+
+ @Override
+ public Set<String> propertyNames() {
+ return PROPERTY_NAMES;
+ }
+
+ @Override
+ public Set<String> secretPropertyNames() {
+ return SECRET_PROPERTY_NAMES;
+ }
+
+ @Override
+ public boolean isLenientProperties() {
+ return true;
+ }
+}
+
diff --git a/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/component.properties b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/component.properties
new file mode 100644
index 0000000..68afd6b
--- /dev/null
+++ b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/component.properties
@@ -0,0 +1,7 @@
+# Generated by camel build tools - do NOT edit this file!
+components=kamelet
+groupId=org.apache.camel
+artifactId=camel-kamelet
+version=3.8.0-SNAPSHOT
+projectName=Camel :: Kamelet
+projectDescription=The Kamelet Component provides support for interacting with the Camel Route Template engine
diff --git a/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/component/kamelet b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/component/kamelet
new file mode 100644
index 0000000..be8044e
--- /dev/null
+++ b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/component/kamelet
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.component.kamelet.KameletComponent
diff --git a/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/configurer/kamelet-component b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/configurer/kamelet-component
new file mode 100644
index 0000000..88d3725
--- /dev/null
+++ b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/configurer/kamelet-component
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.component.kamelet.KameletComponentConfigurer
diff --git a/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/configurer/kamelet-endpoint b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/configurer/kamelet-endpoint
new file mode 100644
index 0000000..17182a5
--- /dev/null
+++ b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/configurer/kamelet-endpoint
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.component.kamelet.KameletEndpointConfigurer
diff --git a/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/urifactory/kamelet-endpoint b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/urifactory/kamelet-endpoint
new file mode 100644
index 0000000..384cf39
--- /dev/null
+++ b/components/camel-kamelet/src/generated/resources/META-INF/services/org/apache/camel/urifactory/kamelet-endpoint
@@ -0,0 +1,2 @@
+# Generated by camel build tools - do NOT edit this file!
+class=org.apache.camel.component.kamelet.KameletEndpointUriFactory
diff --git a/components/camel-kamelet/src/generated/resources/org/apache/camel/component/kamelet/kamelet.json b/components/camel-kamelet/src/generated/resources/org/apache/camel/component/kamelet/kamelet.json
new file mode 100644
index 0000000..bd9d1db
--- /dev/null
+++ b/components/camel-kamelet/src/generated/resources/org/apache/camel/component/kamelet/kamelet.json
@@ -0,0 +1,44 @@
+{
+ "component": {
+ "kind": "component",
+ "name": "kamelet",
+ "title": "Kamelet",
+ "description": "The Kamelet Component provides support for interacting with the Camel Route Template engine",
+ "deprecated": false,
+ "firstVersion": "3.8.0",
+ "label": "core",
+ "javaType": "org.apache.camel.component.kamelet.KameletComponent",
+ "supportLevel": "Preview",
+ "groupId": "org.apache.camel",
+ "artifactId": "camel-kamelet",
+ "version": "3.8.0-SNAPSHOT",
+ "scheme": "kamelet",
+ "extendsScheme": "",
+ "syntax": "kamelet:templateId\/routeId",
+ "async": false,
+ "api": false,
+ "consumerOnly": false,
+ "producerOnly": false,
+ "lenientProperties": true
+ },
+ "componentProperties": {
+ "routeProperties": { "kind": "property", "displayName": "Route Properties", "group": "common", "label": "", "required": false, "type": "object", "javaType": "java.util.Map<java.lang.String, java.util.Properties>", "deprecated": false, "autowired": false, "secret": false, "description": "Set route local parameters." },
+ "templateProperties": { "kind": "property", "displayName": "Template Properties", "group": "common", "label": "", "required": false, "type": "object", "javaType": "java.util.Map<java.lang.String, java.util.Properties>", "deprecated": false, "autowired": false, "secret": false, "description": "Set template local parameters." },
+ "bridgeErrorHandler": { "kind": "property", "displayName": "Bridge Error Handler", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": 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 me [...]
+ "block": { "kind": "property", "displayName": "Block", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "If sending a message to a kamelet endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active." },
+ "lazyStartProducer": { "kind": "property", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during star [...]
+ "timeout": { "kind": "property", "displayName": "Timeout", "group": "producer", "label": "producer", "required": false, "type": "integer", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 30000, "description": "The timeout value to use if block is enabled." },
+ "autowiredEnabled": { "kind": "property", "displayName": "Autowired Enabled", "group": "advanced", "label": "advanced", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which t [...]
+ },
+ "properties": {
+ "templateId": { "kind": "path", "displayName": "Template Id", "group": "common", "label": "", "required": true, "type": "string", "javaType": "java.lang.String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "The Route Template ID" },
+ "routeId": { "kind": "path", "displayName": "Route Id", "group": "common", "label": "", "required": false, "type": "string", "javaType": "java.lang.String", "deprecated": false, "deprecationNote": "", "autowired": false, "secret": false, "description": "The Route ID. Default value notice: The ID will be auto-generated if not provided" },
+ "bridgeErrorHandler": { "kind": "parameter", "displayName": "Bridge Error Handler", "group": "consumer", "label": "consumer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": 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 m [...]
+ "exceptionHandler": { "kind": "parameter", "displayName": "Exception Handler", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.apache.camel.spi.ExceptionHandler", "optionalPrefix": "consumer.", "deprecated": false, "autowired": false, "secret": false, "description": "To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the con [...]
+ "exchangePattern": { "kind": "parameter", "displayName": "Exchange Pattern", "group": "consumer (advanced)", "label": "consumer,advanced", "required": false, "type": "object", "javaType": "org.apache.camel.ExchangePattern", "enum": [ "InOnly", "InOut", "InOptionalOut" ], "deprecated": false, "autowired": false, "secret": false, "description": "Sets the exchange pattern when the consumer creates an exchange." },
+ "block": { "kind": "parameter", "displayName": "Block", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active." },
+ "failIfNoConsumers": { "kind": "parameter", "displayName": "Fail If No Consumers", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": true, "description": "Whether the producer should fail by throwing an exception, when sending to a kamelet endpoint with no active consumers." },
+ "lazyStartProducer": { "kind": "parameter", "displayName": "Lazy Start Producer", "group": "producer", "label": "producer", "required": false, "type": "boolean", "javaType": "boolean", "deprecated": false, "autowired": false, "secret": false, "defaultValue": false, "description": "Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during sta [...]
+ "timeout": { "kind": "parameter", "displayName": "Timeout", "group": "producer", "label": "producer", "required": false, "type": "integer", "javaType": "long", "deprecated": false, "autowired": false, "secret": false, "defaultValue": 30000, "description": "The timeout value to use if block is enabled." }
+ }
+}
diff --git a/components/camel-kamelet/src/main/docs/kamelet-component.adoc b/components/camel-kamelet/src/main/docs/kamelet-component.adoc
new file mode 100644
index 0000000..ae93369
--- /dev/null
+++ b/components/camel-kamelet/src/main/docs/kamelet-component.adoc
@@ -0,0 +1,144 @@
+[[kamelet-component]]
+= Kamelet Component
+:docTitle: Kamelet
+:artifactId: camel-kamelet
+:description: The Kamelet Component provides support for interacting with the Camel Route Template engine
+:since: 3.8
+:supportLevel: Preview
+:component-header: Both producer and consumer are supported
+:core:
+include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kamelet.adoc[opts=optional]
+
+*Since Camel {since}*
+
+*{component-header}*
+
+The Kamelet Component provides support for interacting with the xref:manual::route-template.adoc[Camel Route Template] engine using Endpoint semantic.
+
+== URI format
+
+[source]
+----
+kamelet:templateId/routeId[?options]
+----
+
+== Options
+
+
+
+// component options: START
+The Kamelet component supports 7 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *routeProperties* (common) | Set route local parameters. | | Map
+| *templateProperties* (common) | Set template local parameters. | | Map
+| *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
+| *block* (producer) | If sending a message to a kamelet endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
+| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
+| *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | boolean
+|===
+// component options: END
+
+
+
+
+// endpoint options: START
+The Kamelet endpoint is configured using URI syntax:
+
+----
+kamelet:templateId/routeId
+----
+
+with the following path and query parameters:
+
+=== Path Parameters (2 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *templateId* | *Required* The Route Template ID | | String
+| *routeId* | The Route ID. Default value notice: The ID will be auto-generated if not provided | | String
+|===
+
+
+=== Query Parameters (7 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| 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
+| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. | | ExceptionHandler
+| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
+| *block* (producer) | If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
+| *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a kamelet endpoint with no active consumers. | true | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
+| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
+|===
+// endpoint options: END
+
+[NOTE]
+====
+The *kamelet* endpoint is *lenient*, which means that the endpoint accepts additional parameters that are passed to the ROute Templkate engine and consumed upon route materialization.
+====
+
+== Samples
+
+
+Kamelets can be used as if they were standard Camel components.
+For example, suppose that we have created a Route Template as follows:
+
+[source,java]
+----
+routeTemplate("setMyBody")
+ .templateParameter("bodyValue")
+ .from("kamelet:source")
+ .setBody().constant("{{bodyValue}}");
+----
+
+[IMPORTANT]
+====
+To let the *Kamelet* component wiring the materialized route to the caller processor, we need to be able to identify the input and output endpoint of the route and this is done by using `kamele:source` to mark the input endpoint and `kamelet:sink` for the output endpoint.
+====
+
+Then the template can be instantiated and invoked as shown below:
+
+[source,java]
+----
+from("direct:setMyBody")
+ .to("kamelet:setMyBody?bodyValue=myKamelet");
+----
+
+
+Behind the scenes, the *Kamelet* component does the following things:
+
+1. it instantiates a route out of the Route Template identified by the given `templateId` path parameter (in this case `setBody`)
+2. it will act like the `direct` component and connect the current route to the materialized one.
+
+If you had to do it programmatically, it would have been something like:
+
+[source,java]
+----
+routeTemplate("setMyBody")
+ .templateParameter("bodyValue")
+ .from("direct:{{foo}}")
+ .setBody().constant("{{bodyValue}}");
+
+TemplatedRouteBuilder.builder(context, "setMyBody")
+ .parameter("foo", "bar")
+ .parameter("bodyValue", "myKamelet")
+ .add();
+
+from("direct:template")
+ .to("direct:bar");
+
+----
+
+
+//include::camel-spring-boot::page$kamelet-starter.adoc[]
diff --git a/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/Kamelet.java b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/Kamelet.java
new file mode 100644
index 0000000..5428e2a
--- /dev/null
+++ b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/Kamelet.java
@@ -0,0 +1,132 @@
+/*
+ * 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.kamelet;
+
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Properties;
+import java.util.function.Predicate;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.model.FromDefinition;
+import org.apache.camel.model.RouteDefinition;
+import org.apache.camel.model.RouteTemplateDefinition;
+import org.apache.camel.model.ToDefinition;
+import org.apache.camel.spi.PropertiesComponent;
+import org.apache.camel.support.CamelContextHelper;
+import org.apache.camel.util.ObjectHelper;
+import org.apache.camel.util.StringHelper;
+
+import static org.apache.camel.model.ProcessorDefinitionHelper.filterTypeInOutputs;
+
+public final class Kamelet {
+ public static final String PROPERTIES_PREFIX = "camel.kamelet.";
+ public static final String SCHEME = "kamelet";
+ public static final String SOURCE_ID = "source";
+ public static final String SINK_ID = "sink";
+ public static final String PARAM_ROUTE_ID = "routeId";
+ public static final String PARAM_TEMPLATE_ID = "templateId";
+
+ private Kamelet() {
+ }
+
+ public static Predicate<String> startsWith(String prefix) {
+ return item -> item.startsWith(prefix);
+ }
+
+ public static String extractTemplateId(CamelContext context, String remaining, Map<String, Object> parameters) {
+ Object param = parameters.get(PARAM_TEMPLATE_ID);
+ if (param != null) {
+ return CamelContextHelper.mandatoryConvertTo(context, String.class, param);
+ }
+
+ if (SOURCE_ID.equals(remaining) || SINK_ID.equals(remaining)) {
+ return context.resolvePropertyPlaceholders("{{" + PARAM_TEMPLATE_ID + "}}");
+ }
+
+ String answer = StringHelper.before(remaining, "/");
+ if (answer == null) {
+ answer = remaining;
+ }
+
+ return answer;
+ }
+
+ public static String extractRouteId(CamelContext context, String remaining, Map<String, Object> parameters) {
+ Object param = parameters.get(PARAM_ROUTE_ID);
+ if (param != null) {
+ return CamelContextHelper.mandatoryConvertTo(context, String.class, param);
+ }
+
+ if (SOURCE_ID.equals(remaining) || SINK_ID.equals(remaining)) {
+ return context.resolvePropertyPlaceholders("{{" + PARAM_ROUTE_ID + "}}");
+ }
+
+ String answer = StringHelper.after(remaining, "/");
+ if (answer == null) {
+ answer = extractTemplateId(context, remaining, parameters) + "-" + context.getUuidGenerator().generateUuid();
+ }
+
+ return answer;
+ }
+
+ public static void extractKameletProperties(CamelContext context, Map<String, Object> properties, String... elements) {
+ PropertiesComponent pc = context.getPropertiesComponent();
+ String prefix = Kamelet.PROPERTIES_PREFIX;
+
+ for (String element : elements) {
+ if (element == null) {
+ continue;
+ }
+
+ prefix = prefix + element + ".";
+
+ Properties prefixed = pc.loadProperties(Kamelet.startsWith(prefix));
+ for (String name : prefixed.stringPropertyNames()) {
+ properties.put(name.substring(prefix.length()), prefixed.getProperty(name));
+ }
+ }
+ }
+
+ public static RouteDefinition templateToRoute(RouteTemplateDefinition in, Map<String, Object> parameters) {
+ final String rid = (String) parameters.get(PARAM_ROUTE_ID);
+ final String tid = (String) parameters.get(PARAM_TEMPLATE_ID);
+
+ ObjectHelper.notNull(rid, PARAM_ROUTE_ID);
+ ObjectHelper.notNull(tid, PARAM_TEMPLATE_ID);
+
+ RouteDefinition def = in.asRouteDefinition();
+ def.setId(rid);
+
+ // must make the source and sink endpoints are unique by appending the route id before we create the route from the template
+ if (def.getInput().getEndpointUri().startsWith("kamelet:source")
+ || def.getInput().getEndpointUri().startsWith("kamelet://source")) {
+ def.setInput(null);
+ def.setInput(new FromDefinition("kamelet:source?" + PARAM_ROUTE_ID + "=" + rid));
+ }
+
+ Iterator<ToDefinition> it = filterTypeInOutputs(def.getOutputs(), ToDefinition.class);
+ while (it.hasNext()) {
+ ToDefinition to = it.next();
+ if (to.getEndpointUri().startsWith("kamelet:sink") || to.getEndpointUri().startsWith("kamelet://sink")) {
+ to.setUri("kamelet:sink?" + PARAM_ROUTE_ID + "=" + rid);
+ }
+ }
+
+ return def;
+ }
+}
diff --git a/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletComponent.java b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletComponent.java
new file mode 100644
index 0000000..65b9524
--- /dev/null
+++ b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletComponent.java
@@ -0,0 +1,382 @@
+/*
+ * 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.kamelet;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Endpoint;
+import org.apache.camel.RuntimeCamelException;
+import org.apache.camel.VetoCamelContextStartException;
+import org.apache.camel.model.ModelCamelContext;
+import org.apache.camel.model.RouteDefinition;
+import org.apache.camel.spi.Metadata;
+import org.apache.camel.spi.annotations.Component;
+import org.apache.camel.support.DefaultComponent;
+import org.apache.camel.support.LifecycleStrategySupport;
+import org.apache.camel.support.service.ServiceHelper;
+import org.apache.camel.util.StopWatch;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import static org.apache.camel.component.kamelet.Kamelet.PARAM_ROUTE_ID;
+import static org.apache.camel.component.kamelet.Kamelet.PARAM_TEMPLATE_ID;
+
+/**
+ * The Kamelet Component provides support for materializing routes templates.
+ */
+@Component(Kamelet.SCHEME)
+public class KameletComponent extends DefaultComponent {
+ private static final Logger LOGGER = LoggerFactory.getLogger(KameletComponent.class);
+
+ // active consumers
+ private final Map<String, KameletConsumer> consumers = new HashMap<>();
+ private final LifecycleHandler lifecycleHandler = new LifecycleHandler();
+
+ // counter that is used for producers to keep track if any consumer was added/removed since they last checked
+ // this is used for optimization to avoid each producer to get consumer for each message processed
+ // (locking via synchronized, and then lookup in the map as the cost)
+ // consumers and producers are only added/removed during startup/shutdown or if routes is manually controlled
+ private volatile int stateCounter;
+
+ @Metadata(label = "producer", defaultValue = "true")
+ private boolean block = true;
+ @Metadata(label = "producer", defaultValue = "30000")
+ private long timeout = 30000L;
+
+ @Metadata
+ private Map<String, Properties> templateProperties;
+ @Metadata
+ private Map<String, Properties> routeProperties;
+
+ public KameletComponent() {
+ }
+
+ @Override
+ protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
+ final String templateId = Kamelet.extractTemplateId(getCamelContext(), remaining, parameters);
+ final String routeId = Kamelet.extractRouteId(getCamelContext(), remaining, parameters);
+
+ parameters.remove(PARAM_TEMPLATE_ID);
+ parameters.remove(PARAM_ROUTE_ID);
+
+ final KameletEndpoint endpoint;
+
+ if (Kamelet.SOURCE_ID.equals(remaining) || Kamelet.SINK_ID.equals(remaining)) {
+ //
+ // if remaining is either `source` or `sink' then it is a virtual
+ // endpoint that is used inside the kamelet definition to mark it
+ // as in/out endpoint.
+ //
+ // The following snippet defines a template which will act as a
+ // consumer for this Kamelet:
+ //
+ // from("kamelet:source")
+ // .to("log:info")
+ //
+ // The following snippet defines a template which will act as a
+ // producer for this Kamelet:
+ //
+ // from("telegram:bots")
+ // .to("kamelet:sink")
+ //
+ // Note that at the moment, there's no enforcement around `source`
+ // and `sink' to be defined on the right side (producer or consumer)
+ //
+ endpoint = new KameletEndpoint(uri, this, templateId, routeId);
+
+ // forward component properties
+ endpoint.setBlock(block);
+ endpoint.setTimeout(timeout);
+
+ // set endpoint specific properties
+ setProperties(endpoint, parameters);
+ } else {
+ endpoint = new KameletEndpoint(uri, this, templateId, routeId) {
+ @Override
+ protected void doInit() throws Exception {
+ super.doInit();
+ //
+ // since this is the real kamelet, then we need to hand it
+ // over to the tracker.
+ //
+ lifecycleHandler.track(this);
+ }
+ };
+
+ // forward component properties
+ endpoint.setBlock(block);
+ endpoint.setTimeout(timeout);
+
+ // set and remove endpoint specific properties
+ setProperties(endpoint, parameters);
+
+ Map<String, Object> kameletProperties = new HashMap<>();
+
+ //
+ // Load properties from the component configuration. Template and route specific properties
+ // can be set through properties, as example:
+ //
+ // camel.component.kamelet.template-properties[templateId].key = val
+ // camel.component.kamelet.route-properties[templateId].key = val
+ //
+ if (templateProperties != null) {
+ Properties props = templateProperties.get(routeId);
+ if (props != null) {
+ props.stringPropertyNames().forEach(name -> kameletProperties.put(name, props.get(name)));
+ }
+ }
+ if (routeProperties != null) {
+ Properties props = routeProperties.get(routeId);
+ if (props != null) {
+ props.stringPropertyNames().forEach(name -> kameletProperties.put(name, props.get(name)));
+ }
+ }
+
+ //
+ // We can't mix configuration styles so if properties are not configured through the component,
+ // then fallback to the old - deprecated - style.
+ //
+ if (kameletProperties.isEmpty()) {
+ //
+ // The properties for the kamelets are determined by global properties
+ // and local endpoint parameters,
+ //
+ // Global parameters are loaded in the following order:
+ //
+ // camel.kamelet." + templateId
+ // camel.kamelet." + templateId + "." routeId
+ //
+ Kamelet.extractKameletProperties(getCamelContext(), kameletProperties, templateId, routeId);
+ }
+
+ //
+ // Uri params have the highest precedence
+ //
+ kameletProperties.putAll(parameters);
+
+ //
+ // And finally we have some specific properties that cannot be changed by the user.
+ //
+ kameletProperties.put(PARAM_TEMPLATE_ID, templateId);
+ kameletProperties.put(PARAM_ROUTE_ID, routeId);
+
+ // set kamelet specific properties
+ endpoint.setKameletProperties(kameletProperties);
+
+ //
+ // Add a custom converter to convert a RouteTemplateDefinition to a RouteDefinition
+ // and make sure consumerU URIs are unique.
+ //
+ getCamelContext().adapt(ModelCamelContext.class).addRouteTemplateDefinitionConverter(
+ templateId,
+ Kamelet::templateToRoute);
+ }
+
+ return endpoint;
+ }
+
+ @Override
+ protected boolean resolveRawParameterValues() {
+ return false;
+ }
+
+ public boolean isBlock() {
+ return block;
+ }
+
+ /**
+ * If sending a message to a kamelet endpoint which has no active consumer, then we can tell the producer to block
+ * and wait for the consumer to become active.
+ */
+ public void setBlock(boolean block) {
+ this.block = block;
+ }
+
+ public long getTimeout() {
+ return timeout;
+ }
+
+ /**
+ * The timeout value to use if block is enabled.
+ */
+ public void setTimeout(long timeout) {
+ this.timeout = timeout;
+ }
+
+ public Map<String, Properties> getTemplateProperties() {
+ return templateProperties;
+ }
+
+ /**
+ * Set template local parameters.
+ */
+ public void setTemplateProperties(Map<String, Properties> templateProperties) {
+ this.templateProperties = templateProperties;
+ }
+
+ public Map<String, Properties> getRouteProperties() {
+ return routeProperties;
+ }
+
+ /**
+ * Set route local parameters.
+ */
+ public void setRouteProperties(Map<String, Properties> routeProperties) {
+ this.routeProperties = routeProperties;
+ }
+
+ int getStateCounter() {
+ return stateCounter;
+ }
+
+ public void addConsumer(String key, KameletConsumer consumer) {
+ synchronized (consumers) {
+ if (consumers.putIfAbsent(key, consumer) != null) {
+ throw new IllegalArgumentException(
+ "Cannot add a 2nd consumer to the same endpoint: " + key
+ + ". KameletEndpoint only allows one consumer.");
+ }
+ // state changed so inc counter
+ stateCounter++;
+ consumers.notifyAll();
+ }
+ }
+
+ public void removeConsumer(String key, KameletConsumer consumer) {
+ synchronized (consumers) {
+ consumers.remove(key, consumer);
+ // state changed so inc counter
+ stateCounter++;
+ consumers.notifyAll();
+ }
+ }
+
+ protected KameletConsumer getConsumer(String key, boolean block, long timeout) throws InterruptedException {
+ synchronized (consumers) {
+ KameletConsumer answer = consumers.get(key);
+ if (answer == null && block) {
+ StopWatch watch = new StopWatch();
+ for (;;) {
+ answer = consumers.get(key);
+ if (answer != null) {
+ break;
+ }
+ long rem = timeout - watch.taken();
+ if (rem <= 0) {
+ break;
+ }
+ consumers.wait(rem);
+ }
+ }
+ return answer;
+ }
+ }
+
+ @Override
+ protected void doInit() throws Exception {
+ getCamelContext().addLifecycleStrategy(lifecycleHandler);
+
+ if (getCamelContext().isRunAllowed()) {
+ lifecycleHandler.setInitialized(true);
+ }
+
+ super.doInit();
+ }
+
+ @Override
+ protected void doShutdown() throws Exception {
+ getCamelContext().getLifecycleStrategies().remove(lifecycleHandler);
+
+ ServiceHelper.stopAndShutdownService(consumers);
+ consumers.clear();
+ super.doShutdown();
+ }
+
+ /*
+ * This LifecycleHandler is used to keep track of created kamelet endpoints during startup as
+ * we need to defer create routes from templates until camel context has finished loading
+ * all routes and whatnot.
+ *
+ * Once the camel context is initialized all the endpoint tracked by this LifecycleHandler will
+ * be used to create routes from templates.
+ */
+ private static class LifecycleHandler extends LifecycleStrategySupport {
+ private final List<KameletEndpoint> endpoints;
+ private final AtomicBoolean initialized;
+
+ public LifecycleHandler() {
+ this.endpoints = new ArrayList<>();
+ this.initialized = new AtomicBoolean();
+ }
+
+ public static void createRouteForEndpoint(KameletEndpoint endpoint) throws Exception {
+ LOGGER.debug("Creating route from template={} and id={}", endpoint.getTemplateId(), endpoint.getRouteId());
+
+ final ModelCamelContext context = endpoint.getCamelContext().adapt(ModelCamelContext.class);
+ final String id = context.addRouteFromTemplate(endpoint.getRouteId(), endpoint.getTemplateId(),
+ endpoint.getKameletProperties());
+ final RouteDefinition def = context.getRouteDefinition(id);
+
+ if (!def.isPrepared()) {
+ context.startRouteDefinitions(Collections.singletonList(def));
+ }
+
+ LOGGER.debug("Route with id={} created from template={}", id, endpoint.getTemplateId());
+ }
+
+ @Override
+ public void onContextInitialized(CamelContext context) throws VetoCamelContextStartException {
+ if (this.initialized.compareAndSet(false, true)) {
+ for (KameletEndpoint endpoint : endpoints) {
+ try {
+ createRouteForEndpoint(endpoint);
+ } catch (Exception e) {
+ throw new VetoCamelContextStartException(
+ "Failure creating route from template: " + endpoint.getTemplateId(), e, context);
+ }
+ }
+
+ endpoints.clear();
+ }
+ }
+
+ public void setInitialized(boolean initialized) {
+ this.initialized.set(initialized);
+ }
+
+ public void track(KameletEndpoint endpoint) {
+ if (this.initialized.get()) {
+ try {
+ createRouteForEndpoint(endpoint);
+ } catch (Exception e) {
+ throw RuntimeCamelException.wrapRuntimeException(e);
+ }
+ } else {
+ LOGGER.debug("Tracking route template={} and id={}", endpoint.getTemplateId(), endpoint.getRouteId());
+ this.endpoints.add(endpoint);
+ }
+ }
+ }
+
+}
diff --git a/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletConsumer.java b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletConsumer.java
new file mode 100644
index 0000000..15a02cd
--- /dev/null
+++ b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletConsumer.java
@@ -0,0 +1,83 @@
+/*
+ * 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.kamelet;
+
+import org.apache.camel.Processor;
+import org.apache.camel.ShutdownRunningTask;
+import org.apache.camel.Suspendable;
+import org.apache.camel.spi.ShutdownAware;
+import org.apache.camel.support.DefaultConsumer;
+
+final class KameletConsumer extends DefaultConsumer implements ShutdownAware, Suspendable {
+
+ private final KameletComponent component;
+ private final String key;
+
+ public KameletConsumer(KameletEndpoint endpoint, Processor processor, String key) {
+ super(endpoint, processor);
+ this.component = endpoint.getComponent();
+ this.key = key;
+ }
+
+ @Override
+ public KameletEndpoint getEndpoint() {
+ return (KameletEndpoint) super.getEndpoint();
+ }
+
+ @Override
+ protected void doStart() throws Exception {
+ super.doStart();
+ component.addConsumer(key, this);
+ }
+
+ @Override
+ protected void doStop() throws Exception {
+ component.removeConsumer(key, this);
+ super.doStop();
+ }
+
+ @Override
+ protected void doSuspend() throws Exception {
+ component.removeConsumer(key, this);
+ }
+
+ @Override
+ protected void doResume() throws Exception {
+ // resume by using the start logic
+ component.addConsumer(key, this);
+ }
+
+ @Override
+ public boolean deferShutdown(ShutdownRunningTask shutdownRunningTask) {
+ // deny stopping on shutdown as we want kamelet consumers to run in
+ // case some other queues depend on this consumer to run, so it can
+ // complete its exchanges
+ return true;
+ }
+
+ @Override
+ public int getPendingExchangesSize() {
+ // return 0 as we do not have an internal memory queue with a variable
+ // size of inflight messages.
+ return 0;
+ }
+
+ @Override
+ public void prepareShutdown(boolean suspendOnly, boolean forced) {
+ // noop
+ }
+}
diff --git a/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletConsumerNotAvailableException.java b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletConsumerNotAvailableException.java
new file mode 100644
index 0000000..44f1f4e
--- /dev/null
+++ b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletConsumerNotAvailableException.java
@@ -0,0 +1,27 @@
+/*
+ * 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.kamelet;
+
+import org.apache.camel.CamelExchangeException;
+import org.apache.camel.Exchange;
+
+public class KameletConsumerNotAvailableException extends CamelExchangeException {
+
+ public KameletConsumerNotAvailableException(String message, Exchange exchange) {
+ super(message, exchange);
+ }
+}
diff --git a/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletEndpoint.java b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletEndpoint.java
new file mode 100644
index 0000000..1cc9e43
--- /dev/null
+++ b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletEndpoint.java
@@ -0,0 +1,162 @@
+/*
+ * 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.kamelet;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.camel.Category;
+import org.apache.camel.Consumer;
+import org.apache.camel.Processor;
+import org.apache.camel.Producer;
+import org.apache.camel.spi.Metadata;
+import org.apache.camel.spi.UriEndpoint;
+import org.apache.camel.spi.UriParam;
+import org.apache.camel.spi.UriPath;
+import org.apache.camel.support.DefaultEndpoint;
+import org.apache.camel.util.ObjectHelper;
+
+@UriEndpoint(
+ firstVersion = "3.8.0",
+ scheme = "kamelet",
+ syntax = "kamelet:templateId/routeId",
+ title = "Kamelet",
+ lenientProperties = true,
+ category = Category.CORE)
+public class KameletEndpoint extends DefaultEndpoint {
+ private final String key;
+ private final Map<String, Object> kameletProperties;
+
+ @Metadata(required = true)
+ @UriPath(description = "The Route Template ID")
+ private final String templateId;
+ @Metadata
+ @UriPath(description = "The Route ID", defaultValueNote = "The ID will be auto-generated if not provided")
+ private final String routeId;
+
+ @UriParam(label = "producer", defaultValue = "true")
+ private boolean block = true;
+ @UriParam(label = "producer", defaultValue = "30000")
+ private long timeout = 30000L;
+ @UriParam(label = "producer", defaultValue = "true")
+ private boolean failIfNoConsumers = true;
+
+ public KameletEndpoint(
+ String uri,
+ KameletComponent component,
+ String templateId,
+ String routeId) {
+
+ super(uri, component);
+
+ ObjectHelper.notNull(templateId, "template id");
+ ObjectHelper.notNull(routeId, "route id");
+
+ this.templateId = templateId;
+ this.routeId = routeId;
+ this.key = templateId + "/" + routeId;
+ this.kameletProperties = new HashMap<>();
+ }
+
+ public boolean isBlock() {
+ return block;
+ }
+
+ /**
+ * If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block
+ * and wait for the consumer to become active.
+ */
+ public void setBlock(boolean block) {
+ this.block = block;
+ }
+
+ public long getTimeout() {
+ return timeout;
+ }
+
+ /**
+ * The timeout value to use if block is enabled.
+ *
+ * @param timeout the timeout value
+ */
+ public void setTimeout(long timeout) {
+ this.timeout = timeout;
+ }
+
+ public boolean isFailIfNoConsumers() {
+ return failIfNoConsumers;
+ }
+
+ /**
+ * Whether the producer should fail by throwing an exception, when sending to a kamelet endpoint with no active
+ * consumers.
+ */
+ public void setFailIfNoConsumers(boolean failIfNoConsumers) {
+ this.failIfNoConsumers = failIfNoConsumers;
+ }
+
+ @Override
+ public KameletComponent getComponent() {
+ return (KameletComponent) super.getComponent();
+ }
+
+ @Override
+ public boolean isLenientProperties() {
+ return true;
+ }
+
+ @Override
+ public boolean isSingleton() {
+ return true;
+ }
+
+ public String getTemplateId() {
+ return templateId;
+ }
+
+ public String getRouteId() {
+ return routeId;
+ }
+
+ public Map<String, Object> getKameletProperties() {
+ return Collections.unmodifiableMap(kameletProperties);
+ }
+
+ /**
+ * Custom properties for kamelet
+ */
+ public void setKameletProperties(Map<String, Object> kameletProperties) {
+ if (kameletProperties != null) {
+ this.kameletProperties.clear();
+ this.kameletProperties.putAll(kameletProperties);
+ }
+ }
+
+ @Override
+ public Producer createProducer() throws Exception {
+ return new KameletProducer(this, key);
+ }
+
+ @Override
+ public Consumer createConsumer(Processor processor) throws Exception {
+ Consumer answer = new KameletConsumer(this, processor, key);
+ configureConsumer(answer);
+ return answer;
+ }
+
+}
diff --git a/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletProducer.java b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletProducer.java
new file mode 100644
index 0000000..726c22d
--- /dev/null
+++ b/components/camel-kamelet/src/main/java/org/apache/camel/component/kamelet/KameletProducer.java
@@ -0,0 +1,90 @@
+/*
+ * 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.kamelet;
+
+import org.apache.camel.AsyncCallback;
+import org.apache.camel.Exchange;
+import org.apache.camel.support.DefaultAsyncProducer;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+final class KameletProducer extends DefaultAsyncProducer {
+
+ private static final Logger LOG = LoggerFactory.getLogger(KameletProducer.class);
+
+ private volatile KameletConsumer consumer;
+ private int stateCounter;
+
+ private final KameletEndpoint endpoint;
+ private final KameletComponent component;
+ private final String key;
+ private final boolean block;
+ private final long timeout;
+
+ public KameletProducer(KameletEndpoint endpoint, String key) {
+ super(endpoint);
+ this.endpoint = endpoint;
+ this.component = endpoint.getComponent();
+ this.key = key;
+ this.block = endpoint.isBlock();
+ this.timeout = endpoint.getTimeout();
+ }
+
+ @Override
+ public void process(Exchange exchange) throws Exception {
+ if (consumer == null || stateCounter != component.getStateCounter()) {
+ stateCounter = component.getStateCounter();
+ consumer = component.getConsumer(key, block, timeout);
+ }
+ if (consumer == null) {
+ if (endpoint.isFailIfNoConsumers()) {
+ throw new KameletConsumerNotAvailableException("No consumers available on endpoint: " + endpoint, exchange);
+ } else {
+ LOG.debug("message ignored, no consumers available on endpoint: {}", endpoint);
+ }
+ } else {
+ consumer.getProcessor().process(exchange);
+ }
+ }
+
+ @Override
+ public boolean process(Exchange exchange, AsyncCallback callback) {
+ try {
+ if (consumer == null || stateCounter != component.getStateCounter()) {
+ stateCounter = component.getStateCounter();
+ consumer = component.getConsumer(key, block, timeout);
+ }
+ if (consumer == null) {
+ if (endpoint.isFailIfNoConsumers()) {
+ exchange.setException(new KameletConsumerNotAvailableException(
+ "No consumers available on endpoint: " + endpoint, exchange));
+ } else {
+ LOG.debug("message ignored, no consumers available on endpoint: {}", endpoint);
+ }
+ callback.done(true);
+ return true;
+ } else {
+ return consumer.getAsyncProcessor().process(exchange, callback);
+ }
+ } catch (Exception e) {
+ exchange.setException(e);
+ callback.done(true);
+ return true;
+ }
+ }
+
+}
diff --git a/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletBasicTest.java b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletBasicTest.java
new file mode 100644
index 0000000..ea17c30
--- /dev/null
+++ b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletBasicTest.java
@@ -0,0 +1,89 @@
+/*
+ * 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.kamelet;
+
+import java.util.UUID;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.RoutesBuilder;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.test.junit5.CamelTestSupport;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class KameletBasicTest extends CamelTestSupport {
+ @Test
+ public void canProduceToKamelet() {
+ String body = UUID.randomUUID().toString();
+
+ assertThat(
+ fluentTemplate.toF("kamelet:setBody/test?bodyValue=%s", body).request(String.class)).isEqualTo(body);
+ }
+
+ @Test
+ public void canConsumeFromKamelet() {
+ assertThat(
+ consumer.receiveBody("kamelet:tick", Integer.class)).isEqualTo(1);
+ }
+
+ @Test
+ public void kameletCanBeCreatedWhileContextIsStarting() {
+ assertThat(
+ fluentTemplate.to("direct:templateEmbedded").request(String.class)).isEqualTo("embedded");
+ }
+
+ @Test
+ public void kameletCanBeCreatedAfterContextIsStarted() throws Exception {
+ String body = UUID.randomUUID().toString();
+
+ RouteBuilder.addRoutes(context, b -> {
+ b.from("direct:templateAfter")
+ .toF("kamelet:setBody/test?bodyValue=%s", body);
+ });
+
+ assertThat(
+ fluentTemplate.to("direct:templateAfter").request(String.class)).isEqualTo(body);
+ }
+
+ // **********************************************
+ //
+ // test set-up
+ //
+ // **********************************************
+
+ @Override
+ protected RoutesBuilder createRouteBuilder() throws Exception {
+ return new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+ routeTemplate("setBody")
+ .templateParameter("bodyValue")
+ .from("kamelet:source")
+ .setBody().constant("{{bodyValue}}");
+
+ routeTemplate("tick")
+ .from("timer:{{routeId}}?repeatCount=1&delay=-1")
+ .setBody().exchangeProperty(Exchange.TIMER_COUNTER)
+ .to("kamelet:sink");
+
+ from("direct:templateEmbedded")
+ .toF("kamelet:setBody/embedded?bodyValue=embedded");
+ }
+ };
+ }
+}
diff --git a/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletComponentTest.java b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletComponentTest.java
new file mode 100644
index 0000000..bd05589
--- /dev/null
+++ b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletComponentTest.java
@@ -0,0 +1,52 @@
+/*
+ * 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.kamelet;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.apache.camel.support.PropertyBindingSupport;
+import org.junit.jupiter.api.Test;
+
+import static org.apache.camel.util.CollectionHelper.mapOf;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class KameletComponentTest {
+ @Test
+ public void testComponent() {
+ CamelContext context = new DefaultCamelContext();
+ KameletComponent component = context.getComponent(Kamelet.SCHEME, KameletComponent.class);
+
+ PropertyBindingSupport.build()
+ .withIgnoreCase(true)
+ .withReflection(false)
+ .withRemoveParameters(false)
+ .withCamelContext(context)
+ .withTarget(component)
+ .withConfigurer(component.getComponentPropertyConfigurer())
+ .withProperties(mapOf(
+ "template-properties[myTemplate].foo", "bar",
+ "route-properties[myRoute].foo", "baz"))
+ .bind();
+
+ assertThat(component.getTemplateProperties()).isNotEmpty();
+ assertThat(component.getTemplateProperties()).containsKey("myTemplate");
+ assertThat(component.getTemplateProperties().get("myTemplate")).containsEntry("foo", "bar");
+ assertThat(component.getRouteProperties()).isNotEmpty();
+ assertThat(component.getRouteProperties()).containsKey("myRoute");
+ assertThat(component.getRouteProperties().get("myRoute")).containsEntry("foo", "baz");
+ }
+}
diff --git a/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletPropertiesTest.java b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletPropertiesTest.java
new file mode 100644
index 0000000..94e5f09
--- /dev/null
+++ b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletPropertiesTest.java
@@ -0,0 +1,170 @@
+/*
+ * 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.kamelet;
+
+import java.util.Properties;
+
+import org.apache.camel.RoutesBuilder;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.http.HttpEndpoint;
+import org.apache.camel.test.junit5.CamelTestSupport;
+import org.apache.http.annotation.Obsolete;
+import org.junit.jupiter.api.Test;
+
+import static org.apache.camel.util.PropertiesHelper.asProperties;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class KameletPropertiesTest extends CamelTestSupport {
+ @Test
+ public void propertiesAreTakenFromRouteId() {
+ assertThat(
+ fluentTemplate
+ .to("kamelet:setBody/test")
+ .request(String.class)).isEqualTo("from-route");
+ }
+
+ @Test
+ public void propertiesAreTakenFromTemplateId() {
+ assertThat(
+ fluentTemplate
+ .to("kamelet:setBody")
+ .request(String.class)).isEqualTo("from-template");
+ }
+
+ @Test
+ public void propertiesAreTakenFromURI() {
+ assertThat(
+ fluentTemplate
+ .to("kamelet:setBody?bodyValue={{bodyValue}}")
+ .request(String.class)).isEqualTo("from-uri");
+ }
+
+ @Test
+ public void rawIsPropagated() {
+ context.getEndpoint(
+ "kamelet:http-send?proxyUsr=RAW(u+sr)&proxyPwd=RAW(p+wd)");
+
+ assertThat(context.getEndpoints().stream().filter(HttpEndpoint.class::isInstance).findFirst()
+ .map(HttpEndpoint.class::cast))
+ .get()
+ .hasFieldOrPropertyWithValue("endpointUri",
+ "http://localhost:8080?proxyAuthUsername=u%2Bsr&proxyAuthPassword=p%2Bwd")
+ .hasFieldOrPropertyWithValue("proxyAuthUsername", "u+sr")
+ .hasFieldOrPropertyWithValue("proxyAuthPassword", "p+wd");
+ }
+
+ @Test
+ public void rawWithPlaceholdersIsPropagated() {
+ context.getEndpoint(
+ "kamelet:http-send?proxyUsr=RAW({{proxy.usr}})&proxyPwd=RAW({{proxy.pwd}})");
+
+ assertThat(context.getEndpoints().stream().filter(HttpEndpoint.class::isInstance).findFirst()
+ .map(HttpEndpoint.class::cast))
+ .get()
+ .hasFieldOrPropertyWithValue("endpointUri",
+ "http://localhost:8080?proxyAuthUsername=u%2Bsr&proxyAuthPassword=p%2Bwd")
+ .hasFieldOrPropertyWithValue("proxyAuthUsername", "u+sr")
+ .hasFieldOrPropertyWithValue("proxyAuthPassword", "p+wd");
+ }
+
+ @Test
+ public void rawPropertiesIsPropagated() {
+ context.getEndpoint(
+ "kamelet:http-send?proxyUsr={{raw.proxy.usr}}&proxyPwd={{raw.proxy.pwd}}");
+
+ assertThat(context.getEndpoints().stream().filter(HttpEndpoint.class::isInstance).findFirst()
+ .map(HttpEndpoint.class::cast))
+ .get()
+ .hasFieldOrPropertyWithValue("endpointUri",
+ "http://localhost:8080?proxyAuthUsername=u%2Bsr&proxyAuthPassword=p%2Bwd")
+ .hasFieldOrPropertyWithValue("proxyAuthUsername", "u+sr")
+ .hasFieldOrPropertyWithValue("proxyAuthPassword", "p+wd");
+ }
+
+ @Test
+ public void rawPropertyRefIsPropagated() {
+ context.getEndpoint(
+ "kamelet:http-send?proxyUsr=#property:proxy.usr&proxyPwd=#property:proxy.pwd");
+
+ assertThat(context.getEndpoints().stream().filter(HttpEndpoint.class::isInstance).findFirst()
+ .map(HttpEndpoint.class::cast))
+ .get()
+ .hasFieldOrPropertyWithValue("endpointUri",
+ "http://localhost:8080?proxyAuthUsername=%23property%3Aproxy.usr&proxyAuthPassword=%23property%3Aproxy.pwd")
+ .hasFieldOrPropertyWithValue("proxyAuthUsername", "u+sr")
+ .hasFieldOrPropertyWithValue("proxyAuthPassword", "p+wd");
+ }
+
+ @Test
+ public void urlEncodingIsRespected() {
+ assertThat(context.getEndpoint("kamelet:timer-source?message=Hello+Kamelets&period=1000", KameletEndpoint.class)
+ .getKameletProperties())
+ .containsEntry("message", "Hello Kamelets");
+ assertThat(context
+ .getEndpoint("kamelet:timer-source?message=messaging.knative.dev%2Fv1beta1&period=1000", KameletEndpoint.class)
+ .getKameletProperties())
+ .containsEntry("message", "messaging.knative.dev/v1beta1");
+ }
+
+ // **********************************************
+ //
+ // test set-up
+ //
+ // **********************************************
+
+ @Override
+ protected Properties useOverridePropertiesWithPropertiesComponent() {
+ return asProperties(
+ "proxy.usr", "u+sr",
+ "proxy.pwd", "p+wd",
+ "raw.proxy.usr", "RAW(u+sr)",
+ "raw.proxy.pwd", "RAW(p+wd)",
+ "bodyValue", "from-uri",
+ Kamelet.PROPERTIES_PREFIX + "setBody.bodyValue", "from-template",
+ Kamelet.PROPERTIES_PREFIX + "setBody.test.bodyValue", "from-route");
+ }
+
+ @Obsolete
+ protected RoutesBuilder createRouteBuilder() throws Exception {
+ return new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+ // template
+ routeTemplate("setBody")
+ .templateParameter("bodyValue")
+ .from("kamelet:source")
+ .setBody().constant("{{bodyValue}}");
+
+ // template
+ routeTemplate("http-send")
+ .templateParameter("proxyUsr")
+ .templateParameter("proxyPwd")
+ .from("kamelet:source")
+ .log("info")
+ .to("http://localhost:8080?proxyAuthUsername={{proxyUsr}}&proxyAuthPassword={{proxyPwd}}");
+
+ // template
+ routeTemplate("timer-source")
+ .templateParameter("period")
+ .templateParameter("message")
+ .from("timer:tick")
+ .setBody().constant("{{message}}")
+ .to("kamelet:sink");
+ }
+ };
+ }
+}
diff --git a/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletRouteTest.java b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletRouteTest.java
new file mode 100644
index 0000000..15c0cc8
--- /dev/null
+++ b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletRouteTest.java
@@ -0,0 +1,73 @@
+/*
+ * 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.kamelet;
+
+import java.util.UUID;
+
+import org.apache.camel.RoutesBuilder;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.test.junit5.CamelTestSupport;
+import org.apache.http.annotation.Obsolete;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class KameletRouteTest extends CamelTestSupport {
+ @Test
+ public void testSingle() {
+ String body = UUID.randomUUID().toString();
+
+ assertThat(
+ fluentTemplate.toF("direct:single").withBody(body).request(String.class)).isEqualTo("a-" + body);
+ }
+
+ @Test
+ public void testChain() {
+ String body = UUID.randomUUID().toString();
+
+ assertThat(
+ fluentTemplate.toF("direct:chain").withBody(body).request(String.class)).isEqualTo("b-a-" + body);
+ }
+
+ // **********************************************
+ //
+ // test set-up
+ //
+ // **********************************************
+
+ @Obsolete
+ protected RoutesBuilder createRouteBuilder() throws Exception {
+ return new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+ routeTemplate("echo")
+ .templateParameter("prefix")
+ .from("kamelet:source")
+ .setBody().simple("{{prefix}}-${body}");
+
+ from("direct:single")
+ .to("kamelet:echo?prefix=a")
+ .log("${body}");
+
+ from("direct:chain")
+ .to("kamelet:echo/1?prefix=a")
+ .to("kamelet:echo/2?prefix=b")
+ .log("${body}");
+ }
+ };
+ }
+}
diff --git a/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletValidationTest.java b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletValidationTest.java
new file mode 100644
index 0000000..b4db6fd
--- /dev/null
+++ b/components/camel-kamelet/src/test/java/org/apache/camel/component/kamelet/KameletValidationTest.java
@@ -0,0 +1,49 @@
+/*
+ * 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.kamelet;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.RuntimeCamelException;
+import org.apache.camel.VetoCamelContextStartException;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.impl.DefaultCamelContext;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+
+public class KameletValidationTest {
+ @Test
+ public void validation() throws Exception {
+ CamelContext context = new DefaultCamelContext();
+ context.addRoutes(new RouteBuilder() {
+ @Override
+ public void configure() throws Exception {
+ routeTemplate("setBody")
+ .templateParameter("bodyValue")
+ .from("kamelet:source")
+ .setBody().constant("{{bodyValue}}");
+
+ from("direct:start")
+ .to("kamelet:setBody/test");
+ }
+ });
+
+ assertThatExceptionOfType(RuntimeCamelException.class)
+ .isThrownBy(context::start)
+ .withCauseExactlyInstanceOf(VetoCamelContextStartException.class);
+ }
+}
diff --git a/components/camel-kamelet/src/test/resources/log4j2.properties b/components/camel-kamelet/src/test/resources/log4j2.properties
new file mode 100644
index 0000000..3ecda7a
--- /dev/null
+++ b/components/camel-kamelet/src/test/resources/log4j2.properties
@@ -0,0 +1,34 @@
+## ---------------------------------------------------------------------------
+## 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.file.type = File
+appender.file.name = file
+appender.file.fileName = target/camel-kamelet-test.log
+appender.file.layout.type = PatternLayout
+appender.file.layout.pattern = %d [%-15.15t] %-5p %-30.30c{1} - %m%n
+
+appender.out.type = Console
+appender.out.name = out
+appender.out.layout.type = PatternLayout
+appender.out.layout.pattern = [%30.30t] %-30.30c{1} %-5p %m%n
+
+rootLogger.level = INFO
+rootLogger.appenderRef.file.ref = file
+#rootLogger.appenderRef.out.ref = out
+
+logger.camel-kamelet.name = org.apache.camel.component.kamelet
+logger.camel-kamelet.level = INFO
diff --git a/components/pom.xml b/components/pom.xml
index 9bce699..863d28a 100644
--- a/components/pom.xml
+++ b/components/pom.xml
@@ -267,6 +267,7 @@
<module>camel-jt400</module>
<module>camel-jta</module>
<module>camel-kafka</module>
+ <module>camel-kamelet</module>
<module>camel-kubernetes</module>
<module>camel-kudu</module>
<module>camel-ldap</module>
diff --git a/core/camel-allcomponents/pom.xml b/core/camel-allcomponents/pom.xml
index 197b026..450620e 100644
--- a/core/camel-allcomponents/pom.xml
+++ b/core/camel-allcomponents/pom.xml
@@ -847,6 +847,10 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-kamelet</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-kubernetes</artifactId>
</dependency>
<dependency>
diff --git a/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/ComponentsBuilderFactory.java b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/ComponentsBuilderFactory.java
index e099043..39d2e74 100644
--- a/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/ComponentsBuilderFactory.java
+++ b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/ComponentsBuilderFactory.java
@@ -2759,6 +2759,20 @@ public interface ComponentsBuilderFactory {
return org.apache.camel.builder.component.dsl.KafkaComponentBuilderFactory.kafka();
}
/**
+ * Kamelet (camel-kamelet)
+ * The Kamelet Component provides support for interacting with the Camel
+ * Route Template engine
+ *
+ * Category: core
+ * Since: 3.8
+ * Maven coordinates: org.apache.camel:camel-kamelet
+ *
+ * @return the dsl builder
+ */
+ static org.apache.camel.builder.component.dsl.KameletComponentBuilderFactory.KameletComponentBuilder kamelet() {
+ return org.apache.camel.builder.component.dsl.KameletComponentBuilderFactory.kamelet();
+ }
+ /**
* Kubernetes ConfigMap (camel-kubernetes)
* Perform operations on Kubernetes ConfigMaps and get notified on
* ConfigMaps changes.
diff --git a/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/KameletComponentBuilderFactory.java b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/KameletComponentBuilderFactory.java
new file mode 100644
index 0000000..47b8acf
--- /dev/null
+++ b/core/camel-componentdsl/src/generated/java/org/apache/camel/builder/component/dsl/KameletComponentBuilderFactory.java
@@ -0,0 +1,214 @@
+/*
+ * 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.builder.component.dsl;
+
+import javax.annotation.Generated;
+import org.apache.camel.Component;
+import org.apache.camel.builder.component.AbstractComponentBuilder;
+import org.apache.camel.builder.component.ComponentBuilder;
+import org.apache.camel.component.kamelet.KameletComponent;
+
+/**
+ * The Kamelet Component provides support for interacting with the Camel Route
+ * Template engine
+ *
+ * Generated by camel-package-maven-plugin - do not edit this file!
+ */
+@Generated("org.apache.camel.maven.packaging.ComponentDslMojo")
+public interface KameletComponentBuilderFactory {
+
+ /**
+ * Kamelet (camel-kamelet)
+ * The Kamelet Component provides support for interacting with the Camel
+ * Route Template engine
+ *
+ * Category: core
+ * Since: 3.8
+ * Maven coordinates: org.apache.camel:camel-kamelet
+ *
+ * @return the dsl builder
+ */
+ static KameletComponentBuilder kamelet() {
+ return new KameletComponentBuilderImpl();
+ }
+
+ /**
+ * Builder for the Kamelet component.
+ */
+ interface KameletComponentBuilder
+ extends
+ ComponentBuilder<KameletComponent> {
+ /**
+ * Set route local parameters.
+ *
+ * The option is a: <code>java.util.Map&lt;java.lang.String,
+ * java.util.Properties&gt;</code> type.
+ *
+ * Group: common
+ *
+ * @param routeProperties the value to set
+ * @return the dsl builder
+ */
+ default KameletComponentBuilder routeProperties(
+ java.util.Map<java.lang.String, java.util.Properties> routeProperties) {
+ doSetProperty("routeProperties", routeProperties);
+ return this;
+ }
+ /**
+ * Set template local parameters.
+ *
+ * The option is a: <code>java.util.Map&lt;java.lang.String,
+ * java.util.Properties&gt;</code> type.
+ *
+ * Group: common
+ *
+ * @param templateProperties the value to set
+ * @return the dsl builder
+ */
+ default KameletComponentBuilder templateProperties(
+ java.util.Map<java.lang.String, java.util.Properties> templateProperties) {
+ doSetProperty("templateProperties", templateProperties);
+ return this;
+ }
+ /**
+ * 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.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: false
+ * Group: consumer
+ *
+ * @param bridgeErrorHandler the value to set
+ * @return the dsl builder
+ */
+ default KameletComponentBuilder bridgeErrorHandler(
+ boolean bridgeErrorHandler) {
+ doSetProperty("bridgeErrorHandler", bridgeErrorHandler);
+ return this;
+ }
+ /**
+ * If sending a message to a kamelet endpoint which has no active
+ * consumer, then we can tell the producer to block and wait for the
+ * consumer to become active.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: true
+ * Group: producer
+ *
+ * @param block the value to set
+ * @return the dsl builder
+ */
+ default KameletComponentBuilder block(boolean block) {
+ doSetProperty("block", block);
+ return this;
+ }
+ /**
+ * Whether the producer should be started lazy (on the first message).
+ * By starting lazy you can use this to allow CamelContext and routes to
+ * startup in situations where a producer may otherwise fail during
+ * starting and cause the route to fail being started. By deferring this
+ * startup to be lazy then the startup failure can be handled during
+ * routing messages via Camel's routing error handlers. Beware that when
+ * the first message is processed then creating and starting the
+ * producer may take a little time and prolong the total processing time
+ * of the processing.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: false
+ * Group: producer
+ *
+ * @param lazyStartProducer the value to set
+ * @return the dsl builder
+ */
+ default KameletComponentBuilder lazyStartProducer(
+ boolean lazyStartProducer) {
+ doSetProperty("lazyStartProducer", lazyStartProducer);
+ return this;
+ }
+ /**
+ * The timeout value to use if block is enabled.
+ *
+ * The option is a: <code>long</code> type.
+ *
+ * Default: 30000
+ * Group: producer
+ *
+ * @param timeout the value to set
+ * @return the dsl builder
+ */
+ default KameletComponentBuilder timeout(long timeout) {
+ doSetProperty("timeout", timeout);
+ return this;
+ }
+ /**
+ * Whether autowiring is enabled. This is used for automatic autowiring
+ * options (the option must be marked as autowired) by looking up in the
+ * registry to find if there is a single instance of matching type,
+ * which then gets configured on the component. This can be used for
+ * automatic configuring JDBC data sources, JMS connection factories,
+ * AWS Clients, etc.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: true
+ * Group: advanced
+ *
+ * @param autowiredEnabled the value to set
+ * @return the dsl builder
+ */
+ default KameletComponentBuilder autowiredEnabled(
+ boolean autowiredEnabled) {
+ doSetProperty("autowiredEnabled", autowiredEnabled);
+ return this;
+ }
+ }
+
+ class KameletComponentBuilderImpl
+ extends
+ AbstractComponentBuilder<KameletComponent>
+ implements
+ KameletComponentBuilder {
+ @Override
+ protected KameletComponent buildConcreteComponent() {
+ return new KameletComponent();
+ }
+ @Override
+ protected boolean setPropertyOnComponent(
+ Component component,
+ String name,
+ Object value) {
+ switch (name) {
+ case "routeProperties": ((KameletComponent) component).setRouteProperties((java.util.Map) value); return true;
+ case "templateProperties": ((KameletComponent) component).setTemplateProperties((java.util.Map) value); return true;
+ case "bridgeErrorHandler": ((KameletComponent) component).setBridgeErrorHandler((boolean) value); return true;
+ case "block": ((KameletComponent) component).setBlock((boolean) value); return true;
+ case "lazyStartProducer": ((KameletComponent) component).setLazyStartProducer((boolean) value); return true;
+ case "timeout": ((KameletComponent) component).setTimeout((long) value); return true;
+ case "autowiredEnabled": ((KameletComponent) component).setAutowiredEnabled((boolean) value); return true;
+ default: return false;
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/core/camel-componentdsl/src/generated/resources/metadata.json b/core/camel-componentdsl/src/generated/resources/metadata.json
index 82320fb..8be7968 100644
--- a/core/camel-componentdsl/src/generated/resources/metadata.json
+++ b/core/camel-componentdsl/src/generated/resources/metadata.json
@@ -4545,6 +4545,28 @@
"producerOnly": false,
"lenientProperties": false
},
+ "KameletComponentBuilderFactory": {
+ "kind": "component",
+ "name": "kamelet",
+ "title": "Kamelet",
+ "description": "The Kamelet Component provides support for interacting with the Camel Route Template engine",
+ "deprecated": false,
+ "firstVersion": "3.8.0",
+ "label": "core",
+ "javaType": "org.apache.camel.component.kamelet.KameletComponent",
+ "supportLevel": "Preview",
+ "groupId": "org.apache.camel",
+ "artifactId": "camel-kamelet",
+ "version": "3.8.0-SNAPSHOT",
+ "scheme": "kamelet",
+ "extendsScheme": "",
+ "syntax": "kamelet:templateId\/routeId",
+ "async": false,
+ "api": false,
+ "consumerOnly": false,
+ "producerOnly": false,
+ "lenientProperties": true
+ },
"KubernetesConfigMapsComponentBuilderFactory": {
"kind": "component",
"name": "kubernetes-config-maps",
diff --git a/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java
index 62e2cc0..a168bbc 100644
--- a/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java
@@ -204,6 +204,7 @@ public interface EndpointBuilderFactory
org.apache.camel.builder.endpoint.dsl.KMS2EndpointBuilderFactory.KMS2Builders,
org.apache.camel.builder.endpoint.dsl.KMSEndpointBuilderFactory.KMSBuilders,
org.apache.camel.builder.endpoint.dsl.KafkaEndpointBuilderFactory.KafkaBuilders,
+ org.apache.camel.builder.endpoint.dsl.KameletEndpointBuilderFactory.KameletBuilders,
org.apache.camel.builder.endpoint.dsl.KeystoneEndpointBuilderFactory.KeystoneBuilders,
org.apache.camel.builder.endpoint.dsl.Kinesis2EndpointBuilderFactory.Kinesis2Builders,
org.apache.camel.builder.endpoint.dsl.KinesisEndpointBuilderFactory.KinesisBuilders,
diff --git a/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilders.java b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilders.java
index dfd2bbe..a911ebc 100644
--- a/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilders.java
+++ b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/EndpointBuilders.java
@@ -201,6 +201,7 @@ public interface EndpointBuilders
org.apache.camel.builder.endpoint.dsl.KMS2EndpointBuilderFactory,
org.apache.camel.builder.endpoint.dsl.KMSEndpointBuilderFactory,
org.apache.camel.builder.endpoint.dsl.KafkaEndpointBuilderFactory,
+ org.apache.camel.builder.endpoint.dsl.KameletEndpointBuilderFactory,
org.apache.camel.builder.endpoint.dsl.KeystoneEndpointBuilderFactory,
org.apache.camel.builder.endpoint.dsl.Kinesis2EndpointBuilderFactory,
org.apache.camel.builder.endpoint.dsl.KinesisEndpointBuilderFactory,
diff --git a/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/StaticEndpointBuilders.java b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/StaticEndpointBuilders.java
index 6d971b0..eb6ef5f 100644
--- a/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/StaticEndpointBuilders.java
+++ b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/StaticEndpointBuilders.java
@@ -9356,6 +9356,59 @@ public class StaticEndpointBuilders {
return org.apache.camel.builder.endpoint.dsl.KafkaEndpointBuilderFactory.endpointBuilder(componentName, path);
}
/**
+ * Kamelet (camel-kamelet)
+ * The Kamelet Component provides support for interacting with the Camel
+ * Route Template engine
+ *
+ * Category: core
+ * Since: 3.8
+ * Maven coordinates: org.apache.camel:camel-kamelet
+ *
+ * Syntax: <code>kamelet:templateId/routeId</code>
+ *
+ * Path parameter: templateId (required)
+ * The Route Template ID
+ *
+ * Path parameter: routeId
+ * The Route ID. Default value notice: The ID will be auto-generated if not
+ * provided
+ *
+ * @param path templateId/routeId
+ * @return the dsl builder
+ */
+ public static org.apache.camel.builder.endpoint.dsl.KameletEndpointBuilderFactory.KameletEndpointBuilder kamelet(
+ String path) {
+ return org.apache.camel.builder.endpoint.dsl.KameletEndpointBuilderFactory.endpointBuilder("kamelet", path);
+ }
+ /**
+ * Kamelet (camel-kamelet)
+ * The Kamelet Component provides support for interacting with the Camel
+ * Route Template engine
+ *
+ * Category: core
+ * Since: 3.8
+ * Maven coordinates: org.apache.camel:camel-kamelet
+ *
+ * Syntax: <code>kamelet:templateId/routeId</code>
+ *
+ * Path parameter: templateId (required)
+ * The Route Template ID
+ *
+ * Path parameter: routeId
+ * The Route ID. Default value notice: The ID will be auto-generated if not
+ * provided
+ *
+ * @param componentName to use a custom component name for the endpoint
+ * instead of the default name
+ * @param path templateId/routeId
+ * @return the dsl builder
+ */
+ public static org.apache.camel.builder.endpoint.dsl.KameletEndpointBuilderFactory.KameletEndpointBuilder kamelet(
+ String componentName,
+ String path) {
+ return org.apache.camel.builder.endpoint.dsl.KameletEndpointBuilderFactory.endpointBuilder(componentName, path);
+ }
+ /**
* Kubernetes ConfigMap (camel-kubernetes)
* Perform operations on Kubernetes ConfigMaps and get notified on
* ConfigMaps changes.
diff --git a/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/KameletEndpointBuilderFactory.java b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/KameletEndpointBuilderFactory.java
new file mode 100644
index 0000000..76b652e
--- /dev/null
+++ b/core/camel-endpointdsl/src/generated/java/org/apache/camel/builder/endpoint/dsl/KameletEndpointBuilderFactory.java
@@ -0,0 +1,430 @@
+/*
+ * 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.builder.endpoint.dsl;
+
+import javax.annotation.Generated;
+import org.apache.camel.ExchangePattern;
+import org.apache.camel.builder.EndpointConsumerBuilder;
+import org.apache.camel.builder.EndpointProducerBuilder;
+import org.apache.camel.builder.endpoint.AbstractEndpointBuilder;
+import org.apache.camel.spi.ExceptionHandler;
+
+/**
+ * The Kamelet Component provides support for interacting with the Camel Route
+ * Template engine
+ *
+ * Generated by camel build tools - do NOT edit this file!
+ */
+@Generated("org.apache.camel.maven.packaging.EndpointDslMojo")
+public interface KameletEndpointBuilderFactory {
+
+
+ /**
+ * Builder for endpoint consumers for the Kamelet component.
+ */
+ public interface KameletEndpointConsumerBuilder
+ extends
+ EndpointConsumerBuilder {
+ default AdvancedKameletEndpointConsumerBuilder advanced() {
+ return (AdvancedKameletEndpointConsumerBuilder) this;
+ }
+ /**
+ * 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.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: false
+ * Group: consumer
+ *
+ * @param bridgeErrorHandler the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointConsumerBuilder bridgeErrorHandler(
+ boolean bridgeErrorHandler) {
+ doSetProperty("bridgeErrorHandler", bridgeErrorHandler);
+ return this;
+ }
+ /**
+ * 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.
+ *
+ * The option will be converted to a <code>boolean</code>
+ * type.
+ *
+ * Default: false
+ * Group: consumer
+ *
+ * @param bridgeErrorHandler the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointConsumerBuilder bridgeErrorHandler(
+ String bridgeErrorHandler) {
+ doSetProperty("bridgeErrorHandler", bridgeErrorHandler);
+ return this;
+ }
+ }
+
+ /**
+ * Advanced builder for endpoint consumers for the Kamelet component.
+ */
+ public interface AdvancedKameletEndpointConsumerBuilder
+ extends
+ EndpointConsumerBuilder {
+ default KameletEndpointConsumerBuilder basic() {
+ return (KameletEndpointConsumerBuilder) this;
+ }
+ /**
+ * To let the consumer use a custom ExceptionHandler. Notice if the
+ * option bridgeErrorHandler is enabled then this option is not in use.
+ * By default the consumer will deal with exceptions, that will be
+ * logged at WARN or ERROR level and ignored.
+ *
+ * The option is a:
+ * <code>org.apache.camel.spi.ExceptionHandler</code> type.
+ *
+ * Group: consumer (advanced)
+ *
+ * @param exceptionHandler the value to set
+ * @return the dsl builder
+ */
+ default AdvancedKameletEndpointConsumerBuilder exceptionHandler(
+ ExceptionHandler exceptionHandler) {
+ doSetProperty("exceptionHandler", exceptionHandler);
+ return this;
+ }
+ /**
+ * To let the consumer use a custom ExceptionHandler. Notice if the
+ * option bridgeErrorHandler is enabled then this option is not in use.
+ * By default the consumer will deal with exceptions, that will be
+ * logged at WARN or ERROR level and ignored.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.spi.ExceptionHandler</code> type.
+ *
+ * Group: consumer (advanced)
+ *
+ * @param exceptionHandler the value to set
+ * @return the dsl builder
+ */
+ default AdvancedKameletEndpointConsumerBuilder exceptionHandler(
+ String exceptionHandler) {
+ doSetProperty("exceptionHandler", exceptionHandler);
+ return this;
+ }
+ /**
+ * Sets the exchange pattern when the consumer creates an exchange.
+ *
+ * The option is a:
+ * <code>org.apache.camel.ExchangePattern</code> type.
+ *
+ * Group: consumer (advanced)
+ *
+ * @param exchangePattern the value to set
+ * @return the dsl builder
+ */
+ default AdvancedKameletEndpointConsumerBuilder exchangePattern(
+ ExchangePattern exchangePattern) {
+ doSetProperty("exchangePattern", exchangePattern);
+ return this;
+ }
+ /**
+ * Sets the exchange pattern when the consumer creates an exchange.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.ExchangePattern</code> type.
+ *
+ * Group: consumer (advanced)
+ *
+ * @param exchangePattern the value to set
+ * @return the dsl builder
+ */
+ default AdvancedKameletEndpointConsumerBuilder exchangePattern(
+ String exchangePattern) {
+ doSetProperty("exchangePattern", exchangePattern);
+ return this;
+ }
+ }
+
+ /**
+ * Builder for endpoint producers for the Kamelet component.
+ */
+ public interface KameletEndpointProducerBuilder
+ extends
+ EndpointProducerBuilder {
+ default AdvancedKameletEndpointProducerBuilder advanced() {
+ return (AdvancedKameletEndpointProducerBuilder) this;
+ }
+ /**
+ * If sending a message to a direct endpoint which has no active
+ * consumer, then we can tell the producer to block and wait for the
+ * consumer to become active.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: true
+ * Group: producer
+ *
+ * @param block the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder block(boolean block) {
+ doSetProperty("block", block);
+ return this;
+ }
+ /**
+ * If sending a message to a direct endpoint which has no active
+ * consumer, then we can tell the producer to block and wait for the
+ * consumer to become active.
+ *
+ * The option will be converted to a <code>boolean</code>
+ * type.
+ *
+ * Default: true
+ * Group: producer
+ *
+ * @param block the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder block(String block) {
+ doSetProperty("block", block);
+ return this;
+ }
+ /**
+ * Whether the producer should fail by throwing an exception, when
+ * sending to a kamelet endpoint with no active consumers.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: true
+ * Group: producer
+ *
+ * @param failIfNoConsumers the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder failIfNoConsumers(
+ boolean failIfNoConsumers) {
+ doSetProperty("failIfNoConsumers", failIfNoConsumers);
+ return this;
+ }
+ /**
+ * Whether the producer should fail by throwing an exception, when
+ * sending to a kamelet endpoint with no active consumers.
+ *
+ * The option will be converted to a <code>boolean</code>
+ * type.
+ *
+ * Default: true
+ * Group: producer
+ *
+ * @param failIfNoConsumers the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder failIfNoConsumers(
+ String failIfNoConsumers) {
+ doSetProperty("failIfNoConsumers", failIfNoConsumers);
+ return this;
+ }
+ /**
+ * Whether the producer should be started lazy (on the first message).
+ * By starting lazy you can use this to allow CamelContext and routes to
+ * startup in situations where a producer may otherwise fail during
+ * starting and cause the route to fail being started. By deferring this
+ * startup to be lazy then the startup failure can be handled during
+ * routing messages via Camel's routing error handlers. Beware that when
+ * the first message is processed then creating and starting the
+ * producer may take a little time and prolong the total processing time
+ * of the processing.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Default: false
+ * Group: producer
+ *
+ * @param lazyStartProducer the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder lazyStartProducer(
+ boolean lazyStartProducer) {
+ doSetProperty("lazyStartProducer", lazyStartProducer);
+ return this;
+ }
+ /**
+ * Whether the producer should be started lazy (on the first message).
+ * By starting lazy you can use this to allow CamelContext and routes to
+ * startup in situations where a producer may otherwise fail during
+ * starting and cause the route to fail being started. By deferring this
+ * startup to be lazy then the startup failure can be handled during
+ * routing messages via Camel's routing error handlers. Beware that when
+ * the first message is processed then creating and starting the
+ * producer may take a little time and prolong the total processing time
+ * of the processing.
+ *
+ * The option will be converted to a <code>boolean</code>
+ * type.
+ *
+ * Default: false
+ * Group: producer
+ *
+ * @param lazyStartProducer the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder lazyStartProducer(
+ String lazyStartProducer) {
+ doSetProperty("lazyStartProducer", lazyStartProducer);
+ return this;
+ }
+ /**
+ * The timeout value to use if block is enabled.
+ *
+ * The option is a: <code>long</code> type.
+ *
+ * Default: 30000
+ * Group: producer
+ *
+ * @param timeout the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder timeout(long timeout) {
+ doSetProperty("timeout", timeout);
+ return this;
+ }
+ /**
+ * The timeout value to use if block is enabled.
+ *
+ * The option will be converted to a <code>long</code> type.
+ *
+ * Default: 30000
+ * Group: producer
+ *
+ * @param timeout the value to set
+ * @return the dsl builder
+ */
+ default KameletEndpointProducerBuilder timeout(String timeout) {
+ doSetProperty("timeout", timeout);
+ return this;
+ }
+ }
+
+ /**
+ * Advanced builder for endpoint producers for the Kamelet component.
+ */
+ public interface AdvancedKameletEndpointProducerBuilder
+ extends
+ EndpointProducerBuilder {
+ default KameletEndpointProducerBuilder basic() {
+ return (KameletEndpointProducerBuilder) this;
+ }
+ }
+
+ /**
+ * Builder for endpoint for the Kamelet component.
+ */
+ public interface KameletEndpointBuilder
+ extends
+ KameletEndpointConsumerBuilder,
+ KameletEndpointProducerBuilder {
+ default AdvancedKameletEndpointBuilder advanced() {
+ return (AdvancedKameletEndpointBuilder) this;
+ }
+ }
+
+ /**
+ * Advanced builder for endpoint for the Kamelet component.
+ */
+ public interface AdvancedKameletEndpointBuilder
+ extends
+ AdvancedKameletEndpointConsumerBuilder,
+ AdvancedKameletEndpointProducerBuilder {
+ default KameletEndpointBuilder basic() {
+ return (KameletEndpointBuilder) this;
+ }
+ }
+
+ public interface KameletBuilders {
+ /**
+ * Kamelet (camel-kamelet)
+ * The Kamelet Component provides support for interacting with the Camel
+ * Route Template engine
+ *
+ * Category: core
+ * Since: 3.8
+ * Maven coordinates: org.apache.camel:camel-kamelet
+ *
+ * Syntax: <code>kamelet:templateId/routeId</code>
+ *
+ * Path parameter: templateId (required)
+ * The Route Template ID
+ *
+ * Path parameter: routeId
+ * The Route ID. Default value notice: The ID will be auto-generated if
+ * not provided
+ *
+ * @param path templateId/routeId
+ * @return the dsl builder
+ */
+ default KameletEndpointBuilder kamelet(String path) {
+ return KameletEndpointBuilderFactory.endpointBuilder("kamelet", path);
+ }
+ /**
+ * Kamelet (camel-kamelet)
+ * The Kamelet Component provides support for interacting with the Camel
+ * Route Template engine
+ *
+ * Category: core
+ * Since: 3.8
+ * Maven coordinates: org.apache.camel:camel-kamelet
+ *
+ * Syntax: <code>kamelet:templateId/routeId</code>
+ *
+ * Path parameter: templateId (required)
+ * The Route Template ID
+ *
+ * Path parameter: routeId
+ * The Route ID. Default value notice: The ID will be auto-generated if
+ * not provided
+ *
+ * @param componentName to use a custom component name for the endpoint
+ * instead of the default name
+ * @param path templateId/routeId
+ * @return the dsl builder
+ */
+ default KameletEndpointBuilder kamelet(String componentName, String path) {
+ return KameletEndpointBuilderFactory.endpointBuilder(componentName, path);
+ }
+ }
+ static KameletEndpointBuilder endpointBuilder(
+ String componentName,
+ String path) {
+ class KameletEndpointBuilderImpl extends AbstractEndpointBuilder implements KameletEndpointBuilder, AdvancedKameletEndpointBuilder {
+ public KameletEndpointBuilderImpl(String path) {
+ super(componentName, path);
+ }
+ }
+ return new KameletEndpointBuilderImpl(path);
+ }
+}
\ No newline at end of file
diff --git a/core/camel-util/src/main/java/org/apache/camel/util/PropertiesHelper.java b/core/camel-util/src/main/java/org/apache/camel/util/PropertiesHelper.java
index a534f24..f27cb9e 100644
--- a/core/camel-util/src/main/java/org/apache/camel/util/PropertiesHelper.java
+++ b/core/camel-util/src/main/java/org/apache/camel/util/PropertiesHelper.java
@@ -19,6 +19,8 @@ package org.apache.camel.util;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
+import java.util.Objects;
+import java.util.Properties;
public final class PropertiesHelper {
@@ -82,4 +84,26 @@ public final class PropertiesHelper {
}
}
+ public static Properties asProperties(String... properties) {
+ if ((properties.length & 1) != 0) {
+ throw new InternalError("length is odd");
+ }
+
+ Properties answer = new Properties();
+ for (int i = 0; i < properties.length; i += 2) {
+ answer.setProperty(
+ Objects.requireNonNull(properties[i]),
+ Objects.requireNonNull(properties[i + 1]));
+ }
+
+ return answer;
+ }
+
+ public static Properties asProperties(Map<String, Object> properties) {
+ Properties answer = new Properties();
+ answer.putAll(properties);
+
+ return answer;
+ }
+
}
diff --git a/docs/components/modules/ROOT/nav.adoc b/docs/components/modules/ROOT/nav.adoc
index c755e86..239cf40 100644
--- a/docs/components/modules/ROOT/nav.adoc
+++ b/docs/components/modules/ROOT/nav.adoc
@@ -206,6 +206,7 @@
** xref:jsonata-component.adoc[JSONata]
** xref:jt400-component.adoc[JT400]
** xref:kafka-component.adoc[Kafka]
+** xref:kamelet-component.adoc[Kamelet]
** xref:kubernetes-summary.adoc[Kubernetes]
*** xref:kubernetes-config-maps-component.adoc[Kubernetes ConfigMap]
*** xref:kubernetes-custom-resources-component.adoc[Kubernetes Custom Resources]
diff --git a/docs/components/modules/ROOT/pages/kamelet-component.adoc b/docs/components/modules/ROOT/pages/kamelet-component.adoc
new file mode 100644
index 0000000..98bc6aa
--- /dev/null
+++ b/docs/components/modules/ROOT/pages/kamelet-component.adoc
@@ -0,0 +1,146 @@
+[[kamelet-component]]
+= Kamelet Component
+//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
+:page-source: components/camel-kamelet/src/main/docs/kamelet-component.adoc
+:docTitle: Kamelet
+:artifactId: camel-kamelet
+:description: The Kamelet Component provides support for interacting with the Camel Route Template engine
+:since: 3.8
+:supportLevel: Preview
+:component-header: Both producer and consumer are supported
+:core:
+include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/kamelet.adoc[opts=optional]
+
+*Since Camel {since}*
+
+*{component-header}*
+
+The Kamelet Component provides support for interacting with the xref:manual::route-template.adoc[Camel Route Template] engine using Endpoint semantic.
+
+== URI format
+
+[source]
+----
+kamelet:templateId/routeId[?options]
+----
+
+== Options
+
+
+
+// component options: START
+The Kamelet component supports 7 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *routeProperties* (common) | Set route local parameters. | | Map
+| *templateProperties* (common) | Set template local parameters. | | Map
+| *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
+| *block* (producer) | If sending a message to a kamelet endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
+| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
+| *autowiredEnabled* (advanced) | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. | true | boolean
+|===
+// component options: END
+
+
+
+
+// endpoint options: START
+The Kamelet endpoint is configured using URI syntax:
+
+----
+kamelet:templateId/routeId
+----
+
+with the following path and query parameters:
+
+=== Path Parameters (2 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *templateId* | *Required* The Route Template ID | | String
+| *routeId* | The Route ID. Default value notice: The ID will be auto-generated if not provided | | String
+|===
+
+
+=== Query Parameters (7 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| 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
+| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. | | ExceptionHandler
+| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut | | ExchangePattern
+| *block* (producer) | If sending a message to a direct endpoint which has no active consumer, then we can tell the producer to block and wait for the consumer to become active. | true | boolean
+| *failIfNoConsumers* (producer) | Whether the producer should fail by throwing an exception, when sending to a kamelet endpoint with no active consumers. | true | boolean
+| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and [...]
+| *timeout* (producer) | The timeout value to use if block is enabled. | 30000 | long
+|===
+// endpoint options: END
+
+[NOTE]
+====
+The *kamelet* endpoint is *lenient*, which means that the endpoint accepts additional parameters that are passed to the ROute Templkate engine and consumed upon route materialization.
+====
+
+== Samples
+
+
+Kamelets can be used as if they were standard Camel components.
+For example, suppose that we have created a Route Template as follows:
+
+[source,java]
+----
+routeTemplate("setMyBody")
+ .templateParameter("bodyValue")
+ .from("kamelet:source")
+ .setBody().constant("{{bodyValue}}");
+----
+
+[IMPORTANT]
+====
+To let the *Kamelet* component wiring the materialized route to the caller processor, we need to be able to identify the input and output endpoint of the route and this is done by using `kamele:source` to mark the input endpoint and `kamelet:sink` for the output endpoint.
+====
+
+Then the template can be instantiated and invoked as shown below:
+
+[source,java]
+----
+from("direct:setMyBody")
+ .to("kamelet:setMyBody?bodyValue=myKamelet");
+----
+
+
+Behind the scenes, the *Kamelet* component does the following things:
+
+1. it instantiates a route out of the Route Template identified by the given `templateId` path parameter (in this case `setBody`)
+2. it will act like the `direct` component and connect the current route to the materialized one.
+
+If you had to do it programmatically, it would have been something like:
+
+[source,java]
+----
+routeTemplate("setMyBody")
+ .templateParameter("bodyValue")
+ .from("direct:{{foo}}")
+ .setBody().constant("{{bodyValue}}");
+
+TemplatedRouteBuilder.builder(context, "setMyBody")
+ .parameter("foo", "bar")
+ .parameter("bodyValue", "myKamelet")
+ .add();
+
+from("direct:template")
+ .to("direct:bar");
+
+----
+
+
+//include::camel-spring-boot::page$kamelet-starter.adoc[]
diff --git a/parent/pom.xml b/parent/pom.xml
index 624809f..ecb9331 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -1807,6 +1807,11 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-kamelet</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-kubernetes</artifactId>
<version>${project.version}</version>
</dependency>