Updated Branches:
  refs/heads/master 62e7e1ac5 -> 292544445

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/29254444
Tree: http://git-wip-us.apache.org/repos/asf/camel/tree/29254444
Diff: http://git-wip-us.apache.org/repos/asf/camel/diff/29254444

Branch: refs/heads/master
Commit: 292544445819f26ebbe90afa8140e12a66dea214
Parents: 62e7e1a
Author: Claus Ibsen <[email protected]>
Authored: Wed May 22 14:47:36 2013 +0200
Committer: Claus Ibsen <[email protected]>
Committed: Wed May 22 17:43:56 2013 +0200

----------------------------------------------------------------------
 .../mbean/ManagedBacklogDebuggerMBean.java         |   22 ++-
 .../org/apache/camel/impl/DefaultCamelContext.java |    2 +-
 .../org/apache/camel/impl/DefaultDebugger.java     |   38 +++-
 .../management/mbean/ManagedBacklogDebugger.java   |   29 +++-
 .../camel/processor/CamelInternalProcessor.java    |    2 +-
 .../processor/interceptor/BacklogDebugger.java     |  172 +++++++++++++--
 .../camel/management/BacklogDebuggerTest.java      |    6 +-
 7 files changed, 237 insertions(+), 34 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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
index fd98029..0d938d1 100644
--- 
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
@@ -23,6 +23,12 @@ import org.apache.camel.api.management.ManagedOperation;
 
 public interface ManagedBacklogDebuggerMBean {
 
+    @ManagedAttribute(description = "Logging Level")
+    String getLoggingLevel();
+
+    @ManagedAttribute(description = "Logging Level")
+    void setLoggingLevel(String level);
+
     @ManagedAttribute(description = "Is debugger enabled")
     boolean isEnabled();
 
@@ -38,8 +44,20 @@ public interface ManagedBacklogDebuggerMBean {
     @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 = "Resume running from the suspended 
breakpoint at the given node id")
+    void resumeBreakpoint(String nodeId);
+
+    @ManagedOperation(description = "Resume running any suspended breakpoints, 
and exits step mode")
+    void resumeAll();
+
+    @ManagedOperation(description = "Starts single step debugging from the 
suspended breakpoint at the given node id")
+    void stepBreakpoint(String nodeId);
+
+    @ManagedAttribute(description = "Whether currently in step mode")
+    boolean isSingleStepMode();
+
+    @ManagedOperation(description = "Steps to next node in step mode")
+    void step();
 
     @ManagedOperation(description = "Return the node ids which has 
breakpoints")
     Set<String> getBreakpoints(boolean includeInternal);

http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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 359249d..4067efb 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
@@ -2427,7 +2427,7 @@ public class DefaultCamelContext extends ServiceSupport 
implements ModelCamelCon
 
     public InterceptStrategy getDefaultBacklogDebugger() {
         if (defaultBacklogDebugger == null) {
-            defaultBacklogDebugger = new BacklogDebugger();
+            defaultBacklogDebugger = new BacklogDebugger(this);
         }
         return defaultBacklogDebugger;
     }

http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java
----------------------------------------------------------------------
diff --git 
a/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java 
b/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java
index d6f155e..59f1b26 100644
--- a/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java
+++ b/camel-core/src/main/java/org/apache/camel/impl/DefaultDebugger.java
@@ -39,8 +39,10 @@ import org.apache.camel.processor.interceptor.Tracer;
 import org.apache.camel.spi.Breakpoint;
 import org.apache.camel.spi.Condition;
 import org.apache.camel.spi.Debugger;
+import org.apache.camel.spi.EventNotifier;
 import org.apache.camel.support.EventNotifierSupport;
 import org.apache.camel.util.ObjectHelper;
+import org.apache.camel.util.ServiceHelper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -52,10 +54,12 @@ import org.slf4j.LoggerFactory;
 public class DefaultDebugger implements Debugger, CamelContextAware {
 
     private static final Logger LOG = 
LoggerFactory.getLogger(DefaultDebugger.class);
+    private final EventNotifier debugEventNotifier = new DebugEventNotifier();
     private final List<BreakpointConditions> breakpoints = new 
CopyOnWriteArrayList<BreakpointConditions>();
     private final int maxConcurrentSingleSteps = 1;
     private final Map<String, Breakpoint> singleSteps = new HashMap<String, 
Breakpoint>(maxConcurrentSingleSteps);
     private CamelContext camelContext;
+    private boolean useTracer = true;
 
     /**
      * Holder class for breakpoint and the associated conditions
@@ -97,6 +101,14 @@ public class DefaultDebugger implements Debugger, 
CamelContextAware {
         this.camelContext = camelContext;
     }
 
+    public boolean isUseTracer() {
+        return useTracer;
+    }
+
+    public void setUseTracer(boolean useTracer) {
+        this.useTracer = useTracer;
+    }
+
     public void addBreakpoint(Breakpoint breakpoint) {
         breakpoints.add(new BreakpointConditions(breakpoint));
     }
@@ -325,23 +337,29 @@ public class DefaultDebugger implements Debugger, 
CamelContextAware {
 
     public void start() throws Exception {
         ObjectHelper.notNull(camelContext, "CamelContext", this);
+
         // register our event notifier
-        camelContext.getManagementStrategy().addEventNotifier(new 
DebugEventNotifier());
-        Tracer tracer = Tracer.getTracer(camelContext);
-        if (tracer == null) {
-            // tracer is disabled so enable it silently so we can leverage it 
to trace the Exchanges for us
-            tracer = Tracer.createTracer(camelContext);
-            tracer.setLogLevel(LoggingLevel.OFF);
-            camelContext.addService(tracer);
-            camelContext.addInterceptStrategy(tracer);
+        ServiceHelper.startService(debugEventNotifier);
+        
camelContext.getManagementStrategy().addEventNotifier(debugEventNotifier);
+
+        if (isUseTracer()) {
+            Tracer tracer = Tracer.getTracer(camelContext);
+            if (tracer == null) {
+                // tracer is disabled so enable it silently so we can leverage 
it to trace the Exchanges for us
+                tracer = Tracer.createTracer(camelContext);
+                tracer.setLogLevel(LoggingLevel.OFF);
+                camelContext.addService(tracer);
+                camelContext.addInterceptStrategy(tracer);
+            }
+            // make sure tracer is enabled so the debugger can leverage the 
tracer for debugging purposes
+            tracer.setEnabled(true);
         }
-        // make sure tracer is enabled so the debugger can leverage the tracer 
for debugging purposes
-        tracer.setEnabled(true);
     }
 
     public void stop() throws Exception {
         breakpoints.clear();
         singleSteps.clear();
+        ServiceHelper.stopServices(debugEventNotifier);
     }
 
     @Override

http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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
index 13387a9..3b6282d 100644
--- 
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
@@ -19,7 +19,6 @@ package org.apache.camel.management.mbean;
 import java.util.Set;
 
 import org.apache.camel.CamelContext;
-import org.apache.camel.api.management.ManagedOperation;
 import org.apache.camel.api.management.ManagedResource;
 import org.apache.camel.api.management.mbean.ManagedBacklogDebuggerMBean;
 import org.apache.camel.processor.interceptor.BacklogDebugger;
@@ -48,6 +47,14 @@ public class ManagedBacklogDebugger implements 
ManagedBacklogDebuggerMBean {
         return backlogDebugger;
     }
 
+    public String getLoggingLevel() {
+        return backlogDebugger.getLoggingLevel();
+    }
+
+    public void setLoggingLevel(String level) {
+        backlogDebugger.setLoggingLevel(level);
+    }
+
     public boolean isEnabled() {
         return backlogDebugger.isEnabled();
     }
@@ -72,8 +79,24 @@ public class ManagedBacklogDebugger implements 
ManagedBacklogDebuggerMBean {
         return backlogDebugger.getBreakpoints(includeInternal);
     }
 
-    public void continueBreakpoint(String nodeId) {
-        backlogDebugger.continueBreakpoint(nodeId);
+    public void resumeBreakpoint(String nodeId) {
+        backlogDebugger.resumeBreakpoint(nodeId);
+    }
+
+    public void resumeAll() {
+        backlogDebugger.resumeAll();
+    }
+
+    public void stepBreakpoint(String nodeId) {
+        backlogDebugger.stepBreakpoint(nodeId);
+    }
+
+    public boolean isSingleStepMode() {
+        return backlogDebugger.isSingleStepMode();
+    }
+
+    public void step() {
+        backlogDebugger.step();
     }
 
     public Set<String> getSuspendedBreakpointNodeIds() {

http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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 475dad0..a3052df 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
@@ -449,7 +449,7 @@ public final class CamelInternalProcessor extends 
DelegateAsyncProcessor {
 
         @Override
         public StopWatch before(Exchange exchange) throws Exception {
-            if (backlogDebugger.isEnabled() && 
backlogDebugger.hasBreakpoint(nodeId)) {
+            if (backlogDebugger.isEnabled() && 
(backlogDebugger.hasBreakpoint(nodeId) || backlogDebugger.isSingleStepMode())) {
                 StopWatch watch = new StopWatch();
                 backlogDebugger.beforeProcess(exchange, target, definition);
                 return watch;

http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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
index efac7b1..7966a63 100644
--- 
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
@@ -29,16 +29,19 @@ import java.util.concurrent.atomic.AtomicLong;
 
 import org.apache.camel.CamelContext;
 import org.apache.camel.Exchange;
+import org.apache.camel.LoggingLevel;
 import org.apache.camel.Processor;
 import org.apache.camel.api.management.mbean.BacklogTracerEventMessage;
 import org.apache.camel.impl.BreakpointSupport;
 import org.apache.camel.impl.DefaultDebugger;
+import org.apache.camel.management.event.ExchangeCompletedEvent;
 import org.apache.camel.model.ProcessorDefinition;
 import org.apache.camel.model.ProcessorDefinitionHelper;
 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.CamelLogger;
 import org.apache.camel.util.MessageHelper;
 import org.apache.camel.util.ObjectHelper;
 import org.apache.camel.util.ServiceHelper;
@@ -53,15 +56,22 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
 
     private static final Logger LOG = 
LoggerFactory.getLogger(BacklogDebugger.class);
 
+    private final CamelContext camelContext;
+    private LoggingLevel loggingLevel = LoggingLevel.INFO;
+    private final CamelLogger logger = new CamelLogger(LOG, loggingLevel);
     private final AtomicBoolean enabled = new AtomicBoolean();
     private final AtomicLong debugCounter = new AtomicLong(0);
     private final Debugger debugger;
     private final Map<String, NodeBreakpoint> breakpoints = new 
HashMap<String, NodeBreakpoint>();
     private final Map<String, CountDownLatch> suspendedBreakpoints = new 
HashMap<String, CountDownLatch>();
     private final Map<String, BacklogTracerEventMessage> 
suspendedBreakpointMessages = new HashMap<String, BacklogTracerEventMessage>();
+    private volatile String singleStepExchangeId;
 
-    public BacklogDebugger() {
-        this.debugger = new DefaultDebugger();
+    public BacklogDebugger(CamelContext camelContext) {
+        this.camelContext = camelContext;
+        DefaultDebugger debugger = new DefaultDebugger(camelContext);
+        debugger.setUseTracer(false);
+        this.debugger = debugger;
     }
 
     @Override
@@ -89,10 +99,19 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
         return debugger;
     }
 
+    public String getLoggingLevel() {
+        return loggingLevel.name();
+    }
+
+    public void setLoggingLevel(String level) {
+        loggingLevel = LoggingLevel.valueOf(level);
+        logger.setLevel(loggingLevel);
+    }
+
     public void enableDebugger() {
+        logger.log("Enabling debugger");
         try {
-            // TODO: should not start debugger as its old-schoold tracer 
depedent
-            //debugger.start();
+            ServiceHelper.startService(debugger);
             enabled.set(true);
         } catch (Exception e) {
             throw ObjectHelper.wrapRuntimeCamelException(e);
@@ -100,11 +119,12 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
     }
 
     public void disableDebugger() {
+        logger.log("Disabling debugger");
         try {
             enabled.set(false);
-            debugger.stop();
+            ServiceHelper.stopService(debugger);
         } catch (Exception e) {
-            throw ObjectHelper.wrapRuntimeCamelException(e);
+            // ignore
         }
 
         // make sure to clear state and latches is counted down so we wont 
have hanging threads
@@ -124,7 +144,16 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
         return breakpoints.containsKey(nodeId);
     }
 
+    public boolean isSingleStepMode() {
+        return singleStepExchangeId != null;
+    }
+
     public void addBreakpoint(String nodeId, boolean internal) {
+        if (internal) {
+            logger.log("Adding internal breakpoint " + nodeId);
+        } else {
+            logger.log("Adding breakpoint " + nodeId);
+        }
         if (!breakpoints.containsKey(nodeId)) {
             NodeBreakpoint breakpoint = new NodeBreakpoint(nodeId, internal);
             breakpoints.put(nodeId, breakpoint);
@@ -133,6 +162,7 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
     }
 
     public void removeBreakpoint(String nodeId) {
+        logger.log("Removing breakpoint " + nodeId);
         // when removing a break point then ensure latches is cleared and 
counted down so we wont have hanging threads
         suspendedBreakpointMessages.remove(nodeId);
         CountDownLatch latch = suspendedBreakpoints.remove(nodeId);
@@ -155,7 +185,20 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
         return answer;
     }
 
-    public void continueBreakpoint(String nodeId) {
+    public void resumeBreakpoint(String nodeId) {
+        resumeBreakpoint(nodeId, false);
+    }
+
+    private void resumeBreakpoint(String nodeId, boolean stepMode) {
+        logger.log("Resume breakpoint " + nodeId);
+
+        if (!stepMode) {
+            if (singleStepExchangeId != null) {
+                debugger.stopSingleStepExchange(singleStepExchangeId);
+                singleStepExchangeId = null;
+            }
+        }
+
         // remember to remove the dumped message as its no longer in need
         suspendedBreakpointMessages.remove(nodeId);
         CountDownLatch latch = suspendedBreakpoints.remove(nodeId);
@@ -164,11 +207,52 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
         }
     }
 
+    public void resumeAll() {
+        logger.log("Resume all");
+        // stop single stepping
+        singleStepExchangeId = null;
+
+        for (String node : getSuspendedBreakpointNodeIds()) {
+            // remember to remove the dumped message as its no longer in need
+            suspendedBreakpointMessages.remove(node);
+            CountDownLatch latch = suspendedBreakpoints.remove(node);
+            if (latch != null) {
+                latch.countDown();
+            }
+        }
+    }
+
+    public void stepBreakpoint(String nodeId) {
+        logger.log("Step breakpoint " + nodeId);
+        // we want to step current exchange to next
+        BacklogTracerEventMessage msg = 
suspendedBreakpointMessages.get(nodeId);
+        NodeBreakpoint breakpoint = breakpoints.get(nodeId);
+        if (msg != null && breakpoint != null) {
+            singleStepExchangeId = msg.getExchangeId();
+            if (debugger.startSingleStepExchange(singleStepExchangeId, new 
StepBreakpoint())) {
+                // now resume
+                resumeBreakpoint(nodeId, true);
+            }
+        }
+    }
+
+    public void step() {
+        for (String node : getSuspendedBreakpointNodeIds()) {
+            // remember to remove the dumped message as its no longer in need
+            suspendedBreakpointMessages.remove(node);
+            CountDownLatch latch = suspendedBreakpoints.remove(node);
+            if (latch != null) {
+                latch.countDown();
+            }
+        }
+    }
+
     public Set<String> getSuspendedBreakpointNodeIds() {
         return new LinkedHashSet<String>(suspendedBreakpoints.keySet());
     }
 
     public void suspendBreakpoint(String nodeId) {
+        logger.log("Suspend breakpoint " + nodeId);
         NodeBreakpoint breakpoint = breakpoints.get(nodeId);
         if (breakpoint != null) {
             breakpoint.suspend();
@@ -176,6 +260,7 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
     }
 
     public void activateBreakpoint(String nodeId) {
+        logger.log("Activate breakpoint " + nodeId);
         NodeBreakpoint breakpoint = breakpoints.get(nodeId);
         if (breakpoint != null) {
             breakpoint.activate();
@@ -183,6 +268,7 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
     }
 
     public String dumpTracedMessagesAsXml(String nodeId) {
+        logger.log("Dump trace message from breakpoint " + nodeId);
         BacklogTracerEventMessage msg = 
suspendedBreakpointMessages.get(nodeId);
         if (msg != null) {
             return msg.toXml(4);
@@ -196,6 +282,7 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
     }
 
     public void resetDebugCounter() {
+        logger.log("Reset debug counter");
         debugCounter.set(0);
     }
 
@@ -208,12 +295,11 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
     }
 
     protected void doStart() throws Exception {
-        ServiceHelper.startService(debugger);
+        // noop
     }
 
     protected void doStop() throws Exception {
         disableDebugger();
-        ServiceHelper.stopServices(debugger);
     }
 
     /**
@@ -241,7 +327,7 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
         public void beforeProcess(Exchange exchange, Processor processor, 
ProcessorDefinition<?> definition) {
             // store a copy of the message so we can see that from the debugger
             Date timestamp = new Date();
-            String toNode = nodeId;
+            String toNode = definition.getId();
             String routeId = ProcessorDefinitionHelper.getRouteId(definition);
             String exchangeId = exchange.getExchangeId();
             String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), 
true, 4, false, false, 1000);
@@ -255,13 +341,11 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
             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());
-            }
+            logger.log("NodeBreakpoint at node " + toNode + " is waiting to 
continue for exchangeId: " + exchange.getExchangeId());
             try {
+                // TODO: have a fallback timeout so we wont wait forever
                 latch.await();
-                LOG.info("Breakpoint at node {} is continued for exchangeId: 
{}", nodeId, exchange.getExchangeId());
+                logger.log("NodeBreakpoint at node " + toNode + " is continued 
exchangeId: " + exchange.getExchangeId());
             } catch (InterruptedException e) {
                 // ignore
             }
@@ -278,4 +362,62 @@ public class BacklogDebugger extends ServiceSupport 
implements InterceptStrategy
             return false;
         }
     }
+
+    /**
+     * Represents a {@link org.apache.camel.spi.Breakpoint} that is used 
during single step mode.
+     */
+    private final class StepBreakpoint extends BreakpointSupport implements 
Condition {
+
+        @Override
+        public void beforeProcess(Exchange exchange, Processor processor, 
ProcessorDefinition<?> definition) {
+            // store a copy of the message so we can see that from the debugger
+            Date timestamp = new Date();
+            String toNode = definition.getId();
+            String routeId = ProcessorDefinitionHelper.getRouteId(definition);
+            String exchangeId = exchange.getExchangeId();
+            String messageAsXml = MessageHelper.dumpAsXml(exchange.getIn(), 
true, 4, false, false, 1000);
+            long uid = debugCounter.incrementAndGet();
+
+            BacklogTracerEventMessage msg = new 
DefaultBacklogTracerEventMessage(uid, timestamp, routeId, toNode, exchangeId, 
messageAsXml);
+            suspendedBreakpointMessages.put(toNode, msg);
+
+            // mark as suspend
+            final CountDownLatch latch = new CountDownLatch(1);
+            suspendedBreakpoints.put(toNode, latch);
+
+            // now wait until we should continue
+            logger.log("StepBreakpoint at node " + toNode + " is waiting to 
continue for exchangeId: " + exchange.getExchangeId());
+            try {
+                // TODO: have a fallback timeout so we wont wait forever
+                latch.await();
+                logger.log("StepBreakpoint at node " + toNode + " is continued 
exchangeId: " + exchange.getExchangeId());
+            } catch (InterruptedException e) {
+                // ignore
+            }
+            super.beforeProcess(exchange, processor, definition);
+        }
+
+        @Override
+        public boolean matchProcess(Exchange exchange, Processor processor, 
ProcessorDefinition<?> definition) {
+            return true;
+        }
+
+        @Override
+        public boolean matchEvent(Exchange exchange, EventObject event) {
+            return event instanceof ExchangeCompletedEvent;
+        }
+
+        @Override
+        public void onEvent(Exchange exchange, EventObject event, 
ProcessorDefinition<?> definition) {
+            // when the exchange is complete, we need to turn off single step 
mode if we were debug stepping the exchange
+            if (event instanceof ExchangeCompletedEvent) {
+                String completedId = ((ExchangeCompletedEvent) 
event).getExchange().getExchangeId();
+
+                if (singleStepExchangeId != null && 
singleStepExchangeId.equals(completedId)) {
+                    logger.log("ExchangeId: " + completedId + " is completed, 
so exiting single step mode.");
+                    singleStepExchangeId = null;
+                }
+            }
+        }
+    }
 }

http://git-wip-us.apache.org/repos/asf/camel/blob/29254444/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
index 64969cd..f154572 100644
--- 
a/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java
+++ 
b/camel-core/src/test/java/org/apache/camel/management/BacklogDebuggerTest.java
@@ -43,11 +43,13 @@ public class BacklogDebuggerTest extends 
ManagementTestSupport {
             public void configure() throws Exception {
                 context.setUseBreadcrumb(false);
 
-                from("timer:foo?period=10s").setBody().constant("Hello 
World").to("seda:start");
+                // 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");
+                        .to("log:bar").id("bar")
+                        .transform().constant("Bye World").id("transform")
+                        .to("log:cheese").id("cheese");
             }
         };
     }

Reply via email to