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.model.cloud; 018 019import javax.xml.bind.annotation.XmlAccessType; 020import javax.xml.bind.annotation.XmlAccessorType; 021import javax.xml.bind.annotation.XmlAttribute; 022import javax.xml.bind.annotation.XmlElement; 023import javax.xml.bind.annotation.XmlElements; 024import javax.xml.bind.annotation.XmlRootElement; 025import javax.xml.bind.annotation.XmlTransient; 026 027import org.apache.camel.ExchangePattern; 028import org.apache.camel.Expression; 029import org.apache.camel.builder.ExpressionClause; 030import org.apache.camel.cloud.ServiceChooser; 031import org.apache.camel.cloud.ServiceDiscovery; 032import org.apache.camel.cloud.ServiceFilter; 033import org.apache.camel.cloud.ServiceLoadBalancer; 034import org.apache.camel.model.IdentifiedType; 035import org.apache.camel.spi.Metadata; 036 037/** 038 * Remote service call configuration 039 */ 040@Metadata(label = "routing,cloud") 041@XmlRootElement(name = "serviceCallConfiguration") 042@XmlAccessorType(XmlAccessType.FIELD) 043public class ServiceCallConfigurationDefinition extends IdentifiedType { 044 @XmlAttribute 045 private String uri; 046 @XmlAttribute @Metadata(defaultValue = ServiceCallDefinitionConstants.DEFAULT_COMPONENT) 047 private String component; 048 @XmlAttribute 049 private ExchangePattern pattern; 050 @XmlAttribute 051 private String serviceDiscoveryRef; 052 @XmlTransient 053 private ServiceDiscovery serviceDiscovery; 054 @XmlAttribute 055 private String serviceFilterRef; 056 @XmlTransient 057 private ServiceFilter serviceFilter; 058 @XmlAttribute 059 private String serviceChooserRef; 060 @XmlTransient 061 private ServiceChooser serviceChooser; 062 @XmlAttribute 063 private String loadBalancerRef; 064 @XmlTransient 065 private ServiceLoadBalancer loadBalancer; 066 @XmlAttribute 067 private String expressionRef; 068 @XmlTransient 069 private Expression expression; 070 @XmlElements({ 071 @XmlElement(name = "cachingServiceDiscovery", type = CachingServiceCallServiceDiscoveryConfiguration.class), 072 @XmlElement(name = "aggregatingServiceDiscovery", type = AggregatingServiceCallServiceDiscoveryConfiguration.class), 073 @XmlElement(name = "consulServiceDiscovery", type = ConsulServiceCallServiceDiscoveryConfiguration.class), 074 @XmlElement(name = "dnsServiceDiscovery", type = DnsServiceCallServiceDiscoveryConfiguration.class), 075 @XmlElement(name = "etcdServiceDiscovery", type = EtcdServiceCallServiceDiscoveryConfiguration.class), 076 @XmlElement(name = "kubernetesServiceDiscovery", type = KubernetesServiceCallServiceDiscoveryConfiguration.class), 077 @XmlElement(name = "staticServiceDiscovery", type = StaticServiceCallServiceDiscoveryConfiguration.class), 078 @XmlElement(name = "zookeeperServiceDiscovery", type = ZooKeeperServiceCallServiceDiscoveryConfiguration.class)} 079 ) 080 private ServiceCallServiceDiscoveryConfiguration serviceDiscoveryConfiguration; 081 082 @XmlElements({ 083 @XmlElement(name = "blacklistServiceFilter", type = BlacklistServiceCallServiceFilterConfiguration.class), 084 @XmlElement(name = "chainedServiceFilter", type = ChainedServiceCallServiceFilterConfiguration.class), 085 @XmlElement(name = "customServiceFilter", type = CustomServiceCallServiceFilterConfiguration.class), 086 @XmlElement(name = "healthyServiceFilter", type = HealthyServiceCallServiceFilterConfiguration.class), 087 @XmlElement(name = "passThroughServiceFilter", type = PassThroughServiceCallServiceFilterConfiguration.class)} 088 ) 089 private ServiceCallServiceFilterConfiguration serviceFilterConfiguration; 090 091 @XmlElements({ 092 @XmlElement(name = "ribbonLoadBalancer", type = RibbonServiceCallServiceLoadBalancerConfiguration.class), 093 @XmlElement(name = "defaultLoadBalancer", type = DefaultServiceCallServiceLoadBalancerConfiguration.class) } 094 ) 095 private ServiceCallServiceLoadBalancerConfiguration loadBalancerConfiguration; 096 097 @XmlElements({ 098 @XmlElement(name = "expression", type = ServiceCallExpressionConfiguration.class)} 099 ) 100 private ServiceCallExpressionConfiguration expressionConfiguration; 101 102 public ServiceCallConfigurationDefinition() { 103 } 104 105 // ***************************** 106 // Properties 107 // ***************************** 108 109 public ExchangePattern getPattern() { 110 return pattern; 111 } 112 113 public void setPattern(ExchangePattern pattern) { 114 this.pattern = pattern; 115 } 116 117 public String getUri() { 118 return uri; 119 } 120 121 /** 122 * The uri of the endpoint to send to. 123 * The uri can be dynamic computed using the {@link org.apache.camel.language.simple.SimpleLanguage} expression. 124 */ 125 public void setUri(String uri) { 126 this.uri = uri; 127 } 128 129 public String getComponent() { 130 return component; 131 } 132 133 /** 134 * The component to use. 135 */ 136 public void setComponent(String component) { 137 this.component = component; 138 } 139 140 public String getServiceDiscoveryRef() { 141 return serviceDiscoveryRef; 142 } 143 144 /** 145 * Sets a reference to a custom {@link ServiceDiscovery} to use. 146 */ 147 public void setServiceDiscoveryRef(String serviceDiscoveryRef) { 148 this.serviceDiscoveryRef = serviceDiscoveryRef; 149 } 150 151 public ServiceDiscovery getServiceDiscovery() { 152 return serviceDiscovery; 153 } 154 155 /** 156 * Sets a custom {@link ServiceDiscovery} to use. 157 */ 158 public void setServiceDiscovery(ServiceDiscovery serviceDiscovery) { 159 this.serviceDiscovery = serviceDiscovery; 160 } 161 162 public String getServiceFilterRef() { 163 return serviceFilterRef; 164 } 165 166 /** 167 * Sets a reference to a custom {@link ServiceFilter} to use. 168 */ 169 public void setServiceFilterRef(String serviceFilterRef) { 170 this.serviceFilterRef = serviceFilterRef; 171 } 172 173 public ServiceFilter getServiceFilter() { 174 return serviceFilter; 175 } 176 177 /** 178 * Sets a custom {@link ServiceFilter} to use. 179 */ 180 public void setServiceFilter(ServiceFilter serviceFilter) { 181 this.serviceFilter = serviceFilter; 182 } 183 184 public String getServiceChooserRef() { 185 return serviceChooserRef; 186 } 187 188 /** 189 * Sets a reference to a custom {@link ServiceChooser} to use. 190 */ 191 public void setServiceChooserRef(String serviceChooserRef) { 192 this.serviceChooserRef = serviceChooserRef; 193 } 194 195 public ServiceChooser getServiceChooser() { 196 return serviceChooser; 197 } 198 199 /** 200 * Sets a custom {@link ServiceChooser} to use. 201 */ 202 public void setServiceChooser(ServiceChooser serviceChooser) { 203 this.serviceChooser = serviceChooser; 204 } 205 206 public String getLoadBalancerRef() { 207 return loadBalancerRef; 208 } 209 210 /** 211 * Sets a reference to a custom {@link ServiceLoadBalancer} to use. 212 */ 213 public void setLoadBalancerRef(String loadBalancerRef) { 214 this.loadBalancerRef = loadBalancerRef; 215 } 216 217 public ServiceLoadBalancer getLoadBalancer() { 218 return loadBalancer; 219 } 220 221 /** 222 * Sets a custom {@link ServiceLoadBalancer} to use. 223 */ 224 public void setLoadBalancer(ServiceLoadBalancer loadBalancer) { 225 this.loadBalancer = loadBalancer; 226 } 227 228 public String getExpressionRef() { 229 return expressionRef; 230 } 231 232 /** 233 * Set a reference to a custom {@link Expression} to use. 234 */ 235 public void setExpressionRef(String expressionRef) { 236 this.expressionRef = expressionRef; 237 } 238 239 public Expression getExpression() { 240 return expression; 241 } 242 243 /** 244 * Set a custom {@link Expression} to use. 245 */ 246 public void setExpression(Expression expression) { 247 this.expression = expression; 248 } 249 250 public ServiceCallServiceDiscoveryConfiguration getServiceDiscoveryConfiguration() { 251 return serviceDiscoveryConfiguration; 252 } 253 254 /** 255 * Configures the ServiceDiscovery using the given configuration. 256 */ 257 public void setServiceDiscoveryConfiguration(ServiceCallServiceDiscoveryConfiguration serviceDiscoveryConfiguration) { 258 this.serviceDiscoveryConfiguration = serviceDiscoveryConfiguration; 259 } 260 261 public ServiceCallServiceFilterConfiguration getServiceFilterConfiguration() { 262 return serviceFilterConfiguration; 263 } 264 265 /** 266 * Configures the ServiceFilter using the given configuration. 267 */ 268 public void setServiceFilterConfiguration(ServiceCallServiceFilterConfiguration serviceFilterConfiguration) { 269 this.serviceFilterConfiguration = serviceFilterConfiguration; 270 } 271 272 public ServiceCallServiceLoadBalancerConfiguration getLoadBalancerConfiguration() { 273 return loadBalancerConfiguration; 274 } 275 276 /** 277 * Configures theL oadBalancer using the given configuration. 278 */ 279 public void setLoadBalancerConfiguration(ServiceCallServiceLoadBalancerConfiguration loadBalancerConfiguration) { 280 this.loadBalancerConfiguration = loadBalancerConfiguration; 281 } 282 283 public ServiceCallExpressionConfiguration getExpressionConfiguration() { 284 return expressionConfiguration; 285 } 286 287 /** 288 * Configures the Expression using the given configuration. 289 */ 290 public void setExpressionConfiguration(ServiceCallExpressionConfiguration expressionConfiguration) { 291 this.expressionConfiguration = expressionConfiguration; 292 } 293 294 // ***************************** 295 // Fluent API 296 // ***************************** 297 298 /** 299 * Sets the default Camel component to use for calling the remote service. 300 * <p/> 301 * By default the http component is used. You can configure this to use <tt>netty4-http</tt>, <tt>jetty</tt>, 302 * <tt>restlet</tt> or some other components of choice. If the service is not HTTP protocol you can use other 303 * components such as <tt>mqtt</tt>, <tt>jms</tt>, <tt>amqp</tt> etc. 304 * <p/> 305 * If the service call has been configured using an uri, then the component from the uri is used instead 306 * of this default component. 307 */ 308 public ServiceCallConfigurationDefinition component(String component) { 309 setComponent(component); 310 return this; 311 } 312 313 /** 314 * Sets the uri of the service to use 315 */ 316 public ServiceCallConfigurationDefinition uri(String uri) { 317 setUri(uri); 318 return this; 319 } 320 321 /** 322 * Sets the optional {@link ExchangePattern} used to invoke this endpoint 323 */ 324 public ServiceCallConfigurationDefinition pattern(ExchangePattern pattern) { 325 setPattern(pattern); 326 return this; 327 } 328 329 /** 330 * Sets a reference to a custom {@link ServiceDiscovery} to use. 331 */ 332 public ServiceCallConfigurationDefinition serviceDiscovery(String serviceDiscoveryRef) { 333 setServiceDiscoveryRef(serviceDiscoveryRef); 334 return this; 335 } 336 337 /** 338 * Sets a custom {@link ServiceDiscovery} to use. 339 */ 340 public ServiceCallConfigurationDefinition serviceDiscovery(ServiceDiscovery serviceDiscovery) { 341 setServiceDiscovery(serviceDiscovery); 342 return this; 343 } 344 345 /** 346 * Sets a reference to a custom {@link ServiceFilter} to use. 347 */ 348 public ServiceCallConfigurationDefinition serviceFilter(String serviceFilterRef) { 349 setServiceDiscoveryRef(serviceDiscoveryRef); 350 return this; 351 } 352 353 /** 354 * Sets a custom {@link ServiceFilter} to use. 355 */ 356 public ServiceCallConfigurationDefinition serviceFilter(ServiceFilter serviceFilter) { 357 setServiceFilter(serviceFilter); 358 return this; 359 } 360 361 /** 362 * Sets a reference to a custom {@link ServiceChooser} to use. 363 */ 364 public ServiceCallConfigurationDefinition serviceChooser(String serviceChooserRef) { 365 setServiceChooserRef(serviceChooserRef); 366 return this; 367 } 368 369 /** 370 * Sets a custom {@link ServiceChooser} to use. 371 */ 372 public ServiceCallConfigurationDefinition serviceChooser(ServiceChooser serviceChooser) { 373 setServiceChooser(serviceChooser); 374 return this; 375 } 376 377 /** 378 * Sets a reference to a custom {@link ServiceLoadBalancer} to use. 379 */ 380 public ServiceCallConfigurationDefinition loadBalancer(String loadBalancerRef) { 381 setLoadBalancerRef(loadBalancerRef); 382 return this; 383 } 384 385 /** 386 * Sets a custom {@link ServiceLoadBalancer} to use. 387 */ 388 public ServiceCallConfigurationDefinition loadBalancer(ServiceLoadBalancer loadBalancer) { 389 setLoadBalancer(loadBalancer); 390 return this; 391 } 392 393 /** 394 * Sets a reference to a custom {@link Expression} to use. 395 */ 396 public ServiceCallConfigurationDefinition expression(String expressionRef) { 397 setExpressionRef(loadBalancerRef); 398 return this; 399 } 400 401 /** 402 * Sets a custom {@link Expression} to use. 403 */ 404 public ServiceCallConfigurationDefinition expression(Expression expression) { 405 setExpression(expression); 406 return this; 407 } 408 409 /** 410 * Sets a custom {@link Expression} to use through an expression builder clause. 411 * 412 * @return a expression builder clause to set the body 413 */ 414 public ExpressionClause<ServiceCallConfigurationDefinition> expression() { 415 ExpressionClause<ServiceCallConfigurationDefinition> clause = new ExpressionClause<>(this); 416 setExpression(clause); 417 418 return clause; 419 } 420 421 /** 422 * Configures the ServiceDiscovery using the given configuration. 423 */ 424 public ServiceCallConfigurationDefinition serviceDiscoveryConfiguration(ServiceCallServiceDiscoveryConfiguration serviceDiscoveryConfiguration) { 425 setServiceDiscoveryConfiguration(serviceDiscoveryConfiguration); 426 return this; 427 } 428 429 /** 430 * Configures the ServiceFilter using the given configuration. 431 */ 432 public ServiceCallConfigurationDefinition serviceFilterConfiguration(ServiceCallServiceFilterConfiguration serviceFilterConfiguration) { 433 setServiceFilterConfiguration(serviceFilterConfiguration); 434 return this; 435 } 436 437 /** 438 * Configures the LoadBalancer using the given configuration. 439 */ 440 public ServiceCallConfigurationDefinition loadBalancerConfiguration(ServiceCallServiceLoadBalancerConfiguration loadBalancerConfiguration) { 441 setLoadBalancerConfiguration(loadBalancerConfiguration); 442 return this; 443 } 444 445 /** 446 * Configures the Expression using the given configuration. 447 */ 448 public ServiceCallConfigurationDefinition expressionConfiguration(ServiceCallExpressionConfiguration expressionConfiguration) { 449 setExpressionConfiguration(expressionConfiguration); 450 return this; 451 } 452 453 // ***************************** 454 // Shortcuts - ServiceDiscovery 455 // ***************************** 456 457 public CachingServiceCallServiceDiscoveryConfiguration cachingServiceDiscovery() { 458 CachingServiceCallServiceDiscoveryConfiguration conf = new CachingServiceCallServiceDiscoveryConfiguration(); 459 setServiceDiscoveryConfiguration(conf); 460 461 return conf; 462 } 463 464 public ConsulServiceCallServiceDiscoveryConfiguration consulServiceDiscovery() { 465 ConsulServiceCallServiceDiscoveryConfiguration conf = new ConsulServiceCallServiceDiscoveryConfiguration(); 466 setServiceDiscoveryConfiguration(conf); 467 468 return conf; 469 } 470 471 public DnsServiceCallServiceDiscoveryConfiguration dnsServiceDiscovery() { 472 DnsServiceCallServiceDiscoveryConfiguration conf = new DnsServiceCallServiceDiscoveryConfiguration(); 473 setServiceDiscoveryConfiguration(conf); 474 475 return conf; 476 } 477 478 public ServiceCallConfigurationDefinition dnsServiceDiscovery(String domain) { 479 DnsServiceCallServiceDiscoveryConfiguration conf = new DnsServiceCallServiceDiscoveryConfiguration(); 480 conf.setDomain(domain); 481 482 setServiceDiscoveryConfiguration(conf); 483 484 return this; 485 } 486 487 public ServiceCallConfigurationDefinition dnsServiceDiscovery(String domain, String protocol) { 488 DnsServiceCallServiceDiscoveryConfiguration conf = new DnsServiceCallServiceDiscoveryConfiguration(); 489 conf.setDomain(domain); 490 conf.setProto(protocol); 491 492 setServiceDiscoveryConfiguration(conf); 493 494 return this; 495 } 496 497 public EtcdServiceCallServiceDiscoveryConfiguration etcdServiceDiscovery() { 498 EtcdServiceCallServiceDiscoveryConfiguration conf = new EtcdServiceCallServiceDiscoveryConfiguration(); 499 setServiceDiscoveryConfiguration(conf); 500 501 return conf; 502 } 503 504 public KubernetesServiceCallServiceDiscoveryConfiguration kubernetesServiceDiscovery() { 505 KubernetesServiceCallServiceDiscoveryConfiguration conf = new KubernetesServiceCallServiceDiscoveryConfiguration(); 506 setServiceDiscoveryConfiguration(conf); 507 508 return conf; 509 } 510 511 public KubernetesServiceCallServiceDiscoveryConfiguration kubernetesClientServiceDiscovery() { 512 KubernetesServiceCallServiceDiscoveryConfiguration conf = new KubernetesServiceCallServiceDiscoveryConfiguration(); 513 conf.setLookup("client"); 514 515 setServiceDiscoveryConfiguration(conf); 516 517 return conf; 518 } 519 520 public ServiceCallConfigurationDefinition kubernetesEnvServiceDiscovery() { 521 KubernetesServiceCallServiceDiscoveryConfiguration conf = new KubernetesServiceCallServiceDiscoveryConfiguration(); 522 conf.setLookup("environment"); 523 524 setServiceDiscoveryConfiguration(conf); 525 526 return this; 527 } 528 529 public ServiceCallConfigurationDefinition kubernetesDnsServiceDiscovery(String namespace, String domain) { 530 KubernetesServiceCallServiceDiscoveryConfiguration conf = new KubernetesServiceCallServiceDiscoveryConfiguration(); 531 532 conf.setNamespace(namespace); 533 conf.setDnsDomain(domain); 534 535 setServiceDiscoveryConfiguration(conf); 536 537 return this; 538 } 539 540 public AggregatingServiceCallServiceDiscoveryConfiguration multiServiceDiscovery() { 541 AggregatingServiceCallServiceDiscoveryConfiguration conf = new AggregatingServiceCallServiceDiscoveryConfiguration(); 542 setServiceDiscoveryConfiguration(conf); 543 544 return conf; 545 } 546 547 public ServiceCallConfigurationDefinition multiServiceDiscovery(AggregatingServiceCallServiceDiscoveryConfiguration conf) { 548 setServiceDiscoveryConfiguration(conf); 549 550 return this; 551 } 552 553 public StaticServiceCallServiceDiscoveryConfiguration staticServiceDiscovery() { 554 StaticServiceCallServiceDiscoveryConfiguration conf = new StaticServiceCallServiceDiscoveryConfiguration(); 555 setServiceDiscoveryConfiguration(conf); 556 557 return conf; 558 } 559 560 public ServiceCallConfigurationDefinition staticServiceDiscovery(StaticServiceCallServiceDiscoveryConfiguration conf) { 561 setServiceDiscoveryConfiguration(conf); 562 563 return this; 564 } 565 566 public ZooKeeperServiceCallServiceDiscoveryConfiguration zookeeperServiceDiscovery() { 567 ZooKeeperServiceCallServiceDiscoveryConfiguration conf = new ZooKeeperServiceCallServiceDiscoveryConfiguration(); 568 setServiceDiscoveryConfiguration(conf); 569 570 return conf; 571 } 572 573 public ServiceCallConfigurationDefinition zookeeperServiceDiscovery(String nodes, String basePath) { 574 ZooKeeperServiceCallServiceDiscoveryConfiguration conf = new ZooKeeperServiceCallServiceDiscoveryConfiguration(); 575 conf.setNodes(nodes); 576 conf.setBasePath(basePath); 577 578 setServiceDiscoveryConfiguration(conf); 579 580 return this; 581 } 582 583 // ***************************** 584 // Shortcuts - ServiceFilter 585 // ***************************** 586 587 public ServiceCallConfigurationDefinition healthyFilter() { 588 HealthyServiceCallServiceFilterConfiguration conf = new HealthyServiceCallServiceFilterConfiguration(); 589 setServiceFilterConfiguration(conf); 590 591 return this; 592 } 593 594 public ServiceCallConfigurationDefinition passThroughFilter() { 595 PassThroughServiceCallServiceFilterConfiguration conf = new PassThroughServiceCallServiceFilterConfiguration(); 596 setServiceFilterConfiguration(conf); 597 598 return this; 599 } 600 601 public ChainedServiceCallServiceFilterConfiguration multiFilter() { 602 ChainedServiceCallServiceFilterConfiguration conf = new ChainedServiceCallServiceFilterConfiguration(); 603 setServiceFilterConfiguration(conf); 604 605 return conf; 606 } 607 608 public BlacklistServiceCallServiceFilterConfiguration blacklistFilter() { 609 BlacklistServiceCallServiceFilterConfiguration conf = new BlacklistServiceCallServiceFilterConfiguration(); 610 setServiceFilterConfiguration(conf); 611 612 return conf; 613 } 614 615 public ServiceCallConfigurationDefinition customFilter(String serviceFilter) { 616 CustomServiceCallServiceFilterConfiguration conf = new CustomServiceCallServiceFilterConfiguration(); 617 conf.setServiceFilterRef(serviceFilter); 618 619 setServiceFilterConfiguration(conf); 620 621 return this; 622 } 623 624 public ServiceCallConfigurationDefinition customFilter(ServiceFilter serviceFilter) { 625 CustomServiceCallServiceFilterConfiguration conf = new CustomServiceCallServiceFilterConfiguration(); 626 conf.setServiceFilter(serviceFilter); 627 628 setServiceFilterConfiguration(conf); 629 630 return this; 631 } 632 633 // ***************************** 634 // Shortcuts - LoadBalancer 635 // ***************************** 636 637 public ServiceCallConfigurationDefinition defaultLoadBalancer() { 638 DefaultServiceCallServiceLoadBalancerConfiguration conf = new DefaultServiceCallServiceLoadBalancerConfiguration(); 639 setLoadBalancerConfiguration(conf); 640 641 return this; 642 } 643 644 public ServiceCallConfigurationDefinition ribbonLoadBalancer() { 645 RibbonServiceCallServiceLoadBalancerConfiguration conf = new RibbonServiceCallServiceLoadBalancerConfiguration(); 646 setLoadBalancerConfiguration(conf); 647 648 return this; 649 } 650 651 public ServiceCallConfigurationDefinition ribbonLoadBalancer(String clientName) { 652 RibbonServiceCallServiceLoadBalancerConfiguration conf = new RibbonServiceCallServiceLoadBalancerConfiguration(); 653 conf.setClientName(clientName); 654 655 setLoadBalancerConfiguration(conf); 656 657 return this; 658 } 659}