Updated Branches:
  refs/heads/master 4dd6e5b1e -> b1329677d

CAMEL-6384: Added BacklogDebugger MBean for live debugging of Camel routes. 
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/b1329677
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/b1329677
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/b1329677

Branch: refs/heads/master
Commit: b1329677df520e1ad3a26e2c5eede4bb28bd629d
Parents: 4dd6e5b
Author: Claus Ibsen <[email protected]>
Authored: Tue May 21 19:54:23 2013 +0200
Committer: Claus Ibsen <[email protected]>
Committed: Tue May 21 21:02:23 2013 +0200

----------------------------------------------------------------------
 .../main/java/org/apache/camel/CamelContext.java   |   17 ++
 .../mbean/ManagedBacklogDebuggerMBean.java         |   47 ++++
 .../org/apache/camel/impl/DefaultCamelContext.java |   13 +
 .../DefaultManagementLifecycleStrategy.java        |   14 +
 .../DefaultManagementNamingStrategy.java           |    2 +-
 .../management/ManagedManagementStrategy.java      |    4 +
 .../management/mbean/ManagedBacklogDebugger.java   |   78 ++++++
 .../management/mbean/ManagedBacklogTracer.java     |    2 +-
 .../camel/processor/CamelInternalProcessor.java    |   62 +++--
 .../processor/interceptor/BacklogDebugger.java     |  208 +++++++++++++++
 .../processor/interceptor/DefaultChannel.java      |   36 +++
 .../camel/management/BacklogDebuggerTest.java      |   54 ++++
 12 files changed, 518 insertions(+), 19 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/CamelContext.java
----------------------------------------------------------------------
diff --git a/camel-core/src/main/java/org/apache/camel/CamelContext.java 
b/camel-core/src/main/java/org/apache/camel/CamelContext.java
index 19c308b..5a87ea0 100644
--- a/camel-core/src/main/java/org/apache/camel/CamelContext.java
+++ b/camel-core/src/main/java/org/apache/camel/CamelContext.java
@@ -999,6 +999,23 @@ public interface CamelContext extends SuspendableService, 
RuntimeConfiguration {
     void setDefaultBacklogTracer(InterceptStrategy backlogTracer);
 
     /**
+     * Gets the default backlog debugger
+     *
+     * @return the default backlog debugger
+     */
+    InterceptStrategy getDefaultBacklogDebugger();
+
+    /**
+     * Sets a custom backlog debugger to be used as the default backlog 
debugger.
+     * <p/>
+     * <b>Note:</b> This must be set before any routes are created,
+     * changing the default backlog debugger for existing routes is not 
supported.
+     *
+     * @param backlogDebugger the custom debugger to use as default backlog 
debugger
+     */
+    void setDefaultBacklogDebugger(InterceptStrategy backlogDebugger);
+
+    /**
      * Disables using JMX as {@link org.apache.camel.spi.ManagementStrategy}.
      */
     void disableJMX();

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
 
b/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.java
new file mode 100644
index 0000000..a454d09
--- /dev/null
+++ 
b/camel-core/src/main/java/org/apache/camel/api/management/mbean/ManagedBacklogDebuggerMBean.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 java.util.Set;
+
+import org.apache.camel.api.management.ManagedAttribute;
+import org.apache.camel.api.management.ManagedOperation;
+
+public interface ManagedBacklogDebuggerMBean {
+
+    @ManagedAttribute(description = "Is debugger enabled")
+    boolean isEnabled();
+
+    @ManagedOperation(description = "Enable the debugger")
+    void enableDebugger();
+
+    @ManagedOperation(description = "Disable the debugger")
+    void disableDebugger();
+
+    @ManagedOperation(description = "Add a breakpoint at the given node id")
+    void addBreakpoint(String nodeId);
+
+    @ManagedOperation(description = "Remote the breakpoint from the given node 
id")
+    void removeBreakpoint(String nodeId);
+
+    @ManagedOperation(description = "Continue debugging the suspended 
breakpoints at the given node id")
+    void continueBreakpoint(String nodeId);
+
+    @ManagedOperation(description = "Return the node ids which is currently 
suspended")
+    Set<String> getSuspendedBreakpointNodeIds();
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java 
b/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java
index 89d0972..359249d 100644
--- a/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java
+++ b/camel-core/src/main/java/org/apache/camel/impl/DefaultCamelContext.java
@@ -81,6 +81,7 @@ import org.apache.camel.model.ModelCamelContext;
 import org.apache.camel.model.RouteDefinition;
 import org.apache.camel.model.RouteDefinitionHelper;
 import org.apache.camel.model.RoutesDefinition;
+import org.apache.camel.processor.interceptor.BacklogDebugger;
 import org.apache.camel.processor.interceptor.BacklogTracer;
 import org.apache.camel.processor.interceptor.Debug;
 import org.apache.camel.processor.interceptor.Delayer;
@@ -200,6 +201,7 @@ public class DefaultCamelContext extends ServiceSupport 
implements ModelCamelCon
     private ProcessorFactory processorFactory;
     private InterceptStrategy defaultTracer;
     private InterceptStrategy defaultBacklogTracer;
+    private InterceptStrategy defaultBacklogDebugger;
     private InflightRepository inflightRepository = new 
DefaultInflightRepository();
     private final List<RouteStartupOrder> routeStartupOrder = new 
ArrayList<RouteStartupOrder>();
     // start auto assigning route ids using numbering 1000 and upwards
@@ -2423,6 +2425,17 @@ public class DefaultCamelContext extends ServiceSupport 
implements ModelCamelCon
         this.defaultBacklogTracer = backlogTracer;
     }
 
+    public InterceptStrategy getDefaultBacklogDebugger() {
+        if (defaultBacklogDebugger == null) {
+            defaultBacklogDebugger = new BacklogDebugger();
+        }
+        return defaultBacklogDebugger;
+    }
+
+    public void setDefaultBacklogDebugger(InterceptStrategy 
defaultBacklogDebugger) {
+        this.defaultBacklogDebugger = defaultBacklogDebugger;
+    }
+
     public void disableJMX() {
         disableJMX = true;
     }

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/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 39fe1d9..31d14b6 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
@@ -51,6 +51,7 @@ import org.apache.camel.impl.EndpointRegistry;
 import org.apache.camel.impl.EventDrivenConsumerRoute;
 import org.apache.camel.impl.ProducerCache;
 import org.apache.camel.impl.ThrottlingInflightRoutePolicy;
+import org.apache.camel.management.mbean.ManagedBacklogDebugger;
 import org.apache.camel.management.mbean.ManagedBacklogTracer;
 import org.apache.camel.management.mbean.ManagedCamelContext;
 import org.apache.camel.management.mbean.ManagedConsumerCache;
@@ -71,6 +72,7 @@ import org.apache.camel.model.ProcessorDefinition;
 import org.apache.camel.model.ProcessorDefinitionHelper;
 import org.apache.camel.model.RouteDefinition;
 import org.apache.camel.processor.CamelInternalProcessor;
+import org.apache.camel.processor.interceptor.BacklogDebugger;
 import org.apache.camel.processor.interceptor.BacklogTracer;
 import org.apache.camel.processor.interceptor.Tracer;
 import org.apache.camel.spi.EventNotifier;
@@ -114,6 +116,7 @@ public class DefaultManagementLifecycleStrategy extends 
ServiceSupport implement
     private final Set<String> knowRouteIds = new HashSet<String>();
     private final Map<Tracer, ManagedTracer> managedTracers = new 
HashMap<Tracer, ManagedTracer>();
     private final Map<BacklogTracer, ManagedBacklogTracer> 
managedBacklogTracers = new HashMap<BacklogTracer, ManagedBacklogTracer>();
+    private final Map<BacklogDebugger, ManagedBacklogDebugger> 
managedBacklogDebuggers = new HashMap<BacklogDebugger, 
ManagedBacklogDebugger>();
     private final Map<ThreadPoolExecutor, Object> managedThreadPools = new 
HashMap<ThreadPoolExecutor, Object>();
 
     public DefaultManagementLifecycleStrategy() {
@@ -426,6 +429,16 @@ public class DefaultManagementLifecycleStrategy extends 
ServiceSupport implement
                 managedBacklogTracers.put(backlogTracer, mt);
             }
             return mt;
+        } else if (service instanceof BacklogDebugger) {
+            // special for backlog debugger
+            BacklogDebugger backlogDebugger = (BacklogDebugger) service;
+            ManagedBacklogDebugger md = 
managedBacklogDebuggers.get(backlogDebugger);
+            if (md == null) {
+                md = new ManagedBacklogDebugger(context, backlogDebugger);
+                md.init(getManagementStrategy());
+                managedBacklogDebuggers.put(backlogDebugger, md);
+            }
+            return md;
         } else if (service instanceof EventNotifier) {
             answer = 
getManagementObjectStrategy().getManagedObjectForEventNotifier(context, 
(EventNotifier) service);
         } else if (service instanceof Producer) {
@@ -890,6 +903,7 @@ public class DefaultManagementLifecycleStrategy extends 
ServiceSupport implement
         wrappedProcessors.clear();
         managedTracers.clear();
         managedBacklogTracers.clear();
+        managedBacklogDebuggers.clear();
         managedThreadPools.clear();
     }
 

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/management/DefaultManagementNamingStrategy.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/management/DefaultManagementNamingStrategy.java
 
b/camel-core/src/main/java/org/apache/camel/management/DefaultManagementNamingStrategy.java
index 71a04d7..24ca194 100644
--- 
a/camel-core/src/main/java/org/apache/camel/management/DefaultManagementNamingStrategy.java
+++ 
b/camel-core/src/main/java/org/apache/camel/management/DefaultManagementNamingStrategy.java
@@ -198,7 +198,7 @@ public class DefaultManagementNamingStrategy implements 
ManagementNamingStrategy
     }
 
     public ObjectName getObjectNameForTracer(CamelContext context, 
InterceptStrategy tracer) throws MalformedObjectNameException {
-        // use the simple name of the class as the mbean name (eg Tracer, 
BacklogTracer)
+        // use the simple name of the class as the mbean name (eg Tracer, 
BacklogTracer, BacklogDebugger)
         String name = tracer.getClass().getSimpleName();
 
         StringBuilder buffer = new StringBuilder();

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/management/ManagedManagementStrategy.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/management/ManagedManagementStrategy.java
 
b/camel-core/src/main/java/org/apache/camel/management/ManagedManagementStrategy.java
index 287b4b0..c16e5c1 100644
--- 
a/camel-core/src/main/java/org/apache/camel/management/ManagedManagementStrategy.java
+++ 
b/camel-core/src/main/java/org/apache/camel/management/ManagedManagementStrategy.java
@@ -20,6 +20,7 @@ import javax.management.ObjectName;
 
 import org.apache.camel.CamelContext;
 import org.apache.camel.Endpoint;
+import org.apache.camel.management.mbean.ManagedBacklogDebugger;
 import org.apache.camel.management.mbean.ManagedBacklogTracer;
 import org.apache.camel.management.mbean.ManagedCamelContext;
 import org.apache.camel.management.mbean.ManagedComponent;
@@ -116,6 +117,9 @@ public class ManagedManagementStrategy extends 
DefaultManagementStrategy {
         } else if (managedObject instanceof ManagedBacklogTracer) {
             ManagedBacklogTracer mt = (ManagedBacklogTracer) managedObject;
             objectName = 
getManagementNamingStrategy().getObjectNameForTracer(mt.getContext(), 
mt.getBacklogTracer());
+        } else if (managedObject instanceof ManagedBacklogDebugger) {
+            ManagedBacklogDebugger md = (ManagedBacklogDebugger) managedObject;
+            objectName = 
getManagementNamingStrategy().getObjectNameForTracer(md.getContext(), 
md.getBacklogDebugger());
         } else if (managedObject instanceof ManagedEventNotifier) {
             ManagedEventNotifier men = (ManagedEventNotifier) managedObject;
             objectName = 
getManagementNamingStrategy().getObjectNameForEventNotifier(men.getContext(), 
men.getEventNotifier());

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
 
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
new file mode 100644
index 0000000..b07dcf4
--- /dev/null
+++ 
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogDebugger.java
@@ -0,0 +1,78 @@
+/**
+ * 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 java.util.Set;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.api.management.ManagedResource;
+import org.apache.camel.api.management.mbean.ManagedBacklogDebuggerMBean;
+import org.apache.camel.processor.interceptor.BacklogDebugger;
+import org.apache.camel.spi.ManagementStrategy;
+
+@ManagedResource(description = "Managed BacklogDebugger")
+public class ManagedBacklogDebugger implements ManagedBacklogDebuggerMBean {
+
+    private final CamelContext camelContext;
+    private final BacklogDebugger backlogDebugger;
+
+    public ManagedBacklogDebugger(CamelContext camelContext, BacklogDebugger 
backlogDebugger) {
+        this.camelContext = camelContext;
+        this.backlogDebugger = backlogDebugger;
+    }
+
+    public void init(ManagementStrategy strategy) {
+        // do nothing
+    }
+
+    public CamelContext getContext() {
+        return camelContext;
+    }
+
+    public BacklogDebugger getBacklogDebugger() {
+        return backlogDebugger;
+    }
+
+    public boolean isEnabled() {
+        return backlogDebugger.isEnabled();
+    }
+
+    public void enableDebugger() {
+        backlogDebugger.enableDebugger();
+    }
+
+    public void disableDebugger() {
+        backlogDebugger.disableDebugger();
+    }
+
+    public void addBreakpoint(String nodeId) {
+        backlogDebugger.addBreakpoint(nodeId);
+    }
+
+    public void removeBreakpoint(String nodeId) {
+        backlogDebugger.removeBreakpoint(nodeId);
+    }
+
+    public void continueBreakpoint(String nodeId) {
+        backlogDebugger.continueBreakpoint(nodeId);
+    }
+
+    public Set<String> getSuspendedBreakpointNodeIds() {
+        return backlogDebugger.getSuspendedBreakpointNodeIds();
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
 
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
index f2fda51..20708de 100644
--- 
a/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
+++ 
b/camel-core/src/main/java/org/apache/camel/management/mbean/ManagedBacklogTracer.java
@@ -29,7 +29,7 @@ import org.apache.camel.spi.ManagementStrategy;
  * @version 
  */
 @ManagedResource(description = "Managed BacklogTracer")
-public class ManagedBacklogTracer implements  ManagedTracerBacklogMBean {
+public class ManagedBacklogTracer implements ManagedTracerBacklogMBean {
     private final CamelContext camelContext;
     private final BacklogTracer backlogTracer;
 

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java
 
b/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java
index 9c11b46..475dad0 100644
--- 
a/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java
+++ 
b/camel-core/src/main/java/org/apache/camel/processor/CamelInternalProcessor.java
@@ -22,7 +22,6 @@ import java.util.List;
 import java.util.Queue;
 
 import org.apache.camel.AsyncCallback;
-import org.apache.camel.AsyncProcessor;
 import org.apache.camel.CamelContext;
 import org.apache.camel.Exchange;
 import org.apache.camel.Processor;
@@ -34,6 +33,7 @@ import org.apache.camel.impl.MDCUnitOfWork;
 import org.apache.camel.management.DelegatePerformanceCounter;
 import org.apache.camel.management.mbean.ManagedPerformanceCounter;
 import org.apache.camel.model.ProcessorDefinition;
+import org.apache.camel.processor.interceptor.BacklogDebugger;
 import org.apache.camel.processor.interceptor.BacklogTracer;
 import org.apache.camel.processor.interceptor.DefaultBacklogTracerEventMessage;
 import org.apache.camel.spi.InflightRepository;
@@ -53,8 +53,9 @@ import org.slf4j.LoggerFactory;
  *     <li>Execute {@link RoutePolicy}</li>
  *     <li>Gather JMX performance statics</li>
  *     <li>Tracing</li>
+ *     <li>Debugging</li>
  * </ul>
- * ... and much more.
+ * ... and more.
  * <p/>
  * This implementation executes this cross cutting functionality as a {@link 
CamelInternalProcessorTask} task
  * by executing the {@link 
CamelInternalProcessorTask#before(org.apache.camel.Exchange)} and
@@ -74,18 +75,10 @@ public final class CamelInternalProcessor extends 
DelegateAsyncProcessor {
         super(processor);
     }
 
-    public CamelInternalProcessor(AsyncProcessor processor) {
-        super(processor);
-    }
-
     public void addTask(CamelInternalProcessorTask task) {
         tasks.add(task);
     }
 
-    public void addFirstTask(CamelInternalProcessorTask task) {
-        tasks.add(0, task);
-    }
-
     public <T> T getTask(Class<T> type) {
         for (CamelInternalProcessorTask task : tasks) {
             if (type.isInstance(task)) {
@@ -97,6 +90,9 @@ public final class CamelInternalProcessor extends 
DelegateAsyncProcessor {
 
     @Override
     public boolean process(Exchange exchange, AsyncCallback callback) {
+        // NOTE: if you are debugging Camel routes, then all the code that 
happens before the processor.process method
+        // is internal code only, so you can go straight to the processor (see 
next NOTE in this method)
+
         if (processor == null) {
             // no processor then we are done
             callback.done(true);
@@ -146,6 +142,8 @@ public final class CamelInternalProcessor extends 
DelegateAsyncProcessor {
                 async = uow.beforeProcess(processor, exchange, callback);
             }
 
+            // NOTE: Here we call the next processor in the Camel routes, so 
you can step into the processor.process call
+            // to continue debugging
             if (LOG.isTraceEnabled()) {
                 LOG.trace("Processing exchange for exchangeId: {} -> {}", 
exchange.getExchangeId(), exchange);
             }
@@ -178,6 +176,9 @@ public final class CamelInternalProcessor extends 
DelegateAsyncProcessor {
 
         @Override
         public void done(boolean doneSync) {
+            // NOTE: if you are debugging Camel routes, then all the code in 
the for loop below is internal only
+            // so you can step straight to the finally block and invoke the 
callback
+
             // we should call after in reverse order
             try {
                 for (int i = tasks.size() - 1; i >= 0; i--) {
@@ -432,7 +433,40 @@ public final class CamelInternalProcessor extends 
DelegateAsyncProcessor {
         }
     }
 
-    public static class UnitOfWorkProcessorTask implements 
CamelInternalProcessorTask<UnitOfWork> {
+    public static final class BacklogDebuggerTask implements 
CamelInternalProcessorTask<StopWatch> {
+
+        private final BacklogDebugger backlogDebugger;
+        private final Processor target;
+        private final ProcessorDefinition<?> definition;
+        private final String nodeId;
+
+        public BacklogDebuggerTask(BacklogDebugger backlogDebugger, Processor 
target, ProcessorDefinition<?> definition) {
+            this.backlogDebugger = backlogDebugger;
+            this.target = target;
+            this.definition = definition;
+            this.nodeId = definition.getId();
+        }
+
+        @Override
+        public StopWatch before(Exchange exchange) throws Exception {
+            if (backlogDebugger.isEnabled() && 
backlogDebugger.hasBreakpoint(nodeId)) {
+                StopWatch watch = new StopWatch();
+                backlogDebugger.beforeProcess(exchange, target, definition);
+                return watch;
+            } else {
+                return null;
+            }
+        }
+
+        @Override
+        public void after(Exchange exchange, StopWatch stopWatch) throws 
Exception {
+            if (stopWatch != null) {
+                backlogDebugger.afterProcess(exchange, target, definition, 
stopWatch.stop());
+            }
+        }
+    }
+
+    public static final class UnitOfWorkProcessorTask implements 
CamelInternalProcessorTask<UnitOfWork> {
 
         private final String routeId;
 
@@ -467,12 +501,6 @@ public final class CamelInternalProcessor extends 
DelegateAsyncProcessor {
             }
         }
 
-            /**
-             * Strategy to create the unit of work for the given exchange.
-             *
-             * @param exchange the exchange
-             * @return the created unit of work
-             */
         protected UnitOfWork createUnitOfWork(Exchange exchange) {
             UnitOfWork answer;
             if (exchange.getContext().isUseMDCLogging()) {

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
 
b/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
new file mode 100644
index 0000000..0dd8013
--- /dev/null
+++ 
b/camel-core/src/main/java/org/apache/camel/processor/interceptor/BacklogDebugger.java
@@ -0,0 +1,208 @@
+/**
+ * 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.processor.interceptor;
+
+import java.util.EventObject;
+import java.util.HashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import org.apache.camel.CamelContext;
+import org.apache.camel.Exchange;
+import org.apache.camel.Processor;
+import org.apache.camel.impl.BreakpointSupport;
+import org.apache.camel.impl.DefaultDebugger;
+import org.apache.camel.model.ProcessorDefinition;
+import org.apache.camel.spi.Condition;
+import org.apache.camel.spi.Debugger;
+import org.apache.camel.spi.InterceptStrategy;
+import org.apache.camel.support.ServiceSupport;
+import org.apache.camel.util.ObjectHelper;
+import org.apache.camel.util.ServiceHelper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * A {@link org.apache.camel.spi.Debugger} that should be used together with 
the {@link BacklogTracer} to
+ * offer debugging and tracing functionality.
+ */
+public class BacklogDebugger extends ServiceSupport implements 
InterceptStrategy {
+
+    private static final Logger LOG = 
LoggerFactory.getLogger(BacklogDebugger.class);
+
+    private final AtomicBoolean enabled = new AtomicBoolean();
+    private final Debugger debugger;
+    private final Map<String, NodeBreakpoint> breakpoints = new 
HashMap<String, NodeBreakpoint>();
+    private final Map<String, CountDownLatch> suspendedBreakpoints = new 
HashMap<String, CountDownLatch>();
+
+    public BacklogDebugger() {
+        this.debugger = new DefaultDebugger();
+    }
+
+    @Override
+    @Deprecated
+    public Processor wrapProcessorInInterceptors(CamelContext context, 
ProcessorDefinition<?> definition, Processor target, Processor nextTarget) 
throws Exception {
+        throw new UnsupportedOperationException("Deprecated");
+    }
+
+    /**
+     * A helper method to return the BacklogDebugger instance if one is enabled
+     *
+     * @return the backlog debugger or null if none can be found
+     */
+    public static BacklogDebugger getBacklogDebugger(CamelContext context) {
+        List<InterceptStrategy> list = context.getInterceptStrategies();
+        for (InterceptStrategy interceptStrategy : list) {
+            if (interceptStrategy instanceof BacklogDebugger) {
+                return (BacklogDebugger) interceptStrategy;
+            }
+        }
+        return null;
+    }
+
+    public Debugger getDebugger() {
+        return debugger;
+    }
+
+    public void enableDebugger() {
+        try {
+            // TODO: should not start debugger as its old-schoold tracer 
depedent
+            //debugger.start();
+            enabled.set(true);
+        } catch (Exception e) {
+            throw ObjectHelper.wrapRuntimeCamelException(e);
+        }
+    }
+
+    public void disableDebugger() {
+        try {
+            enabled.set(false);
+            debugger.stop();
+        } catch (Exception e) {
+            throw ObjectHelper.wrapRuntimeCamelException(e);
+        }
+
+        // make sure to clear state and latches is counted down so we wont 
have hanging threads
+        breakpoints.clear();
+        for (CountDownLatch latch : suspendedBreakpoints.values()) {
+            latch.countDown();
+        }
+        suspendedBreakpoints.clear();
+    }
+
+    public boolean isEnabled() {
+        return enabled.get();
+    }
+
+    public boolean hasBreakpoint(String nodeId) {
+        return breakpoints.containsKey(nodeId);
+    }
+
+    public void addBreakpoint(String nodeId) {
+        if (!breakpoints.containsKey(nodeId)) {
+            NodeBreakpoint breakpoint = new NodeBreakpoint(nodeId);
+            breakpoints.put(nodeId, breakpoint);
+            debugger.addBreakpoint(breakpoint);
+        }
+    }
+
+    public void removeBreakpoint(String nodeId) {
+        // when removing a break point then ensure latches is cleared and 
counted down so we wont have hanging threads
+        CountDownLatch latch = suspendedBreakpoints.remove(nodeId);
+        NodeBreakpoint breakpoint = breakpoints.remove(nodeId);
+        if (breakpoint != null) {
+            debugger.removeBreakpoint(breakpoint);
+        }
+        if (latch != null) {
+            latch.countDown();
+        }
+    }
+
+    public void continueBreakpoint(String nodeId) {
+        CountDownLatch latch = suspendedBreakpoints.remove(nodeId);
+        if (latch != null) {
+            latch.countDown();
+        }
+    }
+
+    public Set<String> getSuspendedBreakpointNodeIds() {
+        return new LinkedHashSet<String>(suspendedBreakpoints.keySet());
+    }
+
+    public boolean beforeProcess(Exchange exchange, Processor processor, 
ProcessorDefinition<?> definition) {
+        return debugger.beforeProcess(exchange, processor, definition);
+    }
+
+    public boolean afterProcess(Exchange exchange, Processor processor, 
ProcessorDefinition<?> definition, long timeTaken) {
+        return debugger.afterProcess(exchange, processor, definition, 
timeTaken);
+    }
+
+    protected void doStart() throws Exception {
+        ServiceHelper.startService(debugger);
+    }
+
+    protected void doStop() throws Exception {
+        disableDebugger();
+        ServiceHelper.stopServices(debugger);
+    }
+
+    /**
+     * Represents a {@link org.apache.camel.spi.Breakpoint} that has a {@link 
Condition} on a specific node id.
+     */
+    private final class NodeBreakpoint extends BreakpointSupport implements 
Condition {
+
+        private final String nodeId;
+
+        public NodeBreakpoint(String nodeId) {
+            this.nodeId = nodeId;
+        }
+
+        @Override
+        public void beforeProcess(Exchange exchange, Processor processor, 
ProcessorDefinition<?> definition) {
+            // mark as suspend
+            final CountDownLatch latch = new CountDownLatch(1);
+            suspendedBreakpoints.put(nodeId, latch);
+
+            // now wait until we should continue
+            // TODO: have a fallback timeout so we wont wait forever
+            if (LOG.isInfoEnabled()) {
+                LOG.info("Breakpoint at node {} is waiting to continue for 
exchangeId: {}", nodeId, exchange.getExchangeId());
+            }
+            try {
+                latch.await();
+                LOG.info("Breakpoint at node {} is continued for exchangeId: 
{}", nodeId, exchange.getExchangeId());
+            } catch (InterruptedException e) {
+                // ignore
+            }
+            super.beforeProcess(exchange, processor, definition);
+        }
+
+        @Override
+        public boolean matchProcess(Exchange exchange, Processor processor, 
ProcessorDefinition<?> definition) {
+            return nodeId.equals(definition.getId());
+        }
+
+        @Override
+        public boolean matchEvent(Exchange exchange, EventObject event) {
+            return false;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/main/java/org/apache/camel/processor/interceptor/DefaultChannel.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/processor/interceptor/DefaultChannel.java
 
b/camel-core/src/main/java/org/apache/camel/processor/interceptor/DefaultChannel.java
index fc3b4a5..6d91a02 100644
--- 
a/camel-core/src/main/java/org/apache/camel/processor/interceptor/DefaultChannel.java
+++ 
b/camel-core/src/main/java/org/apache/camel/processor/interceptor/DefaultChannel.java
@@ -212,8 +212,18 @@ public class DefaultChannel extends ServiceSupport 
implements ModelChannel {
             }
 
             internalProcessor.addTask(new 
CamelInternalProcessor.BacklogTracerTask(backlogTracer.getQueue(), 
backlogTracer, targetOutputDef, route, first));
+
+            // add debugger as well so we have both tracing and debugging out 
of the box
+            InterceptStrategy debugger = getOrCreateBacklogDebugger();
+            if (debugger instanceof BacklogDebugger) {
+                BacklogDebugger backlogDebugger = (BacklogDebugger) debugger;
+                internalProcessor.addTask(new 
CamelInternalProcessor.BacklogDebuggerTask(backlogDebugger, target, 
targetOutputDef));
+            }
         }
 
+        // the regular tracer is not a task on internalProcessor as this is 
not really needed
+        // end users have to explicit enable the tracer to use it, and then 
its okay if we wrap
+        // the processors (but by default tracer is disabled, and therefore we 
do not wrap processors)
         tracer = getOrCreateTracer();
         if (tracer != null) {
             TraceInterceptor trace = (TraceInterceptor) 
tracer.wrapProcessorInInterceptors(routeContext.getCamelContext(), 
targetOutputDef, target, null);
@@ -345,6 +355,32 @@ public class DefaultChannel extends ServiceSupport 
implements ModelChannel {
         return tracer;
     }
 
+    private InterceptStrategy getOrCreateBacklogDebugger() {
+        InterceptStrategy debugger = 
BacklogDebugger.getBacklogDebugger(camelContext);
+        if (debugger == null) {
+            if (camelContext.getRegistry() != null) {
+                // lookup in registry
+                Map<String, BacklogDebugger> map = 
camelContext.getRegistry().findByTypeWithName(BacklogDebugger.class);
+                if (map.size() == 1) {
+                    debugger = map.values().iterator().next();
+                }
+            }
+            if (debugger == null) {
+                // fallback to use the default debugger
+                debugger = camelContext.getDefaultBacklogDebugger();
+            }
+        }
+
+        // which we must manage as well
+        for (LifecycleStrategy strategy : 
camelContext.getLifecycleStrategies()) {
+            if (debugger instanceof Service) {
+                strategy.onServiceAdd(camelContext, (Service) debugger, null);
+            }
+        }
+
+        return debugger;
+    }
+
     public void process(Exchange exchange) throws Exception {
         AsyncProcessorHelper.process(this, exchange);
     }

http://git-wip-us.apache.org/repos/asf/camel/blob/b1329677/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java 
b/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java
new file mode 100644
index 0000000..56007b9
--- /dev/null
+++ 
b/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java
@@ -0,0 +1,54 @@
+/**
+ * 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 javax.management.MBeanServer;
+import javax.management.ObjectName;
+
+import org.apache.camel.builder.RouteBuilder;
+
+public class BacklogDebuggerTest extends ManagementTestSupport {
+
+    public void testBacklogDebugger() throws Exception {
+        MBeanServer mbeanServer = getMBeanServer();
+        ObjectName on = new 
ObjectName("org.apache.camel:context=localhost/camel-1,type=tracer,name=BacklogDebugger");
+        assertNotNull(on);
+        mbeanServer.isRegistered(on);
+
+        Boolean enabled = (Boolean) mbeanServer.getAttribute(on, "Enabled");
+        assertEquals("Should not be enabled", Boolean.FALSE, enabled);
+
+        // TODO: add more to this test
+    }
+
+    @Override
+    protected RouteBuilder createRouteBuilder() throws Exception {
+        return new RouteBuilder() {
+            @Override
+            public void configure() throws Exception {
+                context.setUseBreadcrumb(false);
+
+                from("timer:foo?period=10s").setBody().constant("Hello 
World").to("seda:start");
+
+                from("seda:start")
+                        .to("log:foo").id("foo")
+                        .to("log:bar").id("bar");
+            }
+        };
+    }
+
+}

Reply via email to