This is an automated email from the ASF dual-hosted git repository.
davsclaus 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 edd0eee [CAMEL-14159] camel-elytron - Security component (#3401)
edd0eee is described below
commit edd0eee7a5dd083814ed38b30d2fa0417c4e1d9c
Author: JiriOndrusek <jondr...@redhat.com>
AuthorDate: Fri Dec 20 19:40:41 2019 +0100
[CAMEL-14159] camel-elytron - Security component (#3401)
---
apache-camel/pom.xml | 5 +
apache-camel/src/main/descriptors/common-bin.xml | 1 +
bom/camel-bom/pom.xml | 5 +
components/camel-elytron/pom.xml | 161 +++
.../src/main/docs/elytron-component.adoc | 166 +++
.../camel/component/elytron/ElytronComponent.java | 175 +++
.../camel/component/elytron/ElytronConsumer.java | 85 ++
.../camel/component/elytron/ElytronEndpoint.java | 90 ++
.../camel/component/elytron/BaseElytronTest.java | 113 ++
.../component/elytron/ElytronBearerTokenTest.java | 126 ++
.../src/test/resources/log4j2.properties | 29 +
components/pom.xml | 1 +
.../builder/endpoint/EndpointBuilderFactory.java | 1 +
.../dsl/ElytronEndpointBuilderFactory.java | 1352 ++++++++++++++++++++
parent/pom.xml | 10 +
15 files changed, 2320 insertions(+)
diff --git a/apache-camel/pom.xml b/apache-camel/pom.xml
index e7065c27..56023a4 100644
--- a/apache-camel/pom.xml
+++ b/apache-camel/pom.xml
@@ -553,6 +553,11 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-elytron</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-etcd</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/apache-camel/src/main/descriptors/common-bin.xml
b/apache-camel/src/main/descriptors/common-bin.xml
index 1497974..4387b66 100644
--- a/apache-camel/src/main/descriptors/common-bin.xml
+++ b/apache-camel/src/main/descriptors/common-bin.xml
@@ -131,6 +131,7 @@
<include>org.apache.camel:camel-ehcache</include>
<include>org.apache.camel:camel-elasticsearch-rest</include>
<include>org.apache.camel:camel-elsql</include>
+ <include>org.apache.camel:camel-elytron</include>
<include>org.apache.camel:camel-etcd</include>
<include>org.apache.camel:camel-eventadmin</include>
<include>org.apache.camel:camel-exec</include>
diff --git a/bom/camel-bom/pom.xml b/bom/camel-bom/pom.xml
index e01c2cc..9b0f974 100644
--- a/bom/camel-bom/pom.xml
+++ b/bom/camel-bom/pom.xml
@@ -569,6 +569,11 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-elytron</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-endpointdsl</artifactId>
<version>${project.version}</version>
</dependency>
diff --git a/components/camel-elytron/pom.xml b/components/camel-elytron/pom.xml
new file mode 100644
index 0000000..6dbfaa2
--- /dev/null
+++ b/components/camel-elytron/pom.xml
@@ -0,0 +1,161 @@
+<?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.1.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>camel-elytron</artifactId>
+ <packaging>jar</packaging>
+
+ <name>Camel :: Elytron</name>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-undertow</artifactId>
+ </dependency>
+
+ <dependency>
+ <groupId>org.wildfly.security</groupId>
+ <artifactId>wildfly-elytron</artifactId>
+ <version>${wildfly-elytron}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.wildfly.security.elytron-web</groupId>
+ <artifactId>undertow-server</artifactId>
+ <version>${elytron-web}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.wildfly.security.elytron-web</groupId>
+ <artifactId>undertow-server-servlet</artifactId>
+ <version>${elytron-web}</version>
+ </dependency>
+ <dependency>
+ <groupId>io.undertow</groupId>
+ <artifactId>undertow-servlet</artifactId>
+ <version>${undertow-version}</version>
+ </dependency>
+ <dependency>
+ <groupId>com.fasterxml.jackson.jaxrs</groupId>
+ <artifactId>jackson-jaxrs-json-provider</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>javax.json</groupId>
+ <artifactId>javax.json-api</artifactId>
+ <version>${json-api}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish</groupId>
+ <artifactId>javax.json</artifactId>
+ <version>${glassfish-javax-json}</version>
+ </dependency>
+
+ <dependency>
+ <groupId>com.nimbusds</groupId>
+ <artifactId>nimbus-jose-jwt</artifactId>
+ <version>${nimbus-jose-jwt}</version>
+ </dependency>
+
+ <!-- testing -->
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-test</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-test-spring</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>commons-httpclient</groupId>
+ <artifactId>commons-httpclient</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-http</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-rest</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-jackson</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-jaxb</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-swagger-java</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.asynchttpclient</groupId>
+ <artifactId>async-http-client</artifactId>
+ <version>${ahc-version}</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-api</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-core</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.logging.log4j</groupId>
+ <artifactId>log4j-slf4j-impl</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.httpcomponents</groupId>
+ <artifactId>httpmime</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+
+</project>
diff --git a/components/camel-elytron/src/main/docs/elytron-component.adoc
b/components/camel-elytron/src/main/docs/elytron-component.adoc
new file mode 100644
index 0000000..ad85ff8
--- /dev/null
+++ b/components/camel-elytron/src/main/docs/elytron-component.adoc
@@ -0,0 +1,166 @@
+[[elytron-component]]
+= Elytron Component
+
+*Since Camel 3.1*
+
+// HEADER START
+*Both producer and consumer is supported*
+// HEADER END
+
+*OSGi is not supported*
+
+The Elytron component provides Elytron security over camel-undertow component.
+It extends camel-undertow component and adds several parameters.
+In componont it is securityDomainBuilder and mechanismName, in endpoint it is
allowedRoles.
+
+User has to define its SecurityDomain.Builder, which will be used for creation
of security domain.
+MechanismName then allows to define mechanism, which will take care of
authentication from security context.
+(MechanismName should be selected with regard to default securityRealm. For
example: to use bearer_token security, mechanism name has to be "BEARER_TOKEN"
+and realm has to be TokenSecurityRealm.)
+ElytronProvider has to be defined with respect of mechnismName.
+
+Each exchange created by Elytron endpoint contains header 'securityIdentity'
with current Elytron's secrity identity as value.
+('org.wildfly.security.auth.server.SecurityIdentity')
+
+Maven users will need to add the following dependency to their `pom.xml`
+for this component:
+
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-elytron</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+----
+
+== URI format
+
+[source,text]
+----
+elytron:http://hostname[:port][/resourceUri][?options]
+elytron:https://hostname[:port][/resourceUri][?options]
+----
+
+You can append query options to the URI in the following format,
+`?option=value&option=value&...`
+
+== Options
+
+// component options: START
+The Elytron component supports 11 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *securityDomainBuilder* (elytron) | *Required* Definition of Builder, which
will be used for creation of security domain. | | Builder
+| *mechanismName* (elytron) | Name of the mechanism, which will be used for
selection of authentication mechanism. | BEARER_TOKEN | String
+| *elytronProvider* (elytron) | Elytron security provider, has to support
mechanism from parameter mechanismName. | instance of
WildFlyElytronHttpBearerProvider | WildFlyElytronBaseProvider
+| *undertowHttpBinding* (advanced) | To use a custom HttpBinding to control
the mapping between Camel message and HttpClient. | | UndertowHttpBinding
+| *sslContextParameters* (security) | To configure security using
SSLContextParameters | | SSLContextParameters
+| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL
context parameters. | false | boolean
+| *hostOptions* (advanced) | To configure common options, such as thread pools
| | UndertowHostOptions
+| *muteException* (consumer) | If enabled and an Exchange failed processing on
the consumer side the response's body won't contain the exception's stack
trace. | false | boolean
+| *basicPropertyBinding* (advanced) | Whether the component should use basic
property binding (Camel 2.x) or the newer property binding with additional
capabilities | false | boolean
+| *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 [...]
+| *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
+|===
+// component options: END
+
+
+// endpoint options: START
+The Elytron endpoint is configured using URI syntax:
+
+----
+elytron:httpURI
+----
+
+with the following path and query parameters:
+
+=== Path Parameters (1 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *httpURI* | *Required* The url of the HTTP endpoint to use. | | URI
+|===
+
+
+=== Query Parameters (29 parameters):
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *allowedRoles* (allowedRoles) | Comma separated list of allowed roles. | |
String
+| *useStreaming* (common) | For HTTP endpoint: if true, text and binary
messages will be wrapped as java.io.InputStream before they are passed to an
Exchange; otherwise they will be passed as byte. For WebSocket endpoint: if
true, text and binary messages will be wrapped as java.io.Reader and
java.io.InputStream respectively before they are passed to an Exchange;
otherwise they will be passed as String and byte respectively. | false | boolean
+| *accessLog* (consumer) | Whether or not the consumer should write access log
| false | Boolean
+| *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
+| *httpMethodRestrict* (consumer) | Used to only allow consuming if the
HttpMethod matches, such as GET/POST/PUT etc. Multiple methods can be specified
separated by comma. | | String
+| *matchOnUriPrefix* (consumer) | Whether or not the consumer should try to
find a target consumer by matching the URI prefix if no exact match is found. |
false | Boolean
+| *muteException* (consumer) | If enabled and an Exchange failed processing on
the consumer side the response's body won't contain the exception's stack
trace. | false | Boolean
+| *optionsEnabled* (consumer) | Specifies whether to enable HTTP OPTIONS for
this Servlet consumer. By default OPTIONS is turned off. | 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. | | ExchangePattern
+| *handlers* (consumer) | Specifies a comma-delimited set of
io.undertow.server.HttpHandler instances in your Registry (such as your Spring
ApplicationContext). These handlers are added to the Undertow handler chain
(for example, to add security). Important: You can not use different handlers
with different Undertow endpoints using the same port number. The handlers is
associated to the port number. If you need different handlers, then use
different port numbers. | | String
+| *cookieHandler* (producer) | Configure a cookie handler to maintain a HTTP
session | | CookieHandler
+| *keepAlive* (producer) | Setting to ensure socket is not closed due to
inactivity | 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 [...]
+| *options* (producer) | Sets additional channel options. The options that can
be used are defined in org.xnio.Options. To configure from endpoint uri, then
prefix each option with option., such as
option.close-abort=true&option.send-buffer=8192 | | Map
+| *preserveHostHeader* (producer) | If the option is true, UndertowProducer
will set the Host header to the value contained in the current exchange Host
header, useful in reverse proxy applications where you want the Host header
received by the downstream server to reflect the URL called by the upstream
client, this allows applications which use the Host header to generate accurate
URL's for a proxied service. | true | boolean
+| *reuseAddresses* (producer) | Setting to facilitate socket multiplexing |
true | Boolean
+| *tcpNoDelay* (producer) | Setting to improve TCP protocol performance | true
| Boolean
+| *throwExceptionOnFailure* (producer) | Option to disable throwing the
HttpOperationFailedException in case of failed responses from the remote
server. This allows you to get all responses regardless of the HTTP status
code. | true | Boolean
+| *transferException* (producer) | If enabled and an Exchange failed
processing on the consumer side and if the caused Exception was send back
serialized in the response as a application/x-java-serialized-object content
type. On the producer side the exception will be deserialized and thrown as is
instead of the HttpOperationFailedException. The caused exception is required
to be serialized. This is by default turned off. If you enable this then be
aware that Java will deserialize the in [...]
+| *accessLogReceiver* (advanced) | Which Undertow AccessLogReciever should be
used Will use JBossLoggingAccessLogReceiver if not specifid | |
AccessLogReceiver
+| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic
property binding (Camel 2.x) or the newer property binding with additional
capabilities | false | boolean
+| *headerFilterStrategy* (advanced) | To use a custom HeaderFilterStrategy to
filter header to and from Camel message. | | HeaderFilterStrategy
+| *synchronous* (advanced) | Sets whether synchronous processing should be
strictly used, or Camel is allowed to use asynchronous processing (if
supported). | false | boolean
+| *undertowHttpBinding* (advanced) | To use a custom UndertowHttpBinding to
control the mapping between Camel message and undertow. | | UndertowHttpBinding
+| *fireWebSocketChannelEvents* (websocket) | if true, the consumer will post
notifications to the route when a new WebSocket peer connects, disconnects,
etc. See UndertowConstants.EVENT_TYPE and EventType. | false | boolean
+| *sendTimeout* (websocket) | Timeout in milliseconds when sending to a
websocket channel. The default timeout is 30000 (30 seconds). | 30000 | Integer
+| *sendToAll* (websocket) | To send to all websocket subscribers. Can be used
to configure on endpoint level, instead of having to use the
UndertowConstants.SEND_TO_ALL header on the message. | | Boolean
+| *sslContextParameters* (security) | To configure security using
SSLContextParameters | | SSLContextParameters
+|===
+// endpoint options: END
+// spring-boot-auto-configure options: START
+== Spring Boot Auto-Configuration
+
+When using Spring Boot make sure to use the following Maven dependency to have
support for auto configuration:
+
+[source,xml]
+----
+<dependency>
+ <groupId>org.apache.camel.springboot</groupId>
+ <artifactId>camel-elytron-starter</artifactId>
+ <version>x.x.x</version>
+ <!-- use the same version as your Camel core version -->
+</dependency>
+----
+
+
+The component supports 12 options, which are listed below.
+
+
+
+[width="100%",cols="2,5,^1,2",options="header"]
+|===
+| Name | Description | Default | Type
+| *camel.component.elytron.basic-property-binding* | Whether the component
should use basic property binding (Camel 2.x) or the newer property binding
with additional capabilities | false | Boolean
+| *camel.component.elytron.bridge-error-handler* | 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
+| *camel.component.elytron.elytron-provider* | Elytron security provider, has
to support mechanism from parameter mechanismName. The option is a
org.wildfly.security.WildFlyElytronBaseProvider type. | | String
+| *camel.component.elytron.enabled* | Whether to enable auto configuration of
the elytron component. This is enabled by default. | | Boolean
+| *camel.component.elytron.host-options* | To configure common options, such
as thread pools. The option is a
org.apache.camel.component.undertow.UndertowHostOptions type. | | String
+| *camel.component.elytron.lazy-start-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 th [...]
+| *camel.component.elytron.mechanism-name* | Name of the mechanism, which will
be used for selection of authentication mechanism. | BEARER_TOKEN | String
+| *camel.component.elytron.mute-exception* | If enabled and an Exchange failed
processing on the consumer side the response's body won't contain the
exception's stack trace. | false | Boolean
+| *camel.component.elytron.security-domain-builder* | Definition of Builder,
which will be used for creation of security domain. The option is a
org.wildfly.security.auth.server.SecurityDomain.Builder type. | | String
+| *camel.component.elytron.ssl-context-parameters* | To configure security
using SSLContextParameters. The option is a
org.apache.camel.support.jsse.SSLContextParameters type. | | String
+| *camel.component.elytron.undertow-http-binding* | To use a custom
HttpBinding to control the mapping between Camel message and HttpClient. The
option is a org.apache.camel.component.undertow.UndertowHttpBinding type. | |
String
+| *camel.component.elytron.use-global-ssl-context-parameters* | Enable usage
of global SSL context parameters. | false | Boolean
+|===
+// spring-boot-auto-configure options: END
diff --git
a/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronComponent.java
b/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronComponent.java
new file mode 100644
index 0000000..da40433
--- /dev/null
+++
b/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronComponent.java
@@ -0,0 +1,175 @@
+/*
+ * 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.elytron;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.security.Provider;
+import java.util.Collections;
+
+import javax.net.ssl.SSLContext;
+
+import io.undertow.security.handlers.AuthenticationCallHandler;
+import io.undertow.security.handlers.AuthenticationConstraintHandler;
+import io.undertow.server.HttpHandler;
+import org.apache.camel.CamelContext;
+import org.apache.camel.component.undertow.HttpHandlerRegistrationInfo;
+import org.apache.camel.component.undertow.UndertowComponent;
+import org.apache.camel.component.undertow.UndertowEndpoint;
+import org.apache.camel.spi.Metadata;
+import org.apache.camel.spi.annotations.Component;
+import
org.wildfly.elytron.web.undertow.server.ElytronContextAssociationHandler;
+import org.wildfly.elytron.web.undertow.server.ElytronRunAsHandler;
+import org.wildfly.security.WildFlyElytronBaseProvider;
+import org.wildfly.security.auth.server.MechanismConfiguration;
+import org.wildfly.security.auth.server.MechanismConfigurationSelector;
+import org.wildfly.security.auth.server.MechanismRealmConfiguration;
+import org.wildfly.security.auth.server.SecurityDomain;
+import org.wildfly.security.auth.server.http.HttpAuthenticationFactory;
+import org.wildfly.security.http.HttpAuthenticationException;
+import org.wildfly.security.http.HttpConstants;
+import org.wildfly.security.http.HttpServerAuthenticationMechanismFactory;
+import org.wildfly.security.http.bearer.WildFlyElytronHttpBearerProvider;
+import org.wildfly.security.http.util.FilterServerMechanismFactory;
+import org.wildfly.security.http.util.SecurityProviderServerMechanismFactory;
+
+/**
+ * Elytron component brings elytron security over came-undertow component.
+ *
+ * Component work either as producer and as consumer.
+ *
+ * User has to define its SecurityDomain.Builder which will be used for
creation of security domain.
+ * MechanismName then allows to define mechanism, which will take care of
authentication from security context.
+ * MechanismName should be selected with regard to default securityRealm.
+ *
+ * Example: to use bearer_token, mechanism name has to be "BEARER_TOKEN" and
realm has to be TokenSecurityRealm.
+ *
+ * @author JiriOndrusek
+ */
+@Metadata(label = "verifiers", enums = "parameters,connectivity")
+@Component("elytron")
+public class ElytronComponent extends UndertowComponent {
+
+ @Metadata(label = "advanced", required = true)
+ private SecurityDomain.Builder securityDomainBuilder;
+ @Metadata(label = "advanced", defaultValue = HttpConstants.BEARER_TOKEN)
+ private String mechanismName = HttpConstants.BEARER_TOKEN;
+ @Metadata(label = "advanced", defaultValue = "instance of
WildFlyElytronHttpBearerProvider")
+ private WildFlyElytronBaseProvider elytronProvider =
WildFlyElytronHttpBearerProvider.getInstance();
+
+ private SecurityDomain securityDomain;
+
+ public ElytronComponent() {
+ }
+
+ public ElytronComponent(CamelContext context) {
+ super(context);
+ }
+
+ @Override
+ protected String getComponentName() {
+ return "elytron";
+ }
+
+
+ @Override
+ protected UndertowEndpoint createEndpointInstance(URI endpointUri,
UndertowComponent component) throws URISyntaxException {
+ return new ElytronEndpoint(endpointUri.toString(), component);
+ }
+
+ @Override
+ public HttpHandler registerEndpoint(HttpHandlerRegistrationInfo
registrationInfo, SSLContext sslContext, HttpHandler handler) {
+ //injecting elytron
+ return super.registerEndpoint(registrationInfo, sslContext,
wrap(handler, getSecurityDomain()));
+ }
+
+ /**
+ * Definition of Builder, which will be used for creation of security
domain.
+ */
+ public SecurityDomain.Builder getSecurityDomainBuilder() {
+ return securityDomainBuilder;
+ }
+
+ public void setSecurityDomainBuilder(SecurityDomain.Builder
securityDomainBuilder) {
+ this.securityDomainBuilder = securityDomainBuilder;
+ }
+
+ /**
+ * Name of the mechanism, which will be used for selection of
authentication mechanism.
+ */
+ public String getMechanismName() {
+ return mechanismName;
+ }
+
+ public void setMechanismName(String mechanismName) {
+ this.mechanismName = mechanismName;
+ }
+
+ /**
+ * Elytron security provider, has to support mechanism from parameter
mechanismName.
+ */
+ public WildFlyElytronBaseProvider getElytronProvider() {
+ return elytronProvider;
+ }
+
+ public void setElytronProvider(WildFlyElytronBaseProvider elytronProvider)
{
+ this.elytronProvider = elytronProvider;
+ }
+
+ SecurityDomain getSecurityDomain() {
+ if (securityDomain == null) {
+ securityDomain = securityDomainBuilder.build();
+ }
+
+ return securityDomain;
+ }
+
+ private HttpHandler wrap(final HttpHandler toWrap, final SecurityDomain
securityDomain) {
+ HttpAuthenticationFactory httpAuthenticationFactory =
createHttpAuthenticationFactory(securityDomain);
+
+ HttpHandler rootHandler = new ElytronRunAsHandler(toWrap);
+ rootHandler = new AuthenticationCallHandler(rootHandler);
+ rootHandler = new AuthenticationConstraintHandler(rootHandler);
+
+ return ElytronContextAssociationHandler.builder()
+ .setNext(rootHandler)
+ .setMechanismSupplier(() -> {
+ try {
+ return
Collections.singletonList(httpAuthenticationFactory.createMechanism(mechanismName));
+ } catch (HttpAuthenticationException e) {
+ throw new RuntimeException(e);
+ }
+ }).build();
+ }
+
+
+ private HttpAuthenticationFactory createHttpAuthenticationFactory(final
SecurityDomain securityDomain) {
+ HttpServerAuthenticationMechanismFactory providerFactory = new
SecurityProviderServerMechanismFactory(() -> new
Provider[]{getElytronProvider()});
+ HttpServerAuthenticationMechanismFactory httpServerMechanismFactory =
new FilterServerMechanismFactory(providerFactory, true, mechanismName);
+
+ return HttpAuthenticationFactory.builder()
+ .setSecurityDomain(securityDomain)
+
.setMechanismConfigurationSelector(MechanismConfigurationSelector.constantSelector(
+ MechanismConfiguration.builder()
+
.addMechanismRealm(MechanismRealmConfiguration.builder().setRealmName("Elytron
Realm").build())
+ .build()))
+ .setFactory(httpServerMechanismFactory)
+ .build();
+ }
+
+
+}
diff --git
a/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronConsumer.java
b/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronConsumer.java
new file mode 100644
index 0000000..bece847
--- /dev/null
+++
b/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronConsumer.java
@@ -0,0 +1,85 @@
+/*
+ * 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.elytron;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import io.undertow.server.HttpServerExchange;
+import io.undertow.util.StatusCodes;
+import org.apache.camel.Processor;
+import org.apache.camel.component.undertow.UndertowConsumer;
+import org.apache.camel.component.undertow.UndertowEndpoint;
+import org.wildfly.security.auth.server.SecurityIdentity;
+import org.wildfly.security.authz.Roles;
+
+
+
+/**
+ * Consumer contains decides if request contains required roles (which are
defined for endpoint)
+ *
+ * @author JiriOndrusek
+ */
+public class ElytronConsumer extends UndertowConsumer {
+
+ public ElytronConsumer(UndertowEndpoint endpoint, Processor processor) {
+ super(endpoint, processor);
+ }
+
+ public ElytronEndpoint getElytronEndpoint() {
+ return (ElytronEndpoint) super.getEndpoint();
+ }
+
+ @Override
+ public void handleRequest(HttpServerExchange httpExchange) throws
Exception {
+ SecurityIdentity identity =
getElytronEndpoint().getElytronComponent().getSecurityDomain().getCurrentSecurityIdentity();
+
+ if (identity != null) {
+ //already authenticated
+ Set<String> roles = new HashSet<>();
+ Roles identityRoles = identity.getRoles();
+
+ if (identityRoles != null) {
+ for (String roleName : identityRoles) {
+ roles.add(roleName);
+ }
+ }
+
+ if (isAllowed(roles, getElytronEndpoint().getAllowedRolesList())) {
+ super.handleRequest(httpExchange);
+ } else {
+ httpExchange.setStatusCode(StatusCodes.FORBIDDEN);
+ httpExchange.endExchange();
+ }
+
+ return;
+ }
+
+ super.handleRequest(httpExchange);
+ }
+
+ public boolean isAllowed(Set<String> roles, List<String> allowedRoles) {
+ for (String role : allowedRoles) {
+ if (roles.contains(role)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+}
diff --git
a/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronEndpoint.java
b/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronEndpoint.java
new file mode 100644
index 0000000..4893c40
--- /dev/null
+++
b/components/camel-elytron/src/main/java/org/apache/camel/component/elytron/ElytronEndpoint.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.elytron;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import io.undertow.server.HttpServerExchange;
+import org.apache.camel.Consumer;
+import org.apache.camel.Exchange;
+import org.apache.camel.Processor;
+import org.apache.camel.component.undertow.UndertowComponent;
+import org.apache.camel.component.undertow.UndertowEndpoint;
+import org.apache.camel.spi.UriEndpoint;
+import org.apache.camel.spi.UriParam;
+import org.wildfly.security.auth.server.SecurityIdentity;
+
+/**
+ * Endpoint
+ *
+ * @author JiriOndrusek
+ */
+@UriEndpoint(firstVersion = "3.1.0", scheme = "elytron", title = "Elytron",
syntax = "elytron:httpURI",
+ label = "http", lenientProperties = true, extendsScheme = "undertow")
+public class ElytronEndpoint extends UndertowEndpoint {
+
+ /**
+ * Name of the header which contains associated security identity if
request is authenticated.
+ */
+ public static final String SECURITY_IDENTITY_HEADER = "securityIdentity";
+
+ @UriParam(label = "common")
+ private String allowedRoles = "";
+ private List<String> allowedRolesList = Collections.emptyList();
+
+ public ElytronEndpoint(String uri, UndertowComponent component) {
+ super(uri, component);
+ }
+
+ public ElytronComponent getElytronComponent() {
+ return (ElytronComponent) super.getComponent();
+ }
+
+ @Override
+ public Consumer createConsumer(Processor processor) throws Exception {
+ return new ElytronConsumer(this, processor);
+ }
+
+ @Override
+ public Exchange createExchange(HttpServerExchange httpExchange) throws
Exception {
+ Exchange exchange = super.createExchange(httpExchange);
+
+ SecurityIdentity securityIdentity =
getElytronComponent().getSecurityDomain().getCurrentSecurityIdentity();
+ //add security principal to headers
+ exchange.getIn().setHeader(SECURITY_IDENTITY_HEADER, securityIdentity);
+
+ return exchange;
+ }
+
+ public List<String> getAllowedRolesList() {
+ return allowedRolesList;
+ }
+
+ /**
+ * Comma separated list of allowed roles.
+ */
+ public String getAllowedRoles() {
+ return allowedRoles;
+ }
+
+ public void setAllowedRoles(String allowedRoles) {
+ this.allowedRolesList = allowedRoles == null ? null :
Arrays.asList(allowedRoles.split("\\s*,\\s*"));
+ }
+}
diff --git
a/components/camel-elytron/src/test/java/org/apache/camel/component/elytron/BaseElytronTest.java
b/components/camel-elytron/src/test/java/org/apache/camel/component/elytron/BaseElytronTest.java
new file mode 100644
index 0000000..3a24744
--- /dev/null
+++
b/components/camel-elytron/src/test/java/org/apache/camel/component/elytron/BaseElytronTest.java
@@ -0,0 +1,113 @@
+/*
+ * 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.elytron;
+
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.NoSuchAlgorithmException;
+import java.util.Properties;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.BindToRegistry;
+import org.apache.camel.CamelContext;
+import org.apache.camel.test.AvailablePortFinder;
+import org.apache.camel.test.junit4.CamelTestSupport;
+import org.junit.BeforeClass;
+import org.wildfly.security.WildFlyElytronBaseProvider;
+import org.wildfly.security.auth.permission.LoginPermission;
+import org.wildfly.security.auth.realm.token.TokenSecurityRealm;
+import org.wildfly.security.auth.realm.token.validator.JwtValidator;
+import org.wildfly.security.auth.server.SecurityDomain;
+import org.wildfly.security.authz.RoleMapper;
+import org.wildfly.security.authz.Roles;
+import org.wildfly.security.http.HttpConstants;
+import org.wildfly.security.permission.PermissionVerifier;
+
+/**
+ * Base class of tests which allocates ports
+ */
+public abstract class BaseElytronTest extends CamelTestSupport {
+
+ private static volatile int port;
+ private static KeyPair keyPair;
+
+ private final AtomicInteger counter = new AtomicInteger(1);
+
+ abstract String getMechanismName();
+
+ abstract TokenSecurityRealm createBearerRealm() throws
NoSuchAlgorithmException;
+
+ abstract WildFlyElytronBaseProvider getElytronProvider();
+
+ @BeforeClass
+ public static void initPort() throws Exception {
+ port = AvailablePortFinder.getNextAvailable();
+ keyPair = null;
+ }
+
+ protected static int getPort() {
+ return port;
+ }
+
+ @BindToRegistry("prop")
+ public Properties loadProperties() throws Exception {
+
+ Properties prop = new Properties();
+ prop.setProperty("port", "" + getPort());
+ return prop;
+ }
+
+ @Override
+ protected CamelContext createCamelContext() throws Exception {
+ CamelContext context = super.createCamelContext();
+
+ context.getPropertiesComponent().setLocation("ref:prop");
+
+ context.getComponent("elytron",
ElytronComponent.class).setSecurityDomainBuilder(getSecurityDomainBuilder());
+ context.getComponent("elytron",
ElytronComponent.class).setMechanismName(getMechanismName());
+ context.getComponent("elytron",
ElytronComponent.class).setElytronProvider(getElytronProvider());
+
+ return context;
+ }
+
+ SecurityDomain.Builder getSecurityDomainBuilder() throws Exception {
+
+ SecurityDomain.Builder builder = SecurityDomain.builder()
+ .setDefaultRealmName("realm");
+
+ builder.addRealm("realm", createBearerRealm())
+ .build();
+
+
+ builder.setPermissionMapper((principal, roles) ->
PermissionVerifier.from(new LoginPermission()));
+ builder.setRoleMapper(RoleMapper.constant(Roles.of("guest")).or(roles
-> roles));
+
+ return builder;
+ }
+
+ public KeyPair getKeyPair() throws NoSuchAlgorithmException {
+ if (keyPair == null) {
+ keyPair = generateKeyPair();
+ }
+ return keyPair;
+ }
+
+ private KeyPair generateKeyPair() throws NoSuchAlgorithmException {
+ return KeyPairGenerator.getInstance("RSA").generateKeyPair();
+ }
+
+}
diff --git
a/components/camel-elytron/src/test/java/org/apache/camel/component/elytron/ElytronBearerTokenTest.java
b/components/camel-elytron/src/test/java/org/apache/camel/component/elytron/ElytronBearerTokenTest.java
new file mode 100644
index 0000000..922918a
--- /dev/null
+++
b/components/camel-elytron/src/test/java/org/apache/camel/component/elytron/ElytronBearerTokenTest.java
@@ -0,0 +1,126 @@
+/*
+ * 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.elytron;
+
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.util.Date;
+
+import com.nimbusds.jose.JOSEException;
+import com.nimbusds.jose.JWSAlgorithm;
+import com.nimbusds.jose.JWSHeader;
+import com.nimbusds.jose.crypto.RSASSASigner;
+import com.nimbusds.jwt.JWTClaimsSet;
+import com.nimbusds.jwt.SignedJWT;
+import io.undertow.util.Headers;
+import org.apache.camel.CamelExecutionException;
+import org.apache.camel.Exchange;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.http.common.HttpOperationFailedException;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.wildfly.security.WildFlyElytronBaseProvider;
+import org.wildfly.security.auth.realm.token.TokenSecurityRealm;
+import org.wildfly.security.auth.realm.token.validator.JwtValidator;
+import org.wildfly.security.authz.RoleDecoder;
+import org.wildfly.security.http.HttpConstants;
+import org.wildfly.security.http.bearer.WildFlyElytronHttpBearerProvider;
+
+public class ElytronBearerTokenTest extends BaseElytronTest {
+ private static final Logger LOG =
LoggerFactory.getLogger(ElytronBearerTokenTest.class);
+
+ @Override
+ String getMechanismName() {
+ return HttpConstants.BEARER_TOKEN;
+ }
+
+ @Override
+ TokenSecurityRealm createBearerRealm() throws NoSuchAlgorithmException {
+ return TokenSecurityRealm.builder().principalClaimName("username")
+
.validator(JwtValidator.builder().publicKey(getKeyPair().getPublic()).build()).build();
+ }
+
+ @Override
+ WildFlyElytronBaseProvider getElytronProvider() {
+ return WildFlyElytronHttpBearerProvider.getInstance();
+ }
+
+ @Test
+ public void testBearerToken() throws Exception {
+ String response =
template.requestBodyAndHeader("elytron:http://localhost:{{port}}/myapp";,
+ "empty body",
+ Headers.AUTHORIZATION.toString(),
+ "Bearer " + createToken("alice", "user", new Date(new
Date().getTime() + 10000), getKeyPair().getPrivate()),
+ String.class);
+ assertNotNull(response);
+ assertEquals("Hello alice!", response);
+ }
+
+ @Test
+ public void testBearerTokenBadRole() throws Exception {
+ HttpOperationFailedException httpOperationFailedException = null;
+ try {
+ String response =
template.requestBodyAndHeader("elytron:http://localhost:{{port}}/myapp";,
+ "empty body",
+ Headers.AUTHORIZATION.toString(),
+ "Bearer " + createToken("alice", "guest", new Date(new
Date().getTime() + 10000), getKeyPair().getPrivate()),
+ String.class);
+
+ } catch (CamelExecutionException exception) {
+ if (exception.getCause() instanceof HttpOperationFailedException)
{
+ httpOperationFailedException =
(HttpOperationFailedException)exception.getCause();
+ }
+ }
+
+ assertNotNull(httpOperationFailedException);
+ assertEquals(403, httpOperationFailedException.getStatusCode());
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() throws Exception {
+ return new RouteBuilder() {
+ public void configure() {
+
from("elytron:http://localhost:{{port}}/myapp?allowedRoles=user";)
+ .transform(simple("Hello
${in.header.securityIdentity.principal}!"));
+ }
+ };
+ }
+
+
+ private String createToken(String userName, String roles, Date
expirationDate, PrivateKey signingKey) {
+ JWTClaimsSet.Builder claimsSet = new JWTClaimsSet.Builder();
+
+ claimsSet.subject("123445667");
+ claimsSet.claim("username", userName);
+ claimsSet.audience("resource-server");
+ claimsSet.issuer("elytron.org");
+ claimsSet.claim(RoleDecoder.KEY_ROLES, roles);
+ claimsSet.expirationTime(expirationDate);
+
+ SignedJWT signedJWT = new SignedJWT(new JWSHeader(JWSAlgorithm.RS256),
claimsSet.build());
+
+ try {
+ signedJWT.sign(new RSASSASigner(signingKey));
+ } catch (JOSEException e) {
+ e.printStackTrace();
+ }
+
+ return signedJWT.serialize();
+ }
+}
diff --git a/components/camel-elytron/src/test/resources/log4j2.properties
b/components/camel-elytron/src/test/resources/log4j2.properties
new file mode 100644
index 0000000..d1607be
--- /dev/null
+++ b/components/camel-elytron/src/test/resources/log4j2.properties
@@ -0,0 +1,29 @@
+## ---------------------------------------------------------------------------
+## 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-elytron-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 = %d [%-15.15t] %-5p %-30.30c{1} - %m%n
+rootLogger.level = INFO
+rootLogger.appenderRef.file.ref = file
+
diff --git a/components/pom.xml b/components/pom.xml
index cf3a521..d674ae4 100644
--- a/components/pom.xml
+++ b/components/pom.xml
@@ -164,6 +164,7 @@
<module>camel-ehcache</module>
<module>camel-elasticsearch-rest</module>
<module>camel-elsql</module>
+ <module>camel-elytron</module>
<module>camel-etcd</module>
<module>camel-eventadmin</module>
<module>camel-exec</module>
diff --git
a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java
b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java
index b522fae..321d4b8 100644
---
a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java
+++
b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/EndpointBuilderFactory.java
@@ -101,6 +101,7 @@ public interface EndpointBuilderFactory extends
EhcacheEndpointBuilderFactory,
ElasticsearchEndpointBuilderFactory,
ElsqlEndpointBuilderFactory,
+ ElytronEndpointBuilderFactory,
EtcdEndpointBuilderFactory,
EventAdminEndpointBuilderFactory,
EventEndpointBuilderFactory,
diff --git
a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/ElytronEndpointBuilderFactory.java
b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/ElytronEndpointBuilderFactory.java
new file mode 100644
index 0000000..b958a2f
--- /dev/null
+++
b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/ElytronEndpointBuilderFactory.java
@@ -0,0 +1,1352 @@
+/*
+ * 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 java.util.Map;
+import java.util.Set;
+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;
+import org.apache.camel.spi.HeaderFilterStrategy;
+
+/**
+ * Endpoint
+ *
+ * Generated by camel-package-maven-plugin - do not edit this file!
+ */
+@Generated("org.apache.camel.maven.packaging.EndpointDslMojo")
+public interface ElytronEndpointBuilderFactory {
+
+
+ /**
+ * Builder for endpoint consumers for the Elytron component.
+ */
+ public interface ElytronEndpointConsumerBuilder
+ extends
+ EndpointConsumerBuilder {
+ default AdvancedElytronEndpointConsumerBuilder advanced() {
+ return (AdvancedElytronEndpointConsumerBuilder) this;
+ }
+ /**
+ * Comma separated list of allowed roles.
+ *
+ * The option is a: <code>java.lang.String</code> type.
+ *
+ * Group: allowedRoles
+ */
+ default ElytronEndpointConsumerBuilder allowedRoles(String
allowedRoles) {
+ doSetProperty("allowedRoles", allowedRoles);
+ return this;
+ }
+ /**
+ * For HTTP endpoint: if true, text and binary messages will be wrapped
+ * as java.io.InputStream before they are passed to an Exchange;
+ * otherwise they will be passed as byte. For WebSocket endpoint: if
+ * true, text and binary messages will be wrapped as java.io.Reader and
+ * java.io.InputStream respectively before they are passed to an
+ * Exchange; otherwise they will be passed as String and byte
+ * respectively.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: common
+ */
+ default ElytronEndpointConsumerBuilder useStreaming(boolean
useStreaming) {
+ doSetProperty("useStreaming", useStreaming);
+ return this;
+ }
+ /**
+ * For HTTP endpoint: if true, text and binary messages will be wrapped
+ * as java.io.InputStream before they are passed to an Exchange;
+ * otherwise they will be passed as byte. For WebSocket endpoint: if
+ * true, text and binary messages will be wrapped as java.io.Reader and
+ * java.io.InputStream respectively before they are passed to an
+ * Exchange; otherwise they will be passed as String and byte
+ * respectively.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: common
+ */
+ default ElytronEndpointConsumerBuilder useStreaming(String
useStreaming) {
+ doSetProperty("useStreaming", useStreaming);
+ return this;
+ }
+ /**
+ * Whether or not the consumer should write access log.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder accessLog(Boolean accessLog) {
+ doSetProperty("accessLog", accessLog);
+ return this;
+ }
+ /**
+ * Whether or not the consumer should write access log.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder accessLog(String accessLog) {
+ doSetProperty("accessLog", accessLog);
+ 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.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder 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.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder bridgeErrorHandler(
+ String bridgeErrorHandler) {
+ doSetProperty("bridgeErrorHandler", bridgeErrorHandler);
+ return this;
+ }
+ /**
+ * Used to only allow consuming if the HttpMethod matches, such as
+ * GET/POST/PUT etc. Multiple methods can be specified separated by
+ * comma.
+ *
+ * The option is a: <code>java.lang.String</code> type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder httpMethodRestrict(
+ String httpMethodRestrict) {
+ doSetProperty("httpMethodRestrict", httpMethodRestrict);
+ return this;
+ }
+ /**
+ * Whether or not the consumer should try to find a target consumer by
+ * matching the URI prefix if no exact match is found.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder matchOnUriPrefix(
+ Boolean matchOnUriPrefix) {
+ doSetProperty("matchOnUriPrefix", matchOnUriPrefix);
+ return this;
+ }
+ /**
+ * Whether or not the consumer should try to find a target consumer by
+ * matching the URI prefix if no exact match is found.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder matchOnUriPrefix(
+ String matchOnUriPrefix) {
+ doSetProperty("matchOnUriPrefix", matchOnUriPrefix);
+ return this;
+ }
+ /**
+ * If enabled and an Exchange failed processing on the consumer side
the
+ * response's body won't contain the exception's stack trace.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder muteException(
+ boolean muteException) {
+ doSetProperty("muteException", muteException);
+ return this;
+ }
+ /**
+ * If enabled and an Exchange failed processing on the consumer side
the
+ * response's body won't contain the exception's stack trace.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder muteException(
+ String muteException) {
+ doSetProperty("muteException", muteException);
+ return this;
+ }
+ /**
+ * Specifies whether to enable HTTP OPTIONS for this Servlet consumer.
+ * By default OPTIONS is turned off.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder optionsEnabled(
+ boolean optionsEnabled) {
+ doSetProperty("optionsEnabled", optionsEnabled);
+ return this;
+ }
+ /**
+ * Specifies whether to enable HTTP OPTIONS for this Servlet consumer.
+ * By default OPTIONS is turned off.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: consumer
+ */
+ default ElytronEndpointConsumerBuilder optionsEnabled(
+ String optionsEnabled) {
+ doSetProperty("optionsEnabled", optionsEnabled);
+ return this;
+ }
+ /**
+ * if true, the consumer will post notifications to the route when a
new
+ * WebSocket peer connects, disconnects, etc. See
+ * UndertowConstants.EVENT_TYPE and EventType.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: websocket
+ */
+ default ElytronEndpointConsumerBuilder fireWebSocketChannelEvents(
+ boolean fireWebSocketChannelEvents) {
+ doSetProperty("fireWebSocketChannelEvents",
fireWebSocketChannelEvents);
+ return this;
+ }
+ /**
+ * if true, the consumer will post notifications to the route when a
new
+ * WebSocket peer connects, disconnects, etc. See
+ * UndertowConstants.EVENT_TYPE and EventType.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: websocket
+ */
+ default ElytronEndpointConsumerBuilder fireWebSocketChannelEvents(
+ String fireWebSocketChannelEvents) {
+ doSetProperty("fireWebSocketChannelEvents",
fireWebSocketChannelEvents);
+ return this;
+ }
+ /**
+ * To configure security using SSLContextParameters.
+ *
+ * The option is a:
+ * <code>org.apache.camel.support.jsse.SSLContextParameters</code>
type.
+ *
+ * Group: security
+ */
+ default ElytronEndpointConsumerBuilder sslContextParameters(
+ Object sslContextParameters) {
+ doSetProperty("sslContextParameters", sslContextParameters);
+ return this;
+ }
+ /**
+ * To configure security using SSLContextParameters.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.support.jsse.SSLContextParameters</code>
type.
+ *
+ * Group: security
+ */
+ default ElytronEndpointConsumerBuilder sslContextParameters(
+ String sslContextParameters) {
+ doSetProperty("sslContextParameters", sslContextParameters);
+ return this;
+ }
+ }
+
+ /**
+ * Advanced builder for endpoint consumers for the Elytron component.
+ */
+ public interface AdvancedElytronEndpointConsumerBuilder
+ extends
+ EndpointConsumerBuilder {
+ default ElytronEndpointConsumerBuilder basic() {
+ return (ElytronEndpointConsumerBuilder) 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)
+ */
+ default AdvancedElytronEndpointConsumerBuilder 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)
+ */
+ default AdvancedElytronEndpointConsumerBuilder 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)
+ */
+ default AdvancedElytronEndpointConsumerBuilder 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)
+ */
+ default AdvancedElytronEndpointConsumerBuilder exchangePattern(
+ String exchangePattern) {
+ doSetProperty("exchangePattern", exchangePattern);
+ return this;
+ }
+ /**
+ * Specifies a comma-delimited set of io.undertow.server.HttpHandler
+ * instances in your Registry (such as your Spring ApplicationContext).
+ * These handlers are added to the Undertow handler chain (for example,
+ * to add security). Important: You can not use different handlers with
+ * different Undertow endpoints using the same port number. The
handlers
+ * is associated to the port number. If you need different handlers,
+ * then use different port numbers.
+ *
+ * The option is a:
+ *
<code>java.util.Set<org.apache.camel.component.undertow.HttpHandlerRegistrationInfo></code>
type.
+ *
+ * Group: consumer (advanced)
+ */
+ default AdvancedElytronEndpointConsumerBuilder handlers(
+ Set<Object> handlers) {
+ doSetProperty("handlers", handlers);
+ return this;
+ }
+ /**
+ * Specifies a comma-delimited set of io.undertow.server.HttpHandler
+ * instances in your Registry (such as your Spring ApplicationContext).
+ * These handlers are added to the Undertow handler chain (for example,
+ * to add security). Important: You can not use different handlers with
+ * different Undertow endpoints using the same port number. The
handlers
+ * is associated to the port number. If you need different handlers,
+ * then use different port numbers.
+ *
+ * The option will be converted to a
+ *
<code>java.util.Set<org.apache.camel.component.undertow.HttpHandlerRegistrationInfo></code>
type.
+ *
+ * Group: consumer (advanced)
+ */
+ default AdvancedElytronEndpointConsumerBuilder handlers(String
handlers) {
+ doSetProperty("handlers", handlers);
+ return this;
+ }
+ /**
+ * Which Undertow AccessLogReciever should be used Will use
+ * JBossLoggingAccessLogReceiver if not specifid.
+ *
+ * The option is a:
+ * <code>io.undertow.server.handlers.accesslog.AccessLogReceiver</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder accessLogReceiver(
+ Object accessLogReceiver) {
+ doSetProperty("accessLogReceiver", accessLogReceiver);
+ return this;
+ }
+ /**
+ * Which Undertow AccessLogReciever should be used Will use
+ * JBossLoggingAccessLogReceiver if not specifid.
+ *
+ * The option will be converted to a
+ * <code>io.undertow.server.handlers.accesslog.AccessLogReceiver</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder accessLogReceiver(
+ String accessLogReceiver) {
+ doSetProperty("accessLogReceiver", accessLogReceiver);
+ return this;
+ }
+ /**
+ * Whether the endpoint should use basic property binding (Camel 2.x)
or
+ * the newer property binding with additional capabilities.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder basicPropertyBinding(
+ boolean basicPropertyBinding) {
+ doSetProperty("basicPropertyBinding", basicPropertyBinding);
+ return this;
+ }
+ /**
+ * Whether the endpoint should use basic property binding (Camel 2.x)
or
+ * the newer property binding with additional capabilities.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder basicPropertyBinding(
+ String basicPropertyBinding) {
+ doSetProperty("basicPropertyBinding", basicPropertyBinding);
+ return this;
+ }
+ /**
+ * To use a custom HeaderFilterStrategy to filter header to and from
+ * Camel message.
+ *
+ * The option is a:
+ * <code>org.apache.camel.spi.HeaderFilterStrategy</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder headerFilterStrategy(
+ HeaderFilterStrategy headerFilterStrategy) {
+ doSetProperty("headerFilterStrategy", headerFilterStrategy);
+ return this;
+ }
+ /**
+ * To use a custom HeaderFilterStrategy to filter header to and from
+ * Camel message.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.spi.HeaderFilterStrategy</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder headerFilterStrategy(
+ String headerFilterStrategy) {
+ doSetProperty("headerFilterStrategy", headerFilterStrategy);
+ return this;
+ }
+ /**
+ * Sets whether synchronous processing should be strictly used, or
Camel
+ * is allowed to use asynchronous processing (if supported).
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder synchronous(
+ boolean synchronous) {
+ doSetProperty("synchronous", synchronous);
+ return this;
+ }
+ /**
+ * Sets whether synchronous processing should be strictly used, or
Camel
+ * is allowed to use asynchronous processing (if supported).
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder synchronous(
+ String synchronous) {
+ doSetProperty("synchronous", synchronous);
+ return this;
+ }
+ /**
+ * To use a custom UndertowHttpBinding to control the mapping between
+ * Camel message and undertow.
+ *
+ * The option is a:
+ * <code>org.apache.camel.component.undertow.UndertowHttpBinding</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder undertowHttpBinding(
+ Object undertowHttpBinding) {
+ doSetProperty("undertowHttpBinding", undertowHttpBinding);
+ return this;
+ }
+ /**
+ * To use a custom UndertowHttpBinding to control the mapping between
+ * Camel message and undertow.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.component.undertow.UndertowHttpBinding</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointConsumerBuilder undertowHttpBinding(
+ String undertowHttpBinding) {
+ doSetProperty("undertowHttpBinding", undertowHttpBinding);
+ return this;
+ }
+ }
+
+ /**
+ * Builder for endpoint producers for the Elytron component.
+ */
+ public interface ElytronEndpointProducerBuilder
+ extends
+ EndpointProducerBuilder {
+ default AdvancedElytronEndpointProducerBuilder advanced() {
+ return (AdvancedElytronEndpointProducerBuilder) this;
+ }
+ /**
+ * Comma separated list of allowed roles.
+ *
+ * The option is a: <code>java.lang.String</code> type.
+ *
+ * Group: allowedRoles
+ */
+ default ElytronEndpointProducerBuilder allowedRoles(String
allowedRoles) {
+ doSetProperty("allowedRoles", allowedRoles);
+ return this;
+ }
+ /**
+ * For HTTP endpoint: if true, text and binary messages will be wrapped
+ * as java.io.InputStream before they are passed to an Exchange;
+ * otherwise they will be passed as byte. For WebSocket endpoint: if
+ * true, text and binary messages will be wrapped as java.io.Reader and
+ * java.io.InputStream respectively before they are passed to an
+ * Exchange; otherwise they will be passed as String and byte
+ * respectively.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: common
+ */
+ default ElytronEndpointProducerBuilder useStreaming(boolean
useStreaming) {
+ doSetProperty("useStreaming", useStreaming);
+ return this;
+ }
+ /**
+ * For HTTP endpoint: if true, text and binary messages will be wrapped
+ * as java.io.InputStream before they are passed to an Exchange;
+ * otherwise they will be passed as byte. For WebSocket endpoint: if
+ * true, text and binary messages will be wrapped as java.io.Reader and
+ * java.io.InputStream respectively before they are passed to an
+ * Exchange; otherwise they will be passed as String and byte
+ * respectively.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: common
+ */
+ default ElytronEndpointProducerBuilder useStreaming(String
useStreaming) {
+ doSetProperty("useStreaming", useStreaming);
+ return this;
+ }
+ /**
+ * Configure a cookie handler to maintain a HTTP session.
+ *
+ * The option is a:
+ * <code>org.apache.camel.http.common.cookie.CookieHandler</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder cookieHandler(
+ Object cookieHandler) {
+ doSetProperty("cookieHandler", cookieHandler);
+ return this;
+ }
+ /**
+ * Configure a cookie handler to maintain a HTTP session.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.http.common.cookie.CookieHandler</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder cookieHandler(
+ String cookieHandler) {
+ doSetProperty("cookieHandler", cookieHandler);
+ return this;
+ }
+ /**
+ * Setting to ensure socket is not closed due to inactivity.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder keepAlive(Boolean keepAlive) {
+ doSetProperty("keepAlive", keepAlive);
+ return this;
+ }
+ /**
+ * Setting to ensure socket is not closed due to inactivity.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder keepAlive(String keepAlive) {
+ doSetProperty("keepAlive", keepAlive);
+ 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.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder 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.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder lazyStartProducer(
+ String lazyStartProducer) {
+ doSetProperty("lazyStartProducer", lazyStartProducer);
+ return this;
+ }
+ /**
+ * Sets additional channel options. The options that can be used are
+ * defined in org.xnio.Options. To configure from endpoint uri, then
+ * prefix each option with option., such as
+ * option.close-abort=true&option.send-buffer=8192.
+ *
+ * The option is a: <code>java.util.Map<java.lang.String,
+ * java.lang.Object></code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder options(
+ Map<String, Object> options) {
+ doSetProperty("options", options);
+ return this;
+ }
+ /**
+ * Sets additional channel options. The options that can be used are
+ * defined in org.xnio.Options. To configure from endpoint uri, then
+ * prefix each option with option., such as
+ * option.close-abort=true&option.send-buffer=8192.
+ *
+ * The option will be converted to a
+ * <code>java.util.Map<java.lang.String, java.lang.Object></code>
+ * type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder options(String options) {
+ doSetProperty("options", options);
+ return this;
+ }
+ /**
+ * If the option is true, UndertowProducer will set the Host header to
+ * the value contained in the current exchange Host header, useful in
+ * reverse proxy applications where you want the Host header received
by
+ * the downstream server to reflect the URL called by the upstream
+ * client, this allows applications which use the Host header to
+ * generate accurate URL's for a proxied service.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder preserveHostHeader(
+ boolean preserveHostHeader) {
+ doSetProperty("preserveHostHeader", preserveHostHeader);
+ return this;
+ }
+ /**
+ * If the option is true, UndertowProducer will set the Host header to
+ * the value contained in the current exchange Host header, useful in
+ * reverse proxy applications where you want the Host header received
by
+ * the downstream server to reflect the URL called by the upstream
+ * client, this allows applications which use the Host header to
+ * generate accurate URL's for a proxied service.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder preserveHostHeader(
+ String preserveHostHeader) {
+ doSetProperty("preserveHostHeader", preserveHostHeader);
+ return this;
+ }
+ /**
+ * Setting to facilitate socket multiplexing.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder reuseAddresses(
+ Boolean reuseAddresses) {
+ doSetProperty("reuseAddresses", reuseAddresses);
+ return this;
+ }
+ /**
+ * Setting to facilitate socket multiplexing.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder reuseAddresses(
+ String reuseAddresses) {
+ doSetProperty("reuseAddresses", reuseAddresses);
+ return this;
+ }
+ /**
+ * Setting to improve TCP protocol performance.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder tcpNoDelay(Boolean tcpNoDelay) {
+ doSetProperty("tcpNoDelay", tcpNoDelay);
+ return this;
+ }
+ /**
+ * Setting to improve TCP protocol performance.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder tcpNoDelay(String tcpNoDelay) {
+ doSetProperty("tcpNoDelay", tcpNoDelay);
+ return this;
+ }
+ /**
+ * Option to disable throwing the HttpOperationFailedException in case
+ * of failed responses from the remote server. This allows you to get
+ * all responses regardless of the HTTP status code.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder throwExceptionOnFailure(
+ Boolean throwExceptionOnFailure) {
+ doSetProperty("throwExceptionOnFailure", throwExceptionOnFailure);
+ return this;
+ }
+ /**
+ * Option to disable throwing the HttpOperationFailedException in case
+ * of failed responses from the remote server. This allows you to get
+ * all responses regardless of the HTTP status code.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder throwExceptionOnFailure(
+ String throwExceptionOnFailure) {
+ doSetProperty("throwExceptionOnFailure", throwExceptionOnFailure);
+ return this;
+ }
+ /**
+ * If enabled and an Exchange failed processing on the consumer side
and
+ * if the caused Exception was send back serialized in the response as
a
+ * application/x-java-serialized-object content type. On the producer
+ * side the exception will be deserialized and thrown as is instead of
+ * the HttpOperationFailedException. The caused exception is required
to
+ * be serialized. This is by default turned off. If you enable this
then
+ * be aware that Java will deserialize the incoming data from the
+ * request to Java and that can be a potential security risk.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder transferException(
+ Boolean transferException) {
+ doSetProperty("transferException", transferException);
+ return this;
+ }
+ /**
+ * If enabled and an Exchange failed processing on the consumer side
and
+ * if the caused Exception was send back serialized in the response as
a
+ * application/x-java-serialized-object content type. On the producer
+ * side the exception will be deserialized and thrown as is instead of
+ * the HttpOperationFailedException. The caused exception is required
to
+ * be serialized. This is by default turned off. If you enable this
then
+ * be aware that Java will deserialize the incoming data from the
+ * request to Java and that can be a potential security risk.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: producer
+ */
+ default ElytronEndpointProducerBuilder transferException(
+ String transferException) {
+ doSetProperty("transferException", transferException);
+ return this;
+ }
+ /**
+ * Timeout in milliseconds when sending to a websocket channel. The
+ * default timeout is 30000 (30 seconds).
+ *
+ * The option is a: <code>java.lang.Integer</code> type.
+ *
+ * Group: websocket
+ */
+ default ElytronEndpointProducerBuilder sendTimeout(Integer
sendTimeout) {
+ doSetProperty("sendTimeout", sendTimeout);
+ return this;
+ }
+ /**
+ * Timeout in milliseconds when sending to a websocket channel. The
+ * default timeout is 30000 (30 seconds).
+ *
+ * The option will be converted to a <code>java.lang.Integer</code>
+ * type.
+ *
+ * Group: websocket
+ */
+ default ElytronEndpointProducerBuilder sendTimeout(String sendTimeout)
{
+ doSetProperty("sendTimeout", sendTimeout);
+ return this;
+ }
+ /**
+ * To send to all websocket subscribers. Can be used to configure on
+ * endpoint level, instead of having to use the
+ * UndertowConstants.SEND_TO_ALL header on the message.
+ *
+ * The option is a: <code>java.lang.Boolean</code> type.
+ *
+ * Group: websocket
+ */
+ default ElytronEndpointProducerBuilder sendToAll(Boolean sendToAll) {
+ doSetProperty("sendToAll", sendToAll);
+ return this;
+ }
+ /**
+ * To send to all websocket subscribers. Can be used to configure on
+ * endpoint level, instead of having to use the
+ * UndertowConstants.SEND_TO_ALL header on the message.
+ *
+ * The option will be converted to a <code>java.lang.Boolean</code>
+ * type.
+ *
+ * Group: websocket
+ */
+ default ElytronEndpointProducerBuilder sendToAll(String sendToAll) {
+ doSetProperty("sendToAll", sendToAll);
+ return this;
+ }
+ /**
+ * To configure security using SSLContextParameters.
+ *
+ * The option is a:
+ * <code>org.apache.camel.support.jsse.SSLContextParameters</code>
type.
+ *
+ * Group: security
+ */
+ default ElytronEndpointProducerBuilder sslContextParameters(
+ Object sslContextParameters) {
+ doSetProperty("sslContextParameters", sslContextParameters);
+ return this;
+ }
+ /**
+ * To configure security using SSLContextParameters.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.support.jsse.SSLContextParameters</code>
type.
+ *
+ * Group: security
+ */
+ default ElytronEndpointProducerBuilder sslContextParameters(
+ String sslContextParameters) {
+ doSetProperty("sslContextParameters", sslContextParameters);
+ return this;
+ }
+ }
+
+ /**
+ * Advanced builder for endpoint producers for the Elytron component.
+ */
+ public interface AdvancedElytronEndpointProducerBuilder
+ extends
+ EndpointProducerBuilder {
+ default ElytronEndpointProducerBuilder basic() {
+ return (ElytronEndpointProducerBuilder) this;
+ }
+ /**
+ * Which Undertow AccessLogReciever should be used Will use
+ * JBossLoggingAccessLogReceiver if not specifid.
+ *
+ * The option is a:
+ * <code>io.undertow.server.handlers.accesslog.AccessLogReceiver</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder accessLogReceiver(
+ Object accessLogReceiver) {
+ doSetProperty("accessLogReceiver", accessLogReceiver);
+ return this;
+ }
+ /**
+ * Which Undertow AccessLogReciever should be used Will use
+ * JBossLoggingAccessLogReceiver if not specifid.
+ *
+ * The option will be converted to a
+ * <code>io.undertow.server.handlers.accesslog.AccessLogReceiver</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder accessLogReceiver(
+ String accessLogReceiver) {
+ doSetProperty("accessLogReceiver", accessLogReceiver);
+ return this;
+ }
+ /**
+ * Whether the endpoint should use basic property binding (Camel 2.x)
or
+ * the newer property binding with additional capabilities.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder basicPropertyBinding(
+ boolean basicPropertyBinding) {
+ doSetProperty("basicPropertyBinding", basicPropertyBinding);
+ return this;
+ }
+ /**
+ * Whether the endpoint should use basic property binding (Camel 2.x)
or
+ * the newer property binding with additional capabilities.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder basicPropertyBinding(
+ String basicPropertyBinding) {
+ doSetProperty("basicPropertyBinding", basicPropertyBinding);
+ return this;
+ }
+ /**
+ * To use a custom HeaderFilterStrategy to filter header to and from
+ * Camel message.
+ *
+ * The option is a:
+ * <code>org.apache.camel.spi.HeaderFilterStrategy</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder headerFilterStrategy(
+ HeaderFilterStrategy headerFilterStrategy) {
+ doSetProperty("headerFilterStrategy", headerFilterStrategy);
+ return this;
+ }
+ /**
+ * To use a custom HeaderFilterStrategy to filter header to and from
+ * Camel message.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.spi.HeaderFilterStrategy</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder headerFilterStrategy(
+ String headerFilterStrategy) {
+ doSetProperty("headerFilterStrategy", headerFilterStrategy);
+ return this;
+ }
+ /**
+ * Sets whether synchronous processing should be strictly used, or
Camel
+ * is allowed to use asynchronous processing (if supported).
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder synchronous(
+ boolean synchronous) {
+ doSetProperty("synchronous", synchronous);
+ return this;
+ }
+ /**
+ * Sets whether synchronous processing should be strictly used, or
Camel
+ * is allowed to use asynchronous processing (if supported).
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder synchronous(
+ String synchronous) {
+ doSetProperty("synchronous", synchronous);
+ return this;
+ }
+ /**
+ * To use a custom UndertowHttpBinding to control the mapping between
+ * Camel message and undertow.
+ *
+ * The option is a:
+ * <code>org.apache.camel.component.undertow.UndertowHttpBinding</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder undertowHttpBinding(
+ Object undertowHttpBinding) {
+ doSetProperty("undertowHttpBinding", undertowHttpBinding);
+ return this;
+ }
+ /**
+ * To use a custom UndertowHttpBinding to control the mapping between
+ * Camel message and undertow.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.component.undertow.UndertowHttpBinding</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointProducerBuilder undertowHttpBinding(
+ String undertowHttpBinding) {
+ doSetProperty("undertowHttpBinding", undertowHttpBinding);
+ return this;
+ }
+ }
+
+ /**
+ * Builder for endpoint for the Elytron component.
+ */
+ public interface ElytronEndpointBuilder
+ extends
+ ElytronEndpointConsumerBuilder, ElytronEndpointProducerBuilder
{
+ default AdvancedElytronEndpointBuilder advanced() {
+ return (AdvancedElytronEndpointBuilder) this;
+ }
+ /**
+ * Comma separated list of allowed roles.
+ *
+ * The option is a: <code>java.lang.String</code> type.
+ *
+ * Group: allowedRoles
+ */
+ default ElytronEndpointBuilder allowedRoles(String allowedRoles) {
+ doSetProperty("allowedRoles", allowedRoles);
+ return this;
+ }
+ /**
+ * For HTTP endpoint: if true, text and binary messages will be wrapped
+ * as java.io.InputStream before they are passed to an Exchange;
+ * otherwise they will be passed as byte. For WebSocket endpoint: if
+ * true, text and binary messages will be wrapped as java.io.Reader and
+ * java.io.InputStream respectively before they are passed to an
+ * Exchange; otherwise they will be passed as String and byte
+ * respectively.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: common
+ */
+ default ElytronEndpointBuilder useStreaming(boolean useStreaming) {
+ doSetProperty("useStreaming", useStreaming);
+ return this;
+ }
+ /**
+ * For HTTP endpoint: if true, text and binary messages will be wrapped
+ * as java.io.InputStream before they are passed to an Exchange;
+ * otherwise they will be passed as byte. For WebSocket endpoint: if
+ * true, text and binary messages will be wrapped as java.io.Reader and
+ * java.io.InputStream respectively before they are passed to an
+ * Exchange; otherwise they will be passed as String and byte
+ * respectively.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: common
+ */
+ default ElytronEndpointBuilder useStreaming(String useStreaming) {
+ doSetProperty("useStreaming", useStreaming);
+ return this;
+ }
+ /**
+ * To configure security using SSLContextParameters.
+ *
+ * The option is a:
+ * <code>org.apache.camel.support.jsse.SSLContextParameters</code>
type.
+ *
+ * Group: security
+ */
+ default ElytronEndpointBuilder sslContextParameters(
+ Object sslContextParameters) {
+ doSetProperty("sslContextParameters", sslContextParameters);
+ return this;
+ }
+ /**
+ * To configure security using SSLContextParameters.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.support.jsse.SSLContextParameters</code>
type.
+ *
+ * Group: security
+ */
+ default ElytronEndpointBuilder sslContextParameters(
+ String sslContextParameters) {
+ doSetProperty("sslContextParameters", sslContextParameters);
+ return this;
+ }
+ }
+
+ /**
+ * Advanced builder for endpoint for the Elytron component.
+ */
+ public interface AdvancedElytronEndpointBuilder
+ extends
+ AdvancedElytronEndpointConsumerBuilder,
AdvancedElytronEndpointProducerBuilder {
+ default ElytronEndpointBuilder basic() {
+ return (ElytronEndpointBuilder) this;
+ }
+ /**
+ * Which Undertow AccessLogReciever should be used Will use
+ * JBossLoggingAccessLogReceiver if not specifid.
+ *
+ * The option is a:
+ * <code>io.undertow.server.handlers.accesslog.AccessLogReceiver</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder accessLogReceiver(
+ Object accessLogReceiver) {
+ doSetProperty("accessLogReceiver", accessLogReceiver);
+ return this;
+ }
+ /**
+ * Which Undertow AccessLogReciever should be used Will use
+ * JBossLoggingAccessLogReceiver if not specifid.
+ *
+ * The option will be converted to a
+ * <code>io.undertow.server.handlers.accesslog.AccessLogReceiver</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder accessLogReceiver(
+ String accessLogReceiver) {
+ doSetProperty("accessLogReceiver", accessLogReceiver);
+ return this;
+ }
+ /**
+ * Whether the endpoint should use basic property binding (Camel 2.x)
or
+ * the newer property binding with additional capabilities.
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder basicPropertyBinding(
+ boolean basicPropertyBinding) {
+ doSetProperty("basicPropertyBinding", basicPropertyBinding);
+ return this;
+ }
+ /**
+ * Whether the endpoint should use basic property binding (Camel 2.x)
or
+ * the newer property binding with additional capabilities.
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder basicPropertyBinding(
+ String basicPropertyBinding) {
+ doSetProperty("basicPropertyBinding", basicPropertyBinding);
+ return this;
+ }
+ /**
+ * To use a custom HeaderFilterStrategy to filter header to and from
+ * Camel message.
+ *
+ * The option is a:
+ * <code>org.apache.camel.spi.HeaderFilterStrategy</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder headerFilterStrategy(
+ HeaderFilterStrategy headerFilterStrategy) {
+ doSetProperty("headerFilterStrategy", headerFilterStrategy);
+ return this;
+ }
+ /**
+ * To use a custom HeaderFilterStrategy to filter header to and from
+ * Camel message.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.spi.HeaderFilterStrategy</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder headerFilterStrategy(
+ String headerFilterStrategy) {
+ doSetProperty("headerFilterStrategy", headerFilterStrategy);
+ return this;
+ }
+ /**
+ * Sets whether synchronous processing should be strictly used, or
Camel
+ * is allowed to use asynchronous processing (if supported).
+ *
+ * The option is a: <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder synchronous(boolean
synchronous) {
+ doSetProperty("synchronous", synchronous);
+ return this;
+ }
+ /**
+ * Sets whether synchronous processing should be strictly used, or
Camel
+ * is allowed to use asynchronous processing (if supported).
+ *
+ * The option will be converted to a <code>boolean</code> type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder synchronous(String synchronous)
{
+ doSetProperty("synchronous", synchronous);
+ return this;
+ }
+ /**
+ * To use a custom UndertowHttpBinding to control the mapping between
+ * Camel message and undertow.
+ *
+ * The option is a:
+ * <code>org.apache.camel.component.undertow.UndertowHttpBinding</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder undertowHttpBinding(
+ Object undertowHttpBinding) {
+ doSetProperty("undertowHttpBinding", undertowHttpBinding);
+ return this;
+ }
+ /**
+ * To use a custom UndertowHttpBinding to control the mapping between
+ * Camel message and undertow.
+ *
+ * The option will be converted to a
+ * <code>org.apache.camel.component.undertow.UndertowHttpBinding</code>
+ * type.
+ *
+ * Group: advanced
+ */
+ default AdvancedElytronEndpointBuilder undertowHttpBinding(
+ String undertowHttpBinding) {
+ doSetProperty("undertowHttpBinding", undertowHttpBinding);
+ return this;
+ }
+ }
+ /**
+ * Elytron (camel-elytron)
+ * Endpoint
+ *
+ * Category: http
+ * Since: 3.1
+ * Maven coordinates: org.apache.camel:camel-elytron
+ *
+ * Syntax: <code>elytron:httpURI</code>
+ *
+ * Path parameter: httpURI (required)
+ * The url of the HTTP endpoint to use.
+ */
+ default ElytronEndpointBuilder elytron(String path) {
+ class ElytronEndpointBuilderImpl extends AbstractEndpointBuilder
implements ElytronEndpointBuilder, AdvancedElytronEndpointBuilder {
+ public ElytronEndpointBuilderImpl(String path) {
+ super("elytron", path);
+ }
+ }
+ return new ElytronEndpointBuilderImpl(path);
+ }
+}
\ No newline at end of file
diff --git a/parent/pom.xml b/parent/pom.xml
index ad9fecb..e667057 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -183,6 +183,7 @@
<elasticsearch-rest-version>7.3.2</elasticsearch-rest-version>
<elasticsearch-rest-bundle-version>7.3.2_1</elasticsearch-rest-bundle-version>
<elsql-version>1.3</elsql-version>
+ <elytron-web>1.7.0.CR3</elytron-web>
<eddsa-version>0.3.0</eddsa-version>
<embedmongo-version>2.1.1</embedmongo-version>
<etcd4j-version>2.17.0</etcd4j-version>
@@ -328,6 +329,7 @@
<jaxb-bundle-version>2.3.1_1</jaxb-bundle-version>
<jakarta-api-version>2.1.5</jakarta-api-version>
<jakarta-jaxb-version>2.3.2</jakarta-jaxb-version>
+ <glassfish-javax-json>1.0.4</glassfish-javax-json>
<glassfish-jaxb-runtime-version>${jakarta-jaxb-version}</glassfish-jaxb-runtime-version>
<jaxb2-maven-plugin-version>2.5.0</jaxb2-maven-plugin-version>
<jbpm-version>7.31.0.Final</jbpm-version>
@@ -379,6 +381,7 @@
<jsch-version>0.1.55</jsch-version>
<jsch-bundle-version>0.1.55_1</jsch-bundle-version>
<json-accessors-smart-version>1.2</json-accessors-smart-version>
+ <json-api>1.0</json-api>
<jsonassert-version>1.5.0</jsonassert-version>
<json-flattener-version>0.7.1</json-flattener-version>
<json-path-version>2.4.0</json-path-version>
@@ -481,6 +484,7 @@
<netty-reactive-streams-version>2.0.3</netty-reactive-streams-version>
<netty40-version>4.0.56.Final</netty40-version>
<networknt-json-schema-validator-version>1.0.26</networknt-json-schema-validator-version>
+ <nimbus-jose-jwt>4.13.1</nimbus-jose-jwt>
<nitrite-version>3.3.0</nitrite-version>
<noggit-bundle-version>0.5_1</noggit-bundle-version>
<objenesis-version>2.6</objenesis-version>
@@ -647,6 +651,7 @@
<web3j-quorum-version>0.8.0</web3j-quorum-version>
<weld3-version>3.0.5.Final</weld3-version>
<werken-xpath-bundle-version>0.9.4_5</werken-xpath-bundle-version>
+ <wildfly-elytron>1.11.0.CR3</wildfly-elytron>
<wiremock-version>2.24.1</wiremock-version>
<woodstox-version>4.4.1</woodstox-version>
<woodstox-core-version>5.2.1</woodstox-core-version>
@@ -1276,6 +1281,11 @@
</dependency>
<dependency>
<groupId>org.apache.camel</groupId>
+ <artifactId>camel-elytron</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
<artifactId>camel-etcd</artifactId>
<version>${project.version}</version>
</dependency>
