001 /**
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.camel.impl;
018
019 import java.io.IOException;
020 import java.lang.reflect.Constructor;
021 import java.util.ArrayList;
022 import java.util.Collection;
023 import java.util.HashMap;
024 import java.util.List;
025 import java.util.Map;
026 import java.util.concurrent.Callable;
027
028 import javax.naming.Context;
029
030 import org.apache.camel.CamelContext;
031 import org.apache.camel.Component;
032 import org.apache.camel.Endpoint;
033 import org.apache.camel.Exchange;
034 import org.apache.camel.Processor;
035 import org.apache.camel.ProducerTemplate;
036 import org.apache.camel.ResolveEndpointFailedException;
037 import org.apache.camel.Route;
038 import org.apache.camel.Routes;
039 import org.apache.camel.RuntimeCamelException;
040 import org.apache.camel.Service;
041 import org.apache.camel.TypeConverter;
042 import org.apache.camel.builder.ErrorHandlerBuilder;
043 import org.apache.camel.impl.converter.DefaultTypeConverter;
044 import org.apache.camel.management.InstrumentationLifecycleStrategy;
045 import org.apache.camel.management.JmxSystemPropertyKeys;
046 import org.apache.camel.model.RouteType;
047 import org.apache.camel.model.dataformat.DataFormatType;
048 import org.apache.camel.processor.interceptor.Delayer;
049 import org.apache.camel.processor.interceptor.TraceFormatter;
050 import org.apache.camel.processor.interceptor.Tracer;
051 import org.apache.camel.spi.ComponentResolver;
052 import org.apache.camel.spi.ExchangeConverter;
053 import org.apache.camel.spi.Injector;
054 import org.apache.camel.spi.InterceptStrategy;
055 import org.apache.camel.spi.Language;
056 import org.apache.camel.spi.LanguageResolver;
057 import org.apache.camel.spi.LifecycleStrategy;
058 import org.apache.camel.spi.Registry;
059 import org.apache.camel.util.CamelContextHelper;
060 import org.apache.camel.util.FactoryFinder;
061 import org.apache.camel.util.NoFactoryAvailableException;
062 import org.apache.camel.util.ObjectHelper;
063 import org.apache.camel.util.ReflectionInjector;
064 import org.apache.camel.util.SystemHelper;
065 import org.apache.commons.logging.Log;
066 import org.apache.commons.logging.LogFactory;
067
068 import static org.apache.camel.util.ServiceHelper.startServices;
069 import static org.apache.camel.util.ServiceHelper.stopServices;
070
071 /**
072 * Represents the context used to configure routes and the policies to use.
073 *
074 * @version $Revision: 732209 $
075 */
076 public class DefaultCamelContext extends ServiceSupport implements CamelContext, Service {
077 private static final transient Log LOG = LogFactory.getLog(DefaultCamelContext.class);
078 private static final String NAME_PREFIX = "camel-";
079 private static int nameSuffix;
080
081 private String name;
082 private final Map<String, Endpoint> endpoints = new HashMap<String, Endpoint>();
083 private final Map<String, Component> components = new HashMap<String, Component>();
084 private List<Route> routes;
085 private List<Service> servicesToClose = new ArrayList<Service>();
086 private TypeConverter typeConverter;
087 private ExchangeConverter exchangeConverter;
088 private Injector injector;
089 private ComponentResolver componentResolver;
090 private boolean autoCreateComponents = true;
091 private LanguageResolver languageResolver = new DefaultLanguageResolver();
092 private Registry registry;
093 private LifecycleStrategy lifecycleStrategy;
094 private List<RouteType> routeDefinitions = new ArrayList<RouteType>();
095 private List<InterceptStrategy> interceptStrategies = new ArrayList<InterceptStrategy>();
096 private Boolean trace;
097 private Long delay;
098 private ErrorHandlerBuilder errorHandlerBuilder;
099 private Map<String, DataFormatType> dataFormats = new HashMap<String, DataFormatType>();
100 private Class<? extends FactoryFinder> factoryFinderClass = FactoryFinder.class;
101
102 public DefaultCamelContext() {
103 name = NAME_PREFIX + ++nameSuffix;
104
105 if (Boolean.getBoolean(JmxSystemPropertyKeys.DISABLED)) {
106 LOG.info("JMX is disabled. Using DefaultLifecycleStrategy.");
107 lifecycleStrategy = new DefaultLifecycleStrategy();
108 } else {
109 try {
110 LOG.info("JMX enabled. Using InstrumentationLifecycleStrategy.");
111 lifecycleStrategy = new InstrumentationLifecycleStrategy();
112 } catch (NoClassDefFoundError e) {
113 // if we can't instantiate the JMX enabled strategy then fallback to default
114 // could be because of missing .jars on the classpath
115 LOG.warn("Could not find needed classes for JMX lifecycle strategy."
116 + " Needed class is in spring-context.jar using Spring 2.5 or newer ("
117 + " spring-jmx.jar using Spring 2.0.x)."
118 + " NoClassDefFoundError: " + e.getMessage());
119 } catch (Exception e) {
120 LOG.warn("Could not create JMX lifecycle strategy, caused by: " + e.getMessage());
121 }
122 // if not created then fallback to default
123 if (lifecycleStrategy == null) {
124 LOG.warn("Not possible to use JMX lifecycle strategy. Using DefaultLifecycleStrategy instead.");
125 lifecycleStrategy = new DefaultLifecycleStrategy();
126 }
127 }
128 }
129
130 /**
131 * Creates the {@link CamelContext} using the given JNDI context as the
132 * registry
133 */
134 public DefaultCamelContext(Context jndiContext) {
135 this();
136 setJndiContext(jndiContext);
137 }
138
139 /**
140 * Creates the {@link CamelContext} using the given registry
141 */
142 public DefaultCamelContext(Registry registry) {
143 this();
144 this.registry = registry;
145 }
146
147 public String getName() {
148 return name;
149 }
150
151 /**
152 * Sets the name of the this context.
153 */
154 public void setName(String name) {
155 this.name = name;
156 }
157
158 public void addComponent(String componentName, final Component component) {
159 if (component == null) {
160 throw new IllegalArgumentException("Component cannot be null");
161 }
162 synchronized (components) {
163 if (components.containsKey(componentName)) {
164 throw new IllegalArgumentException("Component previously added: " + componentName);
165 }
166 component.setCamelContext(this);
167 components.put(componentName, component);
168 }
169 }
170
171 public Component getComponent(String name) {
172 // synchronize the look up and auto create so that 2 threads can't
173 // concurrently auto create the same component.
174 synchronized (components) {
175 Component component = components.get(name);
176 if (component == null && autoCreateComponents) {
177 try {
178 component = getComponentResolver().resolveComponent(name, this);
179 if (component != null) {
180 addComponent(name, component);
181 if (isStarted()) {
182 // If the component is looked up after the context
183 // is started,
184 // lets start it up.
185 startServices(component);
186 }
187 }
188 } catch (Exception e) {
189 throw new RuntimeCamelException("Could not auto create component: " + name, e);
190 }
191 }
192 return component;
193 }
194 }
195
196 public <T extends Component> T getComponent(String name, Class<T> componentType) {
197 Component component = getComponent(name);
198 if (componentType.isInstance(component)) {
199 return componentType.cast(component);
200 } else {
201 throw new IllegalArgumentException("The component is not of type: " + componentType + " but is: "
202 + component);
203 }
204 }
205
206 public Component removeComponent(String componentName) {
207 synchronized (components) {
208 return components.remove(componentName);
209 }
210 }
211
212 public Component getOrCreateComponent(String componentName, Callable<Component> factory) {
213 synchronized (components) {
214 Component component = components.get(componentName);
215 if (component == null) {
216 try {
217 component = factory.call();
218 if (component == null) {
219 throw new RuntimeCamelException("Factory failed to create the " + componentName
220 + " component, it returned null.");
221 }
222 components.put(componentName, component);
223 component.setCamelContext(this);
224 } catch (Exception e) {
225 throw new RuntimeCamelException("Factory failed to create the " + componentName
226 + " component", e);
227 }
228 }
229 return component;
230 }
231 }
232
233 // Endpoint Management Methods
234 // -----------------------------------------------------------------------
235
236 public Collection<Endpoint> getEndpoints() {
237 synchronized (endpoints) {
238 return new ArrayList<Endpoint>(endpoints.values());
239 }
240 }
241
242 public Collection<Endpoint> getEndpoints(String uri) {
243 Collection<Endpoint> answer = new ArrayList<Endpoint>();
244 Collection<Endpoint> coll;
245 synchronized (endpoints) {
246 Endpoint ep = endpoints.get(uri);
247 if (ep != null) {
248 answer.add(ep);
249 return answer;
250 }
251 coll = new ArrayList<Endpoint>(endpoints.values());
252 }
253 for (Endpoint ep : coll) {
254 if (!ep.isSingleton() && uri.equals(ep.getEndpointUri())) {
255 answer.add(ep);
256 }
257 }
258 return answer;
259 }
260
261 public Collection<Endpoint> getSingletonEndpoints() {
262 Collection<Endpoint> answer = new ArrayList<Endpoint>();
263 Collection<Endpoint> coll = getEndpoints();
264 for (Endpoint ep : coll) {
265 if (ep.isSingleton()) {
266 answer.add(ep);
267 }
268 }
269 return answer;
270 }
271
272 public Endpoint addEndpoint(String uri, Endpoint endpoint) throws Exception {
273 Endpoint oldEndpoint;
274 synchronized (endpoints) {
275 startServices(endpoint);
276 oldEndpoint = endpoints.remove(uri);
277 endpoints.put(CamelContextHelper.getEndpointKey(uri, endpoint), endpoint);
278 if (oldEndpoint != null) {
279 stopServices(oldEndpoint);
280 }
281 }
282 return oldEndpoint;
283 }
284
285 public Collection<Endpoint> removeEndpoints(String uri) throws Exception {
286 Collection<Endpoint> answer = new ArrayList<Endpoint>();
287 synchronized (endpoints) {
288 Endpoint oldEndpoint = endpoints.remove(uri);
289 if (oldEndpoint != null) {
290 answer.add(oldEndpoint);
291 stopServices(oldEndpoint);
292 } else {
293 for (Map.Entry entry : endpoints.entrySet()) {
294 oldEndpoint = (Endpoint)entry.getValue();
295 if (!oldEndpoint.isSingleton() && uri.equals(oldEndpoint.getEndpointUri())) {
296 answer.add(oldEndpoint);
297 stopServices(oldEndpoint);
298 endpoints.remove(entry.getKey());
299 }
300 }
301 }
302 }
303 return answer;
304 }
305
306 public Endpoint addSingletonEndpoint(String uri, Endpoint endpoint) throws Exception {
307 return addEndpoint(uri, endpoint);
308 }
309
310 public Endpoint removeSingletonEndpoint(String uri) throws Exception {
311 Collection<Endpoint> answer = removeEndpoints(uri);
312 return (Endpoint) (answer.size() > 0 ? answer.toArray()[0] : null);
313 }
314
315 public Endpoint getEndpoint(String uri) {
316 Endpoint<?> answer;
317 synchronized (endpoints) {
318 answer = endpoints.get(uri);
319 if (answer == null) {
320 try {
321
322 // Use the URI prefix to find the component.
323 String splitURI[] = ObjectHelper.splitOnCharacter(uri, ":", 2);
324 if (splitURI[1] != null) {
325 String scheme = splitURI[0];
326 Component<?> component = getComponent(scheme);
327
328 // Ask the component to resolve the endpoint.
329 if (component != null) {
330 // Have the component create the endpoint if it can.
331 answer = component.createEndpoint(uri);
332
333 if (answer != null && LOG.isDebugEnabled()) {
334 LOG.debug(uri + " converted to endpoint: " + answer + " by component: " + component);
335 }
336 }
337 }
338 if (answer == null) {
339 answer = createEndpoint(uri);
340 }
341
342 // If it's a singleton then auto register it.
343 if (answer != null) {
344 addService(answer);
345
346 endpoints.put(CamelContextHelper.getEndpointKey(uri, answer), answer);
347 lifecycleStrategy.onEndpointAdd(answer);
348 }
349 } catch (Exception e) {
350 LOG.debug("Failed to resolve endpoint " + uri + ". Reason: " + e, e);
351 throw new ResolveEndpointFailedException(uri, e);
352 }
353 }
354 }
355 return answer;
356 }
357
358 public <T extends Endpoint> T getEndpoint(String name, Class<T> endpointType) {
359 Endpoint endpoint = getEndpoint(name);
360 if (endpointType.isInstance(endpoint)) {
361 return endpointType.cast(endpoint);
362 } else {
363 throw new IllegalArgumentException("The endpoint is not of type: " + endpointType + " but is: "
364 + endpoint);
365 }
366 }
367
368 // Route Management Methods
369 // -----------------------------------------------------------------------
370 public List<Route> getRoutes() {
371 if (routes == null) {
372 routes = new ArrayList<Route>();
373 }
374 return routes;
375 }
376
377 public void setRoutes(List<Route> routes) {
378 this.routes = routes;
379 throw new UnsupportedOperationException("overriding existing routes is not supported yet, use addRoutes instead");
380 }
381
382 public void addRoutes(Collection<Route> routes) throws Exception {
383 if (this.routes == null) {
384 this.routes = new ArrayList<Route>();
385 }
386
387 if (routes != null) {
388 this.routes.addAll(routes);
389
390 lifecycleStrategy.onRoutesAdd(routes);
391 if (shouldStartRoutes()) {
392 startRoutes(routes);
393 }
394 }
395 }
396
397 public void addRoutes(Routes builder) throws Exception {
398 // lets now add the routes from the builder
399 builder.setContext(this);
400 List<Route> routeList = builder.getRouteList();
401 if (LOG.isDebugEnabled()) {
402 LOG.debug("Adding routes from: " + builder + " routes: " + routeList);
403 }
404 addRoutes(routeList);
405 }
406
407 public void addRouteDefinitions(Collection<RouteType> routeDefinitions) throws Exception {
408 this.routeDefinitions.addAll(routeDefinitions);
409 if (shouldStartRoutes()) {
410 startRouteDefinitions(routeDefinitions);
411 }
412
413 }
414
415 /**
416 * Adds a service, starting it so that it will be stopped with this context
417 */
418 public void addService(Object object) throws Exception {
419 if (object instanceof Service) {
420 Service service = (Service) object;
421 getLifecycleStrategy().onServiceAdd(this, service);
422 service.start();
423 servicesToClose.add(service);
424 }
425 }
426
427 // Helper methods
428 // -----------------------------------------------------------------------
429
430 public Language resolveLanguage(String language) {
431 return getLanguageResolver().resolveLanguage(language, this);
432 }
433
434 // Properties
435 // -----------------------------------------------------------------------
436 public ExchangeConverter getExchangeConverter() {
437 if (exchangeConverter == null) {
438 exchangeConverter = createExchangeConverter();
439 }
440 return exchangeConverter;
441 }
442
443 public void setExchangeConverter(ExchangeConverter exchangeConverter) {
444 this.exchangeConverter = exchangeConverter;
445 }
446
447 public TypeConverter getTypeConverter() {
448 if (typeConverter == null) {
449 typeConverter = createTypeConverter();
450 }
451 return typeConverter;
452 }
453
454 public void setTypeConverter(TypeConverter typeConverter) {
455 this.typeConverter = typeConverter;
456 }
457
458 public Injector getInjector() {
459 if (injector == null) {
460 injector = createInjector();
461 }
462 return injector;
463 }
464
465 public void setInjector(Injector injector) {
466 this.injector = injector;
467 }
468
469 public ComponentResolver getComponentResolver() {
470 if (componentResolver == null) {
471 componentResolver = createComponentResolver();
472 }
473 return componentResolver;
474 }
475
476 public void setComponentResolver(ComponentResolver componentResolver) {
477 this.componentResolver = componentResolver;
478 }
479
480 public LanguageResolver getLanguageResolver() {
481 return languageResolver;
482 }
483
484 public void setLanguageResolver(LanguageResolver languageResolver) {
485 this.languageResolver = languageResolver;
486 }
487
488 public boolean isAutoCreateComponents() {
489 return autoCreateComponents;
490 }
491
492 public void setAutoCreateComponents(boolean autoCreateComponents) {
493 this.autoCreateComponents = autoCreateComponents;
494 }
495
496 public Registry getRegistry() {
497 if (registry == null) {
498 registry = createRegistry();
499 }
500 return registry;
501 }
502
503 /**
504 * Sets the registry to the given JNDI context
505 *
506 * @param jndiContext is the JNDI context to use as the registry
507 *
508 * @see #setRegistry(org.apache.camel.spi.Registry)
509 */
510 public void setJndiContext(Context jndiContext) {
511 setRegistry(new JndiRegistry(jndiContext));
512 }
513
514 public void setRegistry(Registry registry) {
515 this.registry = registry;
516 }
517
518 public LifecycleStrategy getLifecycleStrategy() {
519 return lifecycleStrategy;
520 }
521
522 public void setLifecycleStrategy(LifecycleStrategy lifecycleStrategy) {
523 this.lifecycleStrategy = lifecycleStrategy;
524 }
525
526 public List<RouteType> getRouteDefinitions() {
527 return routeDefinitions;
528 }
529
530 public List<InterceptStrategy> getInterceptStrategies() {
531 return interceptStrategies;
532 }
533
534 public void setInterceptStrategies(List<InterceptStrategy> interceptStrategies) {
535 this.interceptStrategies = interceptStrategies;
536 }
537
538 public void addInterceptStrategy(InterceptStrategy interceptStrategy) {
539 getInterceptStrategies().add(interceptStrategy);
540 }
541
542 /**
543 * Returns true if tracing has been enabled or disabled via the {@link #setTrace(Boolean)} method
544 * or it has not been specified then default to the <b>camel.trace</b> system property
545 */
546 public boolean getTrace() {
547 final Boolean value = getTracing();
548 if (value != null) {
549 return value;
550 } else {
551 return SystemHelper.isSystemProperty("camel.trace");
552 }
553 }
554
555 public Boolean getTracing() {
556 return trace;
557 }
558
559 public void setTrace(Boolean trace) {
560 this.trace = trace;
561 }
562
563 /**
564 * Returns the delay in millis if delaying has been enabled or disabled via the {@link #setDelay(Long)} method
565 * or it has not been specified then default to the <b>camel.delay</b> system property
566 */
567 public long getDelay() {
568 final Long value = getDelaying();
569 if (value != null) {
570 return value;
571 } else {
572 String prop = SystemHelper.getSystemProperty("camel.delay");
573 return prop != null ? Long.getLong(prop) : 0;
574 }
575 }
576
577 public Long getDelaying() {
578 return delay;
579 }
580
581 public void setDelay(Long delay) {
582 this.delay = delay;
583 }
584
585 public <E extends Exchange> ProducerTemplate<E> createProducerTemplate() {
586 return new DefaultProducerTemplate<E>(this);
587 }
588
589 public ErrorHandlerBuilder getErrorHandlerBuilder() {
590 return errorHandlerBuilder;
591 }
592
593 /**
594 * Sets the default error handler builder which is inherited by the routes
595 */
596 public void setErrorHandlerBuilder(ErrorHandlerBuilder errorHandlerBuilder) {
597 this.errorHandlerBuilder = errorHandlerBuilder;
598 }
599
600 // Implementation methods
601 // -----------------------------------------------------------------------
602
603 protected void doStart() throws Exception {
604 LOG.info("Apache Camel " + getVersion() + " (CamelContext:" + getName() + ") is starting");
605
606 if (getTrace()) {
607 // only add a new tracer if not already configued
608 if (Tracer.getTracer(this) == null) {
609 Tracer tracer = new Tracer();
610 // lets see if we have a formatter if so use it
611 TraceFormatter formatter = this.getRegistry().lookup("traceFormatter", TraceFormatter.class);
612 if (formatter != null) {
613 tracer.setFormatter(formatter);
614 }
615 addInterceptStrategy(tracer);
616 }
617 }
618
619 if (getDelay() > 0) {
620 // only add a new delayer if not already configued
621 if (Delayer.getDelayer(this) == null) {
622 addInterceptStrategy(new Delayer(getDelay()));
623 }
624 }
625
626 lifecycleStrategy.onContextStart(this);
627
628 forceLazyInitialization();
629 if (components != null) {
630 for (Component component : components.values()) {
631 startServices(component);
632 }
633 }
634 startRouteDefinitions(routeDefinitions);
635 startRoutes(routes);
636
637 LOG.info("Apache Camel " + getVersion() + " (CamelContext:" + getName() + ") started");
638 }
639
640 protected void startRouteDefinitions(Collection<RouteType> list) throws Exception {
641 if (list != null) {
642 Collection<Route> routes = new ArrayList<Route>();
643 for (RouteType route : list) {
644 route.addRoutes(this, routes);
645 }
646 addRoutes(routes);
647 }
648 }
649
650 protected void doStop() throws Exception {
651 stopServices(servicesToClose);
652 if (components != null) {
653 for (Component component : components.values()) {
654 stopServices(component);
655 }
656 }
657 }
658
659 protected void startRoutes(Collection<Route> routeList) throws Exception {
660 if (routeList != null) {
661 for (Route<Exchange> route : routeList) {
662 List<Service> services = route.getServicesForRoute();
663 for (Service service : services) {
664 addService(service);
665 }
666 }
667 }
668 }
669
670 /**
671 * Lets force some lazy initialization to occur upfront before we start any
672 * components and create routes
673 */
674 protected void forceLazyInitialization() {
675 getExchangeConverter();
676 getInjector();
677 getLanguageResolver();
678 getTypeConverter();
679 }
680
681 /**
682 * Lazily create a default implementation
683 */
684 protected ExchangeConverter createExchangeConverter() {
685 return new DefaultExchangeConverter();
686 }
687
688 /**
689 * Lazily create a default implementation
690 */
691 protected TypeConverter createTypeConverter() {
692 return new DefaultTypeConverter(getInjector());
693 }
694
695 /**
696 * Lazily create a default implementation
697 */
698 protected Injector createInjector() {
699 FactoryFinder finder = createFactoryFinder();
700 try {
701 return (Injector) finder.newInstance("Injector");
702 } catch (NoFactoryAvailableException e) {
703 // lets use the default
704 return new ReflectionInjector();
705 } catch (IllegalAccessException e) {
706 throw new RuntimeCamelException(e);
707 } catch (InstantiationException e) {
708 throw new RuntimeCamelException(e);
709 } catch (IOException e) {
710 throw new RuntimeCamelException(e);
711 } catch (ClassNotFoundException e) {
712 throw new RuntimeCamelException(e);
713 }
714 }
715
716 /**
717 * Lazily create a default implementation
718 */
719 protected ComponentResolver createComponentResolver() {
720 return new DefaultComponentResolver();
721 }
722
723 /**
724 * Lazily create a default implementation
725 */
726 protected Registry createRegistry() {
727 return new JndiRegistry();
728 }
729
730 /**
731 * A pluggable strategy to allow an endpoint to be created without requiring
732 * a component to be its factory, such as for looking up the URI inside some
733 * {@link Registry}
734 *
735 * @param uri the uri for the endpoint to be created
736 * @return the newly created endpoint or null if it could not be resolved
737 */
738 protected Endpoint createEndpoint(String uri) {
739 Object value = getRegistry().lookup(uri);
740 if (value instanceof Endpoint) {
741 return (Endpoint) value;
742 } else if (value instanceof Processor) {
743 return new ProcessorEndpoint(uri, this, (Processor) value);
744 } else if (value != null) {
745 return convertBeanToEndpoint(uri, value);
746 }
747 return null;
748 }
749
750 /**
751 * Attempt to convert the bean from a {@link Registry} to an endpoint using
752 * some kind of transformation or wrapper
753 *
754 * @param uri the uri for the endpoint (and name in the registry)
755 * @param bean the bean to be converted to an endpoint, which will be not null
756 * @return a new endpoint
757 */
758 protected Endpoint convertBeanToEndpoint(String uri, Object bean) {
759 throw new IllegalArgumentException("uri: " + uri + " bean: " + bean
760 + " could not be converted to an Endpoint");
761 }
762
763 /**
764 * Should we start newly added routes?
765 */
766 protected boolean shouldStartRoutes() {
767 return isStarted() && !isStarting();
768 }
769
770 public void setDataFormats(Map<String, DataFormatType> dataFormats) {
771 this.dataFormats = dataFormats;
772 }
773
774 public Map<String, DataFormatType> getDataFormats() {
775 return dataFormats;
776 }
777
778 public void setFactoryFinderClass(Class<? extends FactoryFinder> finderClass) {
779 factoryFinderClass = finderClass;
780 }
781
782 public FactoryFinder createFactoryFinder() {
783 try {
784 return factoryFinderClass.newInstance();
785 } catch (Exception e) {
786 throw new RuntimeCamelException(e);
787 }
788 }
789
790 public FactoryFinder createFactoryFinder(String path) {
791 try {
792 Constructor<? extends FactoryFinder> constructor;
793 constructor = factoryFinderClass.getConstructor(String.class);
794 return constructor.newInstance(path);
795 } catch (Exception e) {
796 throw new RuntimeCamelException(e);
797 }
798
799 }
800 }