* 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

*/

    private final transient Logger log = LoggerFactory.getLogger(getClass());

    private JAXBContext jaxbContext;

    private CamelContextNameStrategy nameStrategy = new DefaultCamelContextNameStrategy();

    private ManagementNameStrategy managementNameStrategy = new DefaultManagementNameStrategy(this);

    private String managementName;

    private ClassLoader applicationContextClassLoader;

    private Map<EndpointKey, Endpoint> endpoints;

    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 final Set<Route> routes = new LinkedHashSet<Route>();

    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 ManagementMBeanAssembler managementMBeanAssembler;

    private final AtomicBoolean managementStrategyInitialized = new AtomicBoolean(false);

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

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

    // special flags to control the first startup which can are special

    private volatile boolean firstStartDone;

    private volatile boolean doNotStartRoutesOnFirstStart;

    private final ThreadLocal<Boolean> isStartingRoutes = new ThreadLocal<Boolean>();

    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 Boolean lazyLoadTypeConverters = Boolean.FALSE;

    private Boolean typeConverterStatisticsEnabled = Boolean.FALSE;

    private Boolean useMDCLogging = Boolean.FALSE;

    private Boolean useBreadcrumb = Boolean.TRUE;

    private Long delay;

    private ErrorHandlerFactory errorHandlerBuilder;

    private final Object errorHandlerExecutorServiceLock = new Object();

    private ScheduledExecutorService errorHandlerExecutorService;

    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 PropertiesComponent propertiesComponent;

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

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

    private final Map<String, RouteService> suspendedRouteServices = 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 InterceptStrategy defaultBacklogTracer;

    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 ExecutorServiceManager executorServiceManager;

    private Debugger debugger;

    private UuidGenerator uuidGenerator = createDefaultUuidGenerator();

    private final StopWatch stopWatch = new StopWatch(false);

    private Date startDate;

    /**

     * Creates the {@link CamelContext} using {@link JndiRegistry} as registry,

     * but will silently fallback and use {@link SimpleRegistry} if JNDI cannot be used.

     * <p/>

     * Use one of the other constructors to force use an explicit registry / JNDI.

     */

    public DefaultCamelContext() {

        this.executorServiceManager = new DefaultExecutorServiceManager(this);

        // create endpoint registry at first since end users may access endpoints before CamelContext is started

        this.endpoints = new EndpointRegistry(this);

        // 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 getNameStrategy().getName();

    }

    /**

     * Sets the name of the this context.

     *

     * @param name the name

     */

    public void setName(String name) {

        // use an explicit name strategy since an explicit name was provided to be used

        this.nameStrategy = new ExplicitCamelContextNameStrategy(name);

    }

    public CamelContextNameStrategy getNameStrategy() {

        return nameStrategy;

    }

    public void setNameStrategy(CamelContextNameStrategy nameStrategy) {

        this.nameStrategy = nameStrategy;

    }

    public ManagementNameStrategy getManagementNameStrategy() {

        return managementNameStrategy;

    }

    public void setManagementNameStrategy(ManagementNameStrategy managementNameStrategy) {

        this.managementNameStrategy = managementNameStrategy;

    }

    public String getManagementName() {

        return managementName;

    }

    public void setManagementName(String managementName) {

        this.managementName = managementName;

    }

    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);

            }

            // keep reference to properties component up to date

            if (component instanceof PropertiesComponent && "properties".equals(componentName)) {

                propertiesComponent = (PropertiesComponent) 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 {

                    if (log.isDebugEnabled()) {

                        log.debug("Using ComponentResolver: {} to resolve component with name: {}", getComponentResolver(), name);

                    }

                    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.

                            if (component instanceof Service) {

                                startService((Service)component);

                            }

                        }

                    }

                } catch (Exception e) {

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

                }

            }

            log.trace("getComponent({}) -> {}", name, component);

            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 {

            String message;

            if (component == null) {

                message = "Did not find component given by the name: " + name;

            } else {

                message = "Found component of type: " + component.getClass() + " instead of expected: " + componentType;

            }

            throw new IllegalArgumentException(message);

        }

    }

    public Component removeComponent(String componentName) {

        synchronized (components) {

            Component oldComponent = components.remove(componentName);

            if (oldComponent != null) {

                try {

                    stopServices(oldComponent);

                } catch (Exception e) {

                    log.warn("Error stopping component " + oldComponent + ". This exception will be ignored.", e);

                }

                for (LifecycleStrategy strategy : lifecycleStrategies) {

                    strategy.onComponentRemove(componentName, oldComponent);

                }

            }

            // keep reference to properties component up to date

            if (oldComponent != null && "properties".equals(componentName)) {

                propertiesComponent = null;

            }

            return oldComponent;

        }

    }

    // Endpoint Management Methods

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

    public Collection<Endpoint> getEndpoints() {

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

    }

    public Map<String, Endpoint> getEndpointMap() {

        TreeMap<String, Endpoint> answer = new TreeMap<String, Endpoint>();

        for (Map.Entry<EndpointKey, Endpoint> entry : endpoints.entrySet()) {

            answer.put(entry.getKey().get(), entry.getValue());

        }

        return answer;

    }

    public Endpoint hasEndpoint(String uri) {

        return endpoints.get(getEndpointKey(uri));

    }

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

        Endpoint oldEndpoint;

        startService(endpoint);

        oldEndpoint = endpoints.remove(getEndpointKey(uri));

        for (LifecycleStrategy strategy : lifecycleStrategies) {

            strategy.onEndpointAdd(endpoint);

        }

        addEndpointToRegistry(uri, endpoint);

        if (oldEndpoint != null) {

            stopServices(oldEndpoint);

        }

        return oldEndpoint;

    }

    public Collection<Endpoint> removeEndpoints(String uri) throws Exception {

        Collection<Endpoint> answer = new ArrayList<Endpoint>();

        Endpoint oldEndpoint = endpoints.remove(getEndpointKey(uri));

        if (oldEndpoint != null) {

            answer.add(oldEndpoint);

            stopServices(oldEndpoint);

        } else {

            for (Map.Entry<EndpointKey, Endpoint> entry : endpoints.entrySet()) {

                oldEndpoint = entry.getValue();

                if (EndpointHelper.matchEndpoint(this, oldEndpoint.getEndpointUri(), uri)) {

                    try {

                        stopServices(oldEndpoint);

                    } catch (Exception e) {

                        log.warn("Error stopping endpoint " + oldEndpoint + ". This exception will be ignored.", e);

                    }

                    answer.add(oldEndpoint);

                    endpoints.remove(entry.getKey());

                }

            }

        }

        // notify lifecycle its being removed

        for (Endpoint endpoint : answer) {

            for (LifecycleStrategy strategy : lifecycleStrategies) {

                strategy.onEndpointRemove(endpoint);

            }

        }

        return answer;

    }

    public Endpoint getEndpoint(String uri) {

        ObjectHelper.notEmpty(uri, "uri");

        log.trace("Getting endpoint with 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);

        }

        final String rawUri = uri;

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

        uri = normalizeEndpointUri(uri);

        log.trace("Getting endpoint with raw uri: {}, normalized uri: {}", rawUri, uri);

        Endpoint answer;

        String scheme = null;

        EndpointKey key = getEndpointKey(uri);

        answer = endpoints.get(key);

        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];

                    log.trace("Endpoint uri: {} is from component with name: {}", uri, scheme);

                    Component component = getComponent(scheme);

                    // Ask the component to resolve the endpoint.

                    if (component != null) {

                        log.trace("Creating endpoint from uri: {} using component: {}", uri, component);

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

                        if (component.useRawUri()) {

                            answer = component.createEndpoint(rawUri);

                        } else {

                            answer = component.createEndpoint(uri);

                        }

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

                            log.debug("{} converted to endpoint: {} by component: {}", new Object[]{URISupport.sanitizeUri(uri), answer, component});

                        }

                    }

                }

                if (answer == null) {

                    // no component then try in registry and elsewhere

                    answer = createEndpoint(uri);

                    log.trace("No component to create endpoint from uri: {} fallback lookup in registry -> {}", uri, answer);

                }

                if (answer != null) {

                    addService(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 == null) {

            throw new NoSuchEndpointException(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 != null) {

                    // put will replace existing endpoint with the new endpoint

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

                }

            }

        }

    }

    /**

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

     *

     * @param uri      uri of the endpoint

     * @param endpoint the endpoint to add

     * @return the added endpoint

     */

    protected Endpoint addEndpointToRegistry(String uri, Endpoint endpoint) {

        ObjectHelper.notEmpty(uri, "uri");

        ObjectHelper.notNull(endpoint, "endpoint");

        // if there is endpoint strategies, then use the endpoints they return

        // as this allows to intercept endpoints etc.

        for (EndpointStrategy strategy : endpointStrategies) {

            endpoint = strategy.registerEndpoint(uri, endpoint);

        }

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

        return endpoint;

    }

    /**

     * Normalize uri so we can do endpoint hits with minor mistakes and parameters is not in the same order.

     *

     * @param uri the uri

     * @return normalized uri

     * @throws ResolveEndpointFailedException if uri cannot be normalized

     */

    protected static String normalizeEndpointUri(String uri) {

        try {

            uri = URISupport.normalizeUri(uri);

        } catch (Exception e) {

            throw new ResolveEndpointFailedException(uri, e);

        }

        return uri;

    }

    /**

     * Gets the endpoint key to use for lookup or whe adding endpoints to the {@link EndpointRegistry}

     *

     * @param uri the endpoint uri

     * @return the key

     */

    protected EndpointKey getEndpointKey(String uri) {

        return new EndpointKey(uri);

    }

    /**

     * Gets the endpoint key to use for lookup or whe adding endpoints to the {@link EndpointRegistry}

     *

     * @param uri      the endpoint uri

     * @param endpoint the endpoint

     * @return the key

     */

    protected EndpointKey getEndpointKey(String uri, Endpoint endpoint) {

        if (endpoint != null && !endpoint.isSingleton()) {

            int counter = endpointKeyCounter.incrementAndGet();

            return new EndpointKey(uri + ":" + counter);

        } else {

            return new EndpointKey(uri);

        }

    }

    // Route Management Methods

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

    public List<RouteStartupOrder> getRouteStartupOrder() {

        return routeStartupOrder;

    }

    public List<Route> getRoutes() {

        // 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 : getRoutes()) {

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

                return route;

            }

        }

        return null;

    }

    @Deprecated

    public void setRoutes(List<Route> routes) {

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

    }

    synchronized void removeRouteCollection(Collection<Route> routes) {

        this.routes.removeAll(routes);

    }

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

        this.routes.addAll(routes);

    }

    public void addRoutes(RoutesBuilder builder) throws Exception {

        log.debug("Adding routes from builder: {}", builder);

        // lets now add the routes from the builder

        builder.addRoutesToCamelContext(this);

    }

    public synchronized RoutesDefinition loadRoutesDefinition(InputStream is) throws Exception {

        // load routes using JAXB

        if (jaxbContext == null) {

            // must use classloader from CamelContext to have JAXB working

            jaxbContext = JAXBContext.newInstance(Constants.JAXB_CONTEXT_PACKAGES, CamelContext.class.getClassLoader());

        }

        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();

        Object result = unmarshaller.unmarshal(is);

        if (result == null) {

            throw new IOException("Cannot unmarshal to routes using JAXB from input stream: " + is);

        }

        // can either be routes or a single route

        RoutesDefinition answer = null;

        if (result instanceof RouteDefinition) {

            RouteDefinition route = (RouteDefinition) result;

            answer = new RoutesDefinition();

            answer.getRoutes().add(route);

        } else if (result instanceof RoutesDefinition) {

            answer = (RoutesDefinition) result;

        } else {

            throw new IllegalArgumentException("Unmarshalled object is an unsupported type: " + ObjectHelper.className(result) + " -> " + result);

        }

        return answer;

    }

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

        for (RouteDefinition routeDefinition : routeDefinitions) {

            removeRouteDefinition(routeDefinition);

        }

        this.routeDefinitions.addAll(routeDefinitions);

        if (shouldStartRoutes()) {

            startRouteDefinitions(routeDefinitions);

        }

    }

    public void addRouteDefinition(RouteDefinition routeDefinition) throws Exception {

        addRouteDefinitions(Arrays.asList(routeDefinition));

    }

    /**

     * Removes the route definition with the given key.

     *

     * @return true if one or more routes was removed

     */

    protected boolean removeRouteDefinition(String key) {