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