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