You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by ac...@apache.org on 2022/12/02 08:08:38 UTC
[camel-kamelets] 06/28: Fail on missing data type and add log output
This is an automated email from the ASF dual-hosted git repository.
acosentino pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel-kamelets.git
commit 814654a81cb645e5099ba55910476c3e9915274f
Author: Christoph Deppisch <cd...@redhat.com>
AuthorDate: Fri Nov 18 10:48:51 2022 +0100
Fail on missing data type and add log output
---
.../kamelets/utils/format/DataTypeProcessor.java | 22 ++++++++++-
.../format/DefaultDataTypeConverterResolver.java | 5 +++
.../utils/format/DefaultDataTypeRegistry.java | 44 ++++++++++++++++++----
.../utils/format/DataTypeProcessorTest.java | 3 +-
4 files changed, 65 insertions(+), 9 deletions(-)
diff --git a/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DataTypeProcessor.java b/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DataTypeProcessor.java
index def0f2b8..110c5cd4 100644
--- a/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DataTypeProcessor.java
+++ b/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DataTypeProcessor.java
@@ -21,9 +21,12 @@ import java.util.Optional;
import org.apache.camel.CamelContext;
import org.apache.camel.CamelContextAware;
+import org.apache.camel.CamelExecutionException;
import org.apache.camel.Exchange;
import org.apache.camel.Processor;
import org.apache.camel.kamelets.utils.format.spi.DataTypeConverter;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Processor applies data type conversion based on given format name. Searches for matching data type converter
@@ -33,6 +36,8 @@ public class DataTypeProcessor implements Processor, CamelContextAware {
public static final String DATA_TYPE_FORMAT_PROPERTY = "CamelDataTypeFormat";
+ private static final Logger LOG = LoggerFactory.getLogger(DataTypeProcessor.class);
+
private CamelContext camelContext;
private DefaultDataTypeRegistry registry;
@@ -40,6 +45,8 @@ public class DataTypeProcessor implements Processor, CamelContextAware {
private String scheme;
private String format;
+ private boolean ignoreMissingDataType = false;
+
private DataTypeConverter converter;
@Override
@@ -52,7 +59,16 @@ public class DataTypeProcessor implements Processor, CamelContextAware {
return;
}
- doConverterLookup().ifPresent(converter -> converter.convert(exchange));
+ Optional<DataTypeConverter> dataTypeConverter = doConverterLookup();
+ dataTypeConverter.ifPresent(converter -> converter.convert(exchange));
+
+ if (!dataTypeConverter.isPresent()) {
+ LOG.debug("Unable to find data type for scheme {} and format name {}", scheme, format);
+
+ if (!ignoreMissingDataType) {
+ throw new CamelExecutionException(String.format("Missing data type for scheme %s and format name %s", scheme, format), exchange);
+ }
+ }
}
private Optional<DataTypeConverter> doConverterLookup() {
@@ -78,6 +94,10 @@ public class DataTypeProcessor implements Processor, CamelContextAware {
this.registry = dataTypeRegistry;
}
+ public void setIgnoreMissingDataType(boolean ignoreMissingDataType) {
+ this.ignoreMissingDataType = ignoreMissingDataType;
+ }
+
@Override
public CamelContext getCamelContext() {
return camelContext;
diff --git a/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeConverterResolver.java b/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeConverterResolver.java
index 85444a28..5fdaa790 100644
--- a/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeConverterResolver.java
+++ b/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeConverterResolver.java
@@ -43,6 +43,11 @@ public class DefaultDataTypeConverterResolver implements DataTypeConverterResolv
@Override
public Optional<DataTypeConverter> resolve(String scheme, String name, CamelContext context) {
String converterName = String.format("%s-%s", scheme, name);
+
+ if (getLog().isDebugEnabled()) {
+ getLog().debug("Resolving data type converter {} via: {}{}", converterName, RESOURCE_PATH, converterName);
+ }
+
Class<?> type = findConverter(converterName, context);
if (type == null) {
// not found
diff --git a/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeRegistry.java b/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeRegistry.java
index 7105fb4c..0e262d28 100644
--- a/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeRegistry.java
+++ b/library/camel-kamelets-utils/src/main/java/org/apache/camel/kamelets/utils/format/DefaultDataTypeRegistry.java
@@ -31,6 +31,9 @@ import org.apache.camel.kamelets.utils.format.spi.DataTypeConverterResolver;
import org.apache.camel.kamelets.utils.format.spi.DataTypeLoader;
import org.apache.camel.kamelets.utils.format.spi.DataTypeRegistry;
import org.apache.camel.support.service.ServiceSupport;
+import org.apache.camel.util.ObjectHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
/**
* Default data type registry able to resolve data types converters in the project. Data types may be defined at the component level
@@ -41,6 +44,8 @@ import org.apache.camel.support.service.ServiceSupport;
*/
public class DefaultDataTypeRegistry extends ServiceSupport implements DataTypeRegistry, CamelContextAware {
+ private static final Logger LOG = LoggerFactory.getLogger(DefaultDataTypeRegistry.class);
+
private CamelContext camelContext;
protected final List<DataTypeLoader> dataTypeLoaders = new ArrayList<>();
@@ -51,12 +56,21 @@ public class DefaultDataTypeRegistry extends ServiceSupport implements DataTypeR
@Override
public void addDataTypeConverter(String scheme, DataTypeConverter converter) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Adding data type for scheme {} and name {}", scheme, converter.getName());
+ }
+
this.getComponentDataTypeConverters(scheme).add(converter);
}
@Override
public Optional<DataTypeConverter> lookup(String scheme, String name) {
+ if (LOG.isTraceEnabled()) {
+ LOG.trace("Searching for data type with scheme {} and name {}", scheme, name);
+ }
+
if (dataTypeLoaders.isEmpty()) {
+ LOG.trace("Lazy initializing data type registry");
try {
doInit();
} catch (Exception e) {
@@ -89,6 +103,8 @@ public class DefaultDataTypeRegistry extends ServiceSupport implements DataTypeR
CamelContextAware.trySetCamelContext(loader, getCamelContext());
loader.load(this);
}
+
+ LOG.debug("Loaded {} initial data type converters", dataTypeConverters.size());
}
@Override
@@ -115,17 +131,31 @@ public class DefaultDataTypeRegistry extends ServiceSupport implements DataTypeR
Optional<DataTypeConverter> dataTypeConverter = Optional.ofNullable(camelContext.getRegistry()
.lookupByNameAndType(String.format("%s-%s", scheme, name), DataTypeConverter.class));
- if (!dataTypeConverter.isPresent()) {
- // Try to retrieve converter from preloaded converters in local cache
- dataTypeConverter = getComponentDataTypeConverters(scheme).stream()
+ if (dataTypeConverter.isPresent()) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Found data type {} for scheme {} and name {} in Camel registry", ObjectHelper.name(dataTypeConverter.get().getClass()), scheme, name);
+ }
+ return dataTypeConverter;
+ }
+
+ // Try to retrieve converter from preloaded converters in local cache
+ dataTypeConverter = getComponentDataTypeConverters(scheme).stream()
.filter(dtc -> name.equals(dtc.getName()))
.findFirst();
+
+ if (dataTypeConverter.isPresent()) {
+ if (LOG.isDebugEnabled()) {
+ LOG.debug("Found data type {} for scheme {} and name {}", ObjectHelper.name(dataTypeConverter.get().getClass()), scheme, name);
+ }
+ return dataTypeConverter;
}
- if (!dataTypeConverter.isPresent()) {
- // Try to lazy load converter via resource path lookup
- dataTypeConverter = dataTypeConverterResolver.resolve(scheme, name, camelContext);
- dataTypeConverter.ifPresent(converter -> getComponentDataTypeConverters(scheme).add(converter));
+ // Try to lazy load converter via resource path lookup
+ dataTypeConverter = dataTypeConverterResolver.resolve(scheme, name, camelContext);
+ dataTypeConverter.ifPresent(converter -> getComponentDataTypeConverters(scheme).add(converter));
+
+ if (LOG.isDebugEnabled() && dataTypeConverter.isPresent()) {
+ LOG.debug("Resolved data type {} for scheme {} and name {} via resource path", ObjectHelper.name(dataTypeConverter.get().getClass()), scheme, name);
}
return dataTypeConverter;
diff --git a/library/camel-kamelets-utils/src/test/java/org/apache/camel/kamelets/utils/format/DataTypeProcessorTest.java b/library/camel-kamelets-utils/src/test/java/org/apache/camel/kamelets/utils/format/DataTypeProcessorTest.java
index 0140b6f9..d2c2554a 100644
--- a/library/camel-kamelets-utils/src/test/java/org/apache/camel/kamelets/utils/format/DataTypeProcessorTest.java
+++ b/library/camel-kamelets-utils/src/test/java/org/apache/camel/kamelets/utils/format/DataTypeProcessorTest.java
@@ -70,10 +70,11 @@ class DataTypeProcessorTest {
}
@Test
- public void shouldHandleUnknownDataType() throws Exception {
+ public void shouldIgnoreUnknownDataType() throws Exception {
Exchange exchange = new DefaultExchange(camelContext);
exchange.getMessage().setBody(new ByteArrayInputStream("Test".getBytes(StandardCharsets.UTF_8)));
+ processor.setIgnoreMissingDataType(true);
processor.setScheme("foo");
processor.setFormat("unknown");
processor.process(exchange);