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