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