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