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 */
017package org.apache.camel.impl.lw;
018
019import java.io.IOException;
020import java.io.InputStream;
021import java.util.ArrayList;
022import java.util.Collection;
023import java.util.Collections;
024import java.util.Date;
025import java.util.List;
026import java.util.Map;
027import java.util.Set;
028import java.util.concurrent.ScheduledExecutorService;
029import java.util.concurrent.TimeUnit;
030import java.util.stream.Collectors;
031
032import org.apache.camel.CamelContext;
033import org.apache.camel.CamelContextAware;
034import org.apache.camel.CatalogCamelContext;
035import org.apache.camel.Component;
036import org.apache.camel.ConsumerTemplate;
037import org.apache.camel.Endpoint;
038import org.apache.camel.ErrorHandlerFactory;
039import org.apache.camel.ExchangeConstantProvider;
040import org.apache.camel.Experimental;
041import org.apache.camel.ExtendedCamelContext;
042import org.apache.camel.FluentProducerTemplate;
043import org.apache.camel.GlobalEndpointConfiguration;
044import org.apache.camel.IsSingleton;
045import org.apache.camel.LoggingLevel;
046import org.apache.camel.NoSuchEndpointException;
047import org.apache.camel.NoSuchLanguageException;
048import org.apache.camel.Processor;
049import org.apache.camel.ProducerTemplate;
050import org.apache.camel.ResolveEndpointFailedException;
051import org.apache.camel.Route;
052import org.apache.camel.RouteTemplateContext;
053import org.apache.camel.RoutesBuilder;
054import org.apache.camel.RuntimeCamelException;
055import org.apache.camel.Service;
056import org.apache.camel.ServiceStatus;
057import org.apache.camel.ShutdownRoute;
058import org.apache.camel.ShutdownRunningTask;
059import org.apache.camel.StartupListener;
060import org.apache.camel.StartupSummaryLevel;
061import org.apache.camel.TypeConverter;
062import org.apache.camel.ValueHolder;
063import org.apache.camel.catalog.RuntimeCamelCatalog;
064import org.apache.camel.impl.converter.CoreTypeConverterRegistry;
065import org.apache.camel.impl.engine.DefaultComponentResolver;
066import org.apache.camel.impl.engine.DefaultDataFormatResolver;
067import org.apache.camel.impl.engine.DefaultLanguageResolver;
068import org.apache.camel.spi.AnnotationBasedProcessorFactory;
069import org.apache.camel.spi.AsyncProcessorAwaitManager;
070import org.apache.camel.spi.BeanIntrospection;
071import org.apache.camel.spi.BeanProcessorFactory;
072import org.apache.camel.spi.BeanProxyFactory;
073import org.apache.camel.spi.BootstrapCloseable;
074import org.apache.camel.spi.CamelBeanPostProcessor;
075import org.apache.camel.spi.CamelContextNameStrategy;
076import org.apache.camel.spi.ClassResolver;
077import org.apache.camel.spi.ComponentNameResolver;
078import org.apache.camel.spi.ComponentResolver;
079import org.apache.camel.spi.ConfigurerResolver;
080import org.apache.camel.spi.DataFormat;
081import org.apache.camel.spi.DataFormatResolver;
082import org.apache.camel.spi.DataType;
083import org.apache.camel.spi.Debugger;
084import org.apache.camel.spi.DeferServiceFactory;
085import org.apache.camel.spi.EndpointRegistry;
086import org.apache.camel.spi.EndpointStrategy;
087import org.apache.camel.spi.EndpointUriFactory;
088import org.apache.camel.spi.ExchangeFactory;
089import org.apache.camel.spi.ExchangeFactoryManager;
090import org.apache.camel.spi.ExecutorServiceManager;
091import org.apache.camel.spi.FactoryFinder;
092import org.apache.camel.spi.FactoryFinderResolver;
093import org.apache.camel.spi.HeadersMapFactory;
094import org.apache.camel.spi.InflightRepository;
095import org.apache.camel.spi.Injector;
096import org.apache.camel.spi.InterceptEndpointFactory;
097import org.apache.camel.spi.InterceptSendToEndpoint;
098import org.apache.camel.spi.InterceptStrategy;
099import org.apache.camel.spi.InternalProcessorFactory;
100import org.apache.camel.spi.Language;
101import org.apache.camel.spi.LanguageResolver;
102import org.apache.camel.spi.LifecycleStrategy;
103import org.apache.camel.spi.LogListener;
104import org.apache.camel.spi.ManagementMBeanAssembler;
105import org.apache.camel.spi.ManagementNameStrategy;
106import org.apache.camel.spi.ManagementStrategy;
107import org.apache.camel.spi.MessageHistoryFactory;
108import org.apache.camel.spi.ModelJAXBContextFactory;
109import org.apache.camel.spi.ModelToXMLDumper;
110import org.apache.camel.spi.NodeIdFactory;
111import org.apache.camel.spi.NormalizedEndpointUri;
112import org.apache.camel.spi.PackageScanClassResolver;
113import org.apache.camel.spi.PackageScanResourceResolver;
114import org.apache.camel.spi.ProcessorExchangeFactory;
115import org.apache.camel.spi.ProcessorFactory;
116import org.apache.camel.spi.PropertiesComponent;
117import org.apache.camel.spi.ReactiveExecutor;
118import org.apache.camel.spi.Registry;
119import org.apache.camel.spi.ResourceLoader;
120import org.apache.camel.spi.RestBindingJaxbDataFormatFactory;
121import org.apache.camel.spi.RestConfiguration;
122import org.apache.camel.spi.RestRegistry;
123import org.apache.camel.spi.RouteController;
124import org.apache.camel.spi.RouteFactory;
125import org.apache.camel.spi.RoutePolicyFactory;
126import org.apache.camel.spi.RouteStartupOrder;
127import org.apache.camel.spi.RoutesLoader;
128import org.apache.camel.spi.RuntimeEndpointRegistry;
129import org.apache.camel.spi.ShutdownStrategy;
130import org.apache.camel.spi.StartupStepRecorder;
131import org.apache.camel.spi.StreamCachingStrategy;
132import org.apache.camel.spi.SupervisingRouteController;
133import org.apache.camel.spi.Tracer;
134import org.apache.camel.spi.Transformer;
135import org.apache.camel.spi.TransformerRegistry;
136import org.apache.camel.spi.TypeConverterRegistry;
137import org.apache.camel.spi.UnitOfWorkFactory;
138import org.apache.camel.spi.UriFactoryResolver;
139import org.apache.camel.spi.UuidGenerator;
140import org.apache.camel.spi.Validator;
141import org.apache.camel.spi.ValidatorRegistry;
142import org.apache.camel.spi.XMLRoutesDefinitionLoader;
143import org.apache.camel.support.CamelContextHelper;
144import org.apache.camel.support.NormalizedUri;
145import org.apache.camel.support.jsse.SSLContextParameters;
146import org.apache.camel.util.IOHelper;
147import org.apache.camel.util.ObjectHelper;
148import org.apache.camel.util.StringHelper;
149import org.apache.camel.util.TimeUtils;
150import org.apache.camel.util.URISupport;
151import org.slf4j.Logger;
152import org.slf4j.LoggerFactory;
153
154@Experimental
155public class LightweightRuntimeCamelContext implements ExtendedCamelContext, CatalogCamelContext {
156
157    private static final Logger LOG = LoggerFactory.getLogger(LightweightRuntimeCamelContext.class);
158
159    private final CamelContext reference;
160    private final Registry registry;
161    private final CoreTypeConverterRegistry typeConverter;
162    private final ModelJAXBContextFactory modelJAXBContextFactory;
163    private final ComponentResolver componentResolver;
164    private final ComponentNameResolver componentNameResolver;
165    private final LanguageResolver languageResolver;
166    private final DataFormatResolver dataFormatResolver;
167    private final UuidGenerator uuidGenerator;
168    private final EndpointRegistry<? extends ValueHolder<String>> endpoints;
169    private final Map<String, Component> components;
170    private final Map<String, Language> languages;
171    private final PropertiesComponent propertiesComponent;
172    private final BeanIntrospection beanIntrospection;
173    private final HeadersMapFactory headersMapFactory;
174    private final ExchangeFactory exchangeFactory;
175    private final ExchangeFactoryManager exchangeFactoryManager;
176    private final ProcessorExchangeFactory processorExchangeFactory;
177    private final ReactiveExecutor reactiveExecutor;
178    private final AsyncProcessorAwaitManager asyncProcessorAwaitManager;
179    private final ExecutorServiceManager executorServiceManager;
180    private final ShutdownStrategy shutdownStrategy;
181    private final ClassLoader applicationContextClassLoader;
182    private final UnitOfWorkFactory unitOfWorkFactory;
183    private final RouteController routeController;
184    private final ProcessorFactory processorFactory;
185    private final InternalProcessorFactory internalProcessorFactory;
186    private final InflightRepository inflightRepository;
187    private final Injector injector;
188    private final ClassResolver classResolver;
189    private final Map<String, String> globalOptions;
190    private final String name;
191    private final boolean eventNotificationApplicable;
192    private final boolean useDataType;
193    private final boolean useBreadcrumb;
194    private final boolean dumpRoutes;
195    private final String mdcLoggingKeysPattern;
196    private final boolean useMDCLogging;
197    private final List<Route> routes;
198    private final boolean messageHistory;
199    private final boolean allowUseOriginalMessage;
200    private final boolean logExhaustedMessageBody;
201    private final String version;
202    private Date startDate;
203    private StartupSummaryLevel startupSummaryLevel;
204
205    LightweightRuntimeCamelContext(CamelContext reference, CamelContext context) {
206        this.reference = reference;
207        registry = context.getRegistry();
208        typeConverter = new CoreTypeConverterRegistry(context.getTypeConverterRegistry());
209        modelJAXBContextFactory = context.adapt(ExtendedCamelContext.class).getModelJAXBContextFactory();
210        routes = Collections.unmodifiableList(context.getRoutes());
211        uuidGenerator = context.getUuidGenerator();
212        componentResolver = context.adapt(ExtendedCamelContext.class).getComponentResolver();
213        componentNameResolver = context.adapt(ExtendedCamelContext.class).getComponentNameResolver();
214        languageResolver = context.adapt(ExtendedCamelContext.class).getLanguageResolver();
215        dataFormatResolver = context.adapt(ExtendedCamelContext.class).getDataFormatResolver();
216        endpoints = context.getEndpointRegistry();
217        components = context.getComponentNames().stream().collect(Collectors.toMap(s -> s, context::hasComponent));
218        languages = context.getLanguageNames().stream().collect(Collectors.toMap(s -> s, context::resolveLanguage));
219        propertiesComponent = context.getPropertiesComponent();
220        beanIntrospection = context.adapt(ExtendedCamelContext.class).getBeanIntrospection();
221        headersMapFactory = context.adapt(ExtendedCamelContext.class).getHeadersMapFactory();
222        exchangeFactory = context.adapt(ExtendedCamelContext.class).getExchangeFactory();
223        exchangeFactoryManager = context.adapt(ExtendedCamelContext.class).getExchangeFactoryManager();
224        processorExchangeFactory = context.adapt(ExtendedCamelContext.class).getProcessorExchangeFactory();
225        reactiveExecutor = context.adapt(ExtendedCamelContext.class).getReactiveExecutor();
226        asyncProcessorAwaitManager = context.adapt(ExtendedCamelContext.class).getAsyncProcessorAwaitManager();
227        executorServiceManager = context.getExecutorServiceManager();
228        shutdownStrategy = context.getShutdownStrategy();
229        applicationContextClassLoader = context.getApplicationContextClassLoader();
230        unitOfWorkFactory = context.adapt(ExtendedCamelContext.class).getUnitOfWorkFactory();
231        processorFactory = context.adapt(ExtendedCamelContext.class).getProcessorFactory();
232        internalProcessorFactory = context.adapt(ExtendedCamelContext.class).getInternalProcessorFactory();
233        routeController = context.getRouteController();
234        inflightRepository = context.getInflightRepository();
235        globalOptions = context.getGlobalOptions();
236        injector = context.getInjector();
237        classResolver = context.getClassResolver();
238        name = context.getName();
239        eventNotificationApplicable = context.adapt(ExtendedCamelContext.class).isEventNotificationApplicable();
240        useDataType = context.isUseDataType();
241        useBreadcrumb = context.isUseBreadcrumb();
242        dumpRoutes = context.isDumpRoutes();
243        mdcLoggingKeysPattern = context.getMDCLoggingKeysPattern();
244        useMDCLogging = context.isUseMDCLogging();
245        messageHistory = context.isMessageHistory();
246        allowUseOriginalMessage = context.isAllowUseOriginalMessage();
247        logExhaustedMessageBody = context.isLogExhaustedMessageBody();
248        version = context.getVersion();
249        startupSummaryLevel = context.getStartupSummaryLevel();
250    }
251
252    /**
253     * Normalize uri so we can do endpoint hits with minor mistakes and parameters is not in the same order.
254     *
255     * @param  uri                            the uri
256     * @return                                normalized uri
257     * @throws ResolveEndpointFailedException if uri cannot be normalized
258     */
259    protected static String normalizeEndpointUri(String uri) {
260        try {
261            uri = URISupport.normalizeUri(uri);
262        } catch (Exception e) {
263            throw new ResolveEndpointFailedException(uri, e);
264        }
265        return uri;
266    }
267
268    //
269    // Lifecycle
270    //
271
272    public CamelContext getCamelContextReference() {
273        return reference;
274    }
275
276    @Override
277    public void disposeModel() {
278        // noop
279    }
280
281    @Override
282    public boolean isStarted() {
283        return false;
284    }
285
286    @Override
287    public boolean isStarting() {
288        return false;
289    }
290
291    @Override
292    public boolean isStopped() {
293        return false;
294    }
295
296    @Override
297    public boolean isStopping() {
298        return false;
299    }
300
301    @Override
302    public boolean isSuspended() {
303        return false;
304    }
305
306    @Override
307    public boolean isRunAllowed() {
308        return false;
309    }
310
311    @Override
312    public boolean isSuspending() {
313        return false;
314    }
315
316    @Override
317    public void build() {
318        throw new UnsupportedOperationException();
319    }
320
321    @Override
322    public void init() {
323        throw new UnsupportedOperationException();
324    }
325
326    @Override
327    public void suspend() {
328        throw new UnsupportedOperationException();
329    }
330
331    @Override
332    public void resume() {
333        throw new UnsupportedOperationException();
334    }
335
336    @Override
337    public void start() {
338        startDate = new Date();
339        LOG.info("Apache Camel {} ({}) is starting", getVersion(), getName());
340        for (Route route : routes) {
341            route.getConsumer().start();
342        }
343        if (LOG.isInfoEnabled()) {
344            long l = System.currentTimeMillis() - startDate.getTime();
345            LOG.info("Apache Camel {} ({}) {} routes started in {}",
346                    getVersion(), getName(), routes.size(), TimeUtils.printDuration(l));
347        }
348    }
349
350    @Override
351    public void stop() {
352        for (Route route : routes) {
353            route.getConsumer().stop();
354        }
355    }
356
357    @Override
358    public void shutdown() {
359    }
360
361    //
362    // RuntimeConfig
363    //
364
365    @Override
366    public void close() throws IOException {
367        stop();
368    }
369
370    @Override
371    public void setStreamCaching(Boolean cache) {
372        throw new UnsupportedOperationException();
373    }
374
375    @Override
376    public Boolean isStreamCaching() {
377        throw new UnsupportedOperationException();
378    }
379
380    @Override
381    public Boolean isTracing() {
382        throw new UnsupportedOperationException();
383    }
384
385    @Override
386    public String getTracingPattern() {
387        throw new UnsupportedOperationException();
388    }
389
390    @Override
391    public void setTracingPattern(String tracePattern) {
392        throw new UnsupportedOperationException();
393    }
394
395    @Override
396    public Boolean isBacklogTracing() {
397        throw new UnsupportedOperationException();
398    }
399
400    @Override
401    public Boolean isDebugging() {
402        throw new UnsupportedOperationException();
403    }
404
405    @Override
406    public Boolean isMessageHistory() {
407        return messageHistory;
408    }
409
410    @Override
411    public Boolean isLogMask() {
412        throw new UnsupportedOperationException();
413    }
414
415    @Override
416    public Boolean isLogExhaustedMessageBody() {
417        return logExhaustedMessageBody;
418    }
419
420    @Override
421    public Long getDelayer() {
422        throw new UnsupportedOperationException();
423    }
424
425    @Override
426    public void setDelayer(Long delay) {
427        throw new UnsupportedOperationException();
428    }
429
430    @Override
431    public Boolean isAutoStartup() {
432        throw new UnsupportedOperationException();
433    }
434
435    @Override
436    public ShutdownRoute getShutdownRoute() {
437        throw new UnsupportedOperationException();
438    }
439
440    @Override
441    public void setShutdownRoute(ShutdownRoute shutdownRoute) {
442        throw new UnsupportedOperationException();
443    }
444
445    @Override
446    public ShutdownRunningTask getShutdownRunningTask() {
447        throw new UnsupportedOperationException();
448    }
449
450    //
451    // Model
452    //
453
454    @Override
455    public void setShutdownRunningTask(ShutdownRunningTask shutdownRunningTask) {
456        throw new UnsupportedOperationException();
457    }
458
459    @Override
460    public void setAllowUseOriginalMessage(Boolean allowUseOriginalMessage) {
461        throw new UnsupportedOperationException();
462    }
463
464    @Override
465    public Boolean isAllowUseOriginalMessage() {
466        return allowUseOriginalMessage;
467    }
468
469    @Override
470    public Boolean isCaseInsensitiveHeaders() {
471        throw new UnsupportedOperationException();
472    }
473
474    @Override
475    public void setCaseInsensitiveHeaders(Boolean caseInsensitiveHeaders) {
476        throw new UnsupportedOperationException();
477    }
478
479    @Override
480    public Boolean isAutowiredEnabled() {
481        throw new UnsupportedOperationException();
482    }
483
484    @Override
485    public void setAutowiredEnabled(Boolean autowiredEnabled) {
486        throw new UnsupportedOperationException();
487    }
488
489    @Override
490    public Registry getRegistry() {
491        return registry;
492    }
493
494    @Override
495    public void setRegistry(Registry registry) {
496        throw new UnsupportedOperationException();
497    }
498
499    @Override
500    public TypeConverterRegistry getTypeConverterRegistry() {
501        return typeConverter;
502    }
503
504    @Override
505    public void setTypeConverterRegistry(TypeConverterRegistry typeConverterRegistry) {
506        throw new UnsupportedOperationException();
507    }
508
509    @Override
510    public ModelJAXBContextFactory getModelJAXBContextFactory() {
511        return modelJAXBContextFactory;
512    }
513
514    @Override
515    public void setModelJAXBContextFactory(ModelJAXBContextFactory modelJAXBContextFactory) {
516        throw new UnsupportedOperationException();
517    }
518
519    @Override
520    public ComponentResolver getComponentResolver() {
521        return componentResolver;
522    }
523
524    @Override
525    public void setComponentResolver(ComponentResolver componentResolver) {
526        throw new UnsupportedOperationException();
527    }
528
529    @Override
530    public ComponentNameResolver getComponentNameResolver() {
531        return componentNameResolver;
532    }
533
534    @Override
535    public void setComponentNameResolver(ComponentNameResolver componentResolver) {
536        throw new UnsupportedOperationException();
537    }
538
539    @Override
540    public LanguageResolver getLanguageResolver() {
541        return languageResolver;
542    }
543
544    @Override
545    public void setLanguageResolver(LanguageResolver languageResolver) {
546        throw new UnsupportedOperationException();
547    }
548
549    @Override
550    public DataFormatResolver getDataFormatResolver() {
551        return dataFormatResolver;
552    }
553
554    @Override
555    public void setDataFormatResolver(DataFormatResolver dataFormatResolver) {
556        throw new UnsupportedOperationException();
557    }
558
559    @Override
560    public UuidGenerator getUuidGenerator() {
561        return uuidGenerator;
562    }
563
564    @Override
565    public void setUuidGenerator(UuidGenerator uuidGenerator) {
566        throw new UnsupportedOperationException();
567    }
568
569    @Override
570    public <T extends CamelContext> T adapt(Class<T> type) {
571        if (type.isInstance(this)) {
572            return type.cast(this);
573        }
574        throw new UnsupportedOperationException();
575    }
576
577    @Override
578    public <T> T getExtension(Class<T> type) {
579        throw new UnsupportedOperationException();
580    }
581
582    @Override
583    public <T> void setExtension(Class<T> type, T module) {
584        throw new UnsupportedOperationException();
585    }
586
587    @Override
588    public boolean isVetoStarted() {
589        throw new UnsupportedOperationException();
590    }
591
592    @Override
593    public String getName() {
594        return name;
595    }
596
597    @Override
598    public void setName(String name) {
599        throw new UnsupportedOperationException();
600    }
601
602    @Override
603    public CamelContextNameStrategy getNameStrategy() {
604        throw new UnsupportedOperationException();
605    }
606
607    @Override
608    public void setNameStrategy(CamelContextNameStrategy nameStrategy) {
609        throw new UnsupportedOperationException();
610    }
611
612    @Override
613    public ManagementNameStrategy getManagementNameStrategy() {
614        throw new UnsupportedOperationException();
615    }
616
617    @Override
618    public void setManagementNameStrategy(ManagementNameStrategy nameStrategy) {
619        throw new UnsupportedOperationException();
620    }
621
622    @Override
623    public String getManagementName() {
624        throw new UnsupportedOperationException();
625    }
626
627    @Override
628    public void setManagementName(String name) {
629        throw new UnsupportedOperationException();
630    }
631
632    @Override
633    public String getVersion() {
634        return version;
635    }
636
637    @Override
638    public ServiceStatus getStatus() {
639        return ServiceStatus.Started;
640    }
641
642    @Override
643    public String getUptime() {
644        long delta = getUptimeMillis();
645        if (delta == 0) {
646            return "";
647        }
648        return TimeUtils.printDuration(delta);
649    }
650
651    @Override
652    public long getUptimeMillis() {
653        if (startDate == null) {
654            return 0;
655        }
656        return new Date().getTime() - startDate.getTime();
657    }
658
659    @Override
660    public Date getStartDate() {
661        return startDate;
662    }
663
664    @Override
665    public void addService(Object object) throws Exception {
666    }
667
668    @Override
669    public void addService(Object object, boolean stopOnShutdown) throws Exception {
670
671    }
672
673    @Override
674    public void addService(Object object, boolean stopOnShutdown, boolean forceStart) throws Exception {
675
676    }
677
678    @Override
679    public void addPrototypeService(Object object) throws Exception {
680
681    }
682
683    @Override
684    public boolean removeService(Object object) throws Exception {
685        return false;
686    }
687
688    @Override
689    public void addBootstrap(BootstrapCloseable bootstrap) {
690    }
691
692    @Override
693    public List<Service> getServices() {
694        return null;
695    }
696
697    @Override
698    public boolean hasService(Object object) {
699        return false;
700    }
701
702    @Override
703    public <T> T hasService(Class<T> type) {
704        return null;
705    }
706
707    @Override
708    public <T> Set<T> hasServices(Class<T> type) {
709        return null;
710    }
711
712    @Override
713    public void deferStartService(Object object, boolean stopOnShutdown) throws Exception {
714    }
715
716    @Override
717    public void addStartupListener(StartupListener listener) throws Exception {
718    }
719
720    @Override
721    public Component hasComponent(String componentName) {
722        return components.get(componentName);
723    }
724
725    @Override
726    public Component getComponent(String componentName) {
727        return getComponent(name, true, true);
728    }
729
730    @Override
731    public Component getComponent(String name, boolean autoCreateComponents) {
732        return getComponent(name, autoCreateComponents, true);
733    }
734
735    @Override
736    public Component getComponent(String name, boolean autoCreateComponents, boolean autoStart) {
737        return components.get(name);
738    }
739
740    @Override
741    public <T extends Component> T getComponent(String name, Class<T> componentType) {
742        return componentType.cast(hasComponent(name));
743    }
744
745    @Override
746    public List<String> getComponentNames() {
747        return new ArrayList<>(components.keySet());
748    }
749
750    @Override
751    public EndpointRegistry<? extends ValueHolder<String>> getEndpointRegistry() {
752        return endpoints;
753    }
754
755    @Override
756    public Endpoint getEndpoint(String uri) {
757        return doGetEndpoint(uri, false, false);
758    }
759
760    @Override
761    public Endpoint getEndpoint(String uri, Map<String, Object> parameters) {
762        return doGetEndpoint(uri, parameters, false);
763    }
764
765    @Override
766    public <T extends Endpoint> T getEndpoint(String name, Class<T> endpointType) {
767        Endpoint endpoint = getEndpoint(name);
768        if (endpoint == null) {
769            throw new NoSuchEndpointException(name);
770        }
771        if (endpoint instanceof InterceptSendToEndpoint) {
772            endpoint = ((InterceptSendToEndpoint) endpoint).getOriginalEndpoint();
773        }
774        if (endpointType.isInstance(endpoint)) {
775            return endpointType.cast(endpoint);
776        } else {
777            throw new IllegalArgumentException(
778                    "The endpoint is not of type: " + endpointType + " but is: " + endpoint.getClass().getCanonicalName());
779        }
780    }
781
782    @Override
783    public Collection<Endpoint> getEndpoints() {
784        return new ArrayList<>(endpoints.values());
785    }
786
787    @Override
788    public Map<String, Endpoint> getEndpointMap() {
789        throw new UnsupportedOperationException();
790    }
791
792    @Override
793    public Endpoint hasEndpoint(String uri) {
794        return endpoints.get(NormalizedUri.newNormalizedUri(uri, false));
795    }
796
797    @Override
798    public GlobalEndpointConfiguration getGlobalEndpointConfiguration() {
799        throw new UnsupportedOperationException();
800    }
801
802    @Override
803    public RouteController getRouteController() {
804        return routeController;
805    }
806
807    @Override
808    public void setRouteController(RouteController routeController) {
809        throw new UnsupportedOperationException();
810    }
811
812    @Override
813    public List<Route> getRoutes() {
814        return routes;
815    }
816
817    @Override
818    public int getRoutesSize() {
819        return routes.size();
820    }
821
822    @Override
823    public Route getRoute(String id) {
824        throw new UnsupportedOperationException();
825    }
826
827    @Override
828    public Processor getProcessor(String id) {
829        throw new UnsupportedOperationException();
830    }
831
832    @Override
833    public <T extends Processor> T getProcessor(String id, Class<T> type) {
834        throw new UnsupportedOperationException();
835    }
836
837    @Override
838    public List<RoutePolicyFactory> getRoutePolicyFactories() {
839        throw new UnsupportedOperationException();
840    }
841
842    @Override
843    public RestConfiguration getRestConfiguration() {
844        throw new UnsupportedOperationException();
845    }
846
847    @Override
848    public void setRestConfiguration(RestConfiguration restConfiguration) {
849        throw new UnsupportedOperationException();
850    }
851
852    @Override
853    public RestRegistry getRestRegistry() {
854        throw new UnsupportedOperationException();
855    }
856
857    @Override
858    public void setRestRegistry(RestRegistry restRegistry) {
859        throw new UnsupportedOperationException();
860    }
861
862    @Override
863    public TypeConverter getTypeConverter() {
864        return typeConverter;
865    }
866
867    @Override
868    public <T> T getRegistry(Class<T> type) {
869        return type.cast(registry);
870    }
871
872    @Override
873    public Injector getInjector() {
874        return injector;
875    }
876
877    @Override
878    public void setInjector(Injector injector) {
879        throw new UnsupportedOperationException();
880    }
881
882    @Override
883    public List<LifecycleStrategy> getLifecycleStrategies() {
884        throw new UnsupportedOperationException();
885    }
886
887    @Override
888    public Language resolveLanguage(String language) throws NoSuchLanguageException {
889        Language answer;
890        synchronized (languages) {
891            answer = languages.get(language);
892            // check if the language is singleton, if so return the shared
893            // instance
894            if (answer instanceof IsSingleton) {
895                boolean singleton = ((IsSingleton) answer).isSingleton();
896                if (singleton) {
897                    return answer;
898                }
899            }
900            // language not known or not singleton, then use resolver
901            answer = getLanguageResolver().resolveLanguage(language, reference);
902            // inject CamelContext if aware
903            if (answer != null) {
904                CamelContextAware.trySetCamelContext(answer, reference);
905                if (answer instanceof Service) {
906                    try {
907                        startService((Service) answer);
908                    } catch (Exception e) {
909                        throw RuntimeCamelException.wrapRuntimeCamelException(e);
910                    }
911                }
912                languages.put(language, answer);
913            }
914        }
915        return answer;
916    }
917
918    @Override
919    public String resolvePropertyPlaceholders(String text) {
920        return resolvePropertyPlaceholders(text, false);
921    }
922
923    @Override
924    public String resolvePropertyPlaceholders(String text, boolean keepUnresolvedOptional) {
925        if (text != null && text.contains(PropertiesComponent.PREFIX_TOKEN)) {
926            // the parser will throw exception if property key was not found
927            return getPropertiesComponent().parseUri(text, keepUnresolvedOptional);
928        }
929        // is the value a known field (currently we only support
930        // constants from Exchange.class)
931        if (text != null && text.startsWith("Exchange.")) {
932            String field = StringHelper.after(text, "Exchange.");
933            String constant = ExchangeConstantProvider.lookup(field);
934            if (constant != null) {
935                return constant;
936            } else {
937                throw new IllegalArgumentException("Constant field with name: " + field + " not found on Exchange.class");
938            }
939        }
940        // return original text as is
941        return text;
942    }
943
944    @Override
945    public PropertiesComponent getPropertiesComponent() {
946        return propertiesComponent;
947    }
948
949    @Override
950    public void setPropertiesComponent(PropertiesComponent propertiesComponent) {
951        throw new UnsupportedOperationException();
952    }
953
954    @Override
955    public List<String> getLanguageNames() {
956        throw new UnsupportedOperationException();
957    }
958
959    @Override
960    public ProducerTemplate createProducerTemplate() {
961        throw new UnsupportedOperationException();
962    }
963
964    @Override
965    public ProducerTemplate createProducerTemplate(int maximumCacheSize) {
966        throw new UnsupportedOperationException();
967    }
968
969    @Override
970    public FluentProducerTemplate createFluentProducerTemplate() {
971        throw new UnsupportedOperationException();
972    }
973
974    @Override
975    public FluentProducerTemplate createFluentProducerTemplate(int maximumCacheSize) {
976        throw new UnsupportedOperationException();
977    }
978
979    @Override
980    public ConsumerTemplate createConsumerTemplate() {
981        throw new UnsupportedOperationException();
982    }
983
984    @Override
985    public ConsumerTemplate createConsumerTemplate(int maximumCacheSize) {
986        throw new UnsupportedOperationException();
987    }
988
989    @Override
990    public DataFormat resolveDataFormat(String name) {
991        throw new UnsupportedOperationException();
992    }
993
994    @Override
995    public DataFormat createDataFormat(String name) {
996        throw new UnsupportedOperationException();
997    }
998
999    @Override
1000    public Transformer resolveTransformer(String model) {
1001        throw new UnsupportedOperationException();
1002    }
1003
1004    @Override
1005    public Transformer resolveTransformer(DataType from, DataType to) {
1006        throw new UnsupportedOperationException();
1007    }
1008
1009    @Override
1010    public TransformerRegistry getTransformerRegistry() {
1011        throw new UnsupportedOperationException();
1012    }
1013
1014    @Override
1015    public Validator resolveValidator(DataType type) {
1016        throw new UnsupportedOperationException();
1017    }
1018
1019    @Override
1020    public ValidatorRegistry getValidatorRegistry() {
1021        throw new UnsupportedOperationException();
1022    }
1023
1024    @Override
1025    public Map<String, String> getGlobalOptions() {
1026        return globalOptions;
1027    }
1028
1029    @Override
1030    public void setGlobalOptions(Map<String, String> globalOptions) {
1031        throw new UnsupportedOperationException();
1032    }
1033
1034    @Override
1035    public String getGlobalOption(String key) {
1036        String value = getGlobalOptions().get(key);
1037        if (ObjectHelper.isNotEmpty(value)) {
1038            try {
1039                value = resolvePropertyPlaceholders(value);
1040            } catch (Exception e) {
1041                throw new RuntimeCamelException("Error getting global option: " + key, e);
1042            }
1043        }
1044        return value;
1045    }
1046
1047    @Override
1048    public ClassResolver getClassResolver() {
1049        return classResolver;
1050    }
1051
1052    @Override
1053    public void setClassResolver(ClassResolver resolver) {
1054        throw new UnsupportedOperationException();
1055    }
1056
1057    @Override
1058    public ManagementStrategy getManagementStrategy() {
1059        return null;
1060    }
1061
1062    @Override
1063    public void setManagementStrategy(ManagementStrategy strategy) {
1064        throw new UnsupportedOperationException();
1065    }
1066
1067    @Override
1068    public void disableJMX() throws IllegalStateException {
1069        throw new UnsupportedOperationException();
1070    }
1071
1072    @Override
1073    public InflightRepository getInflightRepository() {
1074        return inflightRepository;
1075    }
1076
1077    @Override
1078    public void setInflightRepository(InflightRepository repository) {
1079        throw new UnsupportedOperationException();
1080    }
1081
1082    //
1083    // ExtendedCamelContext
1084    //
1085
1086    @Override
1087    public ClassLoader getApplicationContextClassLoader() {
1088        return applicationContextClassLoader;
1089    }
1090
1091    @Override
1092    public void setApplicationContextClassLoader(ClassLoader classLoader) {
1093        throw new UnsupportedOperationException();
1094    }
1095
1096    @Override
1097    public ShutdownStrategy getShutdownStrategy() {
1098        return shutdownStrategy;
1099    }
1100
1101    @Override
1102    public void setShutdownStrategy(ShutdownStrategy shutdownStrategy) {
1103        throw new UnsupportedOperationException();
1104    }
1105
1106    @Override
1107    public ExecutorServiceManager getExecutorServiceManager() {
1108        return executorServiceManager;
1109    }
1110
1111    @Override
1112    public void setExecutorServiceManager(ExecutorServiceManager executorServiceManager) {
1113        throw new UnsupportedOperationException();
1114    }
1115
1116    @Override
1117    public MessageHistoryFactory getMessageHistoryFactory() {
1118        throw new UnsupportedOperationException();
1119    }
1120
1121    @Override
1122    public void setMessageHistoryFactory(MessageHistoryFactory messageHistoryFactory) {
1123        throw new UnsupportedOperationException();
1124    }
1125
1126    @Override
1127    public Debugger getDebugger() {
1128        throw new UnsupportedOperationException();
1129    }
1130
1131    @Override
1132    public void setDebugger(Debugger debugger) {
1133        throw new UnsupportedOperationException();
1134    }
1135
1136    @Override
1137    public Tracer getTracer() {
1138        throw new UnsupportedOperationException();
1139    }
1140
1141    @Override
1142    public void setTracer(Tracer tracer) {
1143        throw new UnsupportedOperationException();
1144    }
1145
1146    @Override
1147    public Boolean isLoadTypeConverters() {
1148        throw new UnsupportedOperationException();
1149    }
1150
1151    @Override
1152    public void setLoadTypeConverters(Boolean loadTypeConverters) {
1153        throw new UnsupportedOperationException();
1154    }
1155
1156    @Override
1157    public Boolean isTypeConverterStatisticsEnabled() {
1158        throw new UnsupportedOperationException();
1159    }
1160
1161    @Override
1162    public void setTypeConverterStatisticsEnabled(Boolean typeConverterStatisticsEnabled) {
1163        throw new UnsupportedOperationException();
1164    }
1165
1166    @Override
1167    public Boolean isDumpRoutes() {
1168        return dumpRoutes;
1169    }
1170
1171    @Override
1172    public void setDumpRoutes(Boolean dumpRoutes) {
1173        throw new UnsupportedOperationException();
1174    }
1175
1176    @Override
1177    public Boolean isUseMDCLogging() {
1178        return useMDCLogging;
1179    }
1180
1181    @Override
1182    public void setUseMDCLogging(Boolean useMDCLogging) {
1183        throw new UnsupportedOperationException();
1184    }
1185
1186    @Override
1187    public String getMDCLoggingKeysPattern() {
1188        return mdcLoggingKeysPattern;
1189    }
1190
1191    @Override
1192    public void setMDCLoggingKeysPattern(String pattern) {
1193        throw new UnsupportedOperationException();
1194    }
1195
1196    @Override
1197    public Boolean isUseDataType() {
1198        return useDataType;
1199    }
1200
1201    @Override
1202    public void setUseDataType(Boolean useDataType) {
1203        throw new UnsupportedOperationException();
1204    }
1205
1206    @Override
1207    public Boolean isUseBreadcrumb() {
1208        return useBreadcrumb;
1209    }
1210
1211    @Override
1212    public void setUseBreadcrumb(Boolean useBreadcrumb) {
1213        throw new UnsupportedOperationException();
1214    }
1215
1216    @Override
1217    public StreamCachingStrategy getStreamCachingStrategy() {
1218        throw new UnsupportedOperationException();
1219    }
1220
1221    @Override
1222    public void setStreamCachingStrategy(StreamCachingStrategy streamCachingStrategy) {
1223        throw new UnsupportedOperationException();
1224    }
1225
1226    @Override
1227    public RuntimeEndpointRegistry getRuntimeEndpointRegistry() {
1228        throw new UnsupportedOperationException();
1229    }
1230
1231    @Override
1232    public void setRuntimeEndpointRegistry(RuntimeEndpointRegistry runtimeEndpointRegistry) {
1233        throw new UnsupportedOperationException();
1234    }
1235
1236    @Override
1237    public SSLContextParameters getSSLContextParameters() {
1238        throw new UnsupportedOperationException();
1239    }
1240
1241    @Override
1242    public void setSSLContextParameters(SSLContextParameters sslContextParameters) {
1243        throw new UnsupportedOperationException();
1244    }
1245
1246    @Override
1247    public void setStartupSummaryLevel(StartupSummaryLevel startupSummaryLevel) {
1248        throw new UnsupportedOperationException();
1249    }
1250
1251    @Override
1252    public StartupSummaryLevel getStartupSummaryLevel() {
1253        return startupSummaryLevel;
1254    }
1255
1256    @Override
1257    public Endpoint getPrototypeEndpoint(String uri) {
1258        throw new UnsupportedOperationException();
1259    }
1260
1261    @Override
1262    public Endpoint getPrototypeEndpoint(NormalizedEndpointUri uri) {
1263        throw new UnsupportedOperationException();
1264    }
1265
1266    @Override
1267    public Endpoint hasEndpoint(NormalizedEndpointUri uri) {
1268        return endpoints.get(uri);
1269    }
1270
1271    @Override
1272    public Endpoint getEndpoint(NormalizedEndpointUri uri) {
1273        return doGetEndpoint(uri.getUri(), true, false);
1274    }
1275
1276    @Override
1277    public Endpoint getEndpoint(NormalizedEndpointUri uri, Map<String, Object> parameters) {
1278        return doGetEndpoint(uri.getUri(), parameters, true);
1279    }
1280
1281    protected Endpoint doGetEndpoint(String uri, boolean normalized, boolean prototype) {
1282        StringHelper.notEmpty(uri, "uri");
1283        // in case path has property placeholders then try to let property
1284        // component resolve those
1285        if (!normalized) {
1286            try {
1287                uri = resolvePropertyPlaceholders(uri);
1288            } catch (Exception e) {
1289                throw new ResolveEndpointFailedException(uri, e);
1290            }
1291        }
1292        // normalize uri so we can do endpoint hits with minor mistakes and
1293        // parameters is not in the same order
1294        if (!normalized) {
1295            uri = normalizeEndpointUri(uri);
1296        }
1297        Endpoint answer = null;
1298        if (!prototype) {
1299            // use optimized method to get the endpoint uri
1300            NormalizedUri key = NormalizedUri.newNormalizedUri(uri, true);
1301            // only lookup and reuse existing endpoints if not prototype scoped
1302            answer = endpoints.get(key);
1303        }
1304        // unknown scheme
1305        if (answer == null) {
1306            throw new NoSuchEndpointException(uri);
1307        }
1308        return answer;
1309    }
1310
1311    protected Endpoint doGetEndpoint(String uri, Map<String, Object> parameters, boolean normalized) {
1312        StringHelper.notEmpty(uri, "uri");
1313        // in case path has property placeholders then try to let property
1314        // component resolve those
1315        if (!normalized) {
1316            try {
1317                uri = resolvePropertyPlaceholders(uri);
1318            } catch (Exception e) {
1319                throw new ResolveEndpointFailedException(uri, e);
1320            }
1321        }
1322        // normalize uri so we can do endpoint hits with minor mistakes and
1323        // parameters is not in the same order
1324        if (!normalized) {
1325            uri = normalizeEndpointUri(uri);
1326        }
1327        Endpoint answer;
1328        String scheme = null;
1329        // use optimized method to get the endpoint uri
1330        NormalizedUri key = NormalizedUri.newNormalizedUri(uri, true);
1331        answer = endpoints.get(key);
1332        // unknown scheme
1333        if (answer == null) {
1334            throw new ResolveEndpointFailedException(uri, "No component found with scheme: " + scheme);
1335        }
1336        return answer;
1337    }
1338
1339    @Override
1340    public NormalizedEndpointUri normalizeUri(String uri) {
1341        try {
1342            uri = resolvePropertyPlaceholders(uri);
1343            return NormalizedUri.newNormalizedUri(uri, false);
1344        } catch (Exception e) {
1345            throw new ResolveEndpointFailedException(uri, e);
1346        }
1347    }
1348
1349    //
1350    // CatalogCamelContext
1351    //
1352
1353    @Override
1354    public List<RouteStartupOrder> getRouteStartupOrder() {
1355        throw new UnsupportedOperationException();
1356    }
1357
1358    @Override
1359    public CamelBeanPostProcessor getBeanPostProcessor() {
1360        throw new UnsupportedOperationException();
1361    }
1362
1363    @Override
1364    public ManagementMBeanAssembler getManagementMBeanAssembler() {
1365        throw new UnsupportedOperationException();
1366    }
1367
1368    @Override
1369    public ErrorHandlerFactory getErrorHandlerFactory() {
1370        throw new UnsupportedOperationException();
1371    }
1372
1373    //
1374    // Unsupported mutable methods
1375    //
1376
1377    @Override
1378    public void setErrorHandlerFactory(ErrorHandlerFactory errorHandlerFactory) {
1379        throw new UnsupportedOperationException();
1380    }
1381
1382    @Override
1383    public PackageScanClassResolver getPackageScanClassResolver() {
1384        throw new UnsupportedOperationException();
1385    }
1386
1387    @Override
1388    public void setPackageScanClassResolver(PackageScanClassResolver resolver) {
1389        throw new UnsupportedOperationException();
1390    }
1391
1392    @Override
1393    public PackageScanResourceResolver getPackageScanResourceResolver() {
1394        throw new UnsupportedOperationException();
1395    }
1396
1397    @Override
1398    public void setPackageScanResourceResolver(PackageScanResourceResolver resolver) {
1399        throw new UnsupportedOperationException();
1400    }
1401
1402    @Override
1403    public FactoryFinder getDefaultFactoryFinder() {
1404        throw new UnsupportedOperationException();
1405    }
1406
1407    @Override
1408    public ConfigurerResolver getBootstrapConfigurerResolver() {
1409        throw new UnsupportedOperationException();
1410    }
1411
1412    @Override
1413    public void setBootstrapConfigurerResolver(ConfigurerResolver configurerResolver) {
1414        throw new UnsupportedOperationException();
1415    }
1416
1417    @Override
1418    public FactoryFinder getBootstrapFactoryFinder() {
1419        throw new UnsupportedOperationException();
1420    }
1421
1422    @Override
1423    public void setBootstrapFactoryFinder(FactoryFinder factoryFinder) {
1424        throw new UnsupportedOperationException();
1425    }
1426
1427    @Override
1428    public FactoryFinder getBootstrapFactoryFinder(String path) {
1429        throw new UnsupportedOperationException();
1430    }
1431
1432    @Override
1433    public FactoryFinder getFactoryFinder(String path) {
1434        throw new UnsupportedOperationException();
1435    }
1436
1437    @Override
1438    public FactoryFinderResolver getFactoryFinderResolver() {
1439        throw new UnsupportedOperationException();
1440    }
1441
1442    @Override
1443    public void setFactoryFinderResolver(FactoryFinderResolver resolver) {
1444        throw new UnsupportedOperationException();
1445    }
1446
1447    @Override
1448    public ProcessorFactory getProcessorFactory() {
1449        return processorFactory;
1450    }
1451
1452    @Override
1453    public void setProcessorFactory(ProcessorFactory processorFactory) {
1454        throw new UnsupportedOperationException();
1455    }
1456
1457    @Override
1458    public InternalProcessorFactory getInternalProcessorFactory() {
1459        return internalProcessorFactory;
1460    }
1461
1462    @Override
1463    public void setInternalProcessorFactory(InternalProcessorFactory internalProcessorFactory) {
1464        throw new UnsupportedOperationException();
1465    }
1466
1467    @Override
1468    public InterceptEndpointFactory getInterceptEndpointFactory() {
1469        throw new UnsupportedOperationException();
1470    }
1471
1472    @Override
1473    public void setInterceptEndpointFactory(InterceptEndpointFactory interceptEndpointFactory) {
1474        throw new UnsupportedOperationException();
1475    }
1476
1477    @Override
1478    public RouteFactory getRouteFactory() {
1479        throw new UnsupportedOperationException();
1480    }
1481
1482    @Override
1483    public void setRouteFactory(RouteFactory routeFactory) {
1484        throw new UnsupportedOperationException();
1485    }
1486
1487    @Override
1488    public DeferServiceFactory getDeferServiceFactory() {
1489        throw new UnsupportedOperationException();
1490    }
1491
1492    @Override
1493    public void setDeferServiceFactory(DeferServiceFactory deferServiceFactory) {
1494        throw new UnsupportedOperationException();
1495    }
1496
1497    @Override
1498    public UnitOfWorkFactory getUnitOfWorkFactory() {
1499        return unitOfWorkFactory;
1500    }
1501
1502    @Override
1503    public void setUnitOfWorkFactory(UnitOfWorkFactory unitOfWorkFactory) {
1504        throw new UnsupportedOperationException();
1505    }
1506
1507    @Override
1508    public AnnotationBasedProcessorFactory getAnnotationBasedProcessorFactory() {
1509        throw new UnsupportedOperationException();
1510    }
1511
1512    @Override
1513    public void setAnnotationBasedProcessorFactory(AnnotationBasedProcessorFactory annotationBasedProcessorFactory) {
1514        throw new UnsupportedOperationException();
1515    }
1516
1517    @Override
1518    public BeanProxyFactory getBeanProxyFactory() {
1519        throw new UnsupportedOperationException();
1520    }
1521
1522    @Override
1523    public BeanProcessorFactory getBeanProcessorFactory() {
1524        throw new UnsupportedOperationException();
1525    }
1526
1527    @Override
1528    public ScheduledExecutorService getErrorHandlerExecutorService() {
1529        throw new UnsupportedOperationException();
1530    }
1531
1532    @Override
1533    public List<InterceptStrategy> getInterceptStrategies() {
1534        throw new UnsupportedOperationException();
1535    }
1536
1537    @Override
1538    public Set<LogListener> getLogListeners() {
1539        throw new UnsupportedOperationException();
1540    }
1541
1542    @Override
1543    public AsyncProcessorAwaitManager getAsyncProcessorAwaitManager() {
1544        return asyncProcessorAwaitManager;
1545    }
1546
1547    @Override
1548    public void setAsyncProcessorAwaitManager(AsyncProcessorAwaitManager manager) {
1549        throw new UnsupportedOperationException();
1550    }
1551
1552    @Override
1553    public BeanIntrospection getBeanIntrospection() {
1554        return beanIntrospection;
1555    }
1556
1557    @Override
1558    public void setBeanIntrospection(BeanIntrospection beanIntrospection) {
1559        throw new UnsupportedOperationException();
1560    }
1561
1562    @Override
1563    public HeadersMapFactory getHeadersMapFactory() {
1564        return headersMapFactory;
1565    }
1566
1567    @Override
1568    public void setHeadersMapFactory(HeadersMapFactory factory) {
1569        throw new UnsupportedOperationException();
1570    }
1571
1572    @Override
1573    public ExchangeFactory getExchangeFactory() {
1574        return exchangeFactory;
1575    }
1576
1577    @Override
1578    public ExchangeFactoryManager getExchangeFactoryManager() {
1579        return exchangeFactoryManager;
1580    }
1581
1582    @Override
1583    public void setExchangeFactoryManager(ExchangeFactoryManager exchangeFactoryManager) {
1584        throw new UnsupportedOperationException();
1585    }
1586
1587    @Override
1588    public void setExchangeFactory(ExchangeFactory exchangeFactory) {
1589        throw new UnsupportedOperationException();
1590    }
1591
1592    @Override
1593    public ProcessorExchangeFactory getProcessorExchangeFactory() {
1594        return processorExchangeFactory;
1595    }
1596
1597    @Override
1598    public void setProcessorExchangeFactory(ProcessorExchangeFactory processorExchangeFactory) {
1599        throw new UnsupportedOperationException();
1600    }
1601
1602    @Override
1603    public ReactiveExecutor getReactiveExecutor() {
1604        return reactiveExecutor;
1605    }
1606
1607    @Override
1608    public void setReactiveExecutor(ReactiveExecutor reactiveExecutor) {
1609        throw new UnsupportedOperationException();
1610    }
1611
1612    @Override
1613    public boolean isEventNotificationApplicable() {
1614        return eventNotificationApplicable;
1615    }
1616
1617    @Override
1618    public void setEventNotificationApplicable(boolean eventNotificationApplicable) {
1619        throw new UnsupportedOperationException();
1620    }
1621
1622    @Override
1623    public ModelToXMLDumper getModelToXMLDumper() {
1624        throw new UnsupportedOperationException();
1625    }
1626
1627    @Override
1628    public void setModelToXMLDumper(ModelToXMLDumper modelToXMLDumper) {
1629        throw new UnsupportedOperationException();
1630    }
1631
1632    @Override
1633    public RuntimeCamelCatalog getRuntimeCamelCatalog() {
1634        throw new UnsupportedOperationException();
1635    }
1636
1637    @Override
1638    public void setRuntimeCamelCatalog(RuntimeCamelCatalog runtimeCamelCatalog) {
1639        throw new UnsupportedOperationException();
1640    }
1641
1642    @Override
1643    public ConfigurerResolver getConfigurerResolver() {
1644        throw new UnsupportedOperationException();
1645    }
1646
1647    @Override
1648    public void setConfigurerResolver(ConfigurerResolver configurerResolver) {
1649        throw new UnsupportedOperationException();
1650    }
1651
1652    @Override
1653    public void addRoute(Route route) {
1654        throw new UnsupportedOperationException();
1655    }
1656
1657    @Override
1658    public void removeRoute(Route route) {
1659        throw new UnsupportedOperationException();
1660    }
1661
1662    @Override
1663    public Processor createErrorHandler(Route route, Processor processor) throws Exception {
1664        // TODO: need to revisit this in order to support dynamic endpoints uri
1665        throw new UnsupportedOperationException();
1666    }
1667
1668    @Override
1669    public String getComponentParameterJsonSchema(String componentName) throws IOException {
1670        Class<?> clazz;
1671        Object instance = getRegistry().lookupByNameAndType(componentName, Component.class);
1672        if (instance != null) {
1673            clazz = instance.getClass();
1674        } else {
1675            clazz = getFactoryFinder(DefaultComponentResolver.RESOURCE_PATH).findClass(componentName).orElse(null);
1676            if (clazz == null) {
1677                instance = hasComponent(componentName);
1678                if (instance != null) {
1679                    clazz = instance.getClass();
1680                } else {
1681                    return null;
1682                }
1683            }
1684        }
1685        // special for ActiveMQ as it is really just JMS
1686        if ("ActiveMQComponent".equals(clazz.getSimpleName())) {
1687            return getComponentParameterJsonSchema("jms");
1688        } else {
1689            return getJsonSchema(clazz.getPackage().getName(), componentName);
1690        }
1691    }
1692
1693    @Override
1694    public String getDataFormatParameterJsonSchema(String dataFormatName) throws IOException {
1695        Class<?> clazz;
1696        Object instance = getRegistry().lookupByNameAndType(dataFormatName, DataFormat.class);
1697        if (instance != null) {
1698            clazz = instance.getClass();
1699        } else {
1700            clazz = getFactoryFinder(DefaultDataFormatResolver.DATAFORMAT_RESOURCE_PATH).findClass(dataFormatName).orElse(null);
1701            if (clazz == null) {
1702                return null;
1703            }
1704        }
1705        return getJsonSchema(clazz.getPackage().getName(), dataFormatName);
1706    }
1707
1708    @Override
1709    public String getLanguageParameterJsonSchema(String languageName) throws IOException {
1710        Class<?> clazz;
1711        Object instance = getRegistry().lookupByNameAndType(languageName, Language.class);
1712        if (instance != null) {
1713            clazz = instance.getClass();
1714        } else {
1715            clazz = getFactoryFinder(DefaultLanguageResolver.LANGUAGE_RESOURCE_PATH).findClass(languageName).orElse(null);
1716            if (clazz == null) {
1717                return null;
1718            }
1719        }
1720        return getJsonSchema(clazz.getPackage().getName(), languageName);
1721    }
1722
1723    @Override
1724    public String getEipParameterJsonSchema(String eipName) throws IOException {
1725        // the eip json schema may be in some of the sub-packages so look until
1726        // we find it
1727        String[] subPackages = new String[] { "", "/config", "/dataformat", "/language", "/loadbalancer", "/rest" };
1728        for (String sub : subPackages) {
1729            String path = CamelContextHelper.MODEL_DOCUMENTATION_PREFIX + sub + "/" + eipName + ".json";
1730            InputStream inputStream = getClassResolver().loadResourceAsStream(path);
1731            if (inputStream != null) {
1732                try {
1733                    return IOHelper.loadText(inputStream);
1734                } finally {
1735                    IOHelper.close(inputStream);
1736                }
1737            }
1738        }
1739        return null;
1740    }
1741
1742    private String getJsonSchema(String packageName, String name) throws IOException {
1743        String path = packageName.replace('.', '/') + "/" + name + ".json";
1744        InputStream inputStream = getClassResolver().loadResourceAsStream(path);
1745        if (inputStream != null) {
1746            try {
1747                return IOHelper.loadText(inputStream);
1748            } finally {
1749                IOHelper.close(inputStream);
1750            }
1751        }
1752        return null;
1753    }
1754
1755    @Override
1756    public void setupRoutes(boolean done) {
1757        throw new UnsupportedOperationException();
1758    }
1759
1760    @Override
1761    public boolean isSetupRoutes() {
1762        return false;
1763    }
1764
1765    @Override
1766    public void addInterceptStrategy(InterceptStrategy interceptStrategy) {
1767        throw new UnsupportedOperationException();
1768    }
1769
1770    @Override
1771    public void setupManagement(Map<String, Object> options) {
1772        throw new UnsupportedOperationException();
1773    }
1774
1775    @Override
1776    public void addLogListener(LogListener listener) {
1777        throw new UnsupportedOperationException();
1778    }
1779
1780    @Override
1781    public RestBindingJaxbDataFormatFactory getRestBindingJaxbDataFormatFactory() {
1782        throw new UnsupportedOperationException();
1783    }
1784
1785    @Override
1786    public void setRestBindingJaxbDataFormatFactory(RestBindingJaxbDataFormatFactory restBindingJaxbDataFormatFactory) {
1787        throw new UnsupportedOperationException();
1788    }
1789
1790    @Override
1791    public XMLRoutesDefinitionLoader getXMLRoutesDefinitionLoader() {
1792        throw new UnsupportedOperationException();
1793    }
1794
1795    @Override
1796    public void setXMLRoutesDefinitionLoader(XMLRoutesDefinitionLoader xmlRoutesDefinitionLoader) {
1797        throw new UnsupportedOperationException();
1798    }
1799
1800    @Override
1801    public void setRoutesLoader(RoutesLoader routesLoader) {
1802        throw new UnsupportedOperationException();
1803    }
1804
1805    @Override
1806    public RoutesLoader getRoutesLoader() {
1807        throw new UnsupportedOperationException();
1808    }
1809
1810    @Override
1811    public ResourceLoader getResourceLoader() {
1812        throw new UnsupportedOperationException();
1813    }
1814
1815    @Override
1816    public void setResourceLoader(ResourceLoader resourceLoader) {
1817        throw new UnsupportedOperationException();
1818    }
1819
1820    @Override
1821    public void registerEndpointCallback(EndpointStrategy strategy) {
1822        throw new UnsupportedOperationException();
1823    }
1824
1825    @Override
1826    public Endpoint addEndpoint(String uri, Endpoint endpoint) throws Exception {
1827        throw new UnsupportedOperationException();
1828    }
1829
1830    @Override
1831    public void removeEndpoint(Endpoint endpoint) throws Exception {
1832        throw new UnsupportedOperationException();
1833    }
1834
1835    @Override
1836    public Collection<Endpoint> removeEndpoints(String pattern) throws Exception {
1837        throw new UnsupportedOperationException();
1838    }
1839
1840    @Override
1841    public NodeIdFactory getNodeIdFactory() {
1842        throw new UnsupportedOperationException();
1843    }
1844
1845    @Override
1846    public void setNodeIdFactory(NodeIdFactory factory) {
1847        throw new UnsupportedOperationException();
1848    }
1849
1850    @Override
1851    public void addComponent(String componentName, Component component) {
1852        throw new UnsupportedOperationException();
1853    }
1854
1855    @Override
1856    public Component removeComponent(String componentName) {
1857        throw new UnsupportedOperationException();
1858    }
1859
1860    @Override
1861    public void addRoutes(RoutesBuilder builder) throws Exception {
1862        throw new UnsupportedOperationException();
1863    }
1864
1865    @Override
1866    public boolean removeRoute(String routeId) throws Exception {
1867        throw new UnsupportedOperationException();
1868    }
1869
1870    @Override
1871    public void addRoutePolicyFactory(RoutePolicyFactory routePolicyFactory) {
1872        throw new UnsupportedOperationException();
1873    }
1874
1875    @Override
1876    public void setTracing(Boolean tracing) {
1877        throw new UnsupportedOperationException();
1878    }
1879
1880    @Override
1881    public void setBacklogTracing(Boolean backlogTrace) {
1882        throw new UnsupportedOperationException();
1883    }
1884
1885    @Override
1886    public void setDebugging(Boolean debugging) {
1887        throw new UnsupportedOperationException();
1888    }
1889
1890    @Override
1891    public void setMessageHistory(Boolean messageHistory) {
1892        throw new UnsupportedOperationException();
1893    }
1894
1895    @Override
1896    public void setLogMask(Boolean logMask) {
1897        throw new UnsupportedOperationException();
1898    }
1899
1900    @Override
1901    public void setLogExhaustedMessageBody(Boolean logExhaustedMessageBody) {
1902        throw new UnsupportedOperationException();
1903    }
1904
1905    @Override
1906    public void setAutoStartup(Boolean autoStartup) {
1907        throw new UnsupportedOperationException();
1908    }
1909
1910    @Override
1911    public void addLifecycleStrategy(LifecycleStrategy lifecycleStrategy) {
1912        throw new UnsupportedOperationException();
1913    }
1914
1915    @Override
1916    public String addRouteFromTemplate(String routeId, String routeTemplateId, Map<String, Object> parameters)
1917            throws Exception {
1918        throw new UnsupportedOperationException();
1919    }
1920
1921    @Override
1922    public String addRouteFromTemplate(String routeId, String routeTemplateId, RouteTemplateContext routeTemplateContext)
1923            throws Exception {
1924        throw new UnsupportedOperationException();
1925    }
1926
1927    @Override
1928    public void setLightweight(boolean lightweight) {
1929        throw new UnsupportedOperationException();
1930    }
1931
1932    @Override
1933    public boolean isLightweight() {
1934        return true;
1935    }
1936
1937    @Override
1938    public String getTestExcludeRoutes() {
1939        return null;
1940    }
1941
1942    @Override
1943    public RouteController getInternalRouteController() {
1944        return new RouteController() {
1945            @Override
1946            public LoggingLevel getLoggingLevel() {
1947                throw new UnsupportedOperationException();
1948            }
1949
1950            @Override
1951            public void setLoggingLevel(LoggingLevel loggingLevel) {
1952                throw new UnsupportedOperationException();
1953            }
1954
1955            @Override
1956            public boolean isSupervising() {
1957                return false;
1958            }
1959
1960            @Override
1961            public SupervisingRouteController supervising() {
1962                throw new UnsupportedOperationException();
1963            }
1964
1965            @Override
1966            public <T extends RouteController> T adapt(Class<T> type) {
1967                return type.cast(this);
1968            }
1969
1970            @Override
1971            public Collection<Route> getControlledRoutes() {
1972                return routes;
1973            }
1974
1975            @Override
1976            public void startAllRoutes() throws Exception {
1977                throw new UnsupportedOperationException();
1978            }
1979
1980            @Override
1981            public boolean isStartingRoutes() {
1982                return false;
1983            }
1984
1985            @Override
1986            public ServiceStatus getRouteStatus(String routeId) {
1987                return ServiceStatus.Started;
1988            }
1989
1990            @Override
1991            public void startRoute(String routeId) throws Exception {
1992                throw new UnsupportedOperationException();
1993            }
1994
1995            @Override
1996            public void stopRoute(String routeId) throws Exception {
1997                throw new UnsupportedOperationException();
1998            }
1999
2000            @Override
2001            public void stopRoute(String routeId, long timeout, TimeUnit timeUnit) throws Exception {
2002                throw new UnsupportedOperationException();
2003            }
2004
2005            @Override
2006            public boolean stopRoute(String routeId, long timeout, TimeUnit timeUnit, boolean abortAfterTimeout)
2007                    throws Exception {
2008                throw new UnsupportedOperationException();
2009            }
2010
2011            @Override
2012            public void suspendRoute(String routeId) throws Exception {
2013                throw new UnsupportedOperationException();
2014            }
2015
2016            @Override
2017            public void suspendRoute(String routeId, long timeout, TimeUnit timeUnit) throws Exception {
2018                throw new UnsupportedOperationException();
2019            }
2020
2021            @Override
2022            public void resumeRoute(String routeId) throws Exception {
2023                throw new UnsupportedOperationException();
2024            }
2025
2026            @Override
2027            public CamelContext getCamelContext() {
2028                throw new UnsupportedOperationException();
2029            }
2030
2031            @Override
2032            public void setCamelContext(CamelContext camelContext) {
2033                throw new UnsupportedOperationException();
2034            }
2035
2036            @Override
2037            public void start() {
2038                throw new UnsupportedOperationException();
2039            }
2040
2041            @Override
2042            public void stop() {
2043                throw new UnsupportedOperationException();
2044            }
2045        };
2046    }
2047
2048    @Override
2049    public UriFactoryResolver getUriFactoryResolver() {
2050        throw new UnsupportedOperationException();
2051    }
2052
2053    @Override
2054    public void setUriFactoryResolver(UriFactoryResolver uriFactoryResolver) {
2055        throw new UnsupportedOperationException();
2056    }
2057
2058    @Override
2059    public EndpointUriFactory getEndpointUriFactory(String scheme) {
2060        throw new UnsupportedOperationException();
2061    }
2062
2063    @Override
2064    public StartupStepRecorder getStartupStepRecorder() {
2065        throw new UnsupportedOperationException();
2066    }
2067
2068    @Override
2069    public void setStartupStepRecorder(StartupStepRecorder startupStepRecorder) {
2070        throw new UnsupportedOperationException();
2071    }
2072
2073    private void startService(Service service) throws Exception {
2074        // and register startup aware so they can be notified when
2075        // camel context has been started
2076        if (service instanceof StartupListener) {
2077            StartupListener listener = (StartupListener) service;
2078            addStartupListener(listener);
2079        }
2080        CamelContextAware.trySetCamelContext(service, reference);
2081        service.start();
2082    }
2083}