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