Source code

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