* 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.

*/

* Represents the context used to configure routes and the policies to use.

*

* @version $Revision: 961615 $

*/

    private static final transient Log LOG = LogFactory.getLog(DefaultCamelContext.class);

    private static final String NAME_PREFIX = "camel-";

    private static final AtomicInteger CONTEXT_COUNTER = new AtomicInteger(0);

    private ClassLoader applicationContextClassLoader;

    private boolean routeDefinitionInitiated;

    private String name;

    private final Map<String, Endpoint> endpoints = new LRUCache<String, Endpoint>(1000);

    private final AtomicInteger endpointKeyCounter = new AtomicInteger();

    private final List<EndpointStrategy> endpointStrategies = new ArrayList<EndpointStrategy>();

    private final Map<String, Component> components = new HashMap<String, Component>();

    private List<Route> routes;

    private final List<Service> servicesToClose = new ArrayList<Service>();

    private final Set<StartupListener> startupListeners = new LinkedHashSet<StartupListener>();

    private TypeConverter typeConverter;

    private TypeConverterRegistry typeConverterRegistry;

    private Injector injector;

    private ComponentResolver componentResolver;

    private boolean autoCreateComponents = true;

    private LanguageResolver languageResolver = new DefaultLanguageResolver();

    private final Map<String, Language> languages = new HashMap<String, Language>();

    private Registry registry;

    private List<LifecycleStrategy> lifecycleStrategies = new ArrayList<LifecycleStrategy>();

    private ManagementStrategy managementStrategy;

    private AtomicBoolean managementStrategyInitialized = new AtomicBoolean(false);

    private final List<RouteDefinition> routeDefinitions = new ArrayList<RouteDefinition>();

    private List<InterceptStrategy> interceptStrategies = new ArrayList<InterceptStrategy>();

    private boolean firstStartDone;

    private Boolean autoStartup = Boolean.TRUE;

    private Boolean trace = Boolean.FALSE;

    private Boolean streamCache = Boolean.FALSE;

    private Boolean handleFault = Boolean.FALSE;

    private Boolean disableJMX = Boolean.FALSE;

    private Long delay;

    private ErrorHandlerBuilder errorHandlerBuilder;

    private Map<String, DataFormatDefinition> dataFormats = new HashMap<String, DataFormatDefinition>();

    private DataFormatResolver dataFormatResolver = new DefaultDataFormatResolver();

    private Map<String, String> properties = new HashMap<String, String>();

    private FactoryFinderResolver factoryFinderResolver = new DefaultFactoryFinderResolver();

    private FactoryFinder defaultFactoryFinder;

    private final Map<String, FactoryFinder> factories = new HashMap<String, FactoryFinder>();

    private final Map<String, RouteService> routeServices = new LinkedHashMap<String, RouteService>();

    private ClassResolver classResolver = new DefaultClassResolver();

    private PackageScanClassResolver packageScanClassResolver;

    // we use a capacity of 100 per endpoint, so for the same endpoint we have at most 100 producers in the pool

    // so if we have 6 endpoints in the pool, we can have 6 x 100 producers in total

    private ServicePool<Endpoint, Producer> producerServicePool = new SharedProducerServicePool(100);

    private NodeIdFactory nodeIdFactory = new DefaultNodeIdFactory();

    private ProcessorFactory processorFactory;

    private InterceptStrategy defaultTracer;

    private InflightRepository inflightRepository = new DefaultInflightRepository();

    private final List<RouteStartupOrder> routeStartupOrder = new ArrayList<RouteStartupOrder>();

    // start auto assigning route ids using numbering 1000 and upwards

    private int defaultRouteStartupOrder = 1000;

    private ShutdownStrategy shutdownStrategy = new DefaultShutdownStrategy(this);

    private ShutdownRoute shutdownRoute = ShutdownRoute.Default;

    private ShutdownRunningTask shutdownRunningTask = ShutdownRunningTask.CompleteCurrentTaskOnly;

    private ExecutorServiceStrategy executorServiceStrategy = new DefaultExecutorServiceStrategy(this);

    private Debugger debugger;

    private final StopWatch stopWatch = new StopWatch(false);

    private Date startDate;

    public DefaultCamelContext() {

        super();

        name = NAME_PREFIX + CONTEXT_COUNTER.incrementAndGet();

        // use WebSphere specific resolver if running on WebSphere

        if (WebSpherePackageScanClassResolver.isWebSphereClassLoader(this.getClass().getClassLoader())) {

            LOG.info("Using WebSphere specific PackageScanClassResolver");

            packageScanClassResolver = new WebSpherePackageScanClassResolver("META-INF/services/org/apache/camel/TypeConverter");

        } else {

            packageScanClassResolver = new DefaultPackageScanClassResolver();

        }

    }

    /**

     * Creates the {@link CamelContext} using the given JNDI context as the registry

     *

     * @param jndiContext the JNDI context

     */

    public DefaultCamelContext(Context jndiContext) {

        this();

        setJndiContext(jndiContext);

    }

    /**

     * Creates the {@link CamelContext} using the given registry

     *

     * @param registry the registry

     */

    public DefaultCamelContext(Registry registry) {

        this();

        setRegistry(registry);

    }

    public String getName() {

        return name;

    }

    /**

     * Sets the name of the this context.

     *

     * @param name the name

     */

    public void setName(String name) {

        this.name = name;

    }

    public Component hasComponent(String componentName) {

        return components.get(componentName);

    }

    public void addComponent(String componentName, final Component component) {

        ObjectHelper.notNull(component, "component");

        synchronized (components) {

            if (components.containsKey(componentName)) {

                throw new IllegalArgumentException("Cannot add component as its already previously added: " + componentName);

            }

            component.setCamelContext(this);

            components.put(componentName, component);

            for (LifecycleStrategy strategy : lifecycleStrategies) {

                strategy.onComponentAdd(componentName, component);

            }

        }

    }

    public Component getComponent(String name) {

        // synchronize the look up and auto create so that 2 threads can't

        // concurrently auto create the same component.

        synchronized (components) {

            Component component = components.get(name);

            if (component == null && autoCreateComponents) {

                try {

                    component = getComponentResolver().resolveComponent(name, this);

                    if (component != null) {

                        addComponent(name, component);

                        if (isStarted() || isStarting()) {

                            // If the component is looked up after the context is started, lets start it up.

                            startServices(component);

                        }

                    }

                } catch (Exception e) {

                    throw new RuntimeCamelException("Cannot auto create component: " + name, e);

                }

            }

            return component;

        }

    }

    public <T extends Component> T getComponent(String name, Class<T> componentType) {

        Component component = getComponent(name);

        if (componentType.isInstance(component)) {

            return componentType.cast(component);

        } else {

            throw new IllegalArgumentException("The component is not of type: " + componentType + " but is: "

                    + component);

        }

    }

    public Component removeComponent(String componentName) {

        synchronized (components) {

            Component answer = components.remove(componentName);

            if (answer != null) {

                for (LifecycleStrategy strategy : lifecycleStrategies) {

                    strategy.onComponentRemove(componentName, answer);

                }

            }

            return answer;

        }

    }

    // Endpoint Management Methods

    // -----------------------------------------------------------------------

    public Collection<Endpoint> getEndpoints() {

        synchronized (endpoints) {

            return new ArrayList<Endpoint>(endpoints.values());

        }

    }

    public Map<String, Endpoint> getEndpointMap() {

        synchronized (endpoints) {

            return new TreeMap<String, Endpoint>(endpoints);

        }

    }

    public Endpoint hasEndpoint(String uri) {

        // normalize uri so we can do endpoint hits with minor mistakes and parameters is not in the same order

        try {

            uri = URISupport.normalizeUri(uri);

        } catch (Exception e) {

            throw new ResolveEndpointFailedException(uri, e);

        }

        synchronized (endpoints) {

            return endpoints.get(uri);

        }

    }

    public Endpoint addEndpoint(String uri, Endpoint endpoint) throws Exception {

        Endpoint oldEndpoint;

        synchronized (endpoints) {

            startServices(endpoint);

            oldEndpoint = endpoints.remove(uri);

            for (LifecycleStrategy strategy : lifecycleStrategies) {

                strategy.onEndpointAdd(endpoint);

            }

            addEndpointToRegistry(uri, endpoint);

            if (oldEndpoint != null) {

                stopServices(oldEndpoint);

            }

        }

        return oldEndpoint;

    }

    public Endpoint getEndpoint(String uri) {

        ObjectHelper.notEmpty(uri, "uri");

        // in case path has property placeholders then try to let property component resolve those

        try {

            uri = resolvePropertyPlaceholders(uri);

        } catch (Exception e) {

            throw new ResolveEndpointFailedException(uri, e);

        }

        // normalize uri so we can do endpoint hits with minor mistakes and parameters is not in the same order

        try {

            uri = URISupport.normalizeUri(uri);

        } catch (Exception e) {

            throw new ResolveEndpointFailedException(uri, e);

        }

        if (LOG.isTraceEnabled()) {

            LOG.trace("Getting endpoint with uri: " + uri);

        }

        Endpoint answer;

        String scheme = null;

        synchronized (endpoints) {

            answer = endpoints.get(uri);

            if (answer == null) {

                try {

                    // Use the URI prefix to find the component.

                    String splitURI[] = ObjectHelper.splitOnCharacter(uri, ":", 2);

                    if (splitURI[1] != null) {

                        scheme = splitURI[0];

                        Component component = getComponent(scheme);

                        // Ask the component to resolve the endpoint.

                        if (component != null) {

                            // Have the component create the endpoint if it can.

                            answer = component.createEndpoint(uri);

                            if (answer != null && LOG.isDebugEnabled()) {

                                LOG.debug(uri + " converted to endpoint: " + answer + " by component: " + component);

                            }

                        }

                    }

                    if (answer == null) {

                        // no component then try in registry and elsewhere

                        answer = createEndpoint(uri);

                    }

                    if (answer != null) {

                        addService(answer);

                        for (LifecycleStrategy strategy : lifecycleStrategies) {

                            strategy.onEndpointAdd(answer);

                        }

                        answer = addEndpointToRegistry(uri, answer);

                    }

                } catch (Exception e) {

                    throw new ResolveEndpointFailedException(uri, e);

                }

            }

        }

        // unknown scheme

        if (answer == null && scheme != null) {

            throw new ResolveEndpointFailedException(uri, "No component found with scheme: " + scheme);

        }

        return answer;

    }

    public <T extends Endpoint> T getEndpoint(String name, Class<T> endpointType) {

        Endpoint endpoint = getEndpoint(name);

        if (endpoint instanceof InterceptSendToEndpoint) {

            endpoint = ((InterceptSendToEndpoint) endpoint).getDelegate();

        }

        if (endpointType.isInstance(endpoint)) {

            return endpointType.cast(endpoint);

        } else {

            throw new IllegalArgumentException("The endpoint is not of type: " + endpointType + " but is: "

                    + endpoint.getClass().getCanonicalName());

        }

    }

    public void addRegisterEndpointCallback(EndpointStrategy strategy) {

        if (!endpointStrategies.contains(strategy)) {

            // let it be invoked for already registered endpoints so it can catch-up.

            endpointStrategies.add(strategy);

            for (Endpoint endpoint : getEndpoints()) {

                Endpoint newEndpoint = strategy.registerEndpoint(endpoint.getEndpointUri(), endpoint);

                if (newEndpoint != endpoint) {

                    endpoints.put(getEndpointKey(newEndpoint.getEndpointUri(), newEndpoint), newEndpoint);

                }

            }

        }

    }

    /**

     * Strategy to add the given endpoint to the internal endpoint registry

     *

     * @param uri      uri of endpoint

     * @param endpoint the endpoint to add

     * @return the added endpoint

     */

    protected Endpoint addEndpointToRegistry(String uri, Endpoint endpoint) {

        for (EndpointStrategy strategy : endpointStrategies) {

            endpoint = strategy.registerEndpoint(uri, endpoint);

        }

        endpoints.put(getEndpointKey(uri, endpoint), endpoint);

        return endpoint;

    }

    // Route Management Methods

    // -----------------------------------------------------------------------

    /**

     * Returns the order in which the route inputs was started.

     *

     * @return a list ordered by the starting order of the route inputs

     */

    public List<RouteStartupOrder> getRouteStartupOrder() {

        return routeStartupOrder;

    }

    public synchronized List<Route> getRoutes() {

        if (routes == null) {

            routes = new ArrayList<Route>();

        }

        // lets return a copy of the collection as objects are removed later

        // when services are stopped

        return new ArrayList<Route>(routes);

    }

    public Route getRoute(String id) {

        for (Route route : routes) {

            if (route.getId().equals(id)) {

                return route;

            }

        }

        return null;

    }

    public void setRoutes(List<Route> routes) {

        this.routes = routes;

        throw new UnsupportedOperationException("Overriding existing routes is not supported yet, use addRoutes instead");

    }

    synchronized void removeRouteCollection(Collection<Route> routes) {

        if (this.routes != null) {

            this.routes.removeAll(routes);

        }

    }

    synchronized void addRouteCollection(Collection<Route> routes) throws Exception {

        if (this.routes == null) {

            this.routes = new ArrayList<Route>();

        }

        if (routes != null) {

            this.routes.addAll(routes);

        }

    }

    public void addRoutes(RoutesBuilder builder) throws Exception {

        if (LOG.isDebugEnabled()) {

            LOG.debug("Adding routes from builder: " + builder);

        }

        // lets now add the routes from the builder

        builder.addRoutesToCamelContext(this);

    }

    public void addRouteDefinitions(Collection<RouteDefinition> routeDefinitions) throws Exception {

        for (RouteDefinition routeDefinition : routeDefinitions) {

            removeRouteDefinition(routeDefinition);

        }

        this.routeDefinitions.addAll(routeDefinitions);

        if (shouldStartRoutes()) {

            startRouteDefinitions(routeDefinitions);

        }

    }

    /**

     * Removes the route definition with the given key.

     *

     * @return true if one or more routes was removed

     */

    public boolean removeRouteDefinition(String key) {

        boolean answer = false;

        Iterator<RouteDefinition> iter = routeDefinitions.iterator();

        while (iter.hasNext()) {

            RouteDefinition route = iter.next();

            if (route.idOrCreate(nodeIdFactory).equals(key)) {

                iter.remove();

                answer = true;

            }

        }

        return answer;

    }

    public void removeRouteDefinitions(Collection<RouteDefinition> routeDefinitions) throws Exception {

        this.routeDefinitions.removeAll(routeDefinitions);

        for (RouteDefinition routeDefinition : routeDefinitions) {

            removeRouteDefinition(routeDefinition);

        }

    }

    public void removeRouteDefinition(RouteDefinition routeDefinition) throws Exception {

        String key = routeDefinition.idOrCreate(nodeIdFactory);

        // stop and remove the route

        stopRoute(key);

        this.routeServices.remove(key);

        removeRouteDefinition(key);

    }

    public ServiceStatus getRouteStatus(String key) {

        RouteService routeService = routeServices.get(key);

        if (routeService != null) {

            return routeService.getStatus();

        }

        return null;

    }

    public void startRoute(RouteDefinition route) throws Exception {

        List<Route> routes = new ArrayList<Route>();

        List<RouteContext> routeContexts = route.addRoutes(this, routes);

        RouteService routeService = new RouteService(this, route, routeContexts, routes);

        startRouteService(routeService);

    }

    public synchronized void startRoute(String routeId) throws Exception {

        RouteService routeService = routeServices.get(routeId);

        if (routeService != null) {

            startRouteService(routeService);

        }

    }

    public void stopRoute(RouteDefinition route) throws Exception {

        stopRoute(route.idOrCreate(nodeIdFactory));

    }

    public synchronized void stopRoute(String routeId) throws Exception {

        RouteService routeService = routeServices.get(routeId);

        if (routeService != null) {

            routeService.stop();

        }

    }

    public synchronized void shutdownRoute(String routeId) throws Exception {

        RouteService routeService = routeServices.get(routeId);

        if (routeService != null) {

            routeService.setRemovingRoutes(true);

            List<RouteStartupOrder> routes = new ArrayList<RouteStartupOrder>(1);

            RouteStartupOrder order = new DefaultRouteStartupOrder(1, routeService.getRoutes().iterator().next(), routeService);

            routes.add(order);

            getShutdownStrategy().shutdown(this, routes);

            // must stop route service as well

            routeService.stop();

        }

    }

    public synchronized void shutdownRoute(String routeId, long timeout, TimeUnit timeUnit) throws Exception {

        RouteService routeService = routeServices.get(routeId);

        if (routeService != null) {

            routeService.setRemovingRoutes(true);

            List<RouteStartupOrder> routes = new ArrayList<RouteStartupOrder>(1);

            RouteStartupOrder order = new DefaultRouteStartupOrder(1, routeService.getRoutes().iterator().next(), routeService);

            routes.add(order);

            getShutdownStrategy().shutdown(this, routes, timeout, timeUnit);

            // must stop route service as well

            routeService.stop();

        }

    }

    public void addService(Object object) throws Exception {

        if (object instanceof Service) {

            Service service = (Service) object;

            for (LifecycleStrategy strategy : lifecycleStrategies) {

                strategy.onServiceAdd(this, service, null);

            }

            servicesToClose.add(service);

        }

        startServices(object);

    }

    public boolean hasService(Object object) {

        if (object instanceof Service) {

            Service service = (Service) object;

            return servicesToClose.contains(service);

        }

        return false;

    }

    public void addStartupListener(StartupListener listener) throws Exception {

        // either add to listener so we can invoke then later when CamelContext has been started

        // or invoke the callback right now

        if (isStarted()) {

            listener.onCamelContextStarted(this, true);

        } else {

            startupListeners.add(listener);

        }

    }

    // Helper methods

    // -----------------------------------------------------------------------

    public Language resolveLanguage(String language) {

        Language answer;

        synchronized (languages) {

            answer = languages.get(language);

            // check if the language is singleton, if so return the shared instance

            if (answer instanceof IsSingleton) {

                boolean singleton = ((IsSingleton) answer).isSingleton();

                if (singleton) {

                    return answer;

                }

            }

            // language not known or not singleton, then use resolver

            answer = getLanguageResolver().resolveLanguage(language, this);

            if (answer != null) {

                languages.put(language, answer);

            }

        }

        // no language resolved

        return answer;

    }

    public String resolvePropertyPlaceholders(String uri) throws Exception {

        // do not parse uris that are designated for the properties component as it will handle that itself

        if (uri != null && !uri.startsWith("properties:") && uri.contains(PropertiesComponent.PREFIX_TOKEN)) {

            // the uri contains property placeholders so lookup mandatory properties component and let it parse it

            Component component = hasComponent("properties");

            if (component == null) {

                // then fallback to lookup the component

                component = getRegistry().lookup("properties", Component.class);

            }

            if (component == null) {

                throw new IllegalArgumentException("PropertiesComponent with name properties must be defined"

                        + " in CamelContext to support property placeholders in endpoint URIs");

            }

            // force component to be created and registered as a component

            PropertiesComponent pc = getComponent("properties", PropertiesComponent.class);

            // the parser will throw exception if property key was not found

            String answer = pc.parseUri(uri);

            if (LOG.isDebugEnabled()) {

                LOG.debug("Resolved uri: " + uri + " --> " + answer);

            }

            return answer;

        }

        return uri;

    }

    // Properties

    // -----------------------------------------------------------------------

    public TypeConverter getTypeConverter() {

        if (typeConverter == null) {

            synchronized (this) {

                // we can synchronize on this as there is only one instance

                // of the camel context (its the container)

                typeConverter = createTypeConverter();

                try {

                    addService(typeConverter);

                } catch (Exception e) {

                    throw ObjectHelper.wrapRuntimeCamelException(e);

                }

            }

        }

        return typeConverter;

    }

    public void setTypeConverter(TypeConverter typeConverter) {

        this.typeConverter = typeConverter;

    }

    public TypeConverterRegistry getTypeConverterRegistry() {

        if (typeConverterRegistry == null) {

            // init type converter as its lazy

            if (typeConverter == null) {

                getTypeConverter();

            }

            // type converter is usually the default one that also is the registry

            if (typeConverter instanceof DefaultTypeConverter) {

                typeConverterRegistry = (DefaultTypeConverter) typeConverter;

            }

        }

        return typeConverterRegistry;

    }

    public void setTypeConverterRegistry(TypeConverterRegistry typeConverterRegistry) {

        this.typeConverterRegistry = typeConverterRegistry;

    }

    public Injector getInjector() {

        if (injector == null) {

            injector = createInjector();

        }

        return injector;

    }

    public void setInjector(Injector injector) {

        this.injector = injector;

    }

    public ComponentResolver getComponentResolver() {

        if (componentResolver == null) {

            componentResolver = createComponentResolver();

        }

        return componentResolver;

    }

    public void setComponentResolver(ComponentResolver componentResolver) {

        this.componentResolver = componentResolver;

    }

    public LanguageResolver getLanguageResolver() {

        return languageResolver;

    }

    public void setLanguageResolver(LanguageResolver languageResolver) {

        this.languageResolver = languageResolver;

    }

    public boolean isAutoCreateComponents() {

        return autoCreateComponents;

    }

    public void setAutoCreateComponents(boolean autoCreateComponents) {

        this.autoCreateComponents = autoCreateComponents;

    }

    public Registry getRegistry() {

        if (registry == null) {

            registry = createRegistry();

            setRegistry(registry);

        }

        return registry;

    }

    /**

     * Sets the registry to the given JNDI context

     *

     * @param jndiContext is the JNDI context to use as the registry

     * @see #setRegistry(org.apache.camel.spi.Registry)

     */

    public void setJndiContext(Context jndiContext) {

        setRegistry(new JndiRegistry(jndiContext));

    }

    public void setRegistry(Registry registry) {

        // wrap the registry so we always do propery placeholder lookups

        if (!(registry instanceof PropertyPlaceholderDelegateRegistry)) {

            registry = new PropertyPlaceholderDelegateRegistry(this, registry);

        }

        this.registry = registry;

    }

    public List<LifecycleStrategy> getLifecycleStrategies() {

        return lifecycleStrategies;

    }

    public void setLifecycleStrategies(List<LifecycleStrategy> lifecycleStrategies) {

        this.lifecycleStrategies = lifecycleStrategies;

    }

    public void addLifecycleStrategy(LifecycleStrategy lifecycleStrategy) {

        this.lifecycleStrategies.add(lifecycleStrategy);

    }

    public List<RouteDefinition> getRouteDefinitions() {

        return routeDefinitions;

    }

    public RouteDefinition getRouteDefinition(String id) {

        for (RouteDefinition route : routeDefinitions) {

            if (route.getId().equals(id)) {

                return route;

            }

        }

        return null;

    }

    public List<InterceptStrategy> getInterceptStrategies() {

        return interceptStrategies;

    }

    public void setInterceptStrategies(List<InterceptStrategy> interceptStrategies) {

        this.interceptStrategies = interceptStrategies;

    }

    public void addInterceptStrategy(InterceptStrategy interceptStrategy) {

        getInterceptStrategies().add(interceptStrategy);

        // for backwards compatible or if user add them here instead of the setXXX methods

        if (interceptStrategy instanceof Tracer) {

            setTracing(true);

        } else if (interceptStrategy instanceof HandleFault) {

            setHandleFault(true);

        } else if (interceptStrategy instanceof StreamCaching) {

            setStreamCaching(true);

        } else if (interceptStrategy instanceof Delayer) {

            setDelayer(((Delayer)interceptStrategy).getDelay());

        }

    }

    public void setStreamCaching(Boolean cache) {

        this.streamCache = cache;

    }

    public Boolean isStreamCaching() {

        return streamCache;

    }

    public void setTracing(Boolean tracing) {

        this.trace = tracing;

    }

    public Boolean isTracing() {

        return trace;

    }

    public Boolean isHandleFault() {

        return handleFault;

    }

    public void setHandleFault(Boolean handleFault) {

        this.handleFault = handleFault;

    }

    public Long getDelayer() {

        return delay;

    }

    public void setDelayer(Long delay) {

        this.delay = delay;

    }

    public ProducerTemplate createProducerTemplate() {

        int size = CamelContextHelper.getMaximumCachePoolSize(this);

        return createProducerTemplate(size);

    }

    public ProducerTemplate createProducerTemplate(int maximumCacheSize) {

        DefaultProducerTemplate answer = new DefaultProducerTemplate(this);

        answer.setMaximumCacheSize(maximumCacheSize);

        // start it so its ready to use

        try {

            startServices(answer);

        } catch (Exception e) {

            throw ObjectHelper.wrapRuntimeCamelException(e);

        }

        return answer;

    }

    public ConsumerTemplate createConsumerTemplate() {

        int size = CamelContextHelper.getMaximumCachePoolSize(this);

        return createConsumerTemplate(size);

    }

    public ConsumerTemplate createConsumerTemplate(int maximumCacheSize) {

        DefaultConsumerTemplate answer = new DefaultConsumerTemplate(this);

        answer.setMaximumCacheSize(maximumCacheSize);

        // start it so its ready to use

        try {

            startServices(answer);

        } catch (Exception e) {

            throw ObjectHelper.wrapRuntimeCamelException(e);

        }

        return answer;

    }

    public ErrorHandlerBuilder getErrorHandlerBuilder() {

        return errorHandlerBuilder;

    }

    public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {

        this.errorHandlerBuilder = errorHandlerBuilder;

    }

    public void setProducerServicePool(ServicePool<Endpoint, Producer> producerServicePool) {

        this.producerServicePool = producerServicePool;

    }

    public ServicePool<Endpoint, Producer> getProducerServicePool() {

        return producerServicePool;

    }

    public String getUptime() {

        // compute and log uptime

        if (startDate == null) {

            return "not started";

        }

        long delta = new Date().getTime() - startDate.getTime();

        return TimeUtils.printDuration(delta);

    }

    public void start() throws Exception {

        boolean doNotStart = !firstStartDone && !isAutoStartup();

        firstStartDone = true;

        if (doNotStart) {

            LOG.info("Cannot start Apache Camel " + getVersion() + " (CamelContext: " + getName() + ") as it has been configured to not auto start");

            return;

        }

        // super will invoke doStart which will prepare internal services before we continue and start the routes below

        super.start();

        LOG.debug("Starting routes...");

        // the context is now considered started (i.e. isStarted() == true))

        // starting routes is done after, not during context startup

        safelyStartRouteServices(false, routeServices.values());

        for (int i = 0; i < getRoutes().size(); i++) {

            Route route = getRoutes().get(i);

            LOG.info("Route: " + route.getId() + " started and consuming from: " + route.getEndpoint());

            if (LOG.isDebugEnabled()) {

                LOG.debug("Route " + i + ": " + getRoutes().get(i));

            }

        }

        // now notify any startup aware listeners as all the routes etc has been started.

        for (StartupListener startup : startupListeners) {

            startup.onCamelContextStarted(this, false);

        }

        // and then get rid of the list as we dont need it anymore

        startupListeners.clear();

        stopWatch.stop();

        if (LOG.isInfoEnabled()) {

            LOG.info("Started " + getRoutes().size() + " routes");

            LOG.info("Apache Camel " + getVersion() + " (CamelContext: " + getName() + ") started in " + TimeUtils.printDuration(stopWatch.taken()));

        }

        EventHelper.notifyCamelContextStarted(this);

    }

    // Implementation methods

    // -----------------------------------------------------------------------

    protected synchronized void doStart() throws Exception {

        startDate = new Date();

        stopWatch.restart();

        LOG.info("Apache Camel " + getVersion() + " (CamelContext: " + getName() + ") is starting");

        try {

            doStartCamel();

        } catch (Exception e) {

            // fire event that we failed to start

            EventHelper.notifyCamelContextStartupFailed(this, e);

            // rethrow cause

            throw e;

        }

    }

    private void doStartCamel() throws Exception {

        if (isStreamCaching()) {

            // only add a new stream cache if not already configured

            if (StreamCaching.getStreamCaching(this) == null) {

                LOG.info("StreamCaching is enabled on CamelContext: " + getName());

                addInterceptStrategy(new StreamCaching());

            }

        }

        if (isTracing()) {

            // tracing is added in the DefaultChannel so we can enable it on the fly

            LOG.info("Tracing is enabled on CamelContext: " + getName());

        }

        if (isHandleFault()) {

            // only add a new handle fault if not already configured

            if (HandleFault.getHandleFault(this) == null) {

                LOG.info("HandleFault is enabled on CamelContext: " + getName());

                addInterceptStrategy(new HandleFault());

            }

        }

        if (getDelayer() != null && getDelayer() > 0) {

            // only add a new delayer if not already configured

            if (Delayer.getDelayer(this) == null) {

                long millis = getDelayer();

                LOG.info("Delayer is enabled with: " + millis + " ms. on CamelContext: " + getName());

                addInterceptStrategy(new Delayer(millis));

            }

        }

       

        // register debugger

        if (getDebugger() != null) {

            LOG.info("Debugger: " + getDebugger() + " is enabled on CamelContext: " + getName());

            // register this camel context on the debugger

            getDebugger().setCamelContext(this);

            startServices(getDebugger());

            addInterceptStrategy(new Debug(getDebugger()));

        }

        // start management strategy before lifecycles are started

        getManagementStrategy().start();

        // start lifecycle strategies

        Iterator<LifecycleStrategy> it = lifecycleStrategies.iterator();

        while (it.hasNext()) {

            LifecycleStrategy strategy = it.next();

            try {

                strategy.onContextStart(this);

            } catch (Exception e) {

                // not all containers allow access to its MBeanServer (such as OC4j)

                // so here we remove the troublesome strategy to be able to continue

                LOG.warn("Cannot start lifecycle strategy: " + strategy + ". This strategy will be removed. Cause: " + e.getMessage(), e);

                it.remove();

            }

        }

        // start notifiers as services

        for (EventNotifier notifier : getManagementStrategy().getEventNotifiers()) {

            if (notifier instanceof Service) {

                Service service = (Service) notifier;

                for (LifecycleStrategy strategy : lifecycleStrategies) {

                    strategy.onServiceAdd(this, service, null);

                }

            }

            startServices(notifier);

        }

        // must let some bootstrap service be started before we can notify the starting event

        EventHelper.notifyCamelContextStarting(this);

        forceLazyInitialization();

        addService(executorServiceStrategy);

        addService(producerServicePool);

        addService(inflightRepository);

        addService(shutdownStrategy);

        startServices(components.values());

        // To avoid initiating the routeDefinitions after stopping the camel context

        if (!routeDefinitionInitiated) {

            startRouteDefinitions(routeDefinitions);

            routeDefinitionInitiated = true;

        }

        // starting will continue in the start method

    }

    protected synchronized void doStop() throws Exception {

        stopWatch.restart();

        LOG.info("Apache Camel " + getVersion() + " (CamelContext:" + getName() + ") is shutting down");

        EventHelper.notifyCamelContextStopping(this);

        // stop route inputs in the same order as they was started so we stop the very first inputs first

        try {

            shutdownStrategy.shutdown(this, getRouteStartupOrder());

        } catch (Throwable e) {

            LOG.warn("Error occurred while shutting down routes. This exception will be ignored.", e);

        }

        getRouteStartupOrder().clear();

        shutdownServices(routeServices.values());

        // do not clear route services as we can start Camel again and get the route back as before

        // the stop order is important

        shutdownServices(endpoints.values());

        endpoints.clear();

        shutdownServices(components.values());

        components.clear();

        try {

            for (LifecycleStrategy strategy : lifecycleStrategies) {

                strategy.onContextStop(this);

            }

        } catch (Throwable e) {

            LOG.warn("Error occurred while stopping lifecycle strategies. This exception will be ignored.", e);

        }

        // shutdown services as late as possible

        shutdownServices(servicesToClose);

        servicesToClose.clear();

        startupListeners.clear();

        // must notify that we are stopped before stopping the management strategy

        EventHelper.notifyCamelContextStopped(this);

        // stop the notifier service

        for (EventNotifier notifier : getManagementStrategy().getEventNotifiers()) {

            shutdownServices(notifier);

        }

        // shutdown management as the last one

        shutdownServices(managementStrategy);

        stopWatch.stop();

        if (LOG.isInfoEnabled()) {

            LOG.info("Uptime: " + getUptime());

            LOG.info("Apache Camel " + getVersion() + " (CamelContext: " + getName() + ") is shutdown in " + TimeUtils.printDuration(stopWatch.taken()));

        }

        // and clear start date