You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by da...@apache.org on 2019/08/06 08:04:11 UTC
[camel] 01/02: CAMEL-9971: Added appendChars option to file
component.
This is an automated email from the ASF dual-hosted git repository.
davsclaus pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/camel.git
commit ea2166779b578ea8513ce9d178e24e36a19a76ad
Author: Claus Ibsen <cl...@gmail.com>
AuthorDate: Tue Aug 6 09:56:21 2019 +0200
CAMEL-9971: Added appendChars option to file component.
---
.../camel-file/src/main/docs/file-component.adoc | 4 +-
.../camel/component/file/FileOperations.java | 14 +++++
.../camel/component/file/GenericFileEndpoint.java | 41 ++++++++++++++
.../component/file/FileProduceAppendCharsTest.java | 62 ++++++++++++++++++++++
.../endpoint/dsl/FileEndpointBuilderFactory.java | 14 +++++
5 files changed, 134 insertions(+), 1 deletion(-)
diff --git a/components/camel-file/src/main/docs/file-component.adoc b/components/camel-file/src/main/docs/file-component.adoc
index daa2125..dae967f 100644
--- a/components/camel-file/src/main/docs/file-component.adoc
+++ b/components/camel-file/src/main/docs/file-component.adoc
@@ -85,7 +85,7 @@ with the following path and query parameters:
|===
-=== Query Parameters (90 parameters):
+=== Query Parameters (91 parameters):
[width="100%",cols="2,5,^1,2",options="header"]
@@ -114,6 +114,8 @@ with the following path and query parameters:
| *processStrategy* (consumer) | A pluggable org.apache.camel.component.file.GenericFileProcessStrategy allowing you to implement your own readLock option or similar. Can also be used when special conditions must be met before a file can be consumed, such as a special ready file exists. If this option is set then the readLock option does not apply. | | GenericFileProcess Strategy
| *startingDirectoryMustExist* (consumer) | Whether the starting directory must exist. Mind that the autoCreate option is default enabled, which means the starting directory is normally auto created if it doesn't exist. You can disable autoCreate and enable this to ensure the starting directory must exist. Will thrown an exception if the directory doesn't exist. | false | boolean
| *startingDirectoryMustHave Access* (consumer) | Whether the starting directory has access permissions. Mind that the startingDirectoryMustExist parameter must be set to true in order to verify that the directory exists. Will thrown an exception if the directory doesn't have read and write permissions. | false | boolean
+| *appendChars* (producer) | Used to append characters (text) after writing files. This can for example be used to add new lines or other separators when writing and appending to existing files. To specify new-line (
+ or
) or tab ( ) characters then escape with an extra slash, eg \n | | String
| *fileExist* (producer) | What to do if a file already exists with the same name. Override, which is the default, replaces the existing file. Append - adds content to the existing file. Fail - throws a GenericFileOperationException, indicating that there is already an existing file. Ignore - silently ignores the problem and does not override the existing file, but assumes everything is okay. Move - option requires to use the moveExisting option to be configured as well. The option eager [...]
| *flatten* (producer) | Flatten is used to flatten the file name path to strip any leading paths, so it's just the file name. This allows you to consume recursively into sub-directories, but when you eg write the files to another directory they will be written in a single directory. Setting this to true on the producer enforces that any file name in CamelFileName header will be stripped for any leading paths. | false | boolean
| *jailStartingDirectory* (producer) | Used for jailing (restricting) writing files to the starting directory (and sub) only. This is enabled by default to not allow Camel to write files to outside directories (to be more secured out of the box). You can turn this off to allow writing files to directories outside the starting directory, such as parent or root folders. | true | boolean
diff --git a/components/camel-file/src/main/java/org/apache/camel/component/file/FileOperations.java b/components/camel-file/src/main/java/org/apache/camel/component/file/FileOperations.java
index 4578060..16aade7 100644
--- a/components/camel-file/src/main/java/org/apache/camel/component/file/FileOperations.java
+++ b/components/camel-file/src/main/java/org/apache/camel/component/file/FileOperations.java
@@ -412,6 +412,7 @@ public class FileOperations implements GenericFileOperations<File> {
}
private void writeFileByStream(InputStream in, File target) throws IOException {
+ boolean exists = target.exists();
try (SeekableByteChannel out = prepareOutputFileChannel(target)) {
LOG.debug("Using InputStream to write file: {}", target);
@@ -426,12 +427,21 @@ public class FileOperations implements GenericFileOperations<File> {
out.write(byteBuffer);
byteBuffer.clear();
}
+
+ boolean append = endpoint.getFileExist() == GenericFileExist.Append;
+ if (append && exists && endpoint.getAppendChars() != null) {
+ byteBuffer = ByteBuffer.wrap(endpoint.getAppendChars().getBytes());
+ out.write(byteBuffer);
+ byteBuffer.clear();
+ }
+
} finally {
IOHelper.close(in, target.getName(), LOG);
}
}
private void writeFileByReaderWithCharset(Reader in, File target, String charset) throws IOException {
+ boolean exists = target.exists();
boolean append = endpoint.getFileExist() == GenericFileExist.Append;
try (Writer out = Files.newBufferedWriter(target.toPath(), Charset.forName(charset),
StandardOpenOption.WRITE,
@@ -440,6 +450,10 @@ public class FileOperations implements GenericFileOperations<File> {
LOG.debug("Using Reader to write file: {} with charset: {}", target, charset);
int size = endpoint.getBufferSize();
IOHelper.copy(in, out, size);
+
+ if (append && exists && endpoint.getAppendChars() != null) {
+ out.write(endpoint.getAppendChars());
+ }
} finally {
IOHelper.close(in, target.getName(), LOG);
}
diff --git a/components/camel-file/src/main/java/org/apache/camel/component/file/GenericFileEndpoint.java b/components/camel-file/src/main/java/org/apache/camel/component/file/GenericFileEndpoint.java
index 473f0bc..3f6a020 100644
--- a/components/camel-file/src/main/java/org/apache/camel/component/file/GenericFileEndpoint.java
+++ b/components/camel-file/src/main/java/org/apache/camel/component/file/GenericFileEndpoint.java
@@ -97,6 +97,8 @@ public abstract class GenericFileEndpoint<T> extends ScheduledPollEndpoint imple
protected boolean allowNullBody;
@UriParam(label = "producer", defaultValue = "true")
protected boolean jailStartingDirectory = true;
+ @UriParam(label = "producer")
+ protected String appendChars;
// consumer options
@@ -1239,6 +1241,45 @@ public abstract class GenericFileEndpoint<T> extends ScheduledPollEndpoint imple
this.jailStartingDirectory = jailStartingDirectory;
}
+ public String getAppendChars() {
+ return appendChars;
+ }
+
+ /**
+ * Used to append characters (text) after writing files. This can for example be used to add new lines or other
+ * separators when writing and appending to existing files.
+ * <p/>
+ * To specify new-line (\n or \r) or tab (\t) characters then escape with an extra slash, eg \\n
+ */
+ public void setAppendChars(String appendChars) {
+ StringBuilder sb = new StringBuilder();
+ for (int i = 0; i < appendChars.length(); i++) {
+ char ch = appendChars.charAt(i);
+ boolean escaped = '\\' == ch;
+ if (escaped && i < appendChars.length() - 1) {
+ // grab next character to escape
+ char next = appendChars.charAt(i + 1);
+ // special for new line, tabs and carriage return
+ if ('n' == next) {
+ sb.append("\n");
+ i++;
+ continue;
+ } else if ('t' == next) {
+ sb.append("\t");
+ i++;
+ continue;
+ } else if ('r' == next) {
+ sb.append("\r");
+ i++;
+ continue;
+ }
+ }
+ // not special just a regular character
+ sb.append(ch);
+ }
+ this.appendChars = sb.toString();
+ }
+
public ExceptionHandler getOnCompletionExceptionHandler() {
return onCompletionExceptionHandler;
}
diff --git a/core/camel-core/src/test/java/org/apache/camel/component/file/FileProduceAppendCharsTest.java b/core/camel-core/src/test/java/org/apache/camel/component/file/FileProduceAppendCharsTest.java
new file mode 100644
index 0000000..3f73322
--- /dev/null
+++ b/core/camel-core/src/test/java/org/apache/camel/component/file/FileProduceAppendCharsTest.java
@@ -0,0 +1,62 @@
+/*
+ * 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.file;
+
+import org.apache.camel.ContextTestSupport;
+import org.apache.camel.Exchange;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.component.mock.MockEndpoint;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Unit test to verify the append chars option
+ */
+public class FileProduceAppendCharsTest extends ContextTestSupport {
+
+ @Test
+ public void testAppendChars() throws Exception {
+ MockEndpoint mock = getMockEndpoint("mock:result");
+ mock.expectedMessageCount(2);
+ mock.expectedFileExists("target/data/test-file-append/hello.txt", "Hello\nWorld\nHow are you?\n");
+
+ template.sendBody("direct:start", "World");
+ template.sendBody("direct:start", "How are you?");
+
+ assertMockEndpointsSatisfied();
+ }
+
+ @Override
+ @Before
+ public void setUp() throws Exception {
+ deleteDirectory("target/data/test-file-append");
+ super.setUp();
+ template.sendBodyAndHeader("file://target/data/test-file-append", "Hello\n", Exchange.FILE_NAME, "hello.txt");
+ }
+
+ @Override
+ protected RouteBuilder createRouteBuilder() {
+ return new RouteBuilder() {
+ public void configure() {
+ from("direct:start")
+ .setHeader(Exchange.FILE_NAME, constant("hello.txt"))
+ .to("file://target/data/test-file-append?fileExist=Append&appendChars=\\n", "mock:result");
+ }
+ };
+ }
+
+}
\ No newline at end of file
diff --git a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/FileEndpointBuilderFactory.java b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/FileEndpointBuilderFactory.java
index 8cd56fa..e2ccc7d 100644
--- a/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/FileEndpointBuilderFactory.java
+++ b/core/camel-endpointdsl/src/main/java/org/apache/camel/builder/endpoint/dsl/FileEndpointBuilderFactory.java
@@ -2346,6 +2346,20 @@ public interface FileEndpointBuilderFactory {
return this;
}
/**
+ * Used to append characters (text) after writing files. This can for
+ * example be used to add new lines or other separators when writing and
+ * appending to existing files. To specify new-line (
+ * or
) or tab ( ) characters then escape with an extra slash, eg \n.
+ *
+ * The option is a: <code>java.lang.String</code> type.
+ *
+ * Group: producer
+ */
+ default FileEndpointProducerBuilder appendChars(String appendChars) {
+ setProperty("appendChars", appendChars);
+ return this;
+ }
+ /**
* What to do if a file already exists with the same name. Override,
* which is the default, replaces the existing file. Append - adds
* content to the existing file. Fail - throws a