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