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"); + } + }; + } + +}
