This is an automated email from the ASF dual-hosted git repository. davsclaus pushed a commit to branch CAMEL-27267 in repository https://gitbox.apache.org/repos/asf/camel.git
commit 8060e3a9a579eda23a0352eb5033064e7727c913 Author: Claus Ibsen <[email protected]> AuthorDate: Fri Nov 20 07:31:15 2026 +0100 CAMEL-27267: camel-core - the binary data type keeps a File or WrappedFile body instead of reading it into memory The binary (application-octet-stream) data type kept a stream cache body since CAMEL-27258, but still read a java.io.File or a WrappedFile body, such as the GenericFile of the file and FTP consumers, into a byte[]. A file is binary already, can be read again and may be large: keep it as it is and only set the Content-Type, so a binary default on a file or object sink Kamelet does not read every file into memory. transformerOut of the @BodyTypes lists file, and the 4.24 upgrade guide note says so. Co-Authored-By: Claude Opus 5.5 <[email protected]> Signed-off-by: Claus Ibsen <[email protected]> --- .../transformers/application-octet-stream.json | 3 +- .../transformer/application-octet-stream.json | 3 +- .../transformer/ByteArrayDataTypeTransformer.java | 17 ++++++---- .../ByteArrayDataTypeTransformerTest.java | 36 +++++++++++++++++++++- .../ROOT/pages/camel-4x-upgrade-guide-4_24.adoc | 15 ++++----- 5 files changed, 58 insertions(+), 16 deletions(-) diff --git a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/transformers/application-octet-stream.json b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/transformers/application-octet-stream.json index 5ca07d00c114..38d52fb8f03c 100644 --- a/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/transformers/application-octet-stream.json +++ b/catalog/camel-catalog/src/generated/resources/org/apache/camel/catalog/transformers/application-octet-stream.json @@ -24,9 +24,10 @@ "carriers": [ "bytes", "stream", + "file", "null" ], - "description": "A stream cache body is kept as it is and a null body stays null; any other body becomes a byte array" + "description": "A stream cache or a file body is kept as it is and a null body stays null; any other body becomes a byte array" } } } diff --git a/core/camel-core-processor/src/generated/resources/META-INF/services/org/apache/camel/transformer/application-octet-stream.json b/core/camel-core-processor/src/generated/resources/META-INF/services/org/apache/camel/transformer/application-octet-stream.json index 5ca07d00c114..38d52fb8f03c 100644 --- a/core/camel-core-processor/src/generated/resources/META-INF/services/org/apache/camel/transformer/application-octet-stream.json +++ b/core/camel-core-processor/src/generated/resources/META-INF/services/org/apache/camel/transformer/application-octet-stream.json @@ -24,9 +24,10 @@ "carriers": [ "bytes", "stream", + "file", "null" ], - "description": "A stream cache body is kept as it is and a null body stays null; any other body becomes a byte array" + "description": "A stream cache or a file body is kept as it is and a null body stays null; any other body becomes a byte array" } } } diff --git a/core/camel-core-processor/src/main/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformer.java b/core/camel-core-processor/src/main/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformer.java index 7d734cbe40bc..a5fb54bd43c9 100644 --- a/core/camel-core-processor/src/main/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformer.java +++ b/core/camel-core-processor/src/main/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformer.java @@ -16,9 +16,12 @@ */ package org.apache.camel.processor.transformer; +import java.io.File; + import org.apache.camel.Exchange; import org.apache.camel.Message; import org.apache.camel.StreamCache; +import org.apache.camel.WrappedFile; import org.apache.camel.spi.BodyType; import org.apache.camel.spi.BodyType.Carrier; import org.apache.camel.spi.BodyTypes; @@ -28,23 +31,25 @@ import org.apache.camel.spi.Transformer; /** * Generic binary data type uses Camel message body converter mechanism to convert content to byte array representation. - * A stream cache body is binary already and can be read again, so it is kept as it is: a large body, such as an object - * read from a bucket, is not read into memory. Any other stream is read into a byte array, as it may be read only once. + * A stream cache or a file body is binary already and can be read again, so it is kept as it is: a large body, such as + * an object read from a bucket or a file to upload, is not read into memory. Any other stream is read into a byte + * array, as it may be read only once. */ @DataTypeTransformer(name = "application-octet-stream") @BodyTypes(transformerIn = @BodyType(value = { Carrier.TEXT, Carrier.BYTES, Carrier.STREAM, Carrier.FILE, Carrier.NULL }, description = "A body Camel can convert to a byte array: a number fails, and a null" + " body stays null"), - transformerOut = @BodyType(value = { Carrier.BYTES, Carrier.STREAM, Carrier.NULL }, - description = "A stream cache body is kept as it is and a null body stays null;" - + " any other body becomes a byte array")) + transformerOut = @BodyType(value = { Carrier.BYTES, Carrier.STREAM, Carrier.FILE, Carrier.NULL }, + description = "A stream cache or a file body is kept as it is and a null body" + + " stays null; any other body becomes a byte array")) public class ByteArrayDataTypeTransformer extends Transformer { private static final Transformer DELEGATE = new TypeConverterTransformer(byte[].class); @Override public void transform(Message message, DataType from, DataType to) throws Exception { - if (!(message.getBody() instanceof StreamCache)) { + Object body = message.getBody(); + if (!(body instanceof StreamCache || body instanceof File || body instanceof WrappedFile)) { DELEGATE.transform(message, from, to); } diff --git a/core/camel-core/src/test/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformerTest.java b/core/camel-core/src/test/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformerTest.java index 6cd3e927987f..0c73071d2533 100644 --- a/core/camel-core/src/test/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformerTest.java +++ b/core/camel-core/src/test/java/org/apache/camel/processor/transformer/ByteArrayDataTypeTransformerTest.java @@ -17,12 +17,17 @@ package org.apache.camel.processor.transformer; import java.io.ByteArrayInputStream; +import java.io.File; import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Path; import java.util.List; import org.apache.camel.CamelExecutionException; import org.apache.camel.Exchange; import org.apache.camel.StreamCache; +import org.apache.camel.component.file.FileConsumer; +import org.apache.camel.component.file.GenericFile; import org.apache.camel.converter.stream.ByteArrayInputStreamCache; import org.apache.camel.impl.DefaultCamelContext; import org.apache.camel.impl.engine.DefaultTransformerRegistry; @@ -34,6 +39,7 @@ import org.apache.camel.spi.TransformerKey; import org.apache.camel.support.DefaultExchange; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertInstanceOf; @@ -98,6 +104,33 @@ public class ByteArrayDataTypeTransformerTest { assertEquals("test3.txt", exchange.getMessage().getHeader("file")); } + @Test + void shouldKeepFile(@TempDir Path dir) throws Exception { + // a file is binary already and can be read again: it is kept, so a large file is not read into memory + File file = Files.writeString(dir.resolve("test5.txt"), "Test5").toFile(); + Exchange exchange = new DefaultExchange(camelContext); + exchange.getMessage().setBody(file); + transformer.transform(exchange.getMessage(), DataType.ANY, DataType.ANY); + + assertSame(file, exchange.getMessage().getBody()); + assertEquals("application/octet-stream", exchange.getMessage().getHeader(Exchange.CONTENT_TYPE)); + assertEquals("Test5", exchange.getMessage().getBody(String.class)); + } + + @Test + void shouldKeepWrappedFile(@TempDir Path dir) throws Exception { + // a file of the file consumer is kept the same way + File file = Files.writeString(dir.resolve("test6.txt"), "Test6").toFile(); + GenericFile<File> wrapped = FileConsumer.asGenericFile(dir.toString(), file, null, false); + Exchange exchange = new DefaultExchange(camelContext); + exchange.getMessage().setBody(wrapped); + transformer.transform(exchange.getMessage(), DataType.ANY, DataType.ANY); + + assertSame(wrapped, exchange.getMessage().getBody()); + assertEquals("application/octet-stream", exchange.getMessage().getHeader(Exchange.CONTENT_TYPE)); + assertEquals("Test6", exchange.getMessage().getBody(String.class)); + } + @Test void shouldReadOtherInputStreamToBytes() throws Exception { // a stream that is not a stream cache may be read only once: it becomes a byte array every later step can read @@ -130,7 +163,8 @@ public class ByteArrayDataTypeTransformerTest { BodyTypes bodyTypes = ByteArrayDataTypeTransformer.class.getAnnotation(BodyTypes.class); assertEquals(List.of(Carrier.TEXT, Carrier.BYTES, Carrier.STREAM, Carrier.FILE, Carrier.NULL), List.of(bodyTypes.transformerIn().value())); - assertEquals(List.of(Carrier.BYTES, Carrier.STREAM, Carrier.NULL), List.of(bodyTypes.transformerOut().value())); + assertEquals(List.of(Carrier.BYTES, Carrier.STREAM, Carrier.FILE, Carrier.NULL), + List.of(bodyTypes.transformerOut().value())); for (Object body : List.of("Test", "Test".getBytes(StandardCharsets.UTF_8))) { Exchange exchange = new DefaultExchange(camelContext); exchange.getMessage().setBody(body); 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 d51eef60e2eb..ccbc16b67249 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 @@ -220,13 +220,14 @@ it used to get the body of the component. When no transformer for the type is on the classpath, such as `json` with neither `camel-jackson` nor `camel-jackson3`, the message is handed on unchanged, as before, and a WARN is logged once. -=== camel-core - the binary data type keeps a stream cache body - -The `application-octet-stream` (`binary`) data type transformer keeps a body that is a stream cache as it is, and only -sets the `Content-Type` header to `application/octet-stream`. Before, it read the stream into a `byte[]`. A stream cache -is binary already and can be read again, and a source Kamelet such as `aws-s3-source` or `azure-storage-blob-source` -declares `binary` and gives the object as a stream, which may be large. Any other body, including an `InputStream` that is -not a stream cache (stream caching turned off), is still converted to a `byte[]`. +=== camel-core - the binary data type keeps a stream cache or a file body + +The `application-octet-stream` (`binary`) data type transformer keeps a body that is a stream cache, a `java.io.File` or +a `WrappedFile` (such as the `GenericFile` of the file and FTP consumers) as it is, and only sets the `Content-Type` +header to `application/octet-stream`. Before, it read the body into a `byte[]`. These bodies are binary already and can +be read again, and they may be large: a source Kamelet such as `aws-s3-source` or `azure-storage-blob-source` declares +`binary` and gives the object as a stream, and a file can be uploaded without reading it into memory. Any other body, +including an `InputStream` that is not a stream cache (stream caching turned off), is still converted to a `byte[]`. === camel-kamelet - each Kamelet EIP has a Kamelet route of its own
