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
The following commit(s) were added to refs/heads/master by this push:
new 85d6b32 CAMEL-12937: StreamCaching cipher is misspelled as chiper.
Added deprecated markers. Misspelled to be removed in Camel 3.0
85d6b32 is described below
commit 85d6b3260e021d40759522fdbcd4e43d94e6cee4
Author: Claus Ibsen <claus.ib...@gmail.com>
AuthorDate: Tue Dec 11 17:25:59 2018 +0100
CAMEL-12937: StreamCaching cipher is misspelled as chiper. Added deprecated
markers. Misspelled to be removed in Camel 3.0
---
.../mbean/ManagedStreamCachingStrategyMBean.java | 6 +++++-
.../converter/stream/FileInputStreamCache.java | 4 ++--
.../camel/impl/DefaultStreamCachingStrategy.java | 22 +++++++++++++++-------
.../mbean/ManagedStreamCachingStrategy.java | 7 ++++++-
.../apache/camel/spi/StreamCachingStrategy.java | 18 ++++++++++++++++++
.../camel/util/jsse/BaseSSLContextParameters.java | 2 +-
.../converter/stream/CachedOutputStreamTest.java | 2 +-
.../ManagedStreamCachingStrategyTest.java | 4 ++--
.../core/xml/AbstractCamelContextFactoryBean.java | 5 +++++
.../xml/CamelStreamCachingStrategyDefinition.java | 21 ++++++++++++++++++++-
.../src/main/docs/spring-boot.adoc | 5 +++--
.../camel/spring/boot/CamelAutoConfiguration.java | 1 +
.../spring/boot/CamelConfigurationProperties.java | 20 ++++++++++++++++++++
.../commands/AbstractLocalCamelController.java | 2 +-
.../apache/camel/commands/ContextInfoCommand.java | 6 +++---
15 files changed, 103 insertions(+), 22 deletions(-)
diff --git
a/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedStreamCachingStrategyMBean.java
b/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedStreamCachingStrategyMBean.java
index 5af8674..5f8959c 100644
---
a/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedStreamCachingStrategyMBean.java
+++
b/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedStreamCachingStrategyMBean.java
@@ -28,9 +28,13 @@ public interface ManagedStreamCachingStrategyMBean extends
ManagedServiceMBean {
@ManagedAttribute(description = "Directory used when overflow and spooling
to disk")
String getSpoolDirectory();
- @ManagedAttribute(description = "Chiper used if writing with encryption")
+ @ManagedAttribute(description = "Cipher used if writing with encryption")
+ @Deprecated
String getSpoolChiper();
+ @ManagedAttribute(description = "Cipher used if writing with encryption")
+ String getSpoolCipher();
+
@ManagedAttribute(description = "Threshold in bytes when overflow and
spooling to disk instead of keeping in memory")
void setSpoolThreshold(long threshold);
diff --git
a/camel-core/src/main/java/org/apache/camel/converter/stream/FileInputStreamCache.java
b/camel-core/src/main/java/org/apache/camel/converter/stream/FileInputStreamCache.java
index 1e99e68..f778c99 100644
---
a/camel-core/src/main/java/org/apache/camel/converter/stream/FileInputStreamCache.java
+++
b/camel-core/src/main/java/org/apache/camel/converter/stream/FileInputStreamCache.java
@@ -241,10 +241,10 @@ public final class FileInputStreamCache extends
InputStream implements StreamCac
LOG.trace("Creating temporary stream cache file: {}", tempFile);
OutputStream out = new
BufferedOutputStream(Files.newOutputStream(tempFile.toPath(),
StandardOpenOption.CREATE, StandardOpenOption.WRITE));
- if (ObjectHelper.isNotEmpty(strategy.getSpoolChiper())) {
+ if (ObjectHelper.isNotEmpty(strategy.getSpoolCipher())) {
try {
if (ciphers == null) {
- ciphers = new CipherPair(strategy.getSpoolChiper());
+ ciphers = new CipherPair(strategy.getSpoolCipher());
}
} catch (GeneralSecurityException e) {
throw new IOException(e.getMessage(), e);
diff --git
a/camel-core/src/main/java/org/apache/camel/impl/DefaultStreamCachingStrategy.java
b/camel-core/src/main/java/org/apache/camel/impl/DefaultStreamCachingStrategy.java
index fbedac5..f110d37 100644
---
a/camel-core/src/main/java/org/apache/camel/impl/DefaultStreamCachingStrategy.java
+++
b/camel-core/src/main/java/org/apache/camel/impl/DefaultStreamCachingStrategy.java
@@ -58,7 +58,7 @@ public class DefaultStreamCachingStrategy extends
org.apache.camel.support.Servi
private long spoolThreshold = StreamCache.DEFAULT_SPOOL_THRESHOLD;
private int spoolUsedHeapMemoryThreshold;
private SpoolUsedHeapMemoryLimit spoolUsedHeapMemoryLimit;
- private String spoolChiper;
+ private String spoolCihper;
private int bufferSize = IOHelper.DEFAULT_BUFFER_SIZE;
private boolean removeSpoolDirectoryWhenStopping = true;
private final UtilizationStatistics statistics = new
UtilizationStatistics();
@@ -118,11 +118,19 @@ public class DefaultStreamCachingStrategy extends
org.apache.camel.support.Servi
}
public String getSpoolChiper() {
- return spoolChiper;
+ return getSpoolCipher();
}
public void setSpoolChiper(String spoolChiper) {
- this.spoolChiper = spoolChiper;
+ setSpoolCipher(spoolChiper);
+ }
+
+ public String getSpoolCipher() {
+ return spoolCihper;
+ }
+
+ public void setSpoolCipher(String spoolCipher) {
+ this.spoolCihper = spoolCipher;
}
public int getBufferSize() {
@@ -237,7 +245,7 @@ public class DefaultStreamCachingStrategy extends
org.apache.camel.support.Servi
String bufferSize = camelContext.getGlobalOption(BUFFER_SIZE);
String hold = camelContext.getGlobalOption(THRESHOLD);
- String chiper = camelContext.getGlobalOption(CIPHER_TRANSFORMATION);
+ String cipher = camelContext.getGlobalOption(CIPHER_TRANSFORMATION);
String dir = camelContext.getGlobalOption(TEMP_DIR);
boolean warn = false;
@@ -249,9 +257,9 @@ public class DefaultStreamCachingStrategy extends
org.apache.camel.support.Servi
warn = true;
this.spoolThreshold =
camelContext.getTypeConverter().convertTo(Long.class, hold);
}
- if (chiper != null) {
+ if (cipher != null) {
warn = true;
- this.spoolChiper = chiper;
+ this.spoolCihper = cipher;
}
if (dir != null) {
warn = true;
@@ -337,7 +345,7 @@ public class DefaultStreamCachingStrategy extends
org.apache.camel.support.Servi
public String toString() {
return "DefaultStreamCachingStrategy["
+ "spoolDirectory=" + spoolDirectory
- + ", spoolChiper=" + spoolChiper
+ + ", spoolCihper=" + spoolCihper
+ ", spoolThreshold=" + spoolThreshold
+ ", spoolUsedHeapMemoryThreshold=" + spoolUsedHeapMemoryThreshold
+ ", bufferSize=" + bufferSize
diff --git
a/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedStreamCachingStrategy.java
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedStreamCachingStrategy.java
index cf8c371..2dde43a 100644
---
a/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedStreamCachingStrategy.java
+++
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedStreamCachingStrategy.java
@@ -50,7 +50,12 @@ public class ManagedStreamCachingStrategy extends
ManagedService implements Mana
}
public String getSpoolChiper() {
- return streamCachingStrategy.getSpoolChiper();
+ return streamCachingStrategy.getSpoolCipher();
+ }
+
+ @Override
+ public String getSpoolCipher() {
+ return streamCachingStrategy.getSpoolCipher();
}
public void setSpoolThreshold(long threshold) {
diff --git
a/camel-core/src/main/java/org/apache/camel/spi/StreamCachingStrategy.java
b/camel-core/src/main/java/org/apache/camel/spi/StreamCachingStrategy.java
index 80ee1de..14a7137 100644
--- a/camel-core/src/main/java/org/apache/camel/spi/StreamCachingStrategy.java
+++ b/camel-core/src/main/java/org/apache/camel/spi/StreamCachingStrategy.java
@@ -168,12 +168,30 @@ public interface StreamCachingStrategy extends
StaticService {
* Sets a chiper name to use when spooling to disk to write with
encryption.
* <p/>
* By default the data is not encrypted.
+ *
+ * @deprecated use {@link #setSpoolCipher(String)}
*/
+ @Deprecated
+ // TODO: Remove this in Camel 3
void setSpoolChiper(String chiper);
+ /**
+ * @deprecated use {@link #getSpoolCipher()}
+ */
+ @Deprecated
+ // TODO: Remove this in Camel 3
String getSpoolChiper();
/**
+ * Sets a cipher name to use when spooling to disk to write with
encryption.
+ * <p/>
+ * By default the data is not encrypted.
+ */
+ void setSpoolCipher(String cipher);
+
+ String getSpoolCipher();
+
+ /**
* Whether to remove the temporary directory when stopping.
* <p/>
* This option is default <tt>true</tt>
diff --git
a/camel-core/src/main/java/org/apache/camel/util/jsse/BaseSSLContextParameters.java
b/camel-core/src/main/java/org/apache/camel/util/jsse/BaseSSLContextParameters.java
index f4e3073..9515e87 100644
---
a/camel-core/src/main/java/org/apache/camel/util/jsse/BaseSSLContextParameters.java
+++
b/camel-core/src/main/java/org/apache/camel/util/jsse/BaseSSLContextParameters.java
@@ -830,7 +830,7 @@ public abstract class BaseSSLContextParameters extends
JsseParameters {
@Override
public String toString() {
return String.format("SSLContext[hash=%h, provider=%s,
protocol=%s, needClientAuth=%s, "
- +
"wantClientAuth=%s\n\tdefaultProtocols=%s\n\tdefaultChiperSuites=%s\n\tsupportedProtocols=%s\n\tsupportedChiperSuites=%s\n]",
+ +
"wantClientAuth=%s\n\tdefaultProtocols=%s\n\tdefaultCipherSuites=%s\n\tsupportedProtocols=%s\n\tsupportedCipherSuites=%s\n]",
hashCode(), getProvider(), getProtocol(),
getDefaultSSLParameters().getNeedClientAuth(),
getDefaultSSLParameters().getWantClientAuth(),
collectionAsCommaDelimitedString(getDefaultSSLParameters().getProtocols()),
collectionAsCommaDelimitedString(getDefaultSSLParameters().getCipherSuites()),
diff --git
a/camel-core/src/test/java/org/apache/camel/converter/stream/CachedOutputStreamTest.java
b/camel-core/src/test/java/org/apache/camel/converter/stream/CachedOutputStreamTest.java
index 5d54688..1136606 100644
---
a/camel-core/src/test/java/org/apache/camel/converter/stream/CachedOutputStreamTest.java
+++
b/camel-core/src/test/java/org/apache/camel/converter/stream/CachedOutputStreamTest.java
@@ -141,7 +141,7 @@ public class CachedOutputStreamTest extends
ContextTestSupport {
@Test
public void testCacheStreamToFileAndCloseStreamEncrypted() throws
Exception {
// set some stream or 8-bit block cipher transformation name
- context.getStreamCachingStrategy().setSpoolChiper("RC4");
+ context.getStreamCachingStrategy().setSpoolCipher("RC4");
context.start();
diff --git
a/camel-core/src/test/java/org/apache/camel/management/ManagedStreamCachingStrategyTest.java
b/camel-core/src/test/java/org/apache/camel/management/ManagedStreamCachingStrategyTest.java
index 6020d5f..393883d 100644
---
a/camel-core/src/test/java/org/apache/camel/management/ManagedStreamCachingStrategyTest.java
+++
b/camel-core/src/test/java/org/apache/camel/management/ManagedStreamCachingStrategyTest.java
@@ -80,8 +80,8 @@ public class ManagedStreamCachingStrategyTest extends
ManagementTestSupport {
cacheSize = (Long) mbeanServer.getAttribute(name, "CacheSpoolSize");
assertEquals(0, cacheSize.longValue());
- String chiper = (String) mbeanServer.getAttribute(name, "SpoolChiper");
- assertNull(chiper);
+ String cipher = (String) mbeanServer.getAttribute(name, "SpoolCipher");
+ assertNull(cipher);
Boolean remove = (Boolean) mbeanServer.getAttribute(name,
"RemoveSpoolDirectoryWhenStopping");
assertEquals(Boolean.TRUE, remove);
diff --git
a/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java
b/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java
index bd19ede..2969d73 100644
---
a/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java
+++
b/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/AbstractCamelContextFactoryBean.java
@@ -641,10 +641,15 @@ public abstract class AbstractCamelContextFactoryBean<T
extends ModelCamelContex
StreamCachingStrategy.SpoolUsedHeapMemoryLimit ul =
CamelContextHelper.mandatoryConvertTo(getContext(),
StreamCachingStrategy.SpoolUsedHeapMemoryLimit.class, limit);
getContext().getStreamCachingStrategy().setSpoolUsedHeapMemoryLimit(ul);
}
+ // TODO: Remove this in Camel 3
String spoolChiper = CamelContextHelper.parseText(getContext(),
streamCaching.getSpoolChiper());
if (spoolChiper != null) {
getContext().getStreamCachingStrategy().setSpoolChiper(spoolChiper);
}
+ String spoolCipher = CamelContextHelper.parseText(getContext(),
streamCaching.getSpoolCipher());
+ if (spoolCipher != null) {
+
getContext().getStreamCachingStrategy().setSpoolCipher(spoolCipher);
+ }
Boolean remove = CamelContextHelper.parseBoolean(getContext(),
streamCaching.getRemoveSpoolDirectoryWhenStopping());
if (remove != null) {
getContext().getStreamCachingStrategy().setRemoveSpoolDirectoryWhenStopping(remove);
diff --git
a/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/CamelStreamCachingStrategyDefinition.java
b/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/CamelStreamCachingStrategyDefinition.java
index 83ff906..2c9c05d 100644
---
a/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/CamelStreamCachingStrategyDefinition.java
+++
b/components/camel-core-xml/src/main/java/org/apache/camel/core/xml/CamelStreamCachingStrategyDefinition.java
@@ -38,9 +38,13 @@ public class CamelStreamCachingStrategyDefinition extends
IdentifiedType {
private String enabled;
@XmlAttribute
private String spoolDirectory;
- @XmlAttribute
+ @XmlAttribute @Metadata(deprecationNode = "Use spoolCipher")
+ @Deprecated
+ // TODO: Remove this in Camel 3
private String spoolChiper;
@XmlAttribute
+ private String spoolCipher;
+ @XmlAttribute
private String spoolThreshold;
@XmlAttribute
private String spoolUsedHeapMemoryThreshold;
@@ -84,6 +88,7 @@ public class CamelStreamCachingStrategyDefinition extends
IdentifiedType {
this.spoolDirectory = spoolDirectory;
}
+ @Deprecated
public String getSpoolChiper() {
return spoolChiper;
}
@@ -93,10 +98,24 @@ public class CamelStreamCachingStrategyDefinition extends
IdentifiedType {
* <p/>
* By default the data is not encrypted.
*/
+ @Deprecated
public void setSpoolChiper(String spoolChiper) {
this.spoolChiper = spoolChiper;
}
+ public String getSpoolCipher() {
+ return spoolCipher;
+ }
+
+ /**
+ * Sets a cipher name to use when spooling to disk to write with
encryption.
+ * <p/>
+ * By default the data is not encrypted.
+ */
+ public void setSpoolCipher(String spoolCipher) {
+ this.spoolCipher = spoolCipher;
+ }
+
public String getSpoolThreshold() {
return spoolThreshold;
}
diff --git a/components/camel-spring-boot/src/main/docs/spring-boot.adoc
b/components/camel-spring-boot/src/main/docs/spring-boot.adoc
index 1714859..a9336d7 100644
--- a/components/camel-spring-boot/src/main/docs/spring-boot.adoc
+++ b/components/camel-spring-boot/src/main/docs/spring-boot.adoc
@@ -79,7 +79,7 @@ or `application.yml` file.
=== Spring Boot Auto-Configuration
-The component supports 139 options, which are listed below.
+The component supports 140 options, which are listed below.
@@ -166,7 +166,7 @@ The component supports 139 options, which are listed below.
| *camel.springboot.stream-caching-buffer-size* | Sets the stream caching
buffer size to use when allocating in-memory buffers used for in-memory stream
caches. The default size is 4096. | 0 | Integer
| *camel.springboot.stream-caching-enabled* | Sets whether stream caching is
enabled or not. Default is false. | false | Boolean
| *camel.springboot.stream-caching-remove-spool-directory-when-stopping* |
Whether to remove stream caching temporary directory when stopping. This option
is default true. | true | Boolean
-| *camel.springboot.stream-caching-spool-chiper* | Sets a stream caching
chiper name to use when spooling to disk to write with encryption. By default
the data is not encrypted. | | String
+| *camel.springboot.stream-caching-spool-cipher* | Sets a stream caching
cipher name to use when spooling to disk to write with encryption. By default
the data is not encrypted. | | String
| *camel.springboot.stream-caching-spool-directory* | Sets the stream caching
spool (temporary) directory to use for overflow and spooling to disk. If no
spool directory has been explicit configured, then a temporary directory is
created in the java.io.tmpdir directory. | | String
| *camel.springboot.stream-caching-spool-threshold* | Stream caching threshold
in bytes when overflow to disk is activated. The default threshold is 128kb.
Use -1 to disable overflow to disk. | 0 | Long
| *camel.springboot.stream-caching-spool-used-heap-memory-limit* | Sets what
the upper bounds should be when streamCachingSpoolUsedHeapMemoryThreshold is in
use. | | String
@@ -224,6 +224,7 @@ The component supports 139 options, which are listed below.
| *management.endpoint.camelroutes.read-only* | Whether Camel Routes actuator
is in read-only mode. If not in read-only mode then operations to start/stop
routes would be enabled. | true | Boolean
| *management.info.camel.enabled* | Whether to enable Camel info. | true |
Boolean
| *camel.springboot.stream-caching* | Sets whether stream caching is enabled
or not (deprecated use stream-caching-enabled instead). Default is false. |
false | Boolean
+| *camel.springboot.stream-caching-spool-chiper* | Sets a stream caching
chiper name to use when spooling to disk to write with encryption. By default
the data is not encrypted. @deprecated use streamCachingSpoolCipher | | String
| *camel.springboot.use-m-d-c-logging* | To turn on MDC logging (deprecated
use use-mdc-logging instead) | false | Boolean
|===
// spring-boot-auto-configure options: END
diff --git
a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java
b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java
index 811f3a4..f7a643e 100644
---
a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java
+++
b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelAutoConfiguration.java
@@ -173,6 +173,7 @@ public class CamelAutoConfiguration {
camelContext.getStreamCachingStrategy().setBufferSize(config.getStreamCachingBufferSize());
camelContext.getStreamCachingStrategy().setRemoveSpoolDirectoryWhenStopping(config.isStreamCachingRemoveSpoolDirectoryWhenStopping());
camelContext.getStreamCachingStrategy().setSpoolChiper(config.getStreamCachingSpoolChiper());
+
camelContext.getStreamCachingStrategy().setSpoolCipher(config.getStreamCachingSpoolCipher());
if (config.getStreamCachingSpoolDirectory() != null) {
camelContext.getStreamCachingStrategy().setSpoolDirectory(config.getStreamCachingSpoolDirectory());
}
diff --git
a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelConfigurationProperties.java
b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelConfigurationProperties.java
index 937d13e..81c5d11 100644
---
a/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelConfigurationProperties.java
+++
b/components/camel-spring-boot/src/main/java/org/apache/camel/spring/boot/CamelConfigurationProperties.java
@@ -217,8 +217,18 @@ public class CamelConfigurationProperties {
/**
* Sets a stream caching chiper name to use when spooling to disk to write
with encryption.
* By default the data is not encrypted.
+ *
+ * @deprecated use streamCachingSpoolCipher
*/
+ @Deprecated
private String streamCachingSpoolChiper;
+ // TODO: Remove this in Camel 3
+
+ /**
+ * Sets a stream caching cipher name to use when spooling to disk to write
with encryption.
+ * By default the data is not encrypted.
+ */
+ private String streamCachingSpoolCipher;
/**
* Stream caching threshold in bytes when overflow to disk is activated.
@@ -654,14 +664,24 @@ public class CamelConfigurationProperties {
this.streamCachingSpoolDirectory = streamCachingSpoolDirectory;
}
+ @Deprecated
public String getStreamCachingSpoolChiper() {
return streamCachingSpoolChiper;
}
+ @Deprecated
public void setStreamCachingSpoolChiper(String streamCachingSpoolChiper) {
this.streamCachingSpoolChiper = streamCachingSpoolChiper;
}
+ public String getStreamCachingSpoolCipher() {
+ return streamCachingSpoolCipher;
+ }
+
+ public void setStreamCachingSpoolCipher(String streamCachingSpoolCipher) {
+ this.streamCachingSpoolCipher = streamCachingSpoolCipher;
+ }
+
public long getStreamCachingSpoolThreshold() {
return streamCachingSpoolThreshold;
}
diff --git
a/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/AbstractLocalCamelController.java
b/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/AbstractLocalCamelController.java
index ae1cf30..0531dbb 100644
---
a/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/AbstractLocalCamelController.java
+++
b/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/AbstractLocalCamelController.java
@@ -130,7 +130,7 @@ public abstract class AbstractLocalCamelController extends
AbstractCamelControll
if (context.getStreamCachingStrategy().isEnabled()) {
answer.put("streamCachingEnabled", true);
answer.put("streamCaching.spoolDirectory",
context.getStreamCachingStrategy().getSpoolDirectory());
- answer.put("streamCaching.spoolChiper",
context.getStreamCachingStrategy().getSpoolChiper());
+ answer.put("streamCaching.spoolCipher",
context.getStreamCachingStrategy().getSpoolCipher());
answer.put("streamCaching.spoolThreshold",
context.getStreamCachingStrategy().getSpoolThreshold());
answer.put("streamCaching.spoolUsedHeapMemoryThreshold",
context.getStreamCachingStrategy().getSpoolUsedHeapMemoryThreshold());
answer.put("streamCaching.spoolUsedHeapMemoryLimit",
context.getStreamCachingStrategy().getSpoolUsedHeapMemoryLimit());
diff --git
a/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/ContextInfoCommand.java
b/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/ContextInfoCommand.java
index 419bad8..b9e36b9 100644
---
a/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/ContextInfoCommand.java
+++
b/platforms/commands/commands-core/src/main/java/org/apache/camel/commands/ContextInfoCommand.java
@@ -137,7 +137,7 @@ public class ContextInfoCommand extends
AbstractContextCommand {
enabled = (boolean) row.get("streamCachingEnabled");
if (enabled) {
Object spoolDirectory =
safeNull(row.get("streamCaching.spoolDirectory"));
- Object spoolChiper =
safeNull(row.get("streamCaching.spoolChiper"));
+ Object spoolCipher =
safeNull(row.get("streamCaching.spoolCipher"));
Object spoolThreshold =
safeNull(row.get("streamCaching.spoolThreshold"));
Object spoolUsedHeapMemoryThreshold =
safeNull(row.get("streamCaching.spoolUsedHeapMemoryThreshold"));
Object spoolUsedHeapMemoryLimit =
safeNull(row.get("streamCaching.spoolUsedHeapMemoryLimit"));
@@ -146,9 +146,9 @@ public class ContextInfoCommand extends
AbstractContextCommand {
Object removeSpoolDirectoryWhenStopping =
safeNull(row.get("streamCaching.removeSpoolDirectoryWhenStopping"));
boolean statisticsEnabled = (boolean)
row.get("streamCaching.statisticsEnabled");
- String text = String.format("\tStream caching:
[spoolDirectory=%s, spoolChiper=%s, spoolThreshold=%s,
spoolUsedHeapMemoryThreshold=%s, "
+ String text = String.format("\tStream caching:
[spoolDirectory=%s, spoolCipher=%s, spoolThreshold=%s,
spoolUsedHeapMemoryThreshold=%s, "
+ "spoolUsedHeapMemoryLimit=%s,
anySpoolRules=%s, bufferSize=%s, removeSpoolDirectoryWhenStopping=%s,
statisticsEnabled=%s]",
- spoolDirectory, spoolChiper, spoolThreshold,
spoolUsedHeapMemoryThreshold, spoolUsedHeapMemoryLimit, anySpoolRules,
bufferSize,
+ spoolDirectory, spoolCipher, spoolThreshold,
spoolUsedHeapMemoryThreshold, spoolUsedHeapMemoryLimit, anySpoolRules,
bufferSize,
removeSpoolDirectoryWhenStopping, statisticsEnabled);
out.println(stringEscape.unescapeJava(text));
