in core/camel-base-engine/src/main/java/org/apache/camel/impl/engine/AbstractCamelContext.java [2784:2982]
protected void doStartCamel() throws Exception {
if (!camelContextExtension.getContextPlugin(CamelBeanPostProcessor.class).isEnabled()) {
LOG.info("BeanPostProcessor is disabled. Dependency injection of Camel annotations in beans is not supported.");
}
if (LOG.isDebugEnabled()) {
LOG.debug(
"Using ClassResolver={}, PackageScanClassResolver={}, ApplicationContextClassLoader={}, RouteController={}",
getClassResolver(),
PluginHelper.getPackageScanClassResolver(camelContextExtension), getApplicationContextClassLoader(),
getRouteController());
}
if (isStreamCaching()) {
// stream caching is default enabled so lets report if it has been disabled
LOG.debug("StreamCaching is disabled on CamelContext: {}", camelContextExtension.getName());
}
if (isBacklogTracing()) {
// tracing is added in the DefaultChannel so we can enable it on the fly
LOG.debug("Backlog Tracing is enabled on CamelContext: {}", camelContextExtension.getName());
}
if (isTracing()) {
// tracing is added in the DefaultChannel so we can enable it on the fly
LOG.info("Tracing is enabled on CamelContext: {}", camelContextExtension.getName());
}
if (isUseMDCLogging()) {
// log if MDC has been enabled
String pattern = getMDCLoggingKeysPattern();
if (pattern != null) {
LOG.info("MDC logging (keys-pattern: {}) is enabled on CamelContext: {}", pattern,
camelContextExtension.getName());
} else {
LOG.info("MDC logging is enabled on CamelContext: {}", camelContextExtension.getName());
}
}
if (getDelayer() != null && getDelayer() > 0) {
LOG.info("Delayer is enabled with: {} ms. on CamelContext: {}", getDelayer(), camelContextExtension.getName());
}
// start management strategy before lifecycles are started
startService(getManagementStrategy());
// start lifecycle strategies
final StartupStepRecorder startupStepRecorder = camelContextExtension.getStartupStepRecorder();
if (!lifecycleStrategies.isEmpty()) {
StartupStep subStep
= startupStepRecorder.beginStep(CamelContext.class, camelContextExtension.getName(),
"LifecycleStrategy onContextStarting");
startServices(lifecycleStrategies);
for (LifecycleStrategy strategy : lifecycleStrategies) {
try {
strategy.onContextStarting(this);
} catch (VetoCamelContextStartException e) {
// okay we should not start Camel since it was vetoed
LOG.warn("Lifecycle strategy {} vetoed starting CamelContext ({}) due to: {}", strategy,
camelContextExtension.getName(),
e.getMessage());
throw e;
} catch (Exception e) {
LOG.warn("Lifecycle strategy {} failed starting CamelContext ({}) due to: {}", strategy,
camelContextExtension.getName(),
e.getMessage());
throw e;
}
}
startupStepRecorder.endStep(subStep);
}
// start log listeners
ServiceHelper.startService(getCamelContextExtension().getLogListeners());
// ensure components are started
for (Map.Entry<String, Component> entry : components.entrySet()) {
StartupStep step = startupStepRecorder.beginStep(Component.class, entry.getKey(), "Start Component");
try {
startService(entry.getValue());
} catch (Exception e) {
throw new FailedToStartComponentException(entry.getKey(), e.getMessage(), e);
} finally {
startupStepRecorder.endStep(step);
}
}
if (!startupListeners.isEmpty()) {
StartupStep subStep
= startupStepRecorder.beginStep(CamelContext.class, camelContextExtension.getName(),
"StartupListener onCamelContextStarting");
// sort the startup listeners so they are started in the right order
startupListeners.sort(OrderedComparator.get());
// now call the startup listeners where the routes has been warmed up
// (only the actual route consumer has not yet been started)
for (StartupListener startup : startupListeners) {
startup.onCamelContextStarting(getCamelContextReference(), isStarted());
}
startupStepRecorder.endStep(subStep);
}
// start notifiers as services
for (EventNotifier notifier : getManagementStrategy().getEventNotifiers()) {
if (notifier instanceof Service service) {
startService(service);
}
}
// must let some bootstrap service be started before we can notify the starting event
EventHelper.notifyCamelContextStarting(this);
if (isUseDataType()) {
// log if DataType has been enabled
LOG.debug("Message DataType is enabled on CamelContext: {}", camelContextExtension.getName());
}
// is there any stream caching enabled then log an info about this and
// its limit of spooling to disk, so people is aware of this
if (isStreamCachingInUse()) {
// stream caching is in use so enable the strategy
getStreamCachingStrategy().setEnabled(true);
} else {
// log if stream caching is not in use as this can help people to
// enable it if they use streams
LOG.debug("StreamCaching is not in use. If using streams then it's recommended to enable stream caching."
+ " See more details at https://camel.apache.org/stream-caching.html");
}
if (isAllowUseOriginalMessage()) {
LOG.debug("AllowUseOriginalMessage enabled because UseOriginalMessage is in use");
}
LOG.debug("Using HeadersMapFactory: {}", camelContextExtension.getHeadersMapFactory());
if (isCaseInsensitiveHeaders() && !camelContextExtension.getHeadersMapFactory().isCaseInsensitive()) {
LOG.info(
"HeadersMapFactory: {} is case-sensitive which can cause problems for protocols such as HTTP based, which rely on case-insensitive headers.",
camelContextExtension.getHeadersMapFactory());
} else if (!isCaseInsensitiveHeaders()) {
// notify user that the headers are sensitive which can be a problem
LOG.info(
"Case-insensitive headers is not in use. This can cause problems for protocols such as HTTP based, which rely on case-insensitive headers.");
}
// lets log at INFO level if we are not using the default reactive executor
final ReactiveExecutor reactiveExecutor = camelContextExtension.getReactiveExecutor();
if (!reactiveExecutor.getClass().getSimpleName().equals("DefaultReactiveExecutor")) {
LOG.info("Using ReactiveExecutor: {}", reactiveExecutor);
} else {
LOG.debug("Using ReactiveExecutor: {}", reactiveExecutor);
}
// lets log at INFO level if we are not using the default thread pool factory
if (!getExecutorServiceManager().getThreadPoolFactory().getClass().getSimpleName().equals("DefaultThreadPoolFactory")) {
LOG.info("Using ThreadPoolFactory: {}", getExecutorServiceManager().getThreadPoolFactory());
} else {
LOG.debug("Using ThreadPoolFactory: {}", getExecutorServiceManager().getThreadPoolFactory());
}
HealthCheckRegistry hcr = getCamelContextExtension().getContextPlugin(HealthCheckRegistry.class);
if (hcr != null && hcr.isEnabled()) {
LOG.debug("Using HealthCheck: {}", hcr.getId());
}
// start routes
if (doNotStartRoutesOnFirstStart) {
LOG.debug("Skip starting routes as CamelContext has been configured with autoStartup=false");
}
if (getDumpRoutes() != null && !"false".equals(getDumpRoutes())) {
doDumpRoutes();
}
if (!getRouteController().isSupervising()) {
// invoke this logic to warmup the routes and if possible also start the routes (using default route controller)
StartupStep subStep
= startupStepRecorder.beginStep(CamelContext.class, camelContextExtension.getName(), "Start Routes");
EventHelper.notifyCamelContextRoutesStarting(this);
internalRouteStartupManager.doStartOrResumeRoutes(this, routeServices, true, !doNotStartRoutesOnFirstStart, false,
true);
EventHelper.notifyCamelContextRoutesStarted(this);
startupStepRecorder.endStep(subStep);
}
// ensure extra dev consoles is loaded in case additional JARs has been dynamically added to the classpath
if (devConsole) {
StartupStep step = startupStepRecorder.beginStep(CamelContext.class, null, "Scan DevConsoles (phase 2)");
DevConsoleRegistry dcr = getCamelContextExtension().getContextPlugin(DevConsoleRegistry.class);
if (dcr != null) {
dcr.loadDevConsoles(true);
}
startupStepRecorder.endStep(step);
}
final BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(this);
long cacheCounter = beanIntrospection != null ? beanIntrospection.getCachedClassesCounter() : 0;
if (cacheCounter > 0) {
LOG.debug("Clearing BeanIntrospection cache with {} objects using during starting Camel", cacheCounter);
beanIntrospection.clearCache();
}
long invokedCounter = beanIntrospection != null ? beanIntrospection.getInvokedCounter() : 0;
if (invokedCounter > 0) {
LOG.debug("BeanIntrospection invoked {} times during starting Camel", invokedCounter);
}
// starting will continue in the start method
}