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 2013/07/17 18:43:19 UTC

[1/2] git commit: CAMEL-6476: Introducing StreamCachingStrategy SPI to make it easier to configure and allow 3rd party to plugin custom strategies. Work in progress.

Updated Branches:
  refs/heads/master d0235489f -> b026ba010


CAMEL-6476: Introducing StreamCachingStrategy SPI to make it easier to configure and allow 3rd party to plugin custom strategies. Work in progress.


Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/1471c617
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/1471c617
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/1471c617

Branch: refs/heads/master
Commit: 1471c61746f635435e1f8402645a626b4fbecc08
Parents: d023548
Author: Claus Ibsen <da...@apache.org>
Authored: Wed Jul 17 18:17:46 2013 +0200
Committer: Claus Ibsen <da...@apache.org>
Committed: Wed Jul 17 18:17:46 2013 +0200

----------------------------------------------------------------------
 .../converter/stream/CachedOutputStream.java    |  2 +-
 .../impl/DefaultStreamCachingStrategy.java      | 56 +++++++++++---------
 .../apache/camel/spi/StreamCachingStrategy.java | 14 ++---
 .../stream/CachedOutputStreamTest.java          |  2 +-
 .../processor/SplitterStreamCacheTest.java      |  3 +-
 5 files changed, 42 insertions(+), 35 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/camel/blob/1471c617/camel-core/src/main/java/org/apache/camel/converter/stream/CachedOutputStream.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/converter/stream/CachedOutputStream.java b/camel-core/src/main/java/org/apache/camel/converter/stream/CachedOutputStream.java
index 1b7f90b..b25046b 100644
--- a/camel-core/src/main/java/org/apache/camel/converter/stream/CachedOutputStream.java
+++ b/camel-core/src/main/java/org/apache/camel/converter/stream/CachedOutputStream.java
@@ -208,7 +208,7 @@ public class CachedOutputStream extends OutputStream {
         flush();
 
         ByteArrayOutputStream bout = (ByteArrayOutputStream)currentStream;
-        tempFile = FileUtil.createTempFile("cos", ".tmp", strategy.getTemporaryDirectory());
+        tempFile = FileUtil.createTempFile("cos", ".tmp", strategy.getSpoolDirectory());
 
         LOG.trace("Creating temporary stream cache file: {}", tempFile);
 

http://git-wip-us.apache.org/repos/asf/camel/blob/1471c617/camel-core/src/main/java/org/apache/camel/impl/DefaultStreamCachingStrategy.java
----------------------------------------------------------------------
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 d5f558a..d81c244 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
@@ -47,11 +47,11 @@ public class DefaultStreamCachingStrategy extends org.apache.camel.support.Servi
     private static final Logger LOG = LoggerFactory.getLogger(DefaultStreamCachingStrategy.class);
 
     private CamelContext camelContext;
-    private File temporaryDirectory;
+    private File spoolDirectory;
     private long spoolThreshold = StreamCache.DEFAULT_SPOOL_THRESHOLD;
     private String spoolChiper;
     private int bufferSize = IOHelper.DEFAULT_BUFFER_SIZE;
-    private boolean removeTemporaryDirectoryWhenStopping = true;
+    private boolean removeSpoolDirectoryWhenStopping = true;
 
     public CamelContext getCamelContext() {
         return camelContext;
@@ -61,16 +61,16 @@ public class DefaultStreamCachingStrategy extends org.apache.camel.support.Servi
         this.camelContext = camelContext;
     }
 
-    public void setTemporaryDirectory(String path) {
-        this.temporaryDirectory = new File(path);
+    public void setSpoolDirectory(String path) {
+        this.spoolDirectory = new File(path);
     }
 
-    public void setTemporaryDirectory(File path) {
-        this.temporaryDirectory = path;
+    public void setSpoolDirectory(File path) {
+        this.spoolDirectory = path;
     }
 
-    public File getTemporaryDirectory() {
-        return temporaryDirectory;
+    public File getSpoolDirectory() {
+        return spoolDirectory;
     }
 
     public long getSpoolThreshold() {
@@ -97,12 +97,12 @@ public class DefaultStreamCachingStrategy extends org.apache.camel.support.Servi
         this.bufferSize = bufferSize;
     }
 
-    public boolean isRemoveTemporaryDirectoryWhenStopping() {
-        return removeTemporaryDirectoryWhenStopping;
+    public boolean isRemoveSpoolDirectoryWhenStopping() {
+        return removeSpoolDirectoryWhenStopping;
     }
 
-    public void setRemoveTemporaryDirectoryWhenStopping(boolean removeTemporaryDirectoryWhenStopping) {
-        this.removeTemporaryDirectoryWhenStopping = removeTemporaryDirectoryWhenStopping;
+    public void setRemoveSpoolDirectoryWhenStopping(boolean removeSpoolDirectoryWhenStopping) {
+        this.removeSpoolDirectoryWhenStopping = removeSpoolDirectoryWhenStopping;
     }
 
     @Override
@@ -112,32 +112,40 @@ public class DefaultStreamCachingStrategy extends org.apache.camel.support.Servi
         String chiper = camelContext.getProperty(CIPHER_TRANSFORMATION);
         String dir = camelContext.getProperty(TEMP_DIR);
 
+        boolean warn = false;
         if (bufferSize != null) {
+            warn = true;
             this.bufferSize = camelContext.getTypeConverter().convertTo(Integer.class, bufferSize);
         }
         if (hold != null) {
+            warn = true;
             this.spoolThreshold = camelContext.getTypeConverter().convertTo(Long.class, hold);
         }
         if (chiper != null) {
+            warn = true;
             this.spoolChiper = chiper;
         }
         if (dir != null) {
-            this.temporaryDirectory = camelContext.getTypeConverter().convertTo(File.class, dir);
+            warn = true;
+            this.spoolDirectory = camelContext.getTypeConverter().convertTo(File.class, dir);
+        }
+        if (warn) {
+            LOG.warn("Configuring of StreamCaching using CamelContext properties is deprecated - use StreamCachingStrategy instead.");
         }
 
         LOG.info("StreamCaching in use with {}", this.toString());
 
         // create random temporary directory if none has been created
-        if (temporaryDirectory == null) {
-            temporaryDirectory = FileUtil.createNewTempDir();
-            LOG.info("Created temporary directory {}", temporaryDirectory);
+        if (spoolDirectory == null) {
+            spoolDirectory = FileUtil.createNewTempDir();
+            LOG.info("Created temporary spool directory {}", spoolDirectory);
         } else {
-            if (!temporaryDirectory.exists()) {
-                boolean created = temporaryDirectory.mkdirs();
+            if (!spoolDirectory.exists()) {
+                boolean created = spoolDirectory.mkdirs();
                 if (!created) {
-                    LOG.warn("Cannot create temporary directory {}", temporaryDirectory);
+                    LOG.warn("Cannot create spool directory {}", spoolDirectory);
                 } else {
-                    LOG.info("Created temporary directory {}", temporaryDirectory);
+                    LOG.info("Created spool directory {}", spoolDirectory);
                 }
             }
         }
@@ -145,16 +153,16 @@ public class DefaultStreamCachingStrategy extends org.apache.camel.support.Servi
 
     @Override
     protected void doStop() throws Exception {
-        if (temporaryDirectory != null  && isRemoveTemporaryDirectoryWhenStopping()) {
-            LOG.info("Removing temporary directory {}", temporaryDirectory);
-            FileUtil.removeDir(temporaryDirectory);
+        if (spoolDirectory != null  && isRemoveSpoolDirectoryWhenStopping()) {
+            LOG.info("Removing spool directory {}", spoolDirectory);
+            FileUtil.removeDir(spoolDirectory);
         }
     }
 
     @Override
     public String toString() {
         return "DefaultStreamCachingStrategy["
-            + "temporaryDirectory=" + temporaryDirectory
+            + "spoolDirectory=" + spoolDirectory
             + ", spoolThreshold=" + spoolThreshold
             + ", spoolChiper=" + spoolChiper
             + ", bufferSize=" + bufferSize + "]";

http://git-wip-us.apache.org/repos/asf/camel/blob/1471c617/camel-core/src/main/java/org/apache/camel/spi/StreamCachingStrategy.java
----------------------------------------------------------------------
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 a5cfa1b..217a0fc 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
@@ -24,16 +24,16 @@ import java.io.File;
 public interface StreamCachingStrategy {
 
     /**
-     * Sets the temporary directory to use for overflow and spooling to disk.
+     * Sets the spool (temporary) directory to use for overflow and spooling to disk.
      * <p/>
-     * If no temporary directory has been explicit configured, then a directory
+     * If no spool directory has been explicit configured, then a temporary directory
      * is created in the <tt>java.io.tmpdir</tt> directory.
      */
-    void setTemporaryDirectory(File path);
+    void setSpoolDirectory(File path);
 
-    File getTemporaryDirectory();
+    File getSpoolDirectory();
 
-    void setTemporaryDirectory(String path);
+    void setSpoolDirectory(String path);
 
     /**
      * Threshold in bytes when overflow to disk is activated.
@@ -68,8 +68,8 @@ public interface StreamCachingStrategy {
      * <p/>
      * This option is default <tt>true</tt>
      */
-    void setRemoveTemporaryDirectoryWhenStopping(boolean remove);
+    void setRemoveSpoolDirectoryWhenStopping(boolean remove);
 
-    boolean isRemoveTemporaryDirectoryWhenStopping();
+    boolean isRemoveSpoolDirectoryWhenStopping();
 
 }

http://git-wip-us.apache.org/repos/asf/camel/blob/1471c617/camel-core/src/test/java/org/apache/camel/converter/stream/CachedOutputStreamTest.java
----------------------------------------------------------------------
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 91729f1..a705e1a 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
@@ -43,7 +43,7 @@ public class CachedOutputStreamTest extends ContextTestSupport {
     protected CamelContext createCamelContext() throws Exception {
         CamelContext context = super.createCamelContext();
         context.setStreamCaching(true);
-        context.getStreamCachingStrategy().setTemporaryDirectory("target/cachedir");
+        context.getStreamCachingStrategy().setSpoolDirectory("target/cachedir");
         context.getStreamCachingStrategy().setSpoolThreshold(16);
         return context;
     }

http://git-wip-us.apache.org/repos/asf/camel/blob/1471c617/camel-core/src/test/java/org/apache/camel/processor/SplitterStreamCacheTest.java
----------------------------------------------------------------------
diff --git a/camel-core/src/test/java/org/apache/camel/processor/SplitterStreamCacheTest.java b/camel-core/src/test/java/org/apache/camel/processor/SplitterStreamCacheTest.java
index d17410e..f223730 100644
--- a/camel-core/src/test/java/org/apache/camel/processor/SplitterStreamCacheTest.java
+++ b/camel-core/src/test/java/org/apache/camel/processor/SplitterStreamCacheTest.java
@@ -23,7 +23,6 @@ import org.apache.camel.ContextTestSupport;
 import org.apache.camel.builder.RouteBuilder;
 import org.apache.camel.builder.xml.XPathBuilder;
 import org.apache.camel.component.mock.MockEndpoint;
-import org.apache.camel.converter.stream.CachedOutputStream;
 
 /**
  * @version 
@@ -48,7 +47,7 @@ public class SplitterStreamCacheTest extends ContextTestSupport {
         return new RouteBuilder() {
             public void configure() {
                 //ensure stream is spooled to disk
-                context.getStreamCachingStrategy().setTemporaryDirectory("target/tmp");
+                context.getStreamCachingStrategy().setSpoolDirectory("target/tmp");
                 context.getStreamCachingStrategy().setSpoolThreshold(-1);
 
                 from("seda:parallel?concurrentConsumers=5").streamCaching()


[2/2] git commit: CAMEL-6476: Introducing StreamCachingStrategy SPI to make it easier to configure and allow 3rd party to plugin custom strategies. Work in progress.

Posted by da...@apache.org.
CAMEL-6476: Introducing StreamCachingStrategy SPI to make it easier to configure and allow 3rd party to plugin custom strategies. Work in progress.


Project: http://git-wip-us.apache.org/repos/asf/camel/repo
Commit: http://git-wip-us.apache.org/repos/asf/camel/commit/b026ba01
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/b026ba01
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/b026ba01

Branch: refs/heads/master
Commit: b026ba010425435ee87a126c1b54e65ca082b3da
Parents: 1471c61
Author: Claus Ibsen <da...@apache.org>
Authored: Wed Jul 17 18:43:07 2013 +0200
Committer: Claus Ibsen <da...@apache.org>
Committed: Wed Jul 17 18:43:07 2013 +0200

----------------------------------------------------------------------
 .../ManagedStreamCachingStrategyMBean.java      | 47 ++++++++++++
 .../DefaultManagementLifecycleStrategy.java     |  4 +
 .../mbean/ManagedStreamCachingStrategy.java     | 80 ++++++++++++++++++++
 .../apache/camel/spi/StreamCachingStrategy.java |  4 +-
 .../ManagedStreamCachingStrategyTest.java       | 80 ++++++++++++++++++++
 5 files changed, 214 insertions(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/camel/blob/b026ba01/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedStreamCachingStrategyMBean.java
----------------------------------------------------------------------
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
new file mode 100644
index 0000000..16e8918
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedStreamCachingStrategyMBean.java
@@ -0,0 +1,47 @@
+/**
+ * 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.api.management.mbean;
+
+import org.apache.camel.api.management.ManagedAttribute;
+
+public interface ManagedStreamCachingStrategyMBean {
+
+    @ManagedAttribute(description = "Directory used when overflow and spooling to disk")
+    String getSpoolDirectory();
+
+    @ManagedAttribute(description = "Chiper used if writing with encryption")
+    String getSpoolChiper();
+
+    @ManagedAttribute(description = "Threshold in bytes when overflow and spooling to disk instead of keeping in memory")
+    void setSpoolThreshold(long threshold);
+
+    @ManagedAttribute(description = "Threshold in bytes when overflow and spooling to disk instead of keeping in memory")
+    long getSpoolThreshold();
+
+    @ManagedAttribute(description = "Buffer size in bytes to use when coping between buffers")
+    void setBufferSize(int bufferSize);
+
+    @ManagedAttribute(description = "Buffer size in bytes to use when coping between buffers")
+    int getBufferSize();
+
+    @ManagedAttribute(description = "Whether to remove spool directory when stopping")
+    void setRemoveSpoolDirectoryWhenStopping(boolean remove);
+
+    @ManagedAttribute(description = "Whether to remove spool directory when stopping")
+    boolean isRemoveSpoolDirectoryWhenStopping();
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/b026ba01/camel-core/src/main/java/org/apache/camel/management/DefaultManagementLifecycleStrategy.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/management/DefaultManagementLifecycleStrategy.java b/camel-core/src/main/java/org/apache/camel/management/DefaultManagementLifecycleStrategy.java
index 9b63390..441d832 100644
--- a/camel-core/src/main/java/org/apache/camel/management/DefaultManagementLifecycleStrategy.java
+++ b/camel-core/src/main/java/org/apache/camel/management/DefaultManagementLifecycleStrategy.java
@@ -60,6 +60,7 @@ import org.apache.camel.management.mbean.ManagedEndpointRegistry;
 import org.apache.camel.management.mbean.ManagedProducerCache;
 import org.apache.camel.management.mbean.ManagedRoute;
 import org.apache.camel.management.mbean.ManagedService;
+import org.apache.camel.management.mbean.ManagedStreamCachingStrategy;
 import org.apache.camel.management.mbean.ManagedThrottlingInflightRoutePolicy;
 import org.apache.camel.management.mbean.ManagedTracer;
 import org.apache.camel.management.mbean.ManagedTypeConverterRegistry;
@@ -83,6 +84,7 @@ import org.apache.camel.spi.ManagementNameStrategy;
 import org.apache.camel.spi.ManagementObjectStrategy;
 import org.apache.camel.spi.ManagementStrategy;
 import org.apache.camel.spi.RouteContext;
+import org.apache.camel.spi.StreamCachingStrategy;
 import org.apache.camel.spi.TypeConverterRegistry;
 import org.apache.camel.spi.UnitOfWork;
 import org.apache.camel.support.ServiceSupport;
@@ -458,6 +460,8 @@ public class DefaultManagementLifecycleStrategy extends ServiceSupport implement
             answer = new ManagedEndpointRegistry(context, (EndpointRegistry) service);
         } else if (service instanceof TypeConverterRegistry) {
             answer = new ManagedTypeConverterRegistry(context, (TypeConverterRegistry) service);
+        } else if (service instanceof StreamCachingStrategy) {
+            answer = new ManagedStreamCachingStrategy(context, (StreamCachingStrategy) service);
         } else if (service != null) {
             // fallback as generic service
             answer = getManagementObjectStrategy().getManagedObjectForService(context, service);

http://git-wip-us.apache.org/repos/asf/camel/blob/b026ba01/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedStreamCachingStrategy.java
----------------------------------------------------------------------
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
new file mode 100644
index 0000000..26f1a19
--- /dev/null
+++ b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedStreamCachingStrategy.java
@@ -0,0 +1,80 @@
+/**
+ * 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.management.mbean;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.api.management.ManagedResource;
+import org.apache.camel.api.management.mbean.ManagedStreamCachingStrategyMBean;
+import org.apache.camel.spi.ManagementStrategy;
+import org.apache.camel.spi.StreamCachingStrategy;
+
+@ManagedResource(description = "Managed StreamCachingStrategy")
+public class ManagedStreamCachingStrategy extends ManagedService implements ManagedStreamCachingStrategyMBean {
+
+    private final CamelContext camelContext;
+    private final StreamCachingStrategy streamCachingStrategy;
+
+    public ManagedStreamCachingStrategy(CamelContext camelContext, StreamCachingStrategy streamCachingStrategy) {
+        super(camelContext, streamCachingStrategy);
+        this.camelContext = camelContext;
+        this.streamCachingStrategy = streamCachingStrategy;
+    }
+
+    public void init(ManagementStrategy strategy) {
+        // do nothing
+    }
+
+    public CamelContext getCamelContext() {
+        return camelContext;
+    }
+
+    public StreamCachingStrategy getStreamCachingStrategy() {
+        return streamCachingStrategy;
+    }
+
+    public String getSpoolDirectory() {
+        return streamCachingStrategy.getSpoolDirectory().getPath();
+    }
+
+    public String getSpoolChiper() {
+        return streamCachingStrategy.getSpoolChiper();
+    }
+
+    public void setSpoolThreshold(long threshold) {
+        streamCachingStrategy.setSpoolThreshold(threshold);
+    }
+
+    public long getSpoolThreshold() {
+        return streamCachingStrategy.getSpoolThreshold();
+    }
+
+    public void setBufferSize(int bufferSize) {
+        streamCachingStrategy.setBufferSize(bufferSize);
+    }
+
+    public int getBufferSize() {
+        return streamCachingStrategy.getBufferSize();
+    }
+
+    public void setRemoveSpoolDirectoryWhenStopping(boolean remove) {
+        streamCachingStrategy.setRemoveSpoolDirectoryWhenStopping(remove);
+    }
+
+    public boolean isRemoveSpoolDirectoryWhenStopping() {
+        return streamCachingStrategy.isRemoveSpoolDirectoryWhenStopping();
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/b026ba01/camel-core/src/main/java/org/apache/camel/spi/StreamCachingStrategy.java
----------------------------------------------------------------------
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 217a0fc..797ee8f 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
@@ -18,10 +18,12 @@ package org.apache.camel.spi;
 
 import java.io.File;
 
+import org.apache.camel.Service;
+
 /**
  * Strategy for using <a href="http://camel.apache.org/stream-caching.html">stream caching</a>.
  */
-public interface StreamCachingStrategy {
+public interface StreamCachingStrategy extends Service {
 
     /**
      * Sets the spool (temporary) directory to use for overflow and spooling to disk.

http://git-wip-us.apache.org/repos/asf/camel/blob/b026ba01/camel-core/src/test/java/org/apache/camel/management/ManagedStreamCachingStrategyTest.java
----------------------------------------------------------------------
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
new file mode 100644
index 0000000..8823287
--- /dev/null
+++ b/camel-core/src/test/java/org/apache/camel/management/ManagedStreamCachingStrategyTest.java
@@ -0,0 +1,80 @@
+/**
+ * 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.management;
+
+import java.util.Set;
+import javax.management.MBeanServer;
+import javax.management.ObjectName;
+
+import org.apache.camel.StreamCache;
+import org.apache.camel.builder.RouteBuilder;
+import org.apache.camel.util.IOHelper;
+
+/**
+ * @version 
+ */
+public class ManagedStreamCachingStrategyTest extends ManagementTestSupport {
+
+    public void testStreamCachingStrategy() throws Exception {
+        MBeanServer mbeanServer = getMBeanServer();
+
+        ObjectName on = ObjectName.getInstance("org.apache.camel:context=localhost/camel-1,type=services,*");
+
+        // number of services
+        Set<ObjectName> names = mbeanServer.queryNames(on, null);
+        ObjectName name = null;
+        for (ObjectName service : names) {
+            if (service.toString().contains("DefaultStreamCachingStrategy")) {
+                name = service;
+                break;
+            }
+        }
+        assertNotNull("Cannot find DefaultStreamCachingStrategy", name);
+
+        // is disabled by default
+        String dir = (String) mbeanServer.getAttribute(name, "SpoolDirectory");
+        assertEquals("target/cachedir", dir);
+
+        Long threshold = (Long) mbeanServer.getAttribute(name, "SpoolThreshold");
+        assertEquals(StreamCache.DEFAULT_SPOOL_THRESHOLD, threshold.longValue());
+
+        Integer size = (Integer) mbeanServer.getAttribute(name, "BufferSize");
+        assertEquals(IOHelper.DEFAULT_BUFFER_SIZE, size.intValue());
+
+        String chiper = (String) mbeanServer.getAttribute(name, "SpoolChiper");
+        assertNull(chiper);
+
+        Boolean remove = (Boolean) mbeanServer.getAttribute(name, "RemoveSpoolDirectoryWhenStopping");
+        assertEquals(Boolean.TRUE, remove);
+    }
+
+    @Override
+    protected RouteBuilder createRouteBuilder() throws Exception {
+        return new RouteBuilder() {
+            @Override
+            public void configure() throws Exception {
+                context.setStreamCaching(true);
+                context.getStreamCachingStrategy().setSpoolDirectory("target/cachedir");
+
+                from("direct:start").routeId("foo")
+                    .convertBodyTo(int.class)
+                    .to("mock:a");
+            }
+        };
+    }
+
+}