* 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 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 CopyOnWriteArrayList<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 CopyOnWriteArrayList<LifecycleStrategy>();

    private ManagementStrategy managementStrategy;

    private ManagementMBeanAssembler managementMBeanAssembler;

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

    private final List<RestDefinition> restDefinitions = new ArrayList<RestDefinition>();

    private RestConfiguration restConfiguration = new RestConfiguration();

    private RestRegistry restRegistry = new DefaultRestRegistry();

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

    private List<RoutePolicyFactory> routePolicyFactories = new ArrayList<RoutePolicyFactory>();

    // 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 final ThreadLocal<Boolean> isSetupRoutes = new ThreadLocal<Boolean>();

    private Boolean autoStartup = Boolean.TRUE;

    private Boolean trace = Boolean.FALSE;

    private Boolean messageHistory = Boolean.TRUE;

    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 Boolean allowUseOriginalMessage = 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 StreamCachingStrategy streamCachingStrategy;

    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 InterceptStrategy defaultBacklogDebugger;

    private InflightRepository inflightRepository = new DefaultInflightRepository();

    private RuntimeEndpointRegistry runtimeEndpointRegistry = new DefaultRuntimeEndpointRegistry();

    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 UnitOfWorkFactory unitOfWorkFactory = new DefaultUnitOfWorkFactory();

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

        }

        // setup management strategy first since end users may use it to add event notifiers

        // using the management strategy before the CamelContext has been started

        this.managementStrategy = createManagementStrategy();

        this.managementMBeanAssembler = createManagementMBeanAssembler();

        // Register this context with the registry

        // Note, this may register a partially constructed object

        ((DefaultCamelContextRegistry) CamelContextRegistry.INSTANCE).afterCreate(this);

        // [TODO] Remove in 3.0

        Container.Instance.manage(this);

    }

   

    /**

     * 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) {

        return getComponent(name, autoCreateComponents);

    }

    public Component getComponent(String name, boolean autoCreateComponents) {

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

            }