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