This is an automated email from the ASF dual-hosted git repository.
jono pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-spring-boot.git
The following commit(s) were added to refs/heads/main by this push:
new beccc2f63c5 Camel-15211: configure ssl via auto config (#1003)
beccc2f63c5 is described below
commit beccc2f63c5931ab537207b631e2a500360a1b4d
Author: Jono Morris <[email protected]>
AuthorDate: Thu Nov 9 23:22:56 2023 +1300
Camel-15211: configure ssl via auto config (#1003)
Creates an configures a SSLContextParameters bean using camel.ssl.config
and camel.ssl properties with camel.ssl properties taking precedence.
---
.../camel-vertx-http-starter/pom.xml | 5 +
.../vertx/http/springboot/VertxHttpSSLTest.java | 107 +++++++++++
.../src/test/resources/application.properties | 17 ++
.../src/test/resources/cacerts | Bin 0 -> 109798 bytes
.../src/test/resources/keystore.p12 | Bin 0 -> 2574 bytes
.../src/test/resources/logback.xml | 41 +++++
.../springboot/VertxWebsocketSSLGlobalTest.java | 113 ++++++++++++
.../http/springboot/VertxWebsocketSSLTest.java | 117 ++++++++++++
.../src/test/resources/application.properties | 17 ++
.../src/test/resources/cacerts | Bin 0 -> 109798 bytes
.../src/test/resources/keystore.p12 | Bin 0 -> 2574 bytes
.../src/test/resources/logback.xml | 41 +++++
.../boot/security/CamelSSLAutoConfiguration.java | 179 ++++++++++++++++++-
.../security/CamelSSLConfigurationProperties.java | 52 +++---
.../security/CamelSSLAutoConfigurationTest.java | 198 ++++++++++++++++++++-
15 files changed, 854 insertions(+), 33 deletions(-)
diff --git a/components-starter/camel-vertx-http-starter/pom.xml
b/components-starter/camel-vertx-http-starter/pom.xml
index 9ab48e9df62..71198718579 100644
--- a/components-starter/camel-vertx-http-starter/pom.xml
+++ b/components-starter/camel-vertx-http-starter/pom.xml
@@ -39,6 +39,11 @@
<artifactId>camel-vertx-http</artifactId>
<version>${camel-version}</version>
</dependency>
+ <dependency>
+ <groupId>org.apache.camel</groupId>
+ <artifactId>camel-undertow</artifactId>
+ <scope>test</scope>
+ </dependency>
<!--START OF GENERATED CODE-->
<dependency>
<groupId>org.apache.camel.springboot</groupId>
diff --git
a/components-starter/camel-vertx-http-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxHttpSSLTest.java
b/components-starter/camel-vertx-http-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxHttpSSLTest.java
new file mode 100644
index 00000000000..e1d778249f4
--- /dev/null
+++
b/components-starter/camel-vertx-http-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxHttpSSLTest.java
@@ -0,0 +1,107 @@
+/*
+ * 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.vertx.http.springboot;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.spring.boot.CamelAutoConfiguration;
+import org.apache.camel.support.jsse.SSLContextParameters;
+import org.apache.camel.test.AvailablePortFinder;
+import org.apache.camel.test.spring.junit5.CamelSpringBootTest;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.annotation.DirtiesContext;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Testing camel.ssl.config and camel.ssl configuration using client and
server SSL properties.
+ */
+@CamelSpringBootTest
+@DirtiesContext
+@SpringBootApplication
+@SpringBootTest(
+ classes = {
+ CamelAutoConfiguration.class,
+ VertxHttpSSLTest.TestConfiguration.class
+ },
+ properties = {
+ "debug=false",
+ // camel.ssl.config
+ "camel.ssl.config.cert-alias=web",
+ "camel.ssl.config.key-managers.key-password=changeit",
+
"camel.ssl.config.key-managers.key-store.resource=/keystore.p12",
+ "camel.ssl.config.key-managers.key-store.password=changeit",
+ "camel.ssl.config.key-managers.key-store.type=PKCS12",
+ // camel.ssl
+ "camel.ssl.trust-managers.key-store.resource=/cacerts",
+ "camel.ssl.trust-managers.key-store.password=changeit",
+ "camel.ssl.trust-managers.key-store.type=jks"
+ }
+)
+public class VertxHttpSSLTest {
+
+ private static int port;
+
+ @Autowired
+ private CamelContext camelContext;
+
+ @BeforeAll
+ public static void init() {
+ port = AvailablePortFinder.getNextAvailable();
+ }
+
+ @Test
+ void testConsumeAsSecureClient() throws Exception {
+ ProducerTemplate template = camelContext.createProducerTemplate();
+ String result
+ = template.requestBody("vertx-http:https://localhost:"; + port
+ "?sslContextParameters=#clientSSLParameters",
+ null, String.class);
+ assertEquals("Hello World", result);
+ }
+
+ @Configuration
+ static class TestConfiguration {
+ @Autowired
+ private SSLContextParameters sslContext;
+
+ @Autowired
+ private CamelContext camelContext;
+
+ @Bean
+ public RouteBuilder routeBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+ camelContext.getRegistry().bind("clientSSLParameters",
sslContext);
+ camelContext.getRegistry().bind("serverSSLParameters",
camelContext.getSSLContextParameters());
+
+
fromF("undertow:https://localhost:%d?sslContextParameters=#serverSSLParameters";,
port)
+ .setBody(constant("Hello World"));
+ }
+ };
+ }
+ }
+
+}
diff --git
a/components-starter/camel-vertx-http-starter/src/test/resources/application.properties
b/components-starter/camel-vertx-http-starter/src/test/resources/application.properties
new file mode 100644
index 00000000000..420025891ae
--- /dev/null
+++
b/components-starter/camel-vertx-http-starter/src/test/resources/application.properties
@@ -0,0 +1,17 @@
+## ---------------------------------------------------------------------------
+## 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.
+## ---------------------------------------------------------------------------
+spring.main.banner-mode = off
diff --git
a/components-starter/camel-vertx-http-starter/src/test/resources/cacerts
b/components-starter/camel-vertx-http-starter/src/test/resources/cacerts
new file mode 100644
index 00000000000..902dc68ae57
Binary files /dev/null and
b/components-starter/camel-vertx-http-starter/src/test/resources/cacerts differ
diff --git
a/components-starter/camel-vertx-http-starter/src/test/resources/keystore.p12
b/components-starter/camel-vertx-http-starter/src/test/resources/keystore.p12
new file mode 100644
index 00000000000..677bae91e99
Binary files /dev/null and
b/components-starter/camel-vertx-http-starter/src/test/resources/keystore.p12
differ
diff --git
a/components-starter/camel-vertx-http-starter/src/test/resources/logback.xml
b/components-starter/camel-vertx-http-starter/src/test/resources/logback.xml
new file mode 100644
index 00000000000..e4d68679c47
--- /dev/null
+++ b/components-starter/camel-vertx-http-starter/src/test/resources/logback.xml
@@ -0,0 +1,41 @@
+<?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.
+
+-->
+<configuration>
+
+ <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+ <!-- encoders are assigned the type
+ ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+ <encoder>
+ <pattern>%d{HH:mm:ss.SSS} [%-15.15thread] %-5level %-30.30logger -
%msg%n</pattern>
+ </encoder>
+ </appender>
+
+ <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+ <encoder>
+ <pattern>%d{HH:mm:ss.SSS} [%-15.15thread] %-5level %-30.30logger -
%msg%n</pattern>
+ </encoder>
+ <file>target/camel-undertow-starter-test.log</file>
+ </appender>
+
+ <root level="INFO">
+ <appender-ref ref="FILE"/>
+ </root>
+
+</configuration>
diff --git
a/components-starter/camel-vertx-websocket-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxWebsocketSSLGlobalTest.java
b/components-starter/camel-vertx-websocket-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxWebsocketSSLGlobalTest.java
new file mode 100644
index 00000000000..74f111447b8
--- /dev/null
+++
b/components-starter/camel-vertx-websocket-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxWebsocketSSLGlobalTest.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.vertx.http.springboot;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.spring.boot.CamelAutoConfiguration;
+import org.apache.camel.support.jsse.SSLContextParameters;
+import org.apache.camel.test.AvailablePortFinder;
+import org.apache.camel.test.spring.junit5.CamelSpringBootTest;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.annotation.DirtiesContext;
+
+/**
+ * Testing camel.ssl.config and camel.ssl configuration using global ssl
context.
+ */
+@CamelSpringBootTest
+@DirtiesContext
+@SpringBootApplication
+@SpringBootTest(
+ classes = {
+ CamelAutoConfiguration.class,
+ VertxWebsocketSSLGlobalTest.TestConfiguration.class
+ },
+ properties = {
+ "debug=false",
+
"camel.component.vertx-websocket.use-global-ssl-context-parameters=true",
+ // camel.ssl.config
+ "camel.ssl.config.cert-alias=web",
+ "camel.ssl.config.key-managers.key-password=changeit",
+
"camel.ssl.config.key-managers.key-store.resource=/keystore.p12",
+ "camel.ssl.config.key-managers.key-store.password=changeit",
+ "camel.ssl.config.key-managers.key-store.type=PKCS12",
+ // camel.ssl
+ "camel.ssl.trust-managers.key-store.resource=/cacerts",
+ "camel.ssl.trust-managers.key-store.password=changeit",
+ "camel.ssl.trust-managers.key-store.type=jks"
+ }
+)
+public class VertxWebsocketSSLGlobalTest {
+ private static int port;
+
+ @Autowired
+ private CamelContext camelContext;
+
+ @BeforeAll
+ public static void init() {
+ port = AvailablePortFinder.getNextAvailable();
+ }
+
+ @Test
+ void testConsumeAsSecureClient() throws Exception {
+ MockEndpoint mockEndpoint = camelContext.getEndpoint("mock:result",
MockEndpoint.class);
+ mockEndpoint.expectedBodiesReceived("Hello world");
+
+ ProducerTemplate template = camelContext.createProducerTemplate();
+ template.sendBody("direct:start", "world");
+
+ mockEndpoint.assertIsSatisfied();
+ }
+
+ @Configuration
+ static class TestConfiguration {
+
+ @Autowired
+ private SSLContextParameters sslContext;
+
+ @Autowired
+ private CamelContext camelContext;
+
+ @Bean
+ public RouteBuilder routeBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+ // serverSSLParameters configured via
vertx-websocket.use-global-ssl-context-parameters prop
+ camelContext.getRegistry().bind("clientSSLParameters",
sslContext);
+
+ from("direct:start")
+
.toF("vertx-websocket:localhost:%d/echo?sslContextParameters=#clientSSLParameters",
port);
+
+ fromF("vertx-websocket:localhost:%d/echo", port)
+ .setBody(simple("Hello ${body}"))
+ .to("mock:result");
+ }
+ };
+ }
+ }
+
+}
diff --git
a/components-starter/camel-vertx-websocket-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxWebsocketSSLTest.java
b/components-starter/camel-vertx-websocket-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxWebsocketSSLTest.java
new file mode 100644
index 00000000000..27ee2c832d3
--- /dev/null
+++
b/components-starter/camel-vertx-websocket-starter/src/test/java/org/apache/camel/component/vertx/http/springboot/VertxWebsocketSSLTest.java
@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.vertx.http.springboot;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ProducerTemplate;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.apache.camel.spring.boot.CamelAutoConfiguration;
+import org.apache.camel.support.jsse.SSLContextParameters;
+import org.apache.camel.test.AvailablePortFinder;
+import org.apache.camel.test.spring.junit5.CamelSpringBootTest;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.test.annotation.DirtiesContext;
+
+/**
+ * Testing camel.ssl.config and camel.ssl configuration using client and
server SSL properties.
+ */
+@CamelSpringBootTest
+@DirtiesContext
+@SpringBootApplication
+@SpringBootTest(
+ classes = {
+ CamelAutoConfiguration.class,
+ VertxWebsocketSSLTest.TestConfiguration.class
+ },
+ properties = {
+ "debug=false",
+ // camel.ssl.config
+ "camel.ssl.config.cert-alias=web",
+ "camel.ssl.config.key-managers.key-password=changeit",
+
"camel.ssl.config.key-managers.key-store.resource=/keystore.p12",
+ "camel.ssl.config.key-managers.key-store.password=changeit",
+ "camel.ssl.config.key-managers.key-store.type=PKCS12",
+ // camel.ssl
+ "camel.ssl.trust-managers.key-store.resource=/cacerts",
+ "camel.ssl.trust-managers.key-store.password=changeit",
+ "camel.ssl.trust-managers.key-store.type=jks"
+ }
+)
+public class VertxWebsocketSSLTest {
+ private static int port;
+
+ @Autowired
+ private CamelContext camelContext;
+
+ @BeforeAll
+ public static void init() {
+ port = AvailablePortFinder.getNextAvailable();
+ }
+
+ @Test
+ void testConsumeAsSecureClient() throws Exception {
+ MockEndpoint mockEndpoint =
camelContext.getEndpoint("mock:result", MockEndpoint.class);
+ mockEndpoint.expectedMessageCount(5);
+
+ ProducerTemplate template = camelContext.createProducerTemplate();
+ String uri = "vertx-websocket:wss:localhost:" + port +
"/echo?sslContextParameters=#clientSSLParameters";
+ for (int i = 1; i <= 5; i++) {
+ template.sendBody(uri, "Hello World " + i);
+ }
+
+ mockEndpoint.assertIsSatisfied();
+ }
+
+ @Configuration
+ static class TestConfiguration {
+
+ @Autowired
+ private SSLContextParameters sslContext;
+
+ @Autowired
+ private CamelContext camelContext;
+
+ @Bean
+ public RouteBuilder routeBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+ camelContext.getRegistry().bind("clientSSLParameters",
sslContext);
+ camelContext.getRegistry().bind("serverSSLParameters",
camelContext.getSSLContextParameters());
+
+
fromF("vertx-websocket:localhost:%d/echo?sslContextParameters=#serverSSLParameters",
port)
+ .log("Server consumer received message: ${body}")
+
.toF("vertx-websocket:localhost:%d/echo?sendToAll=true&sslContextParameters=#clientSSLParameters",
+ port);
+
+
fromF("vertx-websocket:localhost:%d/echo?consumeAsClient=true&sslContextParameters=#clientSSLParameters",
port)
+ .log("Client consumer received message: ${body}")
+ .to("mock:result");
+ }
+ };
+ }
+ }
+
+}
diff --git
a/components-starter/camel-vertx-websocket-starter/src/test/resources/application.properties
b/components-starter/camel-vertx-websocket-starter/src/test/resources/application.properties
new file mode 100644
index 00000000000..420025891ae
--- /dev/null
+++
b/components-starter/camel-vertx-websocket-starter/src/test/resources/application.properties
@@ -0,0 +1,17 @@
+## ---------------------------------------------------------------------------
+## 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.
+## ---------------------------------------------------------------------------
+spring.main.banner-mode = off
diff --git
a/components-starter/camel-vertx-websocket-starter/src/test/resources/cacerts
b/components-starter/camel-vertx-websocket-starter/src/test/resources/cacerts
new file mode 100644
index 00000000000..902dc68ae57
Binary files /dev/null and
b/components-starter/camel-vertx-websocket-starter/src/test/resources/cacerts
differ
diff --git
a/components-starter/camel-vertx-websocket-starter/src/test/resources/keystore.p12
b/components-starter/camel-vertx-websocket-starter/src/test/resources/keystore.p12
new file mode 100644
index 00000000000..677bae91e99
Binary files /dev/null and
b/components-starter/camel-vertx-websocket-starter/src/test/resources/keystore.p12
differ
diff --git
a/components-starter/camel-vertx-websocket-starter/src/test/resources/logback.xml
b/components-starter/camel-vertx-websocket-starter/src/test/resources/logback.xml
new file mode 100644
index 00000000000..e4d68679c47
--- /dev/null
+++
b/components-starter/camel-vertx-websocket-starter/src/test/resources/logback.xml
@@ -0,0 +1,41 @@
+<?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.
+
+-->
+<configuration>
+
+ <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+ <!-- encoders are assigned the type
+ ch.qos.logback.classic.encoder.PatternLayoutEncoder by default -->
+ <encoder>
+ <pattern>%d{HH:mm:ss.SSS} [%-15.15thread] %-5level %-30.30logger -
%msg%n</pattern>
+ </encoder>
+ </appender>
+
+ <appender name="FILE" class="ch.qos.logback.core.FileAppender">
+ <encoder>
+ <pattern>%d{HH:mm:ss.SSS} [%-15.15thread] %-5level %-30.30logger -
%msg%n</pattern>
+ </encoder>
+ <file>target/camel-undertow-starter-test.log</file>
+ </appender>
+
+ <root level="INFO">
+ <appender-ref ref="FILE"/>
+ </root>
+
+</configuration>
diff --git
a/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfiguration.java
b/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfiguration.java
index 74078282348..83218f4ad41 100644
---
a/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfiguration.java
+++
b/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfiguration.java
@@ -19,9 +19,14 @@ package org.apache.camel.spring.boot.security;
import java.util.Collections;
import java.util.Map;
+import org.apache.camel.CamelContext;
+import org.apache.camel.main.MainHelper;
+import org.apache.camel.spi.ThreadPoolProfile;
import org.apache.camel.spring.boot.CamelAutoConfiguration;
-import org.apache.camel.support.jsse.GlobalSSLContextParametersSupplier;
-import org.apache.camel.support.jsse.SSLContextParameters;
+import org.apache.camel.support.jsse.*;
+import org.apache.camel.util.OrderedLocationProperties;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.condition.ConditionMessage;
import org.springframework.boot.autoconfigure.condition.ConditionOutcome;
@@ -36,18 +41,60 @@ import org.springframework.context.annotation.Configuration;
import org.springframework.core.type.AnnotatedTypeMetadata;
@Configuration(proxyBeanMethods = false)
-@AutoConfigureBefore(CamelAutoConfiguration.class)
+@AutoConfigureAfter(CamelAutoConfiguration.class)
@EnableConfigurationProperties(CamelSSLConfigurationProperties.class)
-@Conditional(CamelSSLAutoConfiguration.Condition.class)
public class CamelSSLAutoConfiguration {
@Bean
+ @Conditional(CamelSSLAutoConfiguration.SSLCondition.class)
+ public SSLContextParameters sslContextParameters(CamelContext
camelContext, CamelSSLConfigurationProperties properties) {
+ // use any camel.ssl.config props
+ SSLContextParameters sslContext =
camelContext.getSSLContextParameters() != null ?
+ copyParams(camelContext.getSSLContextParameters()) : new
SSLContextParameters();
+
+ // override with any camel.ssl props
+ SSLContextParameters config = new SSLContextBuilder(sslContext)
+ .certAlias(properties.getCertAlias())
+ .cipherSuites(properties.getCipherSuites())
+ .cipherSuitesFilter(properties.getCipherSuitesFilter())
+ .clientParameters(properties.getClientParameters())
+ .keyManagers(properties.getKeyManagers())
+ .provider(properties.getProvider())
+ .secureRandom(properties.getSecureRandom())
+ .secureSocketProtocol(properties.getSecureSocketProtocol())
+ .secureSocketProtocols(properties.getSecureSocketProtocols())
+
.secureSocketProtocolsFilter(properties.getSecureSocketProtocolsFilter())
+ .serverParameters(properties.getServerParameters())
+ .sessionTimeout(properties.getSessionTimeout())
+ .trustManager(properties.getTrustManagers())
+ .build();
+
+ return config;
+ }
+
+ @Bean
+ @Conditional(CamelSSLAutoConfiguration.SSLConfigCondition.class)
public GlobalSSLContextParametersSupplier
sslContextParametersSupplier(CamelSSLConfigurationProperties properties) {
final SSLContextParameters config = properties.getConfig() != null ?
properties.getConfig() : new SSLContextParameters();
return () -> config;
}
- public static class Condition extends SpringBootCondition {
+ public static class SSLCondition extends SpringBootCondition {
+ @Override
+ public ConditionOutcome getMatchOutcome(ConditionContext context,
AnnotatedTypeMetadata annotatedTypeMetadata) {
+ Binder binder = Binder.get(context.getEnvironment());
+ Map<String, Object> sslProperties = binder.bind("camel.ssl",
Bindable.mapOf(String.class, Object.class)).orElse(Collections.emptyMap());
+ sslProperties.remove("config");
+ ConditionMessage.Builder message =
ConditionMessage.forCondition("camel.ssl");
+ if (sslProperties.size() > 0) {
+ return ConditionOutcome.match(message.because("enabled"));
+ }
+
+ return ConditionOutcome.noMatch(message.because("not enabled"));
+ }
+ }
+
+ public static class SSLConfigCondition extends SpringBootCondition {
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context,
AnnotatedTypeMetadata annotatedTypeMetadata) {
Binder binder = Binder.get(context.getEnvironment());
@@ -61,4 +108,126 @@ public class CamelSSLAutoConfiguration {
}
}
+ private SSLContextParameters copyParams(SSLContextParameters
sslContextParameters) {
+ SSLContextParameters copy = new SSLContextParameters();
+ copy.setCertAlias(sslContextParameters.getCertAlias());
+ copy.setCipherSuites(sslContextParameters.getCipherSuites());
+
copy.setCipherSuitesFilter(sslContextParameters.getCipherSuitesFilter());
+ copy.setClientParameters(sslContextParameters.getClientParameters());
+ copy.setKeyManagers(sslContextParameters.getKeyManagers());
+ copy.setProvider(sslContextParameters.getProvider());
+ copy.setSecureRandom(sslContextParameters.getSecureRandom());
+
copy.setSecureSocketProtocol(sslContextParameters.getSecureSocketProtocol());
+
copy.setSecureSocketProtocols(sslContextParameters.getSecureSocketProtocols());
+
copy.setSecureSocketProtocolsFilter(sslContextParameters.getSecureSocketProtocolsFilter());
+ copy.setServerParameters(sslContextParameters.getServerParameters());
+ copy.setSessionTimeout(sslContextParameters.getSessionTimeout());
+ copy.setTrustManagers(sslContextParameters.getTrustManagers());
+ return copy;
+ }
+
+ private class SSLContextBuilder {
+
+ private SSLContextParameters sslContextParameters;
+
+ public SSLContextBuilder(SSLContextParameters sslContextParameters) {
+ this.sslContextParameters = sslContextParameters;
+ }
+
+ public SSLContextBuilder certAlias(String certAlias) {
+ if (certAlias != null) {
+ sslContextParameters.setCertAlias(certAlias);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder cipherSuites(CipherSuitesParameters
cipherSuites) {
+ if (cipherSuites != null) {
+ sslContextParameters.setCipherSuites(cipherSuites);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder cipherSuitesFilter(FilterParameters
cipherSuitesFilter) {
+ if (cipherSuitesFilter != null) {
+ sslContextParameters.setCipherSuitesFilter(cipherSuitesFilter);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder clientParameters(SSLContextClientParameters
clientParameters) {
+ if (clientParameters != null) {
+ sslContextParameters.setClientParameters(clientParameters);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder keyManagers(KeyManagersParameters
keyManagers) {
+ if (keyManagers != null) {
+ sslContextParameters.setKeyManagers(keyManagers);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder provider(String provider) {
+ if (provider != null) {
+ sslContextParameters.setProvider(provider);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder secureRandom(SecureRandomParameters
secureRandom) {
+ if (secureRandom != null) {
+ sslContextParameters.setSecureRandom(secureRandom);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder secureSocketProtocol(String
secureSocketProtocol) {
+ if (secureSocketProtocol != null) {
+
sslContextParameters.setSecureSocketProtocol(secureSocketProtocol);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder
secureSocketProtocols(SecureSocketProtocolsParameters secureSocketProtocols) {
+ if (secureSocketProtocols != null) {
+
sslContextParameters.setSecureSocketProtocols(secureSocketProtocols);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder secureSocketProtocolsFilter(FilterParameters
secureSocketProtocolsFilter) {
+ if (secureSocketProtocolsFilter != null) {
+
sslContextParameters.setSecureSocketProtocolsFilter(secureSocketProtocolsFilter);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder serverParameters(SSLContextServerParameters
serverParameters) {
+ if (serverParameters != null) {
+ sslContextParameters.setServerParameters(serverParameters);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder sessionTimeout(String sessionTimeout) {
+ if (sessionTimeout != null) {
+ sslContextParameters.setSessionTimeout(sessionTimeout);
+ }
+ return this;
+ }
+
+ public SSLContextBuilder trustManager(TrustManagersParameters
trustManager) {
+ if (trustManager != null) {
+ sslContextParameters.setTrustManagers(trustManager);
+ }
+ return this;
+ }
+
+ public SSLContextParameters build() {
+ return this.sslContextParameters;
+ }
+ }
+
}
diff --git
a/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLConfigurationProperties.java
b/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLConfigurationProperties.java
index b3e498e899b..b84441be995 100644
---
a/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLConfigurationProperties.java
+++
b/core/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/security/CamelSSLConfigurationProperties.java
@@ -128,107 +128,107 @@ public class CamelSSLConfigurationProperties {
}
public KeyManagersParameters getKeyManagers() {
- return config.getKeyManagers();
+ return this.keyManagers;
}
public void setKeyManagers(KeyManagersParameters keyManagers) {
- config.setKeyManagers(keyManagers);
+ this.keyManagers = keyManagers;
}
public TrustManagersParameters getTrustManagers() {
- return config.getTrustManagers();
+ return this.trustManagers;
}
public void setTrustManagers(TrustManagersParameters trustManagers) {
- config.setTrustManagers(trustManagers);
+ this.trustManagers = trustManagers;
}
public SecureRandomParameters getSecureRandom() {
- return config.getSecureRandom();
+ return this.secureRandom;
}
public void setSecureRandom(SecureRandomParameters secureRandom) {
- config.setSecureRandom(secureRandom);
+ this.secureRandom = secureRandom;
}
public SSLContextClientParameters getClientParameters() {
- return config.getClientParameters();
+ return this.clientParameters;
}
public void setClientParameters(SSLContextClientParameters
clientParameters) {
- config.setClientParameters(clientParameters);
+ this.clientParameters = clientParameters;
}
public SSLContextServerParameters getServerParameters() {
- return config.getServerParameters();
+ return this.serverParameters;
}
public void setServerParameters(SSLContextServerParameters
serverParameters) {
- config.setServerParameters(serverParameters);
+ this.serverParameters = serverParameters;
}
public String getProvider() {
- return config.getProvider();
+ return this.provider;
}
public void setProvider(String provider) {
- config.setProvider(provider);
+ this.provider = provider;
}
public String getSecureSocketProtocol() {
- return config.getSecureSocketProtocol();
+ return this.secureSocketProtocol;
}
public void setSecureSocketProtocol(String secureSocketProtocol) {
- config.setSecureSocketProtocol(secureSocketProtocol);
+ this.secureSocketProtocol = secureSocketProtocol;
}
public String getCertAlias() {
- return config.getCertAlias();
+ return this.certAlias;
}
public void setCertAlias(String certAlias) {
- config.setCertAlias(certAlias);
+ this.certAlias = certAlias;
}
public CipherSuitesParameters getCipherSuites() {
- return config.getCipherSuites();
+ return this.cipherSuites;
}
public void setCipherSuites(CipherSuitesParameters cipherSuites) {
- config.setCipherSuites(cipherSuites);
+ this.cipherSuites = cipherSuites;
}
public FilterParameters getCipherSuitesFilter() {
- return config.getCipherSuitesFilter();
+ return this.cipherSuitesFilter;
}
public void setCipherSuitesFilter(FilterParameters cipherSuitesFilter) {
- config.setCipherSuitesFilter(cipherSuitesFilter);
+ this.cipherSuitesFilter = cipherSuitesFilter;
}
public SecureSocketProtocolsParameters getSecureSocketProtocols() {
- return config.getSecureSocketProtocols();
+ return this.secureSocketProtocols;
}
public void setSecureSocketProtocols(SecureSocketProtocolsParameters
secureSocketProtocols) {
- config.setSecureSocketProtocols(secureSocketProtocols);
+ this.secureSocketProtocols = secureSocketProtocols;
}
public FilterParameters getSecureSocketProtocolsFilter() {
- return config.getSecureSocketProtocolsFilter();
+ return this.secureSocketProtocolsFilter;
}
public void setSecureSocketProtocolsFilter(FilterParameters
secureSocketProtocolsFilter) {
- config.setSecureSocketProtocolsFilter(secureSocketProtocolsFilter);
+ this.secureSocketProtocolsFilter = secureSocketProtocolsFilter;
}
public String getSessionTimeout() {
- return config.getSessionTimeout();
+ return this.sessionTimeout;
}
public void setSessionTimeout(String sessionTimeout) {
- config.setSessionTimeout(sessionTimeout);
+ this.sessionTimeout = sessionTimeout;
}
}
diff --git
a/core/camel-spring-boot/src/test/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfigurationTest.java
b/core/camel-spring-boot/src/test/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfigurationTest.java
index ddaf775fce1..594f02a9480 100644
---
a/core/camel-spring-boot/src/test/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfigurationTest.java
+++
b/core/camel-spring-boot/src/test/java/org/apache/camel/spring/boot/security/CamelSSLAutoConfigurationTest.java
@@ -18,7 +18,10 @@ package org.apache.camel.spring.boot.security;
import org.apache.camel.spring.boot.CamelAutoConfiguration;
import org.apache.camel.support.jsse.GlobalSSLContextParametersSupplier;
+import org.apache.camel.support.jsse.SSLContextParameters;
+import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.boot.autoconfigure.AutoConfigurations;
import org.springframework.boot.test.context.runner.ApplicationContextRunner;
@@ -31,7 +34,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
*/
public class CamelSSLAutoConfigurationTest {
@Test
- public void checkSSLPropertiesPresent() {
+ public void checkSSLConfigPropertiesPresent() {
new ApplicationContextRunner()
.withConfiguration(
AutoConfigurations.of(
@@ -53,14 +56,205 @@ public class CamelSSLAutoConfigurationTest {
assertNotNull(supplier);
assertNotNull(supplier.get());
assertEquals("web", supplier.get().getCertAlias());
+
assertNotNull(supplier.get().getKeyManagers());
assertEquals("changeit",
supplier.get().getKeyManagers().getKeyPassword());
+
+
assertNotNull(supplier.get().getKeyManagers().getKeyStore());
+ assertEquals("changeit",
supplier.get().getKeyManagers().getKeyStore().getPassword());
+ assertEquals("PKCS12",
supplier.get().getKeyManagers().getKeyStore().getType());
+
assertNotNull(supplier.get().getTrustManagers());
assertNotNull(supplier.get().getTrustManagers().getKeyStore());
+ assertEquals("changeit",
supplier.get().getTrustManagers().getKeyStore().getPassword());
assertEquals("jks",
supplier.get().getTrustManagers().getKeyStore().getType());
-
+
+ // since no camel.ssl properties provided
+
Assertions.assertThrows(NoSuchBeanDefinitionException.class,
+ () -> context.getBean(SSLContextParameters.class));
}
);
}
+ @Test
+ public void checkSSLPropertiesPresent() {
+ new ApplicationContextRunner()
+ .withConfiguration(
+ AutoConfigurations.of(
+ CamelSSLAutoConfiguration.class,
+ CamelAutoConfiguration.class
+ )
+ )
+ .withPropertyValues(
+ "camel.ssl.cert-alias=intra",
+ "camel.ssl.key-managers.key-password=secure",
+ "camel.ssl.key-managers.key-store.password=secure",
+ "camel.ssl.key-managers.key-store.type=jks",
+ "camel.ssl.trust-managers.key-store.password=secure",
+ "camel.ssl.trust-managers.key-store.type=PKCS12"
+ )
+ .run(context -> {
+ SSLContextParameters contextParams =
context.getBean(SSLContextParameters.class);
+ assertNotNull(contextParams);
+ assertEquals("intra", contextParams.getCertAlias());
+
+ assertNotNull(contextParams.getKeyManagers());
+ assertEquals("secure",
contextParams.getKeyManagers().getKeyPassword());
+
+
assertNotNull(contextParams.getKeyManagers().getKeyStore());
+ assertEquals("secure",
contextParams.getKeyManagers().getKeyStore().getPassword());
+ assertEquals("jks",
contextParams.getKeyManagers().getKeyStore().getType());
+
+ assertNotNull(contextParams.getTrustManagers());
+
assertNotNull(contextParams.getTrustManagers().getKeyStore());
+ assertEquals("secure",
contextParams.getTrustManagers().getKeyStore().getPassword());
+ assertEquals("PKCS12",
contextParams.getTrustManagers().getKeyStore().getType());
+
+ // since no camel.ssl.config properties provided
+
Assertions.assertThrows(NoSuchBeanDefinitionException.class,
+ () ->
context.getBean(GlobalSSLContextParametersSupplier.class));
+ });
+ }
+
+ @Test
+ public void checkSSLAndConfigPropertiesBeanPresent() {
+ new ApplicationContextRunner()
+ .withConfiguration(
+ AutoConfigurations.of(
+ CamelSSLAutoConfiguration.class,
+ CamelAutoConfiguration.class
+ )
+ )
+ .withPropertyValues(
+ // camel.ssl.config
+ "camel.ssl.config.cert-alias=web",
+ "camel.ssl.config.key-managers.key-password=changeit",
+
"camel.ssl.config.key-managers.key-store.password=changeit",
+ "camel.ssl.config.key-managers.key-store.type=PKCS12",
+
"camel.ssl.config.trust-managers.key-store.password=changeit",
+ "camel.ssl.config.trust-managers.key-store.type=jks",
+ // camel.ssl
+ "camel.ssl.cert-alias=intra",
+ "camel.ssl.key-managers.key-password=secure",
+ "camel.ssl.key-managers.key-store.password=secure",
+ "camel.ssl.key-managers.key-store.type=jks",
+ "camel.ssl.trust-managers.key-store.password=secure",
+ "camel.ssl.trust-managers.key-store.type=PKCS12"
+ )
+ .run(context -> {
+ // bean with camel.ssl.config properties
+ GlobalSSLContextParametersSupplier supplier =
context.getBean(GlobalSSLContextParametersSupplier.class);
+
assertThat(context).hasSingleBean(CamelSSLAutoConfiguration.class);
+ assertNotNull(supplier);
+ assertNotNull(supplier.get());
+ assertEquals("web", supplier.get().getCertAlias());
+
+ assertNotNull(supplier.get().getKeyManagers());
+ assertEquals("changeit",
supplier.get().getKeyManagers().getKeyPassword());
+
+
assertNotNull(supplier.get().getKeyManagers().getKeyStore());
+ assertEquals("changeit",
supplier.get().getKeyManagers().getKeyStore().getPassword());
+ assertEquals("PKCS12",
supplier.get().getKeyManagers().getKeyStore().getType());
+
+ assertNotNull(supplier.get().getTrustManagers());
+
assertNotNull(supplier.get().getTrustManagers().getKeyStore());
+ assertEquals("changeit",
supplier.get().getTrustManagers().getKeyStore().getPassword());
+ assertEquals("jks",
supplier.get().getTrustManagers().getKeyStore().getType());
+
+ // bean with camel.ssl properties
+ SSLContextParameters contextParams =
context.getBean(SSLContextParameters.class);
+ assertNotNull(contextParams);
+ assertEquals("intra", contextParams.getCertAlias());
+
+ assertNotNull(contextParams.getKeyManagers());
+ assertEquals("secure",
contextParams.getKeyManagers().getKeyPassword());
+
+
assertNotNull(contextParams.getKeyManagers().getKeyStore());
+ assertEquals("secure",
contextParams.getKeyManagers().getKeyStore().getPassword());
+ assertEquals("jks",
contextParams.getKeyManagers().getKeyStore().getType());
+
+ assertNotNull(contextParams.getTrustManagers());
+
assertNotNull(contextParams.getTrustManagers().getKeyStore());
+ assertEquals("secure",
contextParams.getTrustManagers().getKeyStore().getPassword());
+ assertEquals("PKCS12",
contextParams.getTrustManagers().getKeyStore().getType());
+ });
+ }
+
+ @Test
+ public void checkSSLPropertiesCopy() {
+ new ApplicationContextRunner()
+ .withConfiguration(
+ AutoConfigurations.of(
+ CamelSSLAutoConfiguration.class,
+ CamelAutoConfiguration.class
+ )
+ )
+ .withPropertyValues(
+ // camel.ssl.config
+ "camel.ssl.config.cert-alias=web",
+ "camel.ssl.config.key-managers.key-password=changeit",
+
"camel.ssl.config.key-managers.key-store.password=changeit",
+ "camel.ssl.config.key-managers.key-store.type=PKCS12",
+
"camel.ssl.config.trust-managers.key-store.password=changeit",
+ "camel.ssl.config.trust-managers.key-store.type=jks",
+ // camel.ssl
+ "camel.ssl.cert-alias=intra"
+ )
+ .run(context -> {
+ // bean with camel.ssl.config properties
+ GlobalSSLContextParametersSupplier supplier =
context.getBean(GlobalSSLContextParametersSupplier.class);
+
assertThat(context).hasSingleBean(CamelSSLAutoConfiguration.class);
+ assertNotNull(supplier);
+ assertNotNull(supplier.get());
+ assertEquals("web", supplier.get().getCertAlias());
+
+ assertNotNull(supplier.get().getKeyManagers());
+ assertEquals("changeit",
supplier.get().getKeyManagers().getKeyPassword());
+
+
assertNotNull(supplier.get().getKeyManagers().getKeyStore());
+ assertEquals("changeit",
supplier.get().getKeyManagers().getKeyStore().getPassword());
+ assertEquals("PKCS12",
supplier.get().getKeyManagers().getKeyStore().getType());
+
+ assertNotNull(supplier.get().getTrustManagers());
+
assertNotNull(supplier.get().getTrustManagers().getKeyStore());
+ assertEquals("changeit",
supplier.get().getTrustManagers().getKeyStore().getPassword());
+ assertEquals("jks",
supplier.get().getTrustManagers().getKeyStore().getType());
+
+ // bean created since we have a single camel.ssl prop
+ SSLContextParameters contextParams =
context.getBean(SSLContextParameters.class);
+ assertNotNull(contextParams);
+ assertEquals("intra", contextParams.getCertAlias());
+
+ // these copied from camel.ssl.config
+ assertNotNull(contextParams.getKeyManagers());
+ assertEquals("changeit",
contextParams.getKeyManagers().getKeyPassword());
+
+
assertNotNull(contextParams.getKeyManagers().getKeyStore());
+ assertEquals("changeit",
contextParams.getKeyManagers().getKeyStore().getPassword());
+ assertEquals("PKCS12",
contextParams.getKeyManagers().getKeyStore().getType());
+
+ assertNotNull(contextParams.getTrustManagers());
+
assertNotNull(contextParams.getTrustManagers().getKeyStore());
+ assertEquals("changeit",
contextParams.getTrustManagers().getKeyStore().getPassword());
+ assertEquals("jks",
contextParams.getTrustManagers().getKeyStore().getType());
+ });
+ }
+
+ @Test
+ public void checkNoSSLPropertiesPresent() {
+ new ApplicationContextRunner()
+ .withConfiguration(
+ AutoConfigurations.of(
+ CamelSSLAutoConfiguration.class,
+ CamelAutoConfiguration.class
+ )
+ )
+ .run(context -> {
+ Assertions.assertThrows(NoSuchBeanDefinitionException.class,
+ () -> context.getBean(SSLContextParameters.class));
+
+ Assertions.assertThrows(NoSuchBeanDefinitionException.class,
+ () ->
context.getBean(GlobalSSLContextParametersSupplier.class));
+ });
+ }
}
