This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git
The following commit(s) were added to refs/heads/main by this push:
new 13c0615acc06 CAMEL-27160: Dynamic endpoint option values computed from
the message are bound as literal text (#30389)
13c0615acc06 is described below
commit 13c0615acc0617104daf9a8c11d3c16f4ba8ca6b
Author: Claus Ibsen <[email protected]>
AuthorDate: Thu Nov 19 11:37:52 2026 +0100
CAMEL-27160: Dynamic endpoint option values computed from the message are
bound as literal text (#30389)
The option values of an endpoint whose uri is computed from the current
message (toD, enrich, wireTap, pollEnrich,
recipientList, routingSlip, dynamicRouter) are bound as literal text: a
property placeholder, a #class: value or a
#property: value is not resolved, and a RAW(...) value is unwrapped without
evaluating $simple{...} in it. Registry
references (#bean:, #type:, #name) are still resolved.
The CamelContext opens a literal binding scope around
Component#createEndpoint, so component and endpoint overrides
are called as before; PropertyBindingSupport,
EndpointHelper.resolveReferenceParameter, PropertyBindingSupport.resolveBean,
RawParameterHelper and the SendDynamicAware/PollDynamicAware support
classes read the scope.
This completes the work of Andrea Cosentino in #30340.
Co-authored-by: Andrea Cosentino <[email protected]>
Co-Authored-By: Claude Opus 5.5 <[email protected]>
---
.../http/HttpSendDynamicAwareRawSimpleTest.java | 100 ++++++
.../camel/impl/engine/AbstractCamelContext.java | 27 +-
.../impl/engine/DefaultCamelContextExtension.java | 18 +-
.../org/apache/camel/processor/PollEnricher.java | 4 +-
.../apache/camel/processor/ProcessorHelper.java | 16 +-
.../camel/processor/SendDynamicProcessor.java | 6 +-
...DynamicEndpointMessageOptionLiteralLogTest.java | 206 +++++++++++
.../DynamicEndpointMessageOptionLiteralTest.java | 386 +++++++++++++++++++++
.../DynamicEndpointMessageRawOptionTest.java | 224 ++++++++++++
.../support/component/RawParameterHelperTest.java | 9 +
.../org/apache/camel/support/DefaultRegistry.java | 8 +-
.../org/apache/camel/support/EndpointHelper.java | 3 +
.../org/apache/camel/support/NormalizedUri.java | 44 ++-
.../camel/support/PropertyBindingSupport.java | 192 ++++++++--
.../support/component/PollDynamicAwareSupport.java | 10 +-
.../support/component/RawParameterHelper.java | 28 +-
.../support/component/SendDynamicAwareSupport.java | 10 +-
.../ROOT/pages/camel-4x-upgrade-guide-4_24.adoc | 43 +++
docs/user-manual/modules/ROOT/pages/endpoint.adoc | 5 +
19 files changed, 1272 insertions(+), 67 deletions(-)
diff --git
a/components/camel-http/src/test/java/org/apache/camel/component/http/HttpSendDynamicAwareRawSimpleTest.java
b/components/camel-http/src/test/java/org/apache/camel/component/http/HttpSendDynamicAwareRawSimpleTest.java
new file mode 100644
index 000000000000..50a957548b48
--- /dev/null
+++
b/components/camel-http/src/test/java/org/apache/camel/component/http/HttpSendDynamicAwareRawSimpleTest.java
@@ -0,0 +1,100 @@
+/*
+ * 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.http;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+import org.apache.camel.Exchange;
+import org.apache.camel.RoutesBuilder;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.util.StringHelper;
+import org.apache.hc.core5.http.impl.bootstrap.HttpServer;
+import org.apache.hc.core5.http.impl.bootstrap.ServerBootstrap;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * A RAW() query value that toD computes from the message is taken as literal
text on the optimised http path: a
+ * $simple{} in it is not evaluated.
+ */
+public class HttpSendDynamicAwareRawSimpleTest extends BaseHttpTest {
+
+ private static final String PROP = "camel.test.httpRawOption." +
System.nanoTime();
+ private static final String PROP_VALUE = "prop-value-" + System.nanoTime();
+
+ private final AtomicReference<String> receivedQuery = new
AtomicReference<>();
+ private HttpServer localServer;
+
+ @BeforeAll
+ static void setSystemProperty() {
+ System.setProperty(PROP, PROP_VALUE);
+ }
+
+ @AfterAll
+ static void clearSystemProperty() {
+ System.clearProperty(PROP);
+ }
+
+ @Override
+ public void setupResources() throws Exception {
+ localServer = ServerBootstrap.bootstrap()
+ .setCanonicalHostName("localhost")
+ .setHttpProcessor(getBasicHttpProcessor())
+ .setConnectionReuseStrategy(getConnectionReuseStrategy())
+ .setResponseFactory(getHttpResponseFactory())
+ .setSslContext(getSSLContext())
+ .register("/dynamicAware", (request, response, context) -> {
+
receivedQuery.set(StringHelper.after(request.getRequestUri(), "?"));
+ response.setCode(200);
+ })
+ .create();
+ localServer.start();
+ }
+
+ @Override
+ public void cleanupResources() throws Exception {
+ if (localServer != null) {
+ localServer.stop();
+ }
+ }
+
+ @Override
+ protected RoutesBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+ from("direct:dynamicAware")
+ .toD("http://localhost:" + localServer.getLocalPort()
+ "/dynamicAware?q=${header.q}");
+ }
+ };
+ }
+
+ @Test
+ public void testRawSimpleFromMessageIsLiteral() throws Exception {
+ Exchange e = fluentTemplate
+ .to("direct:dynamicAware")
+ .withHeader("q", "RAW($simple{sys." + PROP + "})")
+ .send();
+
+ String expected = "q=%24simple%7Bsys." + PROP + "%7D";
+ assertEquals(expected, e.getIn().getHeader(Exchange.HTTP_QUERY));
+ assertEquals(expected, receivedQuery.get());
+ }
+}
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
index 4df82abb5d11..3b1dd62d7cfc 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java
@@ -201,6 +201,7 @@ import org.apache.camel.support.NormalizedUri;
import org.apache.camel.support.OrderedComparator;
import org.apache.camel.support.PluginHelper;
import org.apache.camel.support.ProcessorEndpoint;
+import org.apache.camel.support.PropertyBindingSupport;
import org.apache.camel.support.ResetableClock;
import org.apache.camel.support.ResolverHelper;
import org.apache.camel.support.jsse.SSLContextParameters;
@@ -874,11 +875,17 @@ public abstract class AbstractCamelContext extends
BaseService
}
protected Endpoint doGetEndpoint(String uri, Map<String, Object>
parameters, boolean normalized, boolean prototype) {
- return doGetEndpoint(uri, null, parameters, normalized, prototype);
+ return doGetEndpoint(uri, null, parameters, normalized, prototype,
false);
}
protected Endpoint doGetEndpoint(
String uri, String explicitRawUri, Map<String, Object> parameters,
boolean normalized, boolean prototype) {
+ return doGetEndpoint(uri, explicitRawUri, parameters, normalized,
prototype, false);
+ }
+
+ protected Endpoint doGetEndpoint(
+ String uri, String explicitRawUri, Map<String, Object> parameters,
boolean normalized, boolean prototype,
+ boolean literalOptionBinding) {
// ensure CamelContext are initialized before we can get an endpoint
build();
@@ -945,9 +952,21 @@ public abstract class AbstractCamelContext extends
BaseService
LOG.trace("Creating endpoint from uri: {} using component:
{}", uri, component);
// Have the component create the endpoint if it can.
- answer = component.createEndpoint(
- component.useRawUri() ? rawUri : uri,
- parameters);
+ String createUri = component.useRawUri() ? rawUri : uri;
+ if (literalOptionBinding) {
+ // the uri was computed from the current message at
runtime, so its option values are bound
+ // as literal text while the component creates the
endpoint: no property placeholders,
+ // #class: or #property: (registry references such as
#bean: and #type: are still resolved).
+ // The scope covers every way a component binds its
options (see PropertyBindingSupport)
+ boolean prev =
PropertyBindingSupport.setLiteralOptionBinding(true);
+ try {
+ answer = component.createEndpoint(createUri,
parameters);
+ } finally {
+
PropertyBindingSupport.setLiteralOptionBinding(prev);
+ }
+ } else {
+ answer = component.createEndpoint(createUri,
parameters);
+ }
if (answer != null && LOG.isDebugEnabled()) {
LOG.debug("{} converted to endpoint: {} by component:
{}", URISupport.sanitizeUri(uri), answer,
diff --git
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
index 0bc46298872e..5d8c6d9a4c73 100644
---
a/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
+++
b/core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/DefaultCamelContextExtension.java
@@ -292,8 +292,10 @@ class DefaultCamelContextExtension implements
ExtendedCamelContext {
@Override
public Endpoint getEndpoint(NormalizedEndpointUri uri) {
- String rawUri = uri instanceof NormalizedUri nu ? nu.getRawUri() :
null;
- return camelContext.doGetEndpoint(uri.getUri(), rawUri, null, true,
false);
+ NormalizedUri nu = uri instanceof NormalizedUri n ? n : null;
+ String rawUri = nu != null ? nu.getRawUri() : null;
+ boolean literal = nu != null && nu.isLiteralOptionBinding();
+ return camelContext.doGetEndpoint(uri.getUri(), rawUri, null, true,
false, literal);
}
@Override
@@ -303,14 +305,18 @@ class DefaultCamelContextExtension implements
ExtendedCamelContext {
@Override
public Endpoint getPrototypeEndpoint(NormalizedEndpointUri uri) {
- String rawUri = uri instanceof NormalizedUri nu ? nu.getRawUri() :
null;
- return camelContext.doGetEndpoint(uri.getUri(), rawUri, null, true,
true);
+ NormalizedUri nu = uri instanceof NormalizedUri n ? n : null;
+ String rawUri = nu != null ? nu.getRawUri() : null;
+ boolean literal = nu != null && nu.isLiteralOptionBinding();
+ return camelContext.doGetEndpoint(uri.getUri(), rawUri, null, true,
true, literal);
}
@Override
public Endpoint getEndpoint(NormalizedEndpointUri uri, Map<String, Object>
parameters) {
- String rawUri = uri instanceof NormalizedUri nu ? nu.getRawUri() :
null;
- return camelContext.doGetEndpoint(uri.getUri(), rawUri, parameters,
true, false);
+ NormalizedUri nu = uri instanceof NormalizedUri n ? n : null;
+ String rawUri = nu != null ? nu.getRawUri() : null;
+ boolean literal = nu != null && nu.isLiteralOptionBinding();
+ return camelContext.doGetEndpoint(uri.getUri(), rawUri, parameters,
true, false, literal);
}
@Override
diff --git
a/core/camel-core-processor/src/main/java/org/apache/camel/processor/PollEnricher.java
b/core/camel-core-processor/src/main/java/org/apache/camel/processor/PollEnricher.java
index 6c9b59f7ac78..4ccf9034e33b 100644
---
a/core/camel-core-processor/src/main/java/org/apache/camel/processor/PollEnricher.java
+++
b/core/camel-core-processor/src/main/java/org/apache/camel/processor/PollEnricher.java
@@ -539,7 +539,9 @@ public class PollEnricher extends BaseProcessorSupport
implements IdAware, Route
// optimize and normalize endpoint without re-resolving property
placeholders on the
// per-message evaluated recipient, matching toD and enrich
(CAMEL-24282 / CAMEL-24414).
// pollEnrich resolves its static uri at build time, so the
placeholder belongs there.
- return NormalizedUri.newNormalizedUri(uri, false);
+ // The per-message recipient comes from the message, so its option
values are bound as literal text
+ // as well: no property placeholders, #class: or #property:
(#bean: and #type: still resolve) - CAMEL-27160
+ return NormalizedUri.newNormalizedUri(uri, false, true);
}
return null;
}
diff --git
a/core/camel-core-processor/src/main/java/org/apache/camel/processor/ProcessorHelper.java
b/core/camel-core-processor/src/main/java/org/apache/camel/processor/ProcessorHelper.java
index 8d865ade6755..5c00fceca0cf 100644
---
a/core/camel-core-processor/src/main/java/org/apache/camel/processor/ProcessorHelper.java
+++
b/core/camel-core-processor/src/main/java/org/apache/camel/processor/ProcessorHelper.java
@@ -28,7 +28,9 @@ import org.apache.camel.ExtendedCamelContext;
import org.apache.camel.NoTypeConversionAvailableException;
import org.apache.camel.ResolveEndpointFailedException;
import org.apache.camel.spi.NormalizedEndpointUri;
+import org.apache.camel.support.EndpointHelper;
import org.apache.camel.support.ExchangeHelper;
+import org.apache.camel.support.NormalizedUri;
import org.apache.camel.support.PatternHelper;
import org.slf4j.MDC;
@@ -84,8 +86,18 @@ final class ProcessorHelper {
// convert to a string type we can work with
uri = ecc.getTypeConverter().mandatoryConvertTo(String.class,
exchange, recipient);
}
- // optimize and normalize endpoint
- return ecc.getCamelContextExtension().normalizeUri(uri);
+ // optimize and normalize endpoint. Property placeholders in the
computed uri string are still resolved
+ // here (documented recipientList/routingSlip/dynamicRouter
behaviour), but the uri was computed from the
+ // message, so its option values are bound as literal text: no
#class: or #property: resolution on the
+ // option values; registry references (#bean:, #type:) are still
resolved (CAMEL-27160).
+ try {
+ String resolved =
EndpointHelper.resolveEndpointUriPropertyPlaceholders(ecc, uri);
+ return NormalizedUri.newNormalizedUri(resolved, false, true);
+ } catch (ResolveEndpointFailedException e) {
+ throw e;
+ } catch (Exception e) {
+ throw new ResolveEndpointFailedException(uri, e);
+ }
}
return null;
}
diff --git
a/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendDynamicProcessor.java
b/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendDynamicProcessor.java
index bf6dcdd23a12..aa6f05387698 100644
---
a/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendDynamicProcessor.java
+++
b/core/camel-core-processor/src/main/java/org/apache/camel/processor/SendDynamicProcessor.java
@@ -333,8 +333,10 @@ public class SendDynamicProcessor extends
BaseProcessorSupport
throw new ResolveEndpointFailedException(uri, "Endpoint should
include scheme:path");
}
// optimize and normalize endpoint without re-resolving property
placeholders on the
- // per-message evaluated recipient (see resolveUri and CAMEL-24282)
- return NormalizedUri.newNormalizedUri(uri, false);
+ // per-message evaluated recipient (see resolveUri and
CAMEL-24282). The per-message recipient
+ // comes from the message, so its option values are bound as
literal text as well: no property
+ // placeholders, #class: or #property: (#bean: and #type: still
resolve) - CAMEL-27160
+ return NormalizedUri.newNormalizedUri(uri, false, true);
}
return null;
}
diff --git
a/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageOptionLiteralLogTest.java
b/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageOptionLiteralLogTest.java
new file mode 100644
index 000000000000..4a4eb02b3a97
--- /dev/null
+++
b/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageOptionLiteralLogTest.java
@@ -0,0 +1,206 @@
+/*
+ * 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.processor;
+
+import java.util.Properties;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ContextTestSupport;
+import org.apache.camel.Exchange;
+import org.apache.camel.ResolveEndpointFailedException;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.log.LogEndpoint;
+import org.apache.camel.component.stub.StubEndpoint;
+import org.apache.camel.spi.ExchangeFormatter;
+import org.apache.camel.support.processor.DefaultExchangeFormatter;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * The option values of an endpoint whose uri is computed from the message are
bound as literal text, also for a real
+ * component that binds its options inside its own {@code createEndpoint},
with a generated configurer and typed options
+ * ({@code log}). A {@code #class:} value is not created for a typed option
(through the configurer and through
+ * {@code resolveAndRemoveReferenceParameter}), a property placeholder stays
literal (also for a bean that the component
+ * configures with {@code setProperties(Object, Map)}), while {@code #bean:}
and {@code #type:} in the static text of
+ * the {@code toD} still resolve, and {@code #class:} in a static {@code to}
still works.
+ */
+class DynamicEndpointMessageOptionLiteralLogTest extends ContextTestSupport {
+
+ @Override
+ protected CamelContext createCamelContext() throws Exception {
+ CamelContext context = super.createCamelContext();
+ Properties prop = new Properties();
+ prop.setProperty("secretTarget", "resolved");
+ context.getPropertiesComponent().setInitialProperties(prop);
+ context.getRegistry().bind("myFormatter", new RegisteredFormatter());
+ // the log component configures this bean with the options of every
log endpoint
+ context.getRegistry().bind("logFormatter", new PrefixFormatter());
+ return context;
+ }
+
+ @BeforeEach
+ void resetCounter() {
+ CountingFormatter.instances = 0;
+ }
+
+ @Test
+ void classValueFromMessageIsNotCreatedForTypedOption() {
+ Exchange out = template.send("direct:tod", e ->
e.getMessage().setHeader("target",
+ "log:m1?exchangeFormatter=#class:" +
CountingFormatter.class.getName()));
+
+
assertThat(out.getException()).isInstanceOf(ResolveEndpointFailedException.class);
+ assertThat(CountingFormatter.instances).isZero();
+ }
+
+ @Test
+ void classValueFromMessageIsNotCreatedForReferenceParameter() {
+ // the log component resolves the logger option with
resolveAndRemoveReferenceParameter
+ Exchange out = template.send("direct:tod", e ->
e.getMessage().setHeader("target",
+ "log:m2?logger=#class:" + CountingFormatter.class.getName()));
+
+
assertThat(out.getException()).isInstanceOf(ResolveEndpointFailedException.class);
+ assertThat(CountingFormatter.instances).isZero();
+ }
+
+ @Test
+ void placeholderFromMessageStaysLiteral() {
+ template.sendBodyAndHeader("direct:marker", "Hello", "m",
"{{secretTarget}}");
+
+
assertThat(logEndpoint("m3").getMarker()).isEqualTo("{{secretTarget}}");
+ }
+
+ @Test
+ void classValueFromMessageStaysLiteralForStringOption() {
+ String value = "#class:" + CountingFormatter.class.getName();
+ template.sendBodyAndHeader("direct:marker", "Hello", "m", value);
+
+ assertThat(logEndpoint("m3").getMarker()).isEqualTo(value);
+ assertThat(CountingFormatter.instances).isZero();
+ }
+
+ @Test
+ void placeholderFromMessageStaysLiteralForComponentConfiguredBean() {
+ // the log component binds the options to the logFormatter bean with
setProperties(Object, Map)
+ template.sendBodyAndHeader("direct:prefix", "Hello", "p",
"{{secretTarget}}");
+
+ PrefixFormatter formatter =
context.getRegistry().lookupByNameAndType("logFormatter",
PrefixFormatter.class);
+ assertThat(formatter.getPrefix()).isEqualTo("{{secretTarget}}");
+ }
+
+ @Test
+ void beanReferenceInStaticTextStillResolves() {
+ template.sendBodyAndHeader("direct:bean", "Hello", "m", "audit");
+
+ LogEndpoint endpoint = logEndpoint("b1");
+
assertThat(endpoint.getExchangeFormatter()).isSameAs(context.getRegistry().lookupByName("myFormatter"));
+ assertThat(endpoint.getMarker()).isEqualTo("audit");
+ }
+
+ @Test
+ void typeReferenceInStaticTextStillResolves() {
+ template.sendBodyAndHeader("direct:type", "Hello", "m", "audit");
+
+ LogEndpoint endpoint = logEndpoint("t1");
+
assertThat(endpoint.getExchangeFormatter()).isSameAs(context.getRegistry().lookupByName("myFormatter"));
+ }
+
+ @Test
+ void classValueInStaticToStillCreated() {
+ LogEndpoint endpoint =
context.getEndpoint("log:s1?exchangeFormatter=#class:" +
StaticFormatter.class.getName(),
+ LogEndpoint.class);
+
+
assertThat(endpoint.getExchangeFormatter()).isInstanceOf(StaticFormatter.class);
+ }
+
+ @Test
+ void componentSetPropertiesOverrideIsUsed() {
+ // the stub component turns off the binding of the options in its
setProperties(Endpoint, Map) override
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"stub:s2?timeout=1234");
+
+ StubEndpoint endpoint = context.getEndpoints().stream()
+
.filter(StubEndpoint.class::isInstance).map(StubEndpoint.class::cast)
+ .filter(e ->
e.getEndpointUri().contains("s2")).findFirst().orElseThrow();
+ assertThat(endpoint.getTimeout()).isEqualTo(30000L);
+ }
+
+ private LogEndpoint logEndpoint(String name) {
+ return context.getEndpoints().stream()
+
.filter(LogEndpoint.class::isInstance).map(LogEndpoint.class::cast)
+ .filter(e -> e.getEndpointUri().startsWith("log://" + name +
"?"))
+ .findFirst().orElseThrow();
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+ from("direct:tod").toD("${header.target}");
+ from("direct:marker").toD("log:m3?marker=${header.m}");
+ from("direct:prefix").toD("log:f1?prefix=${header.p}");
+
from("direct:bean").toD("log:b1?exchangeFormatter=#bean:myFormatter&marker=${header.m}");
+ from("direct:type").toD("log:t1?exchangeFormatter=#type:" +
RegisteredFormatter.class.getName()
+ + "&marker=${header.m}");
+ from("direct:static").to("log:s1?exchangeFormatter=#class:" +
StaticFormatter.class.getName());
+ }
+ };
+ }
+
+ /**
+ * Counts its instances, so a {@code #class:} value that is created can be
detected.
+ */
+ public static class CountingFormatter implements ExchangeFormatter {
+ static volatile int instances;
+
+ public CountingFormatter() {
+ instances++;
+ }
+
+ @Override
+ public String format(Exchange exchange) {
+ return "counting";
+ }
+ }
+
+ public static class StaticFormatter implements ExchangeFormatter {
+ @Override
+ public String format(Exchange exchange) {
+ return "static";
+ }
+ }
+
+ public static class RegisteredFormatter implements ExchangeFormatter {
+ @Override
+ public String format(Exchange exchange) {
+ return "registered";
+ }
+ }
+
+ public static class PrefixFormatter extends DefaultExchangeFormatter {
+ private String prefix;
+
+ public String getPrefix() {
+ return prefix;
+ }
+
+ public void setPrefix(String prefix) {
+ this.prefix = prefix;
+ }
+ }
+}
diff --git
a/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageOptionLiteralTest.java
b/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageOptionLiteralTest.java
new file mode 100644
index 000000000000..2cc63837bac3
--- /dev/null
+++
b/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageOptionLiteralTest.java
@@ -0,0 +1,386 @@
+/*
+ * 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.processor;
+
+import java.util.Map;
+import java.util.Properties;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Consumer;
+import org.apache.camel.ContextTestSupport;
+import org.apache.camel.Endpoint;
+import org.apache.camel.Exchange;
+import org.apache.camel.Header;
+import org.apache.camel.PollingConsumer;
+import org.apache.camel.Processor;
+import org.apache.camel.Producer;
+import org.apache.camel.ResolveEndpointFailedException;
+import org.apache.camel.builder.AggregationStrategies;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.support.DefaultComponent;
+import org.apache.camel.support.DefaultEndpoint;
+import org.apache.camel.support.DefaultProducer;
+import org.apache.camel.support.PollingConsumerSupport;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Companion to {@link DynamicEndpointMessagePlaceholderTest}: the per-message
recipient of the dynamic-uri EIPs is
+ * computed from the message, so its option values are bound as literal text.
A property placeholder ({@code {{...}}}),
+ * a {@code #class:} value or a {@code #property:} value in a runtime-computed
option value is kept verbatim: it is not
+ * resolved and no class is created. Registry references ({@code #bean:},
{@code #type:}) are still resolved. See
+ * CAMEL-27160, which extends the CAMEL-24282 / CAMEL-24414 treatment from the
uri path to the option binding.
+ * <p/>
+ * For {@code recipientList}, {@code routingSlip} and {@code dynamicRouter}
the documented resolution of property
+ * placeholders in the computed uri string is preserved (see {@link
DynamicEndpointMessagePlaceholderTest}); only the
+ * {@code #class:} and {@code #property:} resolution of their runtime option
values is brought in line, which is why
+ * those EIPs are exercised here with {@code #class:} values rather than
placeholders.
+ * <p/>
+ * {@link DynamicEndpointMessageOptionLiteralLogTest} covers a real component
with a generated configurer and typed
+ * options.
+ */
+class DynamicEndpointMessageOptionLiteralTest extends ContextTestSupport {
+
+ private static final String MARKER_CLASS = "#class:" +
Marker.class.getName();
+ private static final String MARKER_BEAN = "#bean:marker";
+
+ @Override
+ protected CamelContext createCamelContext() throws Exception {
+ CamelContext context = super.createCamelContext();
+ Properties prop = new Properties();
+ prop.setProperty("secretTarget", "resolved");
+ prop.setProperty("optionName", "option");
+ context.getPropertiesComponent().setInitialProperties(prop);
+ context.addComponent("sink", new SinkComponent());
+ context.addComponent("selfsink", new SelfBindingSinkComponent());
+ context.addComponent("singletonsink", new SingletonSinkComponent());
+ context.getRegistry().bind("marker", new Marker());
+ return context;
+ }
+
+ @BeforeEach
+ void resetSink() {
+ SinkEndpoint.lastOption = null;
+ Marker.instances = 0;
+ }
+
+ @Test
+ void toDOptionPlaceholderTokenStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"sink:a?option={{secretTarget}}");
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo("{{secretTarget}}");
+ }
+
+ @Test
+ void toDOptionClassReferenceTokenStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"sink:b?option=" + MARKER_CLASS);
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void toDOptionBeanReferenceStillResolves() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"sink:c?option=" + MARKER_BEAN);
+
+ assertMockEndpointsSatisfied();
+ // a #bean: / #type: reference is a plain registry lookup of an
already-registered bean, so it is still
+ // resolved: this keeps references a route author wrote in a dynamic
uri (such as dataSource=#ds) working.
+ // Only property placeholders, #class: and #property: are kept literal.
+
assertThat(SinkEndpoint.lastOption).isSameAs(context.getRegistry().lookupByName("marker"));
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void toDOptionTypeReferenceStillResolves() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"sink:t?option=#type:" + Marker.class.getName());
+
+ assertMockEndpointsSatisfied();
+
assertThat(SinkEndpoint.lastOption).isSameAs(context.getRegistry().lookupByName("marker"));
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void toDOptionNamePlaceholderIsNotResolved() {
+ // the option names of the uri were resolved when the route was built,
a name computed from the message is not
+ Exchange out = template.send("direct:tod",
+ e -> e.getMessage().setHeader("target",
"sink:n?{{optionName}}=hello"));
+
+
assertThat(out.getException()).isInstanceOf(ResolveEndpointFailedException.class);
+ assertThat(SinkEndpoint.lastOption).isNull();
+ }
+
+ @Test
+ void toDSingletonEndpointClassReferenceStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(2);
+
+ // a singleton endpoint is created once and then taken from the
endpoint registry
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"singletonsink:a?option=" + MARKER_CLASS);
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"singletonsink:a?option=" + MARKER_CLASS);
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ assertThat(context.getEndpoints().stream().filter(e ->
e.getEndpointUri().startsWith("singletonsink:"))).hasSize(1);
+ }
+
+ @Test
+ void toDOptionPropertyReferenceStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"sink:p?option=#property:secretTarget");
+
+ assertMockEndpointsSatisfied();
+
assertThat(SinkEndpoint.lastOption).isEqualTo("#property:secretTarget");
+ }
+
+ @Test
+ void toDSelfBindingComponentClassReferenceStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ // selfsink binds its options inside its own createEndpoint, like
log/aws2-s3/sql/jms and ~329 other
+ // components; literal binding must be enforced there too
(CAMEL-27160), so a #class: option value from the
+ // message is not instantiated
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"selfsink:a?option=" + MARKER_CLASS);
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void toDSelfBindingComponentPlaceholderStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:tod", "Hello", "target",
"selfsink:b?option={{secretTarget}}");
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo("{{secretTarget}}");
+ }
+
+ @Test
+ void enrichOptionClassReferenceTokenStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:en", "Hello", "target",
"sink:d?option=" + MARKER_CLASS);
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void pollEnrichOptionClassReferenceTokenStaysLiteral() throws Exception {
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:pe", "Hello", "target",
"sink:e?option=" + MARKER_CLASS);
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void recipientListOptionClassReferenceTokenStaysLiteral() throws Exception
{
+ getMockEndpoint("mock:done").expectedMessageCount(1);
+
+ template.sendBodyAndHeader("direct:rl", "Hello", "target",
"sink:f?option=" + MARKER_CLASS);
+
+ assertMockEndpointsSatisfied();
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void routingSlipOptionClassReferenceTokenStaysLiteral() throws Exception {
+ template.sendBodyAndHeader("direct:rs", "Hello", "target",
"sink:g?option=" + MARKER_CLASS);
+
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ }
+
+ @Test
+ void dynamicRouterOptionClassReferenceTokenStaysLiteral() throws Exception
{
+ template.sendBodyAndHeader("direct:dr", "Hello", "target",
"sink:h?option=" + MARKER_CLASS);
+
+ assertThat(SinkEndpoint.lastOption).isEqualTo(MARKER_CLASS);
+ assertThat(Marker.instances).isZero();
+ }
+
+ /**
+ * Dynamic router bean: routes to the header-supplied recipient on the
first hop, then stops.
+ */
+ public String route(@Header("target") String target,
@Header(Exchange.SLIP_ENDPOINT) String previous) {
+ return previous == null ? target : null;
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+ from("direct:tod").toD("${header.target}").to("mock:done");
+ from("direct:en").enrich().simple("${header.target}")
+
.aggregationStrategy(AggregationStrategies.useOriginal()).to("mock:done");
+
from("direct:pe").pollEnrich().simple("${header.target}").timeout(100).end().to("mock:done");
+
from("direct:rl").recipientList(header("target")).to("mock:done");
+ from("direct:rs").routingSlip(header("target"));
+
from("direct:dr").dynamicRouter(method(DynamicEndpointMessageOptionLiteralTest.this,
"route"));
+ }
+ };
+ }
+
+ /**
+ * Marker whose public no-arg constructor counts instantiations, so a
{@code #class:} reference that is wrongly
+ * resolved can be detected.
+ */
+ public static class Marker {
+ static volatile int instances;
+
+ public Marker() {
+ instances++;
+ }
+ }
+
+ /**
+ * A local in-JVM sink that records the value bound to its {@code option}
property, so the test can assert that a
+ * runtime-computed option value is kept literal.
+ */
+ private static final class SinkComponent extends DefaultComponent {
+ @Override
+ protected Endpoint createEndpoint(String uri, String remaining,
Map<String, Object> parameters) {
+ return new SinkEndpoint(uri, this);
+ }
+ }
+
+ /**
+ * Like {@link SinkComponent} but binds its options inside its own {@code
createEndpoint} (through the two-argument
+ * {@code setProperties}), the pattern used by {@code log}, {@code
aws2-s3}, {@code sql}, {@code jms} and ~329 other
+ * components. It proves that literal binding is also enforced for these
components (CAMEL-27160).
+ */
+ private static final class SelfBindingSinkComponent extends
DefaultComponent {
+ @Override
+ protected Endpoint createEndpoint(String uri, String remaining,
Map<String, Object> parameters)
+ throws Exception {
+ SinkEndpoint endpoint = new SinkEndpoint(uri, this);
+ setProperties(endpoint, parameters);
+ return endpoint;
+ }
+ }
+
+ /**
+ * Like {@link SinkComponent} but its endpoints are singletons, so they
are kept in the endpoint registry.
+ */
+ private static final class SingletonSinkComponent extends DefaultComponent
{
+ @Override
+ protected Endpoint createEndpoint(String uri, String remaining,
Map<String, Object> parameters) {
+ return new SinkEndpoint(uri, this, true);
+ }
+ }
+
+ private static final class SinkEndpoint extends DefaultEndpoint {
+ static volatile Object lastOption;
+ private final boolean singleton;
+ private Object option;
+
+ SinkEndpoint(String uri, DefaultComponent component) {
+ this(uri, component, false);
+ }
+
+ SinkEndpoint(String uri, DefaultComponent component, boolean
singleton) {
+ super(uri, component);
+ this.singleton = singleton;
+ }
+
+ public Object getOption() {
+ return option;
+ }
+
+ public void setOption(Object option) {
+ this.option = option;
+ lastOption = option;
+ }
+
+ @Override
+ public Producer createProducer() {
+ return new DefaultProducer(this) {
+ @Override
+ public void process(Exchange exchange) {
+ // no-op sink
+ }
+ };
+ }
+
+ @Override
+ public Consumer createConsumer(Processor processor) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public PollingConsumer createPollingConsumer() {
+ return new NoopPollingConsumer(this);
+ }
+
+ @Override
+ public boolean isSingleton() {
+ return singleton;
+ }
+ }
+
+ private static final class NoopPollingConsumer extends
PollingConsumerSupport {
+ NoopPollingConsumer(Endpoint endpoint) {
+ super(endpoint);
+ }
+
+ @Override
+ public Exchange receive() {
+ return null;
+ }
+
+ @Override
+ public Exchange receive(long timeout) {
+ return null;
+ }
+
+ @Override
+ public Exchange receiveNoWait() {
+ return null;
+ }
+
+ @Override
+ protected void doStart() {
+ // noop
+ }
+
+ @Override
+ protected void doStop() {
+ // noop
+ }
+ }
+}
diff --git
a/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageRawOptionTest.java
b/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageRawOptionTest.java
new file mode 100644
index 000000000000..5f08f68fd75a
--- /dev/null
+++
b/core/camel-core/src/test/java/org/apache/camel/processor/DynamicEndpointMessageRawOptionTest.java
@@ -0,0 +1,224 @@
+/*
+ * 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.processor;
+
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.ContextTestSupport;
+import org.apache.camel.Endpoint;
+import org.apache.camel.Exchange;
+import org.apache.camel.Processor;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.log.LogEndpoint;
+import org.apache.camel.support.DefaultExchange;
+import org.apache.camel.support.component.PollDynamicAwareSupport;
+import org.apache.camel.support.component.SendDynamicAwareSupport;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Companion to {@link DynamicEndpointMessageOptionLiteralTest}: a {@code
RAW(...)} option value of an endpoint created
+ * from a uri computed from the current message is unwrapped, but taken as
literal text: a {@code $simple{...}} in it is
+ * not evaluated. An endpoint written in the route (such as {@code
to("log:x?marker=RAW($simple{...})")}) still
+ * evaluates it.
+ */
+class DynamicEndpointMessageRawOptionTest extends ContextTestSupport {
+
+ private static final String PROP = "camel.test.rawOption." +
System.nanoTime();
+ private static final String PROP_VALUE = "prop-value-" + System.nanoTime();
+ private static final AtomicInteger HITS = new AtomicInteger();
+
+ @BeforeAll
+ static void setSystemProperty() {
+ System.setProperty(PROP, PROP_VALUE);
+ }
+
+ @AfterAll
+ static void clearSystemProperty() {
+ System.clearProperty(PROP);
+ }
+
+ @BeforeEach
+ void resetHits() {
+ HITS.set(0);
+ }
+
+ @Override
+ protected CamelContext createCamelContext() throws Exception {
+ CamelContext context = super.createCamelContext();
+ context.getRegistry().bind("probe", new Probe());
+ return context;
+ }
+
+ @Test
+ void toDRawSystemPropertyFunctionIsLiteral() {
+ assertToDMarkerIsLiteral("sys", "$simple{sys." + PROP + "}");
+ }
+
+ @Test
+ void toDRawEnvFunctionIsLiteral() {
+ assertToDMarkerIsLiteral("env", "$simple{env.HOME}");
+ }
+
+ @Test
+ void toDRawBeanFunctionIsLiteral() {
+ assertToDMarkerIsLiteral("bean", "$simple{bean:probe?method=hit}");
+ assertThat(HITS.get()).isZero();
+ }
+
+ @Test
+ void toDRawCamelContextFunctionIsLiteral() {
+ assertToDMarkerIsLiteral("ctx", "$simple{camelContext.getName()}");
+ }
+
+ @Test
+ void toDRawValueIsStillUnwrapped() {
+ assertToDMarkerIsLiteral("plain", "a+b&c=d");
+ }
+
+ @Test
+ void toDRawPropertyPlaceholderInRouteIsResolved() {
+ template.sendBodyAndHeader("direct:todph", "Hello", "id", "ph");
+
+ assertThat(markerOf("log://todph-ph")).isEqualTo(PROP_VALUE);
+ }
+
+ @Test
+ void staticEndpointRawSimpleIsEvaluated() {
+ template.sendBody("direct:static", "Hello");
+
+ assertThat(markerOf("log://static")).isEqualTo(PROP_VALUE);
+ }
+
+ @Test
+ void sendDynamicAwareRawSimpleIsLiteral() throws Exception {
+ LenientSendDynamicAware aware = new LenientSendDynamicAware();
+ aware.setCamelContext(context);
+ aware.setScheme("log");
+ aware.init();
+ Exchange exchange = new DefaultExchange(context);
+ String uri = "log:aware?marker=RAW($simple{sys." + PROP +
"})&custom=RAW($simple{bean:probe?method=hit})";
+
+ Map<String, Object> known = aware.endpointProperties(exchange, uri);
+ Map<String, Object> lenient =
aware.endpointLenientProperties(exchange, uri);
+
+ assertThat(known).containsEntry("marker", "$simple{sys." + PROP + "}");
+ assertThat(lenient).containsEntry("custom",
"$simple{bean:probe?method=hit}");
+ assertThat(HITS.get()).isZero();
+ }
+
+ @Test
+ void pollDynamicAwareRawSimpleIsLiteral() throws Exception {
+ LenientPollDynamicAware aware = new LenientPollDynamicAware();
+ aware.setCamelContext(context);
+ aware.setScheme("log");
+ aware.init();
+ Exchange exchange = new DefaultExchange(context);
+ String uri = "log:aware?marker=RAW($simple{sys." + PROP +
"})&custom=RAW($simple{bean:probe?method=hit})";
+
+ Map<String, Object> known = aware.endpointProperties(exchange, uri);
+ Map<String, Object> lenient =
aware.endpointLenientProperties(exchange, uri);
+
+ assertThat(known).containsEntry("marker", "$simple{sys." + PROP + "}");
+ assertThat(lenient).containsEntry("custom",
"$simple{bean:probe?method=hit}");
+ assertThat(HITS.get()).isZero();
+ }
+
+ private void assertToDMarkerIsLiteral(String id, String value) {
+ template.sendBodyAndHeaders("direct:tod", "Hello", Map.of("id", id,
"m", "RAW(" + value + ")"));
+
+ assertThat(markerOf("log://tod-" + id)).isEqualTo(value);
+ }
+
+ private String markerOf(String uriPrefix) {
+ for (Endpoint e : context.getEndpoints()) {
+ if (e instanceof LogEndpoint le &&
e.getEndpointUri().startsWith(uriPrefix)) {
+ return le.getMarker();
+ }
+ }
+ throw new AssertionError("No log endpoint for " + uriPrefix);
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ @Override
+ public void configure() {
+
from("direct:tod").toD("log:tod-${header.id}?marker=${header.m}");
+
from("direct:todph").toD("log:todph-${header.id}?marker=RAW({{sys:" + PROP +
"}})");
+ from("direct:static").to("log:static?marker=RAW($simple{sys."
+ PROP + "})");
+ }
+ };
+ }
+
+ public static class Probe {
+ public String hit() {
+ HITS.incrementAndGet();
+ return "probe-called";
+ }
+ }
+
+ private static final class LenientSendDynamicAware extends
SendDynamicAwareSupport {
+ @Override
+ public boolean isLenientProperties() {
+ return true;
+ }
+
+ @Override
+ public DynamicAwareEntry prepare(Exchange exchange, String uri, String
originalUri) {
+ return null;
+ }
+
+ @Override
+ public String resolveStaticUri(Exchange exchange, DynamicAwareEntry
entry) {
+ return null;
+ }
+
+ @Override
+ public Processor createPreProcessor(Exchange exchange,
DynamicAwareEntry entry) {
+ return null;
+ }
+
+ @Override
+ public Processor createPostProcessor(Exchange exchange,
DynamicAwareEntry entry) {
+ return null;
+ }
+ }
+
+ private static final class LenientPollDynamicAware extends
PollDynamicAwareSupport {
+ @Override
+ public boolean isLenientProperties() {
+ return true;
+ }
+
+ @Override
+ public DynamicAwareEntry prepare(Exchange exchange, String uri, String
originalUri) {
+ return null;
+ }
+
+ @Override
+ public String resolveStaticUri(Exchange exchange, DynamicAwareEntry
entry) {
+ return null;
+ }
+ }
+}
diff --git
a/core/camel-core/src/test/java/org/apache/camel/support/component/RawParameterHelperTest.java
b/core/camel-core/src/test/java/org/apache/camel/support/component/RawParameterHelperTest.java
index 6d8cc4c968f5..8e87ee1a9cfd 100644
---
a/core/camel-core/src/test/java/org/apache/camel/support/component/RawParameterHelperTest.java
+++
b/core/camel-core/src/test/java/org/apache/camel/support/component/RawParameterHelperTest.java
@@ -45,6 +45,15 @@ public class RawParameterHelperTest extends
ContextTestSupport {
Assertions.assertEquals("abc", map.get("username"));
Assertions.assertEquals(context.getName(), map.get("password"));
+ // literal: the RAW token is removed, but the simple expression is not
evaluated
+ map.put("password", "RAW($simple{camelId})");
+ RawParameterHelper.resolveRawParameterValues(context, map, true);
+ Assertions.assertEquals("$simple{camelId}", map.get("password"));
+
+ map.put("password", "RAW(sec*ret)");
+ RawParameterHelper.resolveRawParameterValues(context, map, true);
+ Assertions.assertEquals("sec*ret", map.get("password"));
+
String usr = System.getenv("USER");
if (usr != null) {
map.put("password", "RAW($simple{env:USER})");
diff --git
a/core/camel-support/src/main/java/org/apache/camel/support/DefaultRegistry.java
b/core/camel-support/src/main/java/org/apache/camel/support/DefaultRegistry.java
index cdcec4248bf2..12ec13efc4e5 100644
---
a/core/camel-support/src/main/java/org/apache/camel/support/DefaultRegistry.java
+++
b/core/camel-support/src/main/java/org/apache/camel/support/DefaultRegistry.java
@@ -276,7 +276,9 @@ public class DefaultRegistry extends ServiceSupport
implements Registry, LocalBe
try {
// Must avoid attempting placeholder resolution when looking up
// the properties component or else we end up in an infinite loop.
- if (camelContext != null && !name.equals("properties")) {
+ // A name is not resolved either while an endpoint whose uri is
computed from the message is created,
+ // as the name may come from an option value of that uri.
+ if (camelContext != null && !name.equals("properties") &&
!PropertyBindingSupport.isLiteralOptionBinding()) {
name = camelContext.resolvePropertyPlaceholders(name);
}
} catch (Exception e) {
@@ -317,7 +319,9 @@ public class DefaultRegistry extends ServiceSupport
implements Registry, LocalBe
try {
// Must avoid attempting placeholder resolution when looking up
// the properties component or else we end up in an infinite loop.
- if (camelContext != null && !name.equals("properties")) {
+ // A name is not resolved either while an endpoint whose uri is
computed from the message is created,
+ // as the name may come from an option value of that uri.
+ if (camelContext != null && !name.equals("properties") &&
!PropertyBindingSupport.isLiteralOptionBinding()) {
name = camelContext.resolvePropertyPlaceholders(name);
}
} catch (Exception e) {
diff --git
a/core/camel-support/src/main/java/org/apache/camel/support/EndpointHelper.java
b/core/camel-support/src/main/java/org/apache/camel/support/EndpointHelper.java
index 756a54311fad..5a8bfa95f3bb 100644
---
a/core/camel-support/src/main/java/org/apache/camel/support/EndpointHelper.java
+++
b/core/camel-support/src/main/java/org/apache/camel/support/EndpointHelper.java
@@ -361,6 +361,9 @@ public final class EndpointHelper {
* @throws NoSuchBeanException if object was not found in registry and
<code>mandatory</code> is <code>true</code>.
*/
public static <T> T resolveReferenceParameter(CamelContext context, String
value, Class<T> type, boolean mandatory) {
+ // while an endpoint whose uri is computed from the current message is
created, its option values are bound as
+ // literal text: a placeholder, #class: or #property: value is not
resolved (#bean: and #type: still are)
+ PropertyBindingSupport.checkLiteralOptionReference(value);
Object answer;
if (value.startsWith("#class:")) {
try {
diff --git
a/core/camel-support/src/main/java/org/apache/camel/support/NormalizedUri.java
b/core/camel-support/src/main/java/org/apache/camel/support/NormalizedUri.java
index cbd9f543674d..7d63890ac294 100644
---
a/core/camel-support/src/main/java/org/apache/camel/support/NormalizedUri.java
+++
b/core/camel-support/src/main/java/org/apache/camel/support/NormalizedUri.java
@@ -33,9 +33,19 @@ public final class NormalizedUri extends ValueHolder<String>
implements Normaliz
// NormalizedEndpointUri (e.g. from SendDynamicProcessor / toD).
private final String rawUri;
- private NormalizedUri(String normalizedValue, String rawUri) {
+ // Whether the endpoint uri was computed from the current message at
runtime (for example the per-message
+ // recipient of toD, enrich, wireTap, pollEnrich, recipientList,
routingSlip or dynamicRouter). When true the
+ // query option values are bound more strictly, to stop message content
from being turned into routing
+ // configuration: a {{...}} property placeholder, a #class: reference or a
#property: reference in such a value is
+ // kept as literal text (no placeholder resolution, no class
instantiation, no property lookup), while plain
+ // registry references (#bean:, #type:) are still resolved. Not part of
equals/hashCode: the endpoint registry key
+ // stays the uri alone.
+ private final boolean literalOptionBinding;
+
+ private NormalizedUri(String normalizedValue, String rawUri, boolean
literalOptionBinding) {
super(normalizedValue);
this.rawUri = rawUri;
+ this.literalOptionBinding = literalOptionBinding;
}
/**
@@ -46,10 +56,26 @@ public final class NormalizedUri extends
ValueHolder<String> implements Normaliz
* @return the created normalized uri
*/
public static NormalizedUri newNormalizedUri(String uri, boolean
normalized) {
+ return newNormalizedUri(uri, normalized, false);
+ }
+
+ /**
+ * Creates a new {@link NormalizedUri} instance.
+ *
+ * @param uri the uri
+ * @param normalized whether its already normalized
+ * @param literalOptionBinding whether the uri was computed from the
current message, so its option values are
+ * bound as literal text: no property
placeholders, {@code #class:} or
+ * {@code #property:}; registry references
({@code #bean:}, {@code #type:}) are still
+ * resolved
+ * @return the created normalized uri
+ * @since 4.24
+ */
+ public static NormalizedUri newNormalizedUri(String uri, boolean
normalized, boolean literalOptionBinding) {
if (normalized) {
- return new NormalizedUri(uri, null);
+ return new NormalizedUri(uri, null, literalOptionBinding);
} else {
- return new NormalizedUri(EndpointHelper.normalizeEndpointUri(uri),
uri);
+ return new NormalizedUri(EndpointHelper.normalizeEndpointUri(uri),
uri, literalOptionBinding);
}
}
@@ -68,6 +94,18 @@ public final class NormalizedUri extends ValueHolder<String>
implements Normaliz
return rawUri;
}
+ /**
+ * Whether this uri was computed from the current message at runtime, so
the option values of the endpoint created
+ * from it are bound as literal text: a property placeholder ({@code
{{...}}}), a {@code #class:} value or a
+ * {@code #property:} value is not resolved. Registry references ({@code
#bean:}, {@code #type:}) are still
+ * resolved.
+ *
+ * @since 4.24
+ */
+ public boolean isLiteralOptionBinding() {
+ return literalOptionBinding;
+ }
+
@Override
public String getUri() {
return get();
diff --git
a/core/camel-support/src/main/java/org/apache/camel/support/PropertyBindingSupport.java
b/core/camel-support/src/main/java/org/apache/camel/support/PropertyBindingSupport.java
index 6eda0f45eb70..02ad5ba2b5fa 100644
---
a/core/camel-support/src/main/java/org/apache/camel/support/PropertyBindingSupport.java
+++
b/core/camel-support/src/main/java/org/apache/camel/support/PropertyBindingSupport.java
@@ -118,10 +118,77 @@ public final class PropertyBindingSupport {
private PropertyBindingSupport() {
}
+ // a thread-scoped signal that the endpoint currently being created has a
uri computed from the current message at
+ // runtime (a dynamic endpoint such as
toD/enrich/wireTap/pollEnrich/recipientList/routingSlip/dynamicRouter), so
+ // its option values are bound as literal text. The CamelContext sets it
(in a try/finally) around
+ // Component#createEndpoint(String, Map) only. While it is set, the
Builder binds in literal mode, and resolveBean
+ // and EndpointHelper#resolveReferenceParameter refuse the values that are
kept literal, so every way a component
+ // binds its options is covered (generated configurers, setProperties
overloads, resolveAndRemoveReferenceParameter
+ // and direct use of this class).
+ private static final ThreadLocal<Boolean> LITERAL_OPTION_BINDING = new
ThreadLocal<>();
+
public static Builder build() {
return new Builder();
}
+ /**
+ * Whether the endpoint currently being created on this thread binds its
option values as literal text, because its
+ * uri was computed from the current message at runtime, see {@link
Builder#withLiteral(boolean)}.
+ *
+ * @return true if literal option binding is active on the current thread
+ * @since 4.24
+ */
+ public static boolean isLiteralOptionBinding() {
+ return Boolean.TRUE.equals(LITERAL_OPTION_BINDING.get());
+ }
+
+ /**
+ * Marks (or clears) the current thread as creating an endpoint whose
option values are bound as literal text. The
+ * caller MUST restore the returned previous value in a {@code finally}
block. The CamelContext does this around
+ * {@link org.apache.camel.Component#createEndpoint(String, Map)} when the
uri was computed from the current
+ * message.
+ *
+ * @param literalOptionBinding whether literal option binding is active
+ * @return the previous value, to be restored by the
caller
+ * @since 4.24
+ */
+ public static boolean setLiteralOptionBinding(boolean
literalOptionBinding) {
+ boolean prev = isLiteralOptionBinding();
+ if (literalOptionBinding) {
+ LITERAL_OPTION_BINDING.set(Boolean.TRUE);
+ } else {
+ LITERAL_OPTION_BINDING.remove();
+ }
+ return prev;
+ }
+
+ /**
+ * Whether the value is kept as literal text when bound in literal mode: a
value with a property placeholder
+ * ({@code {{...}}}), a {@code #class:} value or a {@code #property:}
value. Plain registry references such as
+ * {@code #bean:}, {@code #type:} and {@code #name} are not.
+ */
+ static boolean isLiteralOnlyValue(String value) {
+ if (value == null) {
+ return false;
+ }
+ String s = value.trim();
+ return s.contains(PropertiesComponent.PREFIX_TOKEN) ||
s.startsWith("#class:") || s.startsWith("#property:");
+ }
+
+ /**
+ * Fails when literal option binding is active and the value is one that
is only bound as literal text, so it is not
+ * resolved as a property placeholder, created as a class, or looked up as
a property.
+ */
+ static void checkLiteralOptionReference(String value) {
+ if (isLiteralOnlyValue(value) && isLiteralOptionBinding()) {
+ throw new IllegalArgumentException(
+ "The option value is bound as literal text because the
endpoint uri is computed from the message"
+ + " (such as with toD, enrich,
pollEnrich or recipientList): property"
+ + " placeholders, #class: and
#property: are not resolved there."
+ + " Register the bean and refer
to it with #bean:name instead");
+ }
+ }
+
/**
* Binds the properties to the target object, and removes the property
that was bound from properties.
* <p>
@@ -252,6 +319,11 @@ public final class PropertyBindingSupport {
* value
* @param reference whether reference parameter (syntax starts
with #) is in use
* @param placeholder whether to use Camels property placeholder
to resolve placeholders on keys and values
+ * @param literal whether to bind in literal mode: a value
with a property placeholder, a #class: value
+ * or a #property: value is bound as literal
text, and option names are not resolved as
+ * property placeholders. Plain registry
references (#bean:, #type:, #name) are still
+ * resolved. Literal mode is also on while a
literal option binding scope is active, see
+ * {@link #isLiteralOptionBinding()}.
* @param reflection whether to allow using reflection (when
there is no configurer available).
* @param configurer to use an optional {@link
PropertyConfigurer} to configure the properties
* @param listener optional listener
@@ -262,7 +334,7 @@ public final class PropertyBindingSupport {
String optionPrefix, boolean ignoreCase, boolean removeParameter,
boolean flattenProperties,
boolean mandatory, boolean optional,
boolean nesting, boolean deepNesting, boolean fluentBuilder,
boolean allowPrivateSetter,
- boolean reference, boolean placeholder,
+ boolean reference, boolean placeholder, boolean literal,
boolean reflection, PropertyConfigurer configurer,
PropertyBindingListener listener) {
@@ -270,6 +342,10 @@ public final class PropertyBindingSupport {
return false;
}
+ // an endpoint whose uri is computed from the current message binds
its options in literal mode, however the
+ // component binds them
+ literal = literal || isLiteralOptionBinding();
+
if (flattenProperties) {
properties = new FlattenMap(properties);
}
@@ -309,7 +385,8 @@ public final class PropertyBindingSupport {
listener.bindProperty(target, key, value);
}
boolean hit = doBuildPropertyOgnlPath(camelContext, target, key,
value, deepNesting, fluentBuilder,
- allowPrivateSetter, ignoreCase, reference, placeholder,
mandatory, optional, reflection, configurer);
+ allowPrivateSetter, ignoreCase, reference, placeholder,
literal, mandatory, optional, reflection,
+ configurer);
if (hit && removeParameter) {
properties.remove(key);
}
@@ -322,8 +399,8 @@ public final class PropertyBindingSupport {
private static boolean doBuildPropertyOgnlPath(
final CamelContext camelContext, final Object originalTarget,
String name, final Object value,
boolean deepNesting, boolean fluentBuilder, boolean
allowPrivateSetter,
- boolean ignoreCase, boolean reference, boolean placeholder,
boolean mandatory, boolean optional,
- boolean reflection, PropertyConfigurer configurer) {
+ boolean ignoreCase, boolean reference, boolean placeholder,
boolean literal, boolean mandatory,
+ boolean optional, boolean reflection, PropertyConfigurer
configurer) {
if (name.startsWith("?")) {
// the name marks the option as optional
@@ -429,7 +506,7 @@ public final class PropertyBindingSupport {
// we have walked down to the last part of the ognl path and are ready
to set the last piece with the value
// now this is actually also a bit complex so lets use another method
for that
return doSetPropertyValue(camelContext, newTarget, newName, value,
ignoreCase, mandatory,
- fluentBuilder, allowPrivateSetter, reference, placeholder,
optional, reflection, configurer);
+ fluentBuilder, allowPrivateSetter, reference, placeholder,
literal, optional, reflection, configurer);
}
private static Object attemptCreateNewInstanceViaReflection(
@@ -516,44 +593,61 @@ public final class PropertyBindingSupport {
CamelContext camelContext, Object target, String name, Object
value,
boolean ignoreCase, boolean mandatory,
boolean fluentBuilder, boolean allowPrivateSetter,
- boolean reference, boolean placeholder, boolean optional,
+ boolean reference, boolean placeholder, boolean literal, boolean
optional,
boolean reflection, PropertyConfigurer configurer) {
String key = name;
Object text = value;
- if (placeholder) {
- // resolve property placeholders
+ // in literal mode (the endpoint uri was computed from the current
message at runtime) a value with a {{...}}
+ // property placeholder, a #class: value (which creates a class and
can call a factory method) or a #property:
+ // value is bound as literal text. Plain registry references (#bean:,
#type:, #name) are still resolved, so a
+ // reference a route author wrote in the dynamic uri, such as
dataSource=#ds, keeps working.
+ boolean literalValue = literal && text instanceof String lit &&
isLiteralOnlyValue(lit);
+
+ // the option names of the uri were already resolved when the route
was built, so in literal mode they are not
+ // resolved again
+ if (placeholder && !literal) {
key = camelContext.resolvePropertyPlaceholders(key);
- if (text instanceof String s) {
- // resolve property placeholders
- text = camelContext.resolvePropertyPlaceholders(s);
- if (text == null &&
s.startsWith(PropertiesComponent.PREFIX_TOKEN + "?")) {
- // it was an optional value, so we should not try to set
the property but regard it as a "hit"
- return true;
- }
+ }
+ if (placeholder && !literalValue && text instanceof String s) {
+ // resolve property placeholders
+ text = camelContext.resolvePropertyPlaceholders(s);
+ if (text == null && s.startsWith(PropertiesComponent.PREFIX_TOKEN
+ "?")) {
+ // it was an optional value, so we should not try to set the
property but regard it as a "hit"
+ return true;
}
}
// prepare the value before it is bound
- try {
- Object str = resolveValue(camelContext, target, key, text,
ignoreCase, fluentBuilder,
- allowPrivateSetter, reflection, configurer);
- // resolve property placeholders
- if (str instanceof String strValue) {
- // resolve property placeholders
- str = camelContext.resolvePropertyPlaceholders(strValue);
- }
- if (str == null && reference && mandatory && !optional) {
- // we could not resolve the reference and this is mandatory
- throw new PropertyBindingException(target, key, value);
+ if (literalValue) {
+ // keep the value as literal text: no property-placeholder,
#class: or #property: resolution
+ value = text;
+ } else {
+ try {
+ Object str = resolveValue(camelContext, target, key, text,
ignoreCase, fluentBuilder,
+ allowPrivateSetter, reflection, configurer);
+ if (str instanceof String strValue && !literal) {
+ // resolve property placeholders
+ str = camelContext.resolvePropertyPlaceholders(strValue);
+ }
+ if (str == null && reference && mandatory && !optional) {
+ // we could not resolve the reference and this is mandatory
+ throw new PropertyBindingException(target, key, value);
+ }
+ value = str;
+ } catch (Exception e) {
+ // report the exception using the long key and parent target
+ throw new PropertyBindingException(target, key, text, e);
}
- value = str;
- } catch (Exception e) {
- // report the exception using the long key and parent target
- throw new PropertyBindingException(target, key, text, e);
}
+ // a value kept as literal text is not resolved as a reference by
reflection. A configurer resolves a
+ // reference (#...) on its own for an option that is not a String:
there EndpointHelper.resolveReferenceParameter
+ // refuses a #class: or #property: value while the literal option
binding scope is active, and an option of
+ // type String gets the literal text
+ boolean effReference = reference && !literalValue;
+
// okay we are ready to set the value, but the property key
// can still be complex such as a map/list/array so we need to handle
them specially than a regular key
boolean bound = false;
@@ -565,7 +659,7 @@ public final class PropertyBindingSupport {
}
if (!bound && reflection) {
// fallback to reflection based
- bound = setPropertyCollectionViaReflection(camelContext,
target, key, value, ignoreCase, reference,
+ bound = setPropertyCollectionViaReflection(camelContext,
target, key, value, ignoreCase, effReference,
optional);
}
} else {
@@ -576,7 +670,7 @@ public final class PropertyBindingSupport {
if (!bound && reflection) {
// fallback to reflection based
bound = setSimplePropertyViaReflection(camelContext,
target, key, value, fluentBuilder, allowPrivateSetter,
- reflection, ignoreCase);
+ !literalValue && reflection, ignoreCase);
}
// if the target value is a map type, then we can skip
reflection
// and set the entry
@@ -1963,6 +2057,10 @@ public final class PropertyBindingSupport {
Object answer = value;
+ // while an endpoint whose uri is computed from the current message is
created, a placeholder, #class: or
+ // #property: value is not resolved
+ checkLiteralOptionReference(strval);
+
// resolve placeholders
strval = camelContext.resolvePropertyPlaceholders(strval);
@@ -2139,6 +2237,7 @@ public final class PropertyBindingSupport {
private boolean deepNesting = true;
private boolean reference = true;
private boolean placeholder = true;
+ private boolean literal;
private boolean fluentBuilder = true;
private boolean allowPrivateSetter = true;
private boolean ignoreCase;
@@ -2252,6 +2351,23 @@ public final class PropertyBindingSupport {
return this;
}
+ /**
+ * Whether to bind in literal mode, for values computed from message
content at runtime (for example the option
+ * values of a dynamic endpoint). In literal mode a value with a
property placeholder ({@code {{...}}}), a
+ * {@code #class:} value or a {@code #property:} value is bound as
literal text, and option names are not
+ * resolved as property placeholders. Plain registry references
({@code #bean:}, {@code #type:}, {@code #name})
+ * are still resolved.
+ * <p>
+ * Literal mode is also on, whatever this option says, while a literal
option binding scope is active on the
+ * current thread, see {@link
PropertyBindingSupport#isLiteralOptionBinding()}.
+ *
+ * @since 4.24
+ */
+ public Builder withLiteral(boolean literal) {
+ this.literal = literal;
+ return this;
+ }
+
/**
* Whether fluent builder is allowed as a valid getter/setter
*/
@@ -2356,8 +2472,8 @@ public final class PropertyBindingSupport {
return doBindProperties(camelContext, target, removeParameters ?
properties : new HashMap<>(properties),
optionPrefix, ignoreCase, removeParameters,
flattenProperties, mandatory, optional,
- nesting, deepNesting, fluentBuilder, allowPrivateSetter,
reference, placeholder, reflection, configurer,
- listener);
+ nesting, deepNesting, fluentBuilder, allowPrivateSetter,
reference, placeholder, literal, reflection,
+ configurer, listener);
}
/**
@@ -2375,8 +2491,8 @@ public final class PropertyBindingSupport {
return doBindProperties(context, obj, removeParameters ? prop :
new HashMap<>(prop),
optionPrefix, ignoreCase, removeParameters,
flattenProperties, mandatory, optional,
- nesting, deepNesting, fluentBuilder, allowPrivateSetter,
reference, placeholder, reflection, configurer,
- listener);
+ nesting, deepNesting, fluentBuilder, allowPrivateSetter,
reference, placeholder, literal, reflection,
+ configurer, listener);
}
/**
@@ -2394,8 +2510,8 @@ public final class PropertyBindingSupport {
return doBindProperties(camelContext, target, properties,
optionPrefix, ignoreCase, true, false, mandatory,
optional,
- nesting, deepNesting, fluentBuilder, allowPrivateSetter,
reference, placeholder, reflection, configurer,
- listener);
+ nesting, deepNesting, fluentBuilder, allowPrivateSetter,
reference, placeholder, literal, reflection,
+ configurer, listener);
}
}
diff --git
a/core/camel-support/src/main/java/org/apache/camel/support/component/PollDynamicAwareSupport.java
b/core/camel-support/src/main/java/org/apache/camel/support/component/PollDynamicAwareSupport.java
index 1e0664b136b9..d3813fa9e759 100644
---
a/core/camel-support/src/main/java/org/apache/camel/support/component/PollDynamicAwareSupport.java
+++
b/core/camel-support/src/main/java/org/apache/camel/support/component/PollDynamicAwareSupport.java
@@ -84,8 +84,9 @@ public abstract class PollDynamicAwareSupport extends
ServiceSupport implements
if (resolveRawParameterValues()) {
// parameters using raw syntax: RAW(value)
// should have the token removed, so its only the value we
have in parameters, as we are about to create
- // an endpoint and want to have the parameter values without
the RAW tokens
-
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
+ // an endpoint and want to have the parameter values without
the RAW tokens. The uri was computed from
+ // the current message, so the RAW values are taken as literal
text (a $simple{} in them is not evaluated)
+
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map, true);
}
// okay so only add the known properties as they are the non
lenient properties
properties = new LinkedHashMap<>();
@@ -115,8 +116,9 @@ public abstract class PollDynamicAwareSupport extends
ServiceSupport implements
if (resolveRawParameterValues()) {
// parameters using raw syntax: RAW(value)
// should have the token removed, so its only the value we
have in parameters, as we are about to create
- // an endpoint and want to have the parameter values without
the RAW tokens
-
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
+ // an endpoint and want to have the parameter values without
the RAW tokens. The uri was computed from
+ // the current message, so the RAW values are taken as literal
text (a $simple{} in them is not evaluated)
+
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map, true);
}
properties = new LinkedHashMap<>();
map.forEach((k, v) -> {
diff --git
a/core/camel-support/src/main/java/org/apache/camel/support/component/RawParameterHelper.java
b/core/camel-support/src/main/java/org/apache/camel/support/component/RawParameterHelper.java
index 31254462ecd3..419244d45486 100644
---
a/core/camel-support/src/main/java/org/apache/camel/support/component/RawParameterHelper.java
+++
b/core/camel-support/src/main/java/org/apache/camel/support/component/RawParameterHelper.java
@@ -21,6 +21,7 @@ import java.util.Map;
import org.apache.camel.CamelContext;
import org.apache.camel.Exchange;
import org.apache.camel.support.ExchangeHelper;
+import org.apache.camel.support.PropertyBindingSupport;
import org.apache.camel.util.URISupport;
public final class RawParameterHelper {
@@ -36,12 +37,37 @@ public final class RawParameterHelper {
* The value can refer to a simple expression using $simple{xxx} syntax
which allows to refer to passwords defined
* as ENV variables etc.
*
+ * When the endpoint currently being created on this thread binds its
option values as literal text (see
+ * {@link PropertyBindingSupport#isLiteralOptionBinding()}), the RAW
tokens are removed but a $simple{xxx} in the
+ * value is not evaluated, see {@link
#resolveRawParameterValues(CamelContext, Map, boolean)}.
+ *
* @param camelContext the camel context
* @param parameters the uri parameters
*/
public static void resolveRawParameterValues(CamelContext camelContext,
Map<String, Object> parameters) {
+ resolveRawParameterValues(camelContext, parameters,
PropertyBindingSupport.isLiteralOptionBinding());
+ }
+
+ /**
+ * Traverses the given parameters, and resolves any parameter values which
use the RAW token syntax:
+ * <code>key=RAW(value)</code>. This method will then remove the RAW
tokens, and replace the content of the value,
+ * with just the value.
+ *
+ * When {@code literal} is {@code false} the value can refer to a simple
expression using $simple{xxx} syntax which
+ * allows to refer to passwords defined as ENV variables etc. When {@code
literal} is {@code true} the value is
+ * taken as literal text and a $simple{xxx} in it is not evaluated. This
is used for an endpoint whose uri was
+ * computed from the current message at runtime (for example the
per-message recipient of {@code toD} or
+ * {@code pollEnrich}), as its option values come from the message and not
from the route.
+ *
+ * @param camelContext the camel context
+ * @param parameters the uri parameters
+ * @param literal whether the RAW values are taken as literal text,
without evaluating $simple{xxx}
+ * @since 4.24
+ */
+ public static void resolveRawParameterValues(
+ CamelContext camelContext, Map<String, Object> parameters, boolean
literal) {
URISupport.resolveRawParameterValues(parameters, s -> {
- if (s != null && s.contains("$simple{")) {
+ if (!literal && s != null && s.contains("$simple{")) {
Exchange dummy = ExchangeHelper.getDummy(camelContext);
s =
camelContext.resolveLanguage("simple").createExpression(s).evaluate(dummy,
String.class);
}
diff --git
a/core/camel-support/src/main/java/org/apache/camel/support/component/SendDynamicAwareSupport.java
b/core/camel-support/src/main/java/org/apache/camel/support/component/SendDynamicAwareSupport.java
index 117613441960..0d5ae4cab1d5 100644
---
a/core/camel-support/src/main/java/org/apache/camel/support/component/SendDynamicAwareSupport.java
+++
b/core/camel-support/src/main/java/org/apache/camel/support/component/SendDynamicAwareSupport.java
@@ -84,8 +84,9 @@ public abstract class SendDynamicAwareSupport extends
ServiceSupport implements
if (resolveRawParameterValues()) {
// parameters using raw syntax: RAW(value)
// should have the token removed, so its only the value we
have in parameters, as we are about to create
- // an endpoint and want to have the parameter values without
the RAW tokens
-
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
+ // an endpoint and want to have the parameter values without
the RAW tokens. The uri was computed from
+ // the current message, so the RAW values are taken as literal
text (a $simple{} in them is not evaluated)
+
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map, true);
}
// okay so only add the known properties as they are the non
lenient properties
properties = new LinkedHashMap<>();
@@ -115,8 +116,9 @@ public abstract class SendDynamicAwareSupport extends
ServiceSupport implements
if (resolveRawParameterValues()) {
// parameters using raw syntax: RAW(value)
// should have the token removed, so its only the value we
have in parameters, as we are about to create
- // an endpoint and want to have the parameter values without
the RAW tokens
-
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
+ // an endpoint and want to have the parameter values without
the RAW tokens. The uri was computed from
+ // the current message, so the RAW values are taken as literal
text (a $simple{} in them is not evaluated)
+
RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map, true);
}
properties = new LinkedHashMap<>();
map.forEach((k, v) -> {
diff --git
a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
index 4dbf2897885b..76d7f1e2429c 100644
--- a/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
+++ b/docs/user-manual/modules/ROOT/pages/camel-4x-upgrade-guide-4_24.adoc
@@ -133,6 +133,49 @@ the WARN says to use `toD`. The route works as before.
Only the endpoint path is
of `sql`, and the components whose path option is marked
`supportSimpleExpression` in their metadata, which now
includes the template of `sql-stored` and the bucket name of `aws2-s3`.
+=== camel-core - option values of a dynamic endpoint are bound as literal text
+
+The dynamic-endpoint EIPs -- `toD`, `enrich`, `wireTap`, `pollEnrich`,
`recipientList`, `routingSlip` and
+`dynamicRouter` -- compute their target endpoint from the current message at
runtime. The option values of that
+endpoint are now bound as literal text: a property placeholder (`+{{...}}+`),
a `#class:` value or a `#property:` value
+is not resolved. This extends to the options the treatment that `toD`,
`enrich`, `wireTap` and `pollEnrich` already gave
+the endpoint path. It applies however the component binds its options,
including components that bind them in their
+own `createEndpoint` or look up a reference option with
`resolveAndRemoveReferenceParameter`.
+
+This applies to every option of that uri, not only to the parts that come from
the message: a `#class:` or
+`#property:` value written in the text of a `toD`, or in a uri that a bean of
the route builds for `recipientList`,
+`routingSlip` or `dynamicRouter`, is not resolved either. For an option of
type `String` the text is bound as is. For
+an option of another type, a `#class:` value fails the creation of the
endpoint with a `ResolveEndpointFailedException`.
+Register the bean instead and refer to it with `#bean:`, for example:
+
+[source,java]
+----
+// before: the class was created for every new endpoint
+toD("log:audit?exchangeFormatter=#class:com.foo.MyFormatter&marker=${header.customer}")
+
+// after: create the bean once (e.g. camel.beans.myFormatter =
#class:com.foo.MyFormatter) and refer to it
+toD("log:audit?exchangeFormatter=#bean:myFormatter&marker=${header.customer}")
+----
+
+What still works as before:
+
+* Registry references (`#bean:name`, `#type:`, `#name`) are still resolved, so
`+toD("sql:${header.query}?dataSource=#ds")+` keeps working.
+* Property placeholders written in the text of a `toD` are resolved once when
the route is built, so
+ `+toD("mock:foo?delay={{myDelay}}")+` is unchanged. `recipientList`,
`routingSlip` and `dynamicRouter` still resolve
+ property placeholders in the computed uri string.
+* An endpoint in a static `to(...)`, or configured on the component, binds
`#class:`, `#property:` and placeholders as
+ before.
+
+=== camel-core - RAW() option values of a dynamic endpoint computed from the
message are literal text
+
+A `RAW(...)` option value of an endpoint whose uri is computed from the
current message at runtime (`toD`, `enrich`,
+`wireTap`, `pollEnrich`, `recipientList`, `routingSlip` and `dynamicRouter`)
is still unwrapped, but its content is now
+taken as literal text: a `+++$simple{...}+++` in it is no longer evaluated.
Endpoints written in the route, such as
+`+to("ftp:[email protected]?password=RAW($simple{env:MY_FTP_PASSWORD})")+`,
are unchanged. As the whole uri of `toD`
+is computed per message, this also applies to a
`+++RAW($simple{env:MY_PASSWORD})+++` written in the `toD` uri itself;
+use a property placeholder instead, such as
`+toD("ftp:joe@${header.host}?password=RAW({{env:MY_PASSWORD}})")+`, which
+is resolved once when the route is created.
+
=== camel-core - Rest DSL binding mode json fails at startup without a JSON
data format
A Rest DSL service with `bindingMode` `json` or `json_xml` whose JSON data
format (`jackson` unless `jsonDataFormat`
diff --git a/docs/user-manual/modules/ROOT/pages/endpoint.adoc
b/docs/user-manual/modules/ROOT/pages/endpoint.adoc
index a6c82d05910a..2ad0a2c8c3d7 100644
--- a/docs/user-manual/modules/ROOT/pages/endpoint.adoc
+++ b/docs/user-manual/modules/ROOT/pages/endpoint.adoc
@@ -322,6 +322,11 @@ YAML::
====
+NOTE: The `+++$simple{xxx}+++` in a `RAW(...)` value is evaluated only for
endpoints written in the route. For an
+endpoint whose uri is computed from the message at runtime, such as with `toD`
or `pollEnrich`, a `RAW(...)` value is
+taken as literal text. Use a property placeholder such as
`+RAW({{env:MY_FTP_PASSWORD}})+` there, which is resolved
+when the route is created.
+
=== Endpoint URIs with property placeholders
Camel has extensive support for using xref:using-propertyplaceholder.adoc[].