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