1 /* 2 * Copyright 2020 Google LLC 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * https://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 // Generated by the protocol buffer compiler. DO NOT EDIT! 17 // source: google/cloud/compute/v1/compute.proto 18 19 package com.google.cloud.compute.v1; 20 21 /** 22 * 23 * 24 * <pre> 25 * Represents a Backend Service resource. A backend service defines how Google Cloud load balancers distribute traffic. The backend service configuration contains a set of values, such as the protocol used to connect to backends, various distribution and session settings, health checks, and timeouts. These settings provide fine-grained control over how your load balancer behaves. Most of the settings have default values that allow for easy configuration if you need to get started quickly. Backend services in Google Compute Engine can be either regionally or globally scoped. * [Global](https://cloud.google.com/compute/docs/reference/rest/v1/backendServices) * [Regional](https://cloud.google.com/compute/docs/reference/rest/v1/regionBackendServices) For more information, see Backend Services. 26 * </pre> 27 * 28 * Protobuf type {@code google.cloud.compute.v1.BackendService} 29 */ 30 public final class BackendService extends com.google.protobuf.GeneratedMessageV3 31 implements 32 // @@protoc_insertion_point(message_implements:google.cloud.compute.v1.BackendService) 33 BackendServiceOrBuilder { 34 private static final long serialVersionUID = 0L; 35 // Use BackendService.newBuilder() to construct. BackendService(com.google.protobuf.GeneratedMessageV3.Builder<?> builder)36 private BackendService(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) { 37 super(builder); 38 } 39 BackendService()40 private BackendService() { 41 backends_ = java.util.Collections.emptyList(); 42 compressionMode_ = ""; 43 creationTimestamp_ = ""; 44 customRequestHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY; 45 customResponseHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY; 46 description_ = ""; 47 edgeSecurityPolicy_ = ""; 48 fingerprint_ = ""; 49 healthChecks_ = com.google.protobuf.LazyStringArrayList.EMPTY; 50 kind_ = ""; 51 loadBalancingScheme_ = ""; 52 localityLbPolicies_ = java.util.Collections.emptyList(); 53 localityLbPolicy_ = ""; 54 name_ = ""; 55 network_ = ""; 56 portName_ = ""; 57 protocol_ = ""; 58 region_ = ""; 59 securityPolicy_ = ""; 60 selfLink_ = ""; 61 serviceBindings_ = com.google.protobuf.LazyStringArrayList.EMPTY; 62 sessionAffinity_ = ""; 63 } 64 65 @java.lang.Override 66 @SuppressWarnings({"unused"}) newInstance(UnusedPrivateParameter unused)67 protected java.lang.Object newInstance(UnusedPrivateParameter unused) { 68 return new BackendService(); 69 } 70 71 @java.lang.Override getUnknownFields()72 public final com.google.protobuf.UnknownFieldSet getUnknownFields() { 73 return this.unknownFields; 74 } 75 getDescriptor()76 public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { 77 return com.google.cloud.compute.v1.Compute 78 .internal_static_google_cloud_compute_v1_BackendService_descriptor; 79 } 80 81 @java.lang.Override 82 protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()83 internalGetFieldAccessorTable() { 84 return com.google.cloud.compute.v1.Compute 85 .internal_static_google_cloud_compute_v1_BackendService_fieldAccessorTable 86 .ensureFieldAccessorsInitialized( 87 com.google.cloud.compute.v1.BackendService.class, 88 com.google.cloud.compute.v1.BackendService.Builder.class); 89 } 90 91 /** 92 * 93 * 94 * <pre> 95 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 96 * </pre> 97 * 98 * Protobuf enum {@code google.cloud.compute.v1.BackendService.CompressionMode} 99 */ 100 public enum CompressionMode implements com.google.protobuf.ProtocolMessageEnum { 101 /** 102 * 103 * 104 * <pre> 105 * A value indicating that the enum field is not set. 106 * </pre> 107 * 108 * <code>UNDEFINED_COMPRESSION_MODE = 0;</code> 109 */ 110 UNDEFINED_COMPRESSION_MODE(0), 111 /** 112 * 113 * 114 * <pre> 115 * Automatically uses the best compression based on the Accept-Encoding header sent by the client. 116 * </pre> 117 * 118 * <code>AUTOMATIC = 165298699;</code> 119 */ 120 AUTOMATIC(165298699), 121 /** 122 * 123 * 124 * <pre> 125 * Disables compression. Existing compressed responses cached by Cloud CDN will not be served to clients. 126 * </pre> 127 * 128 * <code>DISABLED = 516696700;</code> 129 */ 130 DISABLED(516696700), 131 UNRECOGNIZED(-1), 132 ; 133 134 /** 135 * 136 * 137 * <pre> 138 * A value indicating that the enum field is not set. 139 * </pre> 140 * 141 * <code>UNDEFINED_COMPRESSION_MODE = 0;</code> 142 */ 143 public static final int UNDEFINED_COMPRESSION_MODE_VALUE = 0; 144 /** 145 * 146 * 147 * <pre> 148 * Automatically uses the best compression based on the Accept-Encoding header sent by the client. 149 * </pre> 150 * 151 * <code>AUTOMATIC = 165298699;</code> 152 */ 153 public static final int AUTOMATIC_VALUE = 165298699; 154 /** 155 * 156 * 157 * <pre> 158 * Disables compression. Existing compressed responses cached by Cloud CDN will not be served to clients. 159 * </pre> 160 * 161 * <code>DISABLED = 516696700;</code> 162 */ 163 public static final int DISABLED_VALUE = 516696700; 164 getNumber()165 public final int getNumber() { 166 if (this == UNRECOGNIZED) { 167 throw new java.lang.IllegalArgumentException( 168 "Can't get the number of an unknown enum value."); 169 } 170 return value; 171 } 172 173 /** 174 * @param value The numeric wire value of the corresponding enum entry. 175 * @return The enum associated with the given numeric wire value. 176 * @deprecated Use {@link #forNumber(int)} instead. 177 */ 178 @java.lang.Deprecated valueOf(int value)179 public static CompressionMode valueOf(int value) { 180 return forNumber(value); 181 } 182 183 /** 184 * @param value The numeric wire value of the corresponding enum entry. 185 * @return The enum associated with the given numeric wire value. 186 */ forNumber(int value)187 public static CompressionMode forNumber(int value) { 188 switch (value) { 189 case 0: 190 return UNDEFINED_COMPRESSION_MODE; 191 case 165298699: 192 return AUTOMATIC; 193 case 516696700: 194 return DISABLED; 195 default: 196 return null; 197 } 198 } 199 internalGetValueMap()200 public static com.google.protobuf.Internal.EnumLiteMap<CompressionMode> internalGetValueMap() { 201 return internalValueMap; 202 } 203 204 private static final com.google.protobuf.Internal.EnumLiteMap<CompressionMode> 205 internalValueMap = 206 new com.google.protobuf.Internal.EnumLiteMap<CompressionMode>() { 207 public CompressionMode findValueByNumber(int number) { 208 return CompressionMode.forNumber(number); 209 } 210 }; 211 getValueDescriptor()212 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 213 if (this == UNRECOGNIZED) { 214 throw new java.lang.IllegalStateException( 215 "Can't get the descriptor of an unrecognized enum value."); 216 } 217 return getDescriptor().getValues().get(ordinal()); 218 } 219 getDescriptorForType()220 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 221 return getDescriptor(); 222 } 223 getDescriptor()224 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 225 return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(0); 226 } 227 228 private static final CompressionMode[] VALUES = values(); 229 valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)230 public static CompressionMode valueOf( 231 com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 232 if (desc.getType() != getDescriptor()) { 233 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 234 } 235 if (desc.getIndex() == -1) { 236 return UNRECOGNIZED; 237 } 238 return VALUES[desc.getIndex()]; 239 } 240 241 private final int value; 242 CompressionMode(int value)243 private CompressionMode(int value) { 244 this.value = value; 245 } 246 247 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.CompressionMode) 248 } 249 250 /** 251 * 252 * 253 * <pre> 254 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 255 * </pre> 256 * 257 * Protobuf enum {@code google.cloud.compute.v1.BackendService.LoadBalancingScheme} 258 */ 259 public enum LoadBalancingScheme implements com.google.protobuf.ProtocolMessageEnum { 260 /** 261 * 262 * 263 * <pre> 264 * A value indicating that the enum field is not set. 265 * </pre> 266 * 267 * <code>UNDEFINED_LOAD_BALANCING_SCHEME = 0;</code> 268 */ 269 UNDEFINED_LOAD_BALANCING_SCHEME(0), 270 /** 271 * 272 * 273 * <pre> 274 * Signifies that this will be used for external HTTP(S), SSL Proxy, TCP Proxy, or Network Load Balancing 275 * </pre> 276 * 277 * <code>EXTERNAL = 35607499;</code> 278 */ 279 EXTERNAL(35607499), 280 /** 281 * 282 * 283 * <pre> 284 * Signifies that this will be used for External Managed HTTP(S) Load Balancing. 285 * </pre> 286 * 287 * <code>EXTERNAL_MANAGED = 512006923;</code> 288 */ 289 EXTERNAL_MANAGED(512006923), 290 /** 291 * 292 * 293 * <pre> 294 * Signifies that this will be used for Internal TCP/UDP Load Balancing. 295 * </pre> 296 * 297 * <code>INTERNAL = 279295677;</code> 298 */ 299 INTERNAL(279295677), 300 /** 301 * 302 * 303 * <pre> 304 * Signifies that this will be used for Internal HTTP(S) Load Balancing. 305 * </pre> 306 * 307 * <code>INTERNAL_MANAGED = 37350397;</code> 308 */ 309 INTERNAL_MANAGED(37350397), 310 /** 311 * 312 * 313 * <pre> 314 * Signifies that this will be used by Traffic Director. 315 * </pre> 316 * 317 * <code>INTERNAL_SELF_MANAGED = 236211150;</code> 318 */ 319 INTERNAL_SELF_MANAGED(236211150), 320 /** <code>INVALID_LOAD_BALANCING_SCHEME = 275352060;</code> */ 321 INVALID_LOAD_BALANCING_SCHEME(275352060), 322 UNRECOGNIZED(-1), 323 ; 324 325 /** 326 * 327 * 328 * <pre> 329 * A value indicating that the enum field is not set. 330 * </pre> 331 * 332 * <code>UNDEFINED_LOAD_BALANCING_SCHEME = 0;</code> 333 */ 334 public static final int UNDEFINED_LOAD_BALANCING_SCHEME_VALUE = 0; 335 /** 336 * 337 * 338 * <pre> 339 * Signifies that this will be used for external HTTP(S), SSL Proxy, TCP Proxy, or Network Load Balancing 340 * </pre> 341 * 342 * <code>EXTERNAL = 35607499;</code> 343 */ 344 public static final int EXTERNAL_VALUE = 35607499; 345 /** 346 * 347 * 348 * <pre> 349 * Signifies that this will be used for External Managed HTTP(S) Load Balancing. 350 * </pre> 351 * 352 * <code>EXTERNAL_MANAGED = 512006923;</code> 353 */ 354 public static final int EXTERNAL_MANAGED_VALUE = 512006923; 355 /** 356 * 357 * 358 * <pre> 359 * Signifies that this will be used for Internal TCP/UDP Load Balancing. 360 * </pre> 361 * 362 * <code>INTERNAL = 279295677;</code> 363 */ 364 public static final int INTERNAL_VALUE = 279295677; 365 /** 366 * 367 * 368 * <pre> 369 * Signifies that this will be used for Internal HTTP(S) Load Balancing. 370 * </pre> 371 * 372 * <code>INTERNAL_MANAGED = 37350397;</code> 373 */ 374 public static final int INTERNAL_MANAGED_VALUE = 37350397; 375 /** 376 * 377 * 378 * <pre> 379 * Signifies that this will be used by Traffic Director. 380 * </pre> 381 * 382 * <code>INTERNAL_SELF_MANAGED = 236211150;</code> 383 */ 384 public static final int INTERNAL_SELF_MANAGED_VALUE = 236211150; 385 /** <code>INVALID_LOAD_BALANCING_SCHEME = 275352060;</code> */ 386 public static final int INVALID_LOAD_BALANCING_SCHEME_VALUE = 275352060; 387 getNumber()388 public final int getNumber() { 389 if (this == UNRECOGNIZED) { 390 throw new java.lang.IllegalArgumentException( 391 "Can't get the number of an unknown enum value."); 392 } 393 return value; 394 } 395 396 /** 397 * @param value The numeric wire value of the corresponding enum entry. 398 * @return The enum associated with the given numeric wire value. 399 * @deprecated Use {@link #forNumber(int)} instead. 400 */ 401 @java.lang.Deprecated valueOf(int value)402 public static LoadBalancingScheme valueOf(int value) { 403 return forNumber(value); 404 } 405 406 /** 407 * @param value The numeric wire value of the corresponding enum entry. 408 * @return The enum associated with the given numeric wire value. 409 */ forNumber(int value)410 public static LoadBalancingScheme forNumber(int value) { 411 switch (value) { 412 case 0: 413 return UNDEFINED_LOAD_BALANCING_SCHEME; 414 case 35607499: 415 return EXTERNAL; 416 case 512006923: 417 return EXTERNAL_MANAGED; 418 case 279295677: 419 return INTERNAL; 420 case 37350397: 421 return INTERNAL_MANAGED; 422 case 236211150: 423 return INTERNAL_SELF_MANAGED; 424 case 275352060: 425 return INVALID_LOAD_BALANCING_SCHEME; 426 default: 427 return null; 428 } 429 } 430 431 public static com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme> internalGetValueMap()432 internalGetValueMap() { 433 return internalValueMap; 434 } 435 436 private static final com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme> 437 internalValueMap = 438 new com.google.protobuf.Internal.EnumLiteMap<LoadBalancingScheme>() { 439 public LoadBalancingScheme findValueByNumber(int number) { 440 return LoadBalancingScheme.forNumber(number); 441 } 442 }; 443 getValueDescriptor()444 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 445 if (this == UNRECOGNIZED) { 446 throw new java.lang.IllegalStateException( 447 "Can't get the descriptor of an unrecognized enum value."); 448 } 449 return getDescriptor().getValues().get(ordinal()); 450 } 451 getDescriptorForType()452 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 453 return getDescriptor(); 454 } 455 getDescriptor()456 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 457 return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(1); 458 } 459 460 private static final LoadBalancingScheme[] VALUES = values(); 461 valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)462 public static LoadBalancingScheme valueOf( 463 com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 464 if (desc.getType() != getDescriptor()) { 465 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 466 } 467 if (desc.getIndex() == -1) { 468 return UNRECOGNIZED; 469 } 470 return VALUES[desc.getIndex()]; 471 } 472 473 private final int value; 474 LoadBalancingScheme(int value)475 private LoadBalancingScheme(int value) { 476 this.value = value; 477 } 478 479 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.LoadBalancingScheme) 480 } 481 482 /** 483 * 484 * 485 * <pre> 486 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 487 * </pre> 488 * 489 * Protobuf enum {@code google.cloud.compute.v1.BackendService.LocalityLbPolicy} 490 */ 491 public enum LocalityLbPolicy implements com.google.protobuf.ProtocolMessageEnum { 492 /** 493 * 494 * 495 * <pre> 496 * A value indicating that the enum field is not set. 497 * </pre> 498 * 499 * <code>UNDEFINED_LOCALITY_LB_POLICY = 0;</code> 500 */ 501 UNDEFINED_LOCALITY_LB_POLICY(0), 502 /** <code>INVALID_LB_POLICY = 323318707;</code> */ 503 INVALID_LB_POLICY(323318707), 504 /** 505 * 506 * 507 * <pre> 508 * An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. 509 * </pre> 510 * 511 * <code>LEAST_REQUEST = 46604921;</code> 512 */ 513 LEAST_REQUEST(46604921), 514 /** 515 * 516 * 517 * <pre> 518 * This algorithm implements consistent hashing to backends. Maglev can be used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 519 * </pre> 520 * 521 * <code>MAGLEV = 119180266;</code> 522 */ 523 MAGLEV(119180266), 524 /** 525 * 526 * 527 * <pre> 528 * Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. 529 * </pre> 530 * 531 * <code>ORIGINAL_DESTINATION = 166297216;</code> 532 */ 533 ORIGINAL_DESTINATION(166297216), 534 /** 535 * 536 * 537 * <pre> 538 * The load balancer selects a random healthy host. 539 * </pre> 540 * 541 * <code>RANDOM = 262527171;</code> 542 */ 543 RANDOM(262527171), 544 /** 545 * 546 * 547 * <pre> 548 * The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. 549 * </pre> 550 * 551 * <code>RING_HASH = 432795069;</code> 552 */ 553 RING_HASH(432795069), 554 /** 555 * 556 * 557 * <pre> 558 * This is a simple policy in which each healthy backend is selected in round robin order. This is the default. 559 * </pre> 560 * 561 * <code>ROUND_ROBIN = 153895801;</code> 562 */ 563 ROUND_ROBIN(153895801), 564 /** 565 * 566 * 567 * <pre> 568 * Per-instance weighted Load Balancing via health check reported weights. If set, the Backend Service must configure a non legacy HTTP-based Health Check, and health check replies are expected to contain non-standard HTTP response header field X-Load-Balancing-Endpoint-Weight to specify the per-instance weights. If set, Load Balancing is weighted based on the per-instance weights reported in the last processed health check replies, as long as every instance either reported a valid weight or had UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains equal-weight. This option is only supported in Network Load Balancing. 569 * </pre> 570 * 571 * <code>WEIGHTED_MAGLEV = 254930962;</code> 572 */ 573 WEIGHTED_MAGLEV(254930962), 574 UNRECOGNIZED(-1), 575 ; 576 577 /** 578 * 579 * 580 * <pre> 581 * A value indicating that the enum field is not set. 582 * </pre> 583 * 584 * <code>UNDEFINED_LOCALITY_LB_POLICY = 0;</code> 585 */ 586 public static final int UNDEFINED_LOCALITY_LB_POLICY_VALUE = 0; 587 /** <code>INVALID_LB_POLICY = 323318707;</code> */ 588 public static final int INVALID_LB_POLICY_VALUE = 323318707; 589 /** 590 * 591 * 592 * <pre> 593 * An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. 594 * </pre> 595 * 596 * <code>LEAST_REQUEST = 46604921;</code> 597 */ 598 public static final int LEAST_REQUEST_VALUE = 46604921; 599 /** 600 * 601 * 602 * <pre> 603 * This algorithm implements consistent hashing to backends. Maglev can be used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 604 * </pre> 605 * 606 * <code>MAGLEV = 119180266;</code> 607 */ 608 public static final int MAGLEV_VALUE = 119180266; 609 /** 610 * 611 * 612 * <pre> 613 * Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. 614 * </pre> 615 * 616 * <code>ORIGINAL_DESTINATION = 166297216;</code> 617 */ 618 public static final int ORIGINAL_DESTINATION_VALUE = 166297216; 619 /** 620 * 621 * 622 * <pre> 623 * The load balancer selects a random healthy host. 624 * </pre> 625 * 626 * <code>RANDOM = 262527171;</code> 627 */ 628 public static final int RANDOM_VALUE = 262527171; 629 /** 630 * 631 * 632 * <pre> 633 * The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. 634 * </pre> 635 * 636 * <code>RING_HASH = 432795069;</code> 637 */ 638 public static final int RING_HASH_VALUE = 432795069; 639 /** 640 * 641 * 642 * <pre> 643 * This is a simple policy in which each healthy backend is selected in round robin order. This is the default. 644 * </pre> 645 * 646 * <code>ROUND_ROBIN = 153895801;</code> 647 */ 648 public static final int ROUND_ROBIN_VALUE = 153895801; 649 /** 650 * 651 * 652 * <pre> 653 * Per-instance weighted Load Balancing via health check reported weights. If set, the Backend Service must configure a non legacy HTTP-based Health Check, and health check replies are expected to contain non-standard HTTP response header field X-Load-Balancing-Endpoint-Weight to specify the per-instance weights. If set, Load Balancing is weighted based on the per-instance weights reported in the last processed health check replies, as long as every instance either reported a valid weight or had UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains equal-weight. This option is only supported in Network Load Balancing. 654 * </pre> 655 * 656 * <code>WEIGHTED_MAGLEV = 254930962;</code> 657 */ 658 public static final int WEIGHTED_MAGLEV_VALUE = 254930962; 659 getNumber()660 public final int getNumber() { 661 if (this == UNRECOGNIZED) { 662 throw new java.lang.IllegalArgumentException( 663 "Can't get the number of an unknown enum value."); 664 } 665 return value; 666 } 667 668 /** 669 * @param value The numeric wire value of the corresponding enum entry. 670 * @return The enum associated with the given numeric wire value. 671 * @deprecated Use {@link #forNumber(int)} instead. 672 */ 673 @java.lang.Deprecated valueOf(int value)674 public static LocalityLbPolicy valueOf(int value) { 675 return forNumber(value); 676 } 677 678 /** 679 * @param value The numeric wire value of the corresponding enum entry. 680 * @return The enum associated with the given numeric wire value. 681 */ forNumber(int value)682 public static LocalityLbPolicy forNumber(int value) { 683 switch (value) { 684 case 0: 685 return UNDEFINED_LOCALITY_LB_POLICY; 686 case 323318707: 687 return INVALID_LB_POLICY; 688 case 46604921: 689 return LEAST_REQUEST; 690 case 119180266: 691 return MAGLEV; 692 case 166297216: 693 return ORIGINAL_DESTINATION; 694 case 262527171: 695 return RANDOM; 696 case 432795069: 697 return RING_HASH; 698 case 153895801: 699 return ROUND_ROBIN; 700 case 254930962: 701 return WEIGHTED_MAGLEV; 702 default: 703 return null; 704 } 705 } 706 internalGetValueMap()707 public static com.google.protobuf.Internal.EnumLiteMap<LocalityLbPolicy> internalGetValueMap() { 708 return internalValueMap; 709 } 710 711 private static final com.google.protobuf.Internal.EnumLiteMap<LocalityLbPolicy> 712 internalValueMap = 713 new com.google.protobuf.Internal.EnumLiteMap<LocalityLbPolicy>() { 714 public LocalityLbPolicy findValueByNumber(int number) { 715 return LocalityLbPolicy.forNumber(number); 716 } 717 }; 718 getValueDescriptor()719 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 720 if (this == UNRECOGNIZED) { 721 throw new java.lang.IllegalStateException( 722 "Can't get the descriptor of an unrecognized enum value."); 723 } 724 return getDescriptor().getValues().get(ordinal()); 725 } 726 getDescriptorForType()727 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 728 return getDescriptor(); 729 } 730 getDescriptor()731 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 732 return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(2); 733 } 734 735 private static final LocalityLbPolicy[] VALUES = values(); 736 valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)737 public static LocalityLbPolicy valueOf( 738 com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 739 if (desc.getType() != getDescriptor()) { 740 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 741 } 742 if (desc.getIndex() == -1) { 743 return UNRECOGNIZED; 744 } 745 return VALUES[desc.getIndex()]; 746 } 747 748 private final int value; 749 LocalityLbPolicy(int value)750 private LocalityLbPolicy(int value) { 751 this.value = value; 752 } 753 754 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.LocalityLbPolicy) 755 } 756 757 /** 758 * 759 * 760 * <pre> 761 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 762 * </pre> 763 * 764 * Protobuf enum {@code google.cloud.compute.v1.BackendService.Protocol} 765 */ 766 public enum Protocol implements com.google.protobuf.ProtocolMessageEnum { 767 /** 768 * 769 * 770 * <pre> 771 * A value indicating that the enum field is not set. 772 * </pre> 773 * 774 * <code>UNDEFINED_PROTOCOL = 0;</code> 775 */ 776 UNDEFINED_PROTOCOL(0), 777 /** 778 * 779 * 780 * <pre> 781 * gRPC (available for Traffic Director). 782 * </pre> 783 * 784 * <code>GRPC = 2196510;</code> 785 */ 786 GRPC(2196510), 787 /** <code>HTTP = 2228360;</code> */ 788 HTTP(2228360), 789 /** 790 * 791 * 792 * <pre> 793 * HTTP/2 with SSL. 794 * </pre> 795 * 796 * <code>HTTP2 = 69079210;</code> 797 */ 798 HTTP2(69079210), 799 /** <code>HTTPS = 69079243;</code> */ 800 HTTPS(69079243), 801 /** 802 * 803 * 804 * <pre> 805 * TCP proxying with SSL. 806 * </pre> 807 * 808 * <code>SSL = 82412;</code> 809 */ 810 SSL(82412), 811 /** 812 * 813 * 814 * <pre> 815 * TCP proxying or TCP pass-through. 816 * </pre> 817 * 818 * <code>TCP = 82881;</code> 819 */ 820 TCP(82881), 821 /** 822 * 823 * 824 * <pre> 825 * UDP. 826 * </pre> 827 * 828 * <code>UDP = 83873;</code> 829 */ 830 UDP(83873), 831 /** 832 * 833 * 834 * <pre> 835 * If a Backend Service has UNSPECIFIED as its protocol, it can be used with any L3/L4 Forwarding Rules. 836 * </pre> 837 * 838 * <code>UNSPECIFIED = 526786327;</code> 839 */ 840 UNSPECIFIED(526786327), 841 UNRECOGNIZED(-1), 842 ; 843 844 /** 845 * 846 * 847 * <pre> 848 * A value indicating that the enum field is not set. 849 * </pre> 850 * 851 * <code>UNDEFINED_PROTOCOL = 0;</code> 852 */ 853 public static final int UNDEFINED_PROTOCOL_VALUE = 0; 854 /** 855 * 856 * 857 * <pre> 858 * gRPC (available for Traffic Director). 859 * </pre> 860 * 861 * <code>GRPC = 2196510;</code> 862 */ 863 public static final int GRPC_VALUE = 2196510; 864 /** <code>HTTP = 2228360;</code> */ 865 public static final int HTTP_VALUE = 2228360; 866 /** 867 * 868 * 869 * <pre> 870 * HTTP/2 with SSL. 871 * </pre> 872 * 873 * <code>HTTP2 = 69079210;</code> 874 */ 875 public static final int HTTP2_VALUE = 69079210; 876 /** <code>HTTPS = 69079243;</code> */ 877 public static final int HTTPS_VALUE = 69079243; 878 /** 879 * 880 * 881 * <pre> 882 * TCP proxying with SSL. 883 * </pre> 884 * 885 * <code>SSL = 82412;</code> 886 */ 887 public static final int SSL_VALUE = 82412; 888 /** 889 * 890 * 891 * <pre> 892 * TCP proxying or TCP pass-through. 893 * </pre> 894 * 895 * <code>TCP = 82881;</code> 896 */ 897 public static final int TCP_VALUE = 82881; 898 /** 899 * 900 * 901 * <pre> 902 * UDP. 903 * </pre> 904 * 905 * <code>UDP = 83873;</code> 906 */ 907 public static final int UDP_VALUE = 83873; 908 /** 909 * 910 * 911 * <pre> 912 * If a Backend Service has UNSPECIFIED as its protocol, it can be used with any L3/L4 Forwarding Rules. 913 * </pre> 914 * 915 * <code>UNSPECIFIED = 526786327;</code> 916 */ 917 public static final int UNSPECIFIED_VALUE = 526786327; 918 getNumber()919 public final int getNumber() { 920 if (this == UNRECOGNIZED) { 921 throw new java.lang.IllegalArgumentException( 922 "Can't get the number of an unknown enum value."); 923 } 924 return value; 925 } 926 927 /** 928 * @param value The numeric wire value of the corresponding enum entry. 929 * @return The enum associated with the given numeric wire value. 930 * @deprecated Use {@link #forNumber(int)} instead. 931 */ 932 @java.lang.Deprecated valueOf(int value)933 public static Protocol valueOf(int value) { 934 return forNumber(value); 935 } 936 937 /** 938 * @param value The numeric wire value of the corresponding enum entry. 939 * @return The enum associated with the given numeric wire value. 940 */ forNumber(int value)941 public static Protocol forNumber(int value) { 942 switch (value) { 943 case 0: 944 return UNDEFINED_PROTOCOL; 945 case 2196510: 946 return GRPC; 947 case 2228360: 948 return HTTP; 949 case 69079210: 950 return HTTP2; 951 case 69079243: 952 return HTTPS; 953 case 82412: 954 return SSL; 955 case 82881: 956 return TCP; 957 case 83873: 958 return UDP; 959 case 526786327: 960 return UNSPECIFIED; 961 default: 962 return null; 963 } 964 } 965 internalGetValueMap()966 public static com.google.protobuf.Internal.EnumLiteMap<Protocol> internalGetValueMap() { 967 return internalValueMap; 968 } 969 970 private static final com.google.protobuf.Internal.EnumLiteMap<Protocol> internalValueMap = 971 new com.google.protobuf.Internal.EnumLiteMap<Protocol>() { 972 public Protocol findValueByNumber(int number) { 973 return Protocol.forNumber(number); 974 } 975 }; 976 getValueDescriptor()977 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 978 if (this == UNRECOGNIZED) { 979 throw new java.lang.IllegalStateException( 980 "Can't get the descriptor of an unrecognized enum value."); 981 } 982 return getDescriptor().getValues().get(ordinal()); 983 } 984 getDescriptorForType()985 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 986 return getDescriptor(); 987 } 988 getDescriptor()989 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 990 return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(3); 991 } 992 993 private static final Protocol[] VALUES = values(); 994 valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc)995 public static Protocol valueOf(com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 996 if (desc.getType() != getDescriptor()) { 997 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 998 } 999 if (desc.getIndex() == -1) { 1000 return UNRECOGNIZED; 1001 } 1002 return VALUES[desc.getIndex()]; 1003 } 1004 1005 private final int value; 1006 Protocol(int value)1007 private Protocol(int value) { 1008 this.value = value; 1009 } 1010 1011 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.Protocol) 1012 } 1013 1014 /** 1015 * 1016 * 1017 * <pre> 1018 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 1019 * </pre> 1020 * 1021 * Protobuf enum {@code google.cloud.compute.v1.BackendService.SessionAffinity} 1022 */ 1023 public enum SessionAffinity implements com.google.protobuf.ProtocolMessageEnum { 1024 /** 1025 * 1026 * 1027 * <pre> 1028 * A value indicating that the enum field is not set. 1029 * </pre> 1030 * 1031 * <code>UNDEFINED_SESSION_AFFINITY = 0;</code> 1032 */ 1033 UNDEFINED_SESSION_AFFINITY(0), 1034 /** 1035 * 1036 * 1037 * <pre> 1038 * 2-tuple hash on packet's source and destination IP addresses. Connections from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. 1039 * </pre> 1040 * 1041 * <code>CLIENT_IP = 345665051;</code> 1042 */ 1043 CLIENT_IP(345665051), 1044 /** 1045 * 1046 * 1047 * <pre> 1048 * 1-tuple hash only on packet's source IP address. Connections from the same source IP address will be served by the same backend VM while that VM remains healthy. This option can only be used for Internal TCP/UDP Load Balancing. 1049 * </pre> 1050 * 1051 * <code>CLIENT_IP_NO_DESTINATION = 106122516;</code> 1052 */ 1053 CLIENT_IP_NO_DESTINATION(106122516), 1054 /** 1055 * 1056 * 1057 * <pre> 1058 * 5-tuple hash on packet's source and destination IP addresses, IP protocol, and source and destination ports. Connections for the same IP protocol from the same source IP address and port to the same destination IP address and port will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. 1059 * </pre> 1060 * 1061 * <code>CLIENT_IP_PORT_PROTO = 221722926;</code> 1062 */ 1063 CLIENT_IP_PORT_PROTO(221722926), 1064 /** 1065 * 1066 * 1067 * <pre> 1068 * 3-tuple hash on packet's source and destination IP addresses, and IP protocol. Connections for the same IP protocol from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. 1069 * </pre> 1070 * 1071 * <code>CLIENT_IP_PROTO = 25322148;</code> 1072 */ 1073 CLIENT_IP_PROTO(25322148), 1074 /** 1075 * 1076 * 1077 * <pre> 1078 * Hash based on a cookie generated by the L7 loadbalancer. Only valid for HTTP(S) load balancing. 1079 * </pre> 1080 * 1081 * <code>GENERATED_COOKIE = 370321204;</code> 1082 */ 1083 GENERATED_COOKIE(370321204), 1084 /** 1085 * 1086 * 1087 * <pre> 1088 * The hash is based on a user specified header field. 1089 * </pre> 1090 * 1091 * <code>HEADER_FIELD = 200737960;</code> 1092 */ 1093 HEADER_FIELD(200737960), 1094 /** 1095 * 1096 * 1097 * <pre> 1098 * The hash is based on a user provided cookie. 1099 * </pre> 1100 * 1101 * <code>HTTP_COOKIE = 494981627;</code> 1102 */ 1103 HTTP_COOKIE(494981627), 1104 /** 1105 * 1106 * 1107 * <pre> 1108 * No session affinity. Connections from the same client IP may go to any instance in the pool. 1109 * </pre> 1110 * 1111 * <code>NONE = 2402104;</code> 1112 */ 1113 NONE(2402104), 1114 UNRECOGNIZED(-1), 1115 ; 1116 1117 /** 1118 * 1119 * 1120 * <pre> 1121 * A value indicating that the enum field is not set. 1122 * </pre> 1123 * 1124 * <code>UNDEFINED_SESSION_AFFINITY = 0;</code> 1125 */ 1126 public static final int UNDEFINED_SESSION_AFFINITY_VALUE = 0; 1127 /** 1128 * 1129 * 1130 * <pre> 1131 * 2-tuple hash on packet's source and destination IP addresses. Connections from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. 1132 * </pre> 1133 * 1134 * <code>CLIENT_IP = 345665051;</code> 1135 */ 1136 public static final int CLIENT_IP_VALUE = 345665051; 1137 /** 1138 * 1139 * 1140 * <pre> 1141 * 1-tuple hash only on packet's source IP address. Connections from the same source IP address will be served by the same backend VM while that VM remains healthy. This option can only be used for Internal TCP/UDP Load Balancing. 1142 * </pre> 1143 * 1144 * <code>CLIENT_IP_NO_DESTINATION = 106122516;</code> 1145 */ 1146 public static final int CLIENT_IP_NO_DESTINATION_VALUE = 106122516; 1147 /** 1148 * 1149 * 1150 * <pre> 1151 * 5-tuple hash on packet's source and destination IP addresses, IP protocol, and source and destination ports. Connections for the same IP protocol from the same source IP address and port to the same destination IP address and port will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. 1152 * </pre> 1153 * 1154 * <code>CLIENT_IP_PORT_PROTO = 221722926;</code> 1155 */ 1156 public static final int CLIENT_IP_PORT_PROTO_VALUE = 221722926; 1157 /** 1158 * 1159 * 1160 * <pre> 1161 * 3-tuple hash on packet's source and destination IP addresses, and IP protocol. Connections for the same IP protocol from the same source IP address to the same destination IP address will be served by the same backend VM while that VM remains healthy. This option cannot be used for HTTP(S) load balancing. 1162 * </pre> 1163 * 1164 * <code>CLIENT_IP_PROTO = 25322148;</code> 1165 */ 1166 public static final int CLIENT_IP_PROTO_VALUE = 25322148; 1167 /** 1168 * 1169 * 1170 * <pre> 1171 * Hash based on a cookie generated by the L7 loadbalancer. Only valid for HTTP(S) load balancing. 1172 * </pre> 1173 * 1174 * <code>GENERATED_COOKIE = 370321204;</code> 1175 */ 1176 public static final int GENERATED_COOKIE_VALUE = 370321204; 1177 /** 1178 * 1179 * 1180 * <pre> 1181 * The hash is based on a user specified header field. 1182 * </pre> 1183 * 1184 * <code>HEADER_FIELD = 200737960;</code> 1185 */ 1186 public static final int HEADER_FIELD_VALUE = 200737960; 1187 /** 1188 * 1189 * 1190 * <pre> 1191 * The hash is based on a user provided cookie. 1192 * </pre> 1193 * 1194 * <code>HTTP_COOKIE = 494981627;</code> 1195 */ 1196 public static final int HTTP_COOKIE_VALUE = 494981627; 1197 /** 1198 * 1199 * 1200 * <pre> 1201 * No session affinity. Connections from the same client IP may go to any instance in the pool. 1202 * </pre> 1203 * 1204 * <code>NONE = 2402104;</code> 1205 */ 1206 public static final int NONE_VALUE = 2402104; 1207 getNumber()1208 public final int getNumber() { 1209 if (this == UNRECOGNIZED) { 1210 throw new java.lang.IllegalArgumentException( 1211 "Can't get the number of an unknown enum value."); 1212 } 1213 return value; 1214 } 1215 1216 /** 1217 * @param value The numeric wire value of the corresponding enum entry. 1218 * @return The enum associated with the given numeric wire value. 1219 * @deprecated Use {@link #forNumber(int)} instead. 1220 */ 1221 @java.lang.Deprecated valueOf(int value)1222 public static SessionAffinity valueOf(int value) { 1223 return forNumber(value); 1224 } 1225 1226 /** 1227 * @param value The numeric wire value of the corresponding enum entry. 1228 * @return The enum associated with the given numeric wire value. 1229 */ forNumber(int value)1230 public static SessionAffinity forNumber(int value) { 1231 switch (value) { 1232 case 0: 1233 return UNDEFINED_SESSION_AFFINITY; 1234 case 345665051: 1235 return CLIENT_IP; 1236 case 106122516: 1237 return CLIENT_IP_NO_DESTINATION; 1238 case 221722926: 1239 return CLIENT_IP_PORT_PROTO; 1240 case 25322148: 1241 return CLIENT_IP_PROTO; 1242 case 370321204: 1243 return GENERATED_COOKIE; 1244 case 200737960: 1245 return HEADER_FIELD; 1246 case 494981627: 1247 return HTTP_COOKIE; 1248 case 2402104: 1249 return NONE; 1250 default: 1251 return null; 1252 } 1253 } 1254 internalGetValueMap()1255 public static com.google.protobuf.Internal.EnumLiteMap<SessionAffinity> internalGetValueMap() { 1256 return internalValueMap; 1257 } 1258 1259 private static final com.google.protobuf.Internal.EnumLiteMap<SessionAffinity> 1260 internalValueMap = 1261 new com.google.protobuf.Internal.EnumLiteMap<SessionAffinity>() { 1262 public SessionAffinity findValueByNumber(int number) { 1263 return SessionAffinity.forNumber(number); 1264 } 1265 }; 1266 getValueDescriptor()1267 public final com.google.protobuf.Descriptors.EnumValueDescriptor getValueDescriptor() { 1268 if (this == UNRECOGNIZED) { 1269 throw new java.lang.IllegalStateException( 1270 "Can't get the descriptor of an unrecognized enum value."); 1271 } 1272 return getDescriptor().getValues().get(ordinal()); 1273 } 1274 getDescriptorForType()1275 public final com.google.protobuf.Descriptors.EnumDescriptor getDescriptorForType() { 1276 return getDescriptor(); 1277 } 1278 getDescriptor()1279 public static final com.google.protobuf.Descriptors.EnumDescriptor getDescriptor() { 1280 return com.google.cloud.compute.v1.BackendService.getDescriptor().getEnumTypes().get(4); 1281 } 1282 1283 private static final SessionAffinity[] VALUES = values(); 1284 valueOf( com.google.protobuf.Descriptors.EnumValueDescriptor desc)1285 public static SessionAffinity valueOf( 1286 com.google.protobuf.Descriptors.EnumValueDescriptor desc) { 1287 if (desc.getType() != getDescriptor()) { 1288 throw new java.lang.IllegalArgumentException("EnumValueDescriptor is not for this type."); 1289 } 1290 if (desc.getIndex() == -1) { 1291 return UNRECOGNIZED; 1292 } 1293 return VALUES[desc.getIndex()]; 1294 } 1295 1296 private final int value; 1297 SessionAffinity(int value)1298 private SessionAffinity(int value) { 1299 this.value = value; 1300 } 1301 1302 // @@protoc_insertion_point(enum_scope:google.cloud.compute.v1.BackendService.SessionAffinity) 1303 } 1304 1305 private int bitField0_; 1306 private int bitField1_; 1307 public static final int AFFINITY_COOKIE_TTL_SEC_FIELD_NUMBER = 369996954; 1308 private int affinityCookieTtlSec_ = 0; 1309 /** 1310 * 1311 * 1312 * <pre> 1313 * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 1314 * </pre> 1315 * 1316 * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code> 1317 * 1318 * @return Whether the affinityCookieTtlSec field is set. 1319 */ 1320 @java.lang.Override hasAffinityCookieTtlSec()1321 public boolean hasAffinityCookieTtlSec() { 1322 return ((bitField0_ & 0x00000001) != 0); 1323 } 1324 /** 1325 * 1326 * 1327 * <pre> 1328 * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 1329 * </pre> 1330 * 1331 * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code> 1332 * 1333 * @return The affinityCookieTtlSec. 1334 */ 1335 @java.lang.Override getAffinityCookieTtlSec()1336 public int getAffinityCookieTtlSec() { 1337 return affinityCookieTtlSec_; 1338 } 1339 1340 public static final int BACKENDS_FIELD_NUMBER = 510839903; 1341 1342 @SuppressWarnings("serial") 1343 private java.util.List<com.google.cloud.compute.v1.Backend> backends_; 1344 /** 1345 * 1346 * 1347 * <pre> 1348 * The list of backends that serve this BackendService. 1349 * </pre> 1350 * 1351 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 1352 */ 1353 @java.lang.Override getBackendsList()1354 public java.util.List<com.google.cloud.compute.v1.Backend> getBackendsList() { 1355 return backends_; 1356 } 1357 /** 1358 * 1359 * 1360 * <pre> 1361 * The list of backends that serve this BackendService. 1362 * </pre> 1363 * 1364 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 1365 */ 1366 @java.lang.Override 1367 public java.util.List<? extends com.google.cloud.compute.v1.BackendOrBuilder> getBackendsOrBuilderList()1368 getBackendsOrBuilderList() { 1369 return backends_; 1370 } 1371 /** 1372 * 1373 * 1374 * <pre> 1375 * The list of backends that serve this BackendService. 1376 * </pre> 1377 * 1378 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 1379 */ 1380 @java.lang.Override getBackendsCount()1381 public int getBackendsCount() { 1382 return backends_.size(); 1383 } 1384 /** 1385 * 1386 * 1387 * <pre> 1388 * The list of backends that serve this BackendService. 1389 * </pre> 1390 * 1391 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 1392 */ 1393 @java.lang.Override getBackends(int index)1394 public com.google.cloud.compute.v1.Backend getBackends(int index) { 1395 return backends_.get(index); 1396 } 1397 /** 1398 * 1399 * 1400 * <pre> 1401 * The list of backends that serve this BackendService. 1402 * </pre> 1403 * 1404 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 1405 */ 1406 @java.lang.Override getBackendsOrBuilder(int index)1407 public com.google.cloud.compute.v1.BackendOrBuilder getBackendsOrBuilder(int index) { 1408 return backends_.get(index); 1409 } 1410 1411 public static final int CDN_POLICY_FIELD_NUMBER = 213976452; 1412 private com.google.cloud.compute.v1.BackendServiceCdnPolicy cdnPolicy_; 1413 /** 1414 * 1415 * 1416 * <pre> 1417 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 1418 * </pre> 1419 * 1420 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;</code> 1421 * 1422 * @return Whether the cdnPolicy field is set. 1423 */ 1424 @java.lang.Override hasCdnPolicy()1425 public boolean hasCdnPolicy() { 1426 return ((bitField0_ & 0x00000002) != 0); 1427 } 1428 /** 1429 * 1430 * 1431 * <pre> 1432 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 1433 * </pre> 1434 * 1435 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;</code> 1436 * 1437 * @return The cdnPolicy. 1438 */ 1439 @java.lang.Override getCdnPolicy()1440 public com.google.cloud.compute.v1.BackendServiceCdnPolicy getCdnPolicy() { 1441 return cdnPolicy_ == null 1442 ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance() 1443 : cdnPolicy_; 1444 } 1445 /** 1446 * 1447 * 1448 * <pre> 1449 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 1450 * </pre> 1451 * 1452 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452;</code> 1453 */ 1454 @java.lang.Override getCdnPolicyOrBuilder()1455 public com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder getCdnPolicyOrBuilder() { 1456 return cdnPolicy_ == null 1457 ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance() 1458 : cdnPolicy_; 1459 } 1460 1461 public static final int CIRCUIT_BREAKERS_FIELD_NUMBER = 421340061; 1462 private com.google.cloud.compute.v1.CircuitBreakers circuitBreakers_; 1463 /** 1464 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 1465 * 1466 * @return Whether the circuitBreakers field is set. 1467 */ 1468 @java.lang.Override hasCircuitBreakers()1469 public boolean hasCircuitBreakers() { 1470 return ((bitField0_ & 0x00000004) != 0); 1471 } 1472 /** 1473 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 1474 * 1475 * @return The circuitBreakers. 1476 */ 1477 @java.lang.Override getCircuitBreakers()1478 public com.google.cloud.compute.v1.CircuitBreakers getCircuitBreakers() { 1479 return circuitBreakers_ == null 1480 ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance() 1481 : circuitBreakers_; 1482 } 1483 /** 1484 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 1485 */ 1486 @java.lang.Override getCircuitBreakersOrBuilder()1487 public com.google.cloud.compute.v1.CircuitBreakersOrBuilder getCircuitBreakersOrBuilder() { 1488 return circuitBreakers_ == null 1489 ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance() 1490 : circuitBreakers_; 1491 } 1492 1493 public static final int COMPRESSION_MODE_FIELD_NUMBER = 95520988; 1494 1495 @SuppressWarnings("serial") 1496 private volatile java.lang.Object compressionMode_ = ""; 1497 /** 1498 * 1499 * 1500 * <pre> 1501 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 1502 * Check the CompressionMode enum for the list of possible values. 1503 * </pre> 1504 * 1505 * <code>optional string compression_mode = 95520988;</code> 1506 * 1507 * @return Whether the compressionMode field is set. 1508 */ 1509 @java.lang.Override hasCompressionMode()1510 public boolean hasCompressionMode() { 1511 return ((bitField0_ & 0x00000008) != 0); 1512 } 1513 /** 1514 * 1515 * 1516 * <pre> 1517 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 1518 * Check the CompressionMode enum for the list of possible values. 1519 * </pre> 1520 * 1521 * <code>optional string compression_mode = 95520988;</code> 1522 * 1523 * @return The compressionMode. 1524 */ 1525 @java.lang.Override getCompressionMode()1526 public java.lang.String getCompressionMode() { 1527 java.lang.Object ref = compressionMode_; 1528 if (ref instanceof java.lang.String) { 1529 return (java.lang.String) ref; 1530 } else { 1531 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1532 java.lang.String s = bs.toStringUtf8(); 1533 compressionMode_ = s; 1534 return s; 1535 } 1536 } 1537 /** 1538 * 1539 * 1540 * <pre> 1541 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 1542 * Check the CompressionMode enum for the list of possible values. 1543 * </pre> 1544 * 1545 * <code>optional string compression_mode = 95520988;</code> 1546 * 1547 * @return The bytes for compressionMode. 1548 */ 1549 @java.lang.Override getCompressionModeBytes()1550 public com.google.protobuf.ByteString getCompressionModeBytes() { 1551 java.lang.Object ref = compressionMode_; 1552 if (ref instanceof java.lang.String) { 1553 com.google.protobuf.ByteString b = 1554 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1555 compressionMode_ = b; 1556 return b; 1557 } else { 1558 return (com.google.protobuf.ByteString) ref; 1559 } 1560 } 1561 1562 public static final int CONNECTION_DRAINING_FIELD_NUMBER = 461096747; 1563 private com.google.cloud.compute.v1.ConnectionDraining connectionDraining_; 1564 /** 1565 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 1566 * </code> 1567 * 1568 * @return Whether the connectionDraining field is set. 1569 */ 1570 @java.lang.Override hasConnectionDraining()1571 public boolean hasConnectionDraining() { 1572 return ((bitField0_ & 0x00000010) != 0); 1573 } 1574 /** 1575 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 1576 * </code> 1577 * 1578 * @return The connectionDraining. 1579 */ 1580 @java.lang.Override getConnectionDraining()1581 public com.google.cloud.compute.v1.ConnectionDraining getConnectionDraining() { 1582 return connectionDraining_ == null 1583 ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance() 1584 : connectionDraining_; 1585 } 1586 /** 1587 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 1588 * </code> 1589 */ 1590 @java.lang.Override getConnectionDrainingOrBuilder()1591 public com.google.cloud.compute.v1.ConnectionDrainingOrBuilder getConnectionDrainingOrBuilder() { 1592 return connectionDraining_ == null 1593 ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance() 1594 : connectionDraining_; 1595 } 1596 1597 public static final int CONNECTION_TRACKING_POLICY_FIELD_NUMBER = 143994969; 1598 private com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy 1599 connectionTrackingPolicy_; 1600 /** 1601 * 1602 * 1603 * <pre> 1604 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 1605 * </pre> 1606 * 1607 * <code> 1608 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 1609 * </code> 1610 * 1611 * @return Whether the connectionTrackingPolicy field is set. 1612 */ 1613 @java.lang.Override hasConnectionTrackingPolicy()1614 public boolean hasConnectionTrackingPolicy() { 1615 return ((bitField0_ & 0x00000020) != 0); 1616 } 1617 /** 1618 * 1619 * 1620 * <pre> 1621 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 1622 * </pre> 1623 * 1624 * <code> 1625 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 1626 * </code> 1627 * 1628 * @return The connectionTrackingPolicy. 1629 */ 1630 @java.lang.Override 1631 public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy getConnectionTrackingPolicy()1632 getConnectionTrackingPolicy() { 1633 return connectionTrackingPolicy_ == null 1634 ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.getDefaultInstance() 1635 : connectionTrackingPolicy_; 1636 } 1637 /** 1638 * 1639 * 1640 * <pre> 1641 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 1642 * </pre> 1643 * 1644 * <code> 1645 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 1646 * </code> 1647 */ 1648 @java.lang.Override 1649 public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder getConnectionTrackingPolicyOrBuilder()1650 getConnectionTrackingPolicyOrBuilder() { 1651 return connectionTrackingPolicy_ == null 1652 ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.getDefaultInstance() 1653 : connectionTrackingPolicy_; 1654 } 1655 1656 public static final int CONSISTENT_HASH_FIELD_NUMBER = 905883; 1657 private com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistentHash_; 1658 /** 1659 * 1660 * 1661 * <pre> 1662 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 1663 * </pre> 1664 * 1665 * <code> 1666 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 1667 * </code> 1668 * 1669 * @return Whether the consistentHash field is set. 1670 */ 1671 @java.lang.Override hasConsistentHash()1672 public boolean hasConsistentHash() { 1673 return ((bitField0_ & 0x00000040) != 0); 1674 } 1675 /** 1676 * 1677 * 1678 * <pre> 1679 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 1680 * </pre> 1681 * 1682 * <code> 1683 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 1684 * </code> 1685 * 1686 * @return The consistentHash. 1687 */ 1688 @java.lang.Override getConsistentHash()1689 public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings getConsistentHash() { 1690 return consistentHash_ == null 1691 ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance() 1692 : consistentHash_; 1693 } 1694 /** 1695 * 1696 * 1697 * <pre> 1698 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 1699 * </pre> 1700 * 1701 * <code> 1702 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 1703 * </code> 1704 */ 1705 @java.lang.Override 1706 public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder getConsistentHashOrBuilder()1707 getConsistentHashOrBuilder() { 1708 return consistentHash_ == null 1709 ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance() 1710 : consistentHash_; 1711 } 1712 1713 public static final int CREATION_TIMESTAMP_FIELD_NUMBER = 30525366; 1714 1715 @SuppressWarnings("serial") 1716 private volatile java.lang.Object creationTimestamp_ = ""; 1717 /** 1718 * 1719 * 1720 * <pre> 1721 * [Output Only] Creation timestamp in RFC3339 text format. 1722 * </pre> 1723 * 1724 * <code>optional string creation_timestamp = 30525366;</code> 1725 * 1726 * @return Whether the creationTimestamp field is set. 1727 */ 1728 @java.lang.Override hasCreationTimestamp()1729 public boolean hasCreationTimestamp() { 1730 return ((bitField0_ & 0x00000080) != 0); 1731 } 1732 /** 1733 * 1734 * 1735 * <pre> 1736 * [Output Only] Creation timestamp in RFC3339 text format. 1737 * </pre> 1738 * 1739 * <code>optional string creation_timestamp = 30525366;</code> 1740 * 1741 * @return The creationTimestamp. 1742 */ 1743 @java.lang.Override getCreationTimestamp()1744 public java.lang.String getCreationTimestamp() { 1745 java.lang.Object ref = creationTimestamp_; 1746 if (ref instanceof java.lang.String) { 1747 return (java.lang.String) ref; 1748 } else { 1749 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1750 java.lang.String s = bs.toStringUtf8(); 1751 creationTimestamp_ = s; 1752 return s; 1753 } 1754 } 1755 /** 1756 * 1757 * 1758 * <pre> 1759 * [Output Only] Creation timestamp in RFC3339 text format. 1760 * </pre> 1761 * 1762 * <code>optional string creation_timestamp = 30525366;</code> 1763 * 1764 * @return The bytes for creationTimestamp. 1765 */ 1766 @java.lang.Override getCreationTimestampBytes()1767 public com.google.protobuf.ByteString getCreationTimestampBytes() { 1768 java.lang.Object ref = creationTimestamp_; 1769 if (ref instanceof java.lang.String) { 1770 com.google.protobuf.ByteString b = 1771 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1772 creationTimestamp_ = b; 1773 return b; 1774 } else { 1775 return (com.google.protobuf.ByteString) ref; 1776 } 1777 } 1778 1779 public static final int CUSTOM_REQUEST_HEADERS_FIELD_NUMBER = 27977992; 1780 1781 @SuppressWarnings("serial") 1782 private com.google.protobuf.LazyStringList customRequestHeaders_; 1783 /** 1784 * 1785 * 1786 * <pre> 1787 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1788 * </pre> 1789 * 1790 * <code>repeated string custom_request_headers = 27977992;</code> 1791 * 1792 * @return A list containing the customRequestHeaders. 1793 */ getCustomRequestHeadersList()1794 public com.google.protobuf.ProtocolStringList getCustomRequestHeadersList() { 1795 return customRequestHeaders_; 1796 } 1797 /** 1798 * 1799 * 1800 * <pre> 1801 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1802 * </pre> 1803 * 1804 * <code>repeated string custom_request_headers = 27977992;</code> 1805 * 1806 * @return The count of customRequestHeaders. 1807 */ getCustomRequestHeadersCount()1808 public int getCustomRequestHeadersCount() { 1809 return customRequestHeaders_.size(); 1810 } 1811 /** 1812 * 1813 * 1814 * <pre> 1815 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1816 * </pre> 1817 * 1818 * <code>repeated string custom_request_headers = 27977992;</code> 1819 * 1820 * @param index The index of the element to return. 1821 * @return The customRequestHeaders at the given index. 1822 */ getCustomRequestHeaders(int index)1823 public java.lang.String getCustomRequestHeaders(int index) { 1824 return customRequestHeaders_.get(index); 1825 } 1826 /** 1827 * 1828 * 1829 * <pre> 1830 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1831 * </pre> 1832 * 1833 * <code>repeated string custom_request_headers = 27977992;</code> 1834 * 1835 * @param index The index of the value to return. 1836 * @return The bytes of the customRequestHeaders at the given index. 1837 */ getCustomRequestHeadersBytes(int index)1838 public com.google.protobuf.ByteString getCustomRequestHeadersBytes(int index) { 1839 return customRequestHeaders_.getByteString(index); 1840 } 1841 1842 public static final int CUSTOM_RESPONSE_HEADERS_FIELD_NUMBER = 387539094; 1843 1844 @SuppressWarnings("serial") 1845 private com.google.protobuf.LazyStringList customResponseHeaders_; 1846 /** 1847 * 1848 * 1849 * <pre> 1850 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1851 * </pre> 1852 * 1853 * <code>repeated string custom_response_headers = 387539094;</code> 1854 * 1855 * @return A list containing the customResponseHeaders. 1856 */ getCustomResponseHeadersList()1857 public com.google.protobuf.ProtocolStringList getCustomResponseHeadersList() { 1858 return customResponseHeaders_; 1859 } 1860 /** 1861 * 1862 * 1863 * <pre> 1864 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1865 * </pre> 1866 * 1867 * <code>repeated string custom_response_headers = 387539094;</code> 1868 * 1869 * @return The count of customResponseHeaders. 1870 */ getCustomResponseHeadersCount()1871 public int getCustomResponseHeadersCount() { 1872 return customResponseHeaders_.size(); 1873 } 1874 /** 1875 * 1876 * 1877 * <pre> 1878 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1879 * </pre> 1880 * 1881 * <code>repeated string custom_response_headers = 387539094;</code> 1882 * 1883 * @param index The index of the element to return. 1884 * @return The customResponseHeaders at the given index. 1885 */ getCustomResponseHeaders(int index)1886 public java.lang.String getCustomResponseHeaders(int index) { 1887 return customResponseHeaders_.get(index); 1888 } 1889 /** 1890 * 1891 * 1892 * <pre> 1893 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 1894 * </pre> 1895 * 1896 * <code>repeated string custom_response_headers = 387539094;</code> 1897 * 1898 * @param index The index of the value to return. 1899 * @return The bytes of the customResponseHeaders at the given index. 1900 */ getCustomResponseHeadersBytes(int index)1901 public com.google.protobuf.ByteString getCustomResponseHeadersBytes(int index) { 1902 return customResponseHeaders_.getByteString(index); 1903 } 1904 1905 public static final int DESCRIPTION_FIELD_NUMBER = 422937596; 1906 1907 @SuppressWarnings("serial") 1908 private volatile java.lang.Object description_ = ""; 1909 /** 1910 * 1911 * 1912 * <pre> 1913 * An optional description of this resource. Provide this property when you create the resource. 1914 * </pre> 1915 * 1916 * <code>optional string description = 422937596;</code> 1917 * 1918 * @return Whether the description field is set. 1919 */ 1920 @java.lang.Override hasDescription()1921 public boolean hasDescription() { 1922 return ((bitField0_ & 0x00000100) != 0); 1923 } 1924 /** 1925 * 1926 * 1927 * <pre> 1928 * An optional description of this resource. Provide this property when you create the resource. 1929 * </pre> 1930 * 1931 * <code>optional string description = 422937596;</code> 1932 * 1933 * @return The description. 1934 */ 1935 @java.lang.Override getDescription()1936 public java.lang.String getDescription() { 1937 java.lang.Object ref = description_; 1938 if (ref instanceof java.lang.String) { 1939 return (java.lang.String) ref; 1940 } else { 1941 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 1942 java.lang.String s = bs.toStringUtf8(); 1943 description_ = s; 1944 return s; 1945 } 1946 } 1947 /** 1948 * 1949 * 1950 * <pre> 1951 * An optional description of this resource. Provide this property when you create the resource. 1952 * </pre> 1953 * 1954 * <code>optional string description = 422937596;</code> 1955 * 1956 * @return The bytes for description. 1957 */ 1958 @java.lang.Override getDescriptionBytes()1959 public com.google.protobuf.ByteString getDescriptionBytes() { 1960 java.lang.Object ref = description_; 1961 if (ref instanceof java.lang.String) { 1962 com.google.protobuf.ByteString b = 1963 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 1964 description_ = b; 1965 return b; 1966 } else { 1967 return (com.google.protobuf.ByteString) ref; 1968 } 1969 } 1970 1971 public static final int EDGE_SECURITY_POLICY_FIELD_NUMBER = 41036943; 1972 1973 @SuppressWarnings("serial") 1974 private volatile java.lang.Object edgeSecurityPolicy_ = ""; 1975 /** 1976 * 1977 * 1978 * <pre> 1979 * [Output Only] The resource URL for the edge security policy associated with this backend service. 1980 * </pre> 1981 * 1982 * <code>optional string edge_security_policy = 41036943;</code> 1983 * 1984 * @return Whether the edgeSecurityPolicy field is set. 1985 */ 1986 @java.lang.Override hasEdgeSecurityPolicy()1987 public boolean hasEdgeSecurityPolicy() { 1988 return ((bitField0_ & 0x00000200) != 0); 1989 } 1990 /** 1991 * 1992 * 1993 * <pre> 1994 * [Output Only] The resource URL for the edge security policy associated with this backend service. 1995 * </pre> 1996 * 1997 * <code>optional string edge_security_policy = 41036943;</code> 1998 * 1999 * @return The edgeSecurityPolicy. 2000 */ 2001 @java.lang.Override getEdgeSecurityPolicy()2002 public java.lang.String getEdgeSecurityPolicy() { 2003 java.lang.Object ref = edgeSecurityPolicy_; 2004 if (ref instanceof java.lang.String) { 2005 return (java.lang.String) ref; 2006 } else { 2007 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2008 java.lang.String s = bs.toStringUtf8(); 2009 edgeSecurityPolicy_ = s; 2010 return s; 2011 } 2012 } 2013 /** 2014 * 2015 * 2016 * <pre> 2017 * [Output Only] The resource URL for the edge security policy associated with this backend service. 2018 * </pre> 2019 * 2020 * <code>optional string edge_security_policy = 41036943;</code> 2021 * 2022 * @return The bytes for edgeSecurityPolicy. 2023 */ 2024 @java.lang.Override getEdgeSecurityPolicyBytes()2025 public com.google.protobuf.ByteString getEdgeSecurityPolicyBytes() { 2026 java.lang.Object ref = edgeSecurityPolicy_; 2027 if (ref instanceof java.lang.String) { 2028 com.google.protobuf.ByteString b = 2029 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2030 edgeSecurityPolicy_ = b; 2031 return b; 2032 } else { 2033 return (com.google.protobuf.ByteString) ref; 2034 } 2035 } 2036 2037 public static final int ENABLE_C_D_N_FIELD_NUMBER = 250733499; 2038 private boolean enableCDN_ = false; 2039 /** 2040 * 2041 * 2042 * <pre> 2043 * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer. 2044 * </pre> 2045 * 2046 * <code>optional bool enable_c_d_n = 250733499;</code> 2047 * 2048 * @return Whether the enableCDN field is set. 2049 */ 2050 @java.lang.Override hasEnableCDN()2051 public boolean hasEnableCDN() { 2052 return ((bitField0_ & 0x00000400) != 0); 2053 } 2054 /** 2055 * 2056 * 2057 * <pre> 2058 * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer. 2059 * </pre> 2060 * 2061 * <code>optional bool enable_c_d_n = 250733499;</code> 2062 * 2063 * @return The enableCDN. 2064 */ 2065 @java.lang.Override getEnableCDN()2066 public boolean getEnableCDN() { 2067 return enableCDN_; 2068 } 2069 2070 public static final int FAILOVER_POLICY_FIELD_NUMBER = 105658655; 2071 private com.google.cloud.compute.v1.BackendServiceFailoverPolicy failoverPolicy_; 2072 /** 2073 * 2074 * 2075 * <pre> 2076 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 2077 * </pre> 2078 * 2079 * <code> 2080 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 2081 * </code> 2082 * 2083 * @return Whether the failoverPolicy field is set. 2084 */ 2085 @java.lang.Override hasFailoverPolicy()2086 public boolean hasFailoverPolicy() { 2087 return ((bitField0_ & 0x00000800) != 0); 2088 } 2089 /** 2090 * 2091 * 2092 * <pre> 2093 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 2094 * </pre> 2095 * 2096 * <code> 2097 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 2098 * </code> 2099 * 2100 * @return The failoverPolicy. 2101 */ 2102 @java.lang.Override getFailoverPolicy()2103 public com.google.cloud.compute.v1.BackendServiceFailoverPolicy getFailoverPolicy() { 2104 return failoverPolicy_ == null 2105 ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance() 2106 : failoverPolicy_; 2107 } 2108 /** 2109 * 2110 * 2111 * <pre> 2112 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 2113 * </pre> 2114 * 2115 * <code> 2116 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 2117 * </code> 2118 */ 2119 @java.lang.Override 2120 public com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder getFailoverPolicyOrBuilder()2121 getFailoverPolicyOrBuilder() { 2122 return failoverPolicy_ == null 2123 ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance() 2124 : failoverPolicy_; 2125 } 2126 2127 public static final int FINGERPRINT_FIELD_NUMBER = 234678500; 2128 2129 @SuppressWarnings("serial") 2130 private volatile java.lang.Object fingerprint_ = ""; 2131 /** 2132 * 2133 * 2134 * <pre> 2135 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 2136 * </pre> 2137 * 2138 * <code>optional string fingerprint = 234678500;</code> 2139 * 2140 * @return Whether the fingerprint field is set. 2141 */ 2142 @java.lang.Override hasFingerprint()2143 public boolean hasFingerprint() { 2144 return ((bitField0_ & 0x00001000) != 0); 2145 } 2146 /** 2147 * 2148 * 2149 * <pre> 2150 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 2151 * </pre> 2152 * 2153 * <code>optional string fingerprint = 234678500;</code> 2154 * 2155 * @return The fingerprint. 2156 */ 2157 @java.lang.Override getFingerprint()2158 public java.lang.String getFingerprint() { 2159 java.lang.Object ref = fingerprint_; 2160 if (ref instanceof java.lang.String) { 2161 return (java.lang.String) ref; 2162 } else { 2163 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2164 java.lang.String s = bs.toStringUtf8(); 2165 fingerprint_ = s; 2166 return s; 2167 } 2168 } 2169 /** 2170 * 2171 * 2172 * <pre> 2173 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 2174 * </pre> 2175 * 2176 * <code>optional string fingerprint = 234678500;</code> 2177 * 2178 * @return The bytes for fingerprint. 2179 */ 2180 @java.lang.Override getFingerprintBytes()2181 public com.google.protobuf.ByteString getFingerprintBytes() { 2182 java.lang.Object ref = fingerprint_; 2183 if (ref instanceof java.lang.String) { 2184 com.google.protobuf.ByteString b = 2185 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2186 fingerprint_ = b; 2187 return b; 2188 } else { 2189 return (com.google.protobuf.ByteString) ref; 2190 } 2191 } 2192 2193 public static final int HEALTH_CHECKS_FIELD_NUMBER = 448370606; 2194 2195 @SuppressWarnings("serial") 2196 private com.google.protobuf.LazyStringList healthChecks_; 2197 /** 2198 * 2199 * 2200 * <pre> 2201 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 2202 * </pre> 2203 * 2204 * <code>repeated string health_checks = 448370606;</code> 2205 * 2206 * @return A list containing the healthChecks. 2207 */ getHealthChecksList()2208 public com.google.protobuf.ProtocolStringList getHealthChecksList() { 2209 return healthChecks_; 2210 } 2211 /** 2212 * 2213 * 2214 * <pre> 2215 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 2216 * </pre> 2217 * 2218 * <code>repeated string health_checks = 448370606;</code> 2219 * 2220 * @return The count of healthChecks. 2221 */ getHealthChecksCount()2222 public int getHealthChecksCount() { 2223 return healthChecks_.size(); 2224 } 2225 /** 2226 * 2227 * 2228 * <pre> 2229 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 2230 * </pre> 2231 * 2232 * <code>repeated string health_checks = 448370606;</code> 2233 * 2234 * @param index The index of the element to return. 2235 * @return The healthChecks at the given index. 2236 */ getHealthChecks(int index)2237 public java.lang.String getHealthChecks(int index) { 2238 return healthChecks_.get(index); 2239 } 2240 /** 2241 * 2242 * 2243 * <pre> 2244 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 2245 * </pre> 2246 * 2247 * <code>repeated string health_checks = 448370606;</code> 2248 * 2249 * @param index The index of the value to return. 2250 * @return The bytes of the healthChecks at the given index. 2251 */ getHealthChecksBytes(int index)2252 public com.google.protobuf.ByteString getHealthChecksBytes(int index) { 2253 return healthChecks_.getByteString(index); 2254 } 2255 2256 public static final int IAP_FIELD_NUMBER = 104024; 2257 private com.google.cloud.compute.v1.BackendServiceIAP iap_; 2258 /** 2259 * 2260 * 2261 * <pre> 2262 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 2263 * </pre> 2264 * 2265 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 2266 * 2267 * @return Whether the iap field is set. 2268 */ 2269 @java.lang.Override hasIap()2270 public boolean hasIap() { 2271 return ((bitField0_ & 0x00002000) != 0); 2272 } 2273 /** 2274 * 2275 * 2276 * <pre> 2277 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 2278 * </pre> 2279 * 2280 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 2281 * 2282 * @return The iap. 2283 */ 2284 @java.lang.Override getIap()2285 public com.google.cloud.compute.v1.BackendServiceIAP getIap() { 2286 return iap_ == null ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance() : iap_; 2287 } 2288 /** 2289 * 2290 * 2291 * <pre> 2292 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 2293 * </pre> 2294 * 2295 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 2296 */ 2297 @java.lang.Override getIapOrBuilder()2298 public com.google.cloud.compute.v1.BackendServiceIAPOrBuilder getIapOrBuilder() { 2299 return iap_ == null ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance() : iap_; 2300 } 2301 2302 public static final int ID_FIELD_NUMBER = 3355; 2303 private long id_ = 0L; 2304 /** 2305 * 2306 * 2307 * <pre> 2308 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 2309 * </pre> 2310 * 2311 * <code>optional uint64 id = 3355;</code> 2312 * 2313 * @return Whether the id field is set. 2314 */ 2315 @java.lang.Override hasId()2316 public boolean hasId() { 2317 return ((bitField0_ & 0x00004000) != 0); 2318 } 2319 /** 2320 * 2321 * 2322 * <pre> 2323 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 2324 * </pre> 2325 * 2326 * <code>optional uint64 id = 3355;</code> 2327 * 2328 * @return The id. 2329 */ 2330 @java.lang.Override getId()2331 public long getId() { 2332 return id_; 2333 } 2334 2335 public static final int KIND_FIELD_NUMBER = 3292052; 2336 2337 @SuppressWarnings("serial") 2338 private volatile java.lang.Object kind_ = ""; 2339 /** 2340 * 2341 * 2342 * <pre> 2343 * [Output Only] Type of resource. Always compute#backendService for backend services. 2344 * </pre> 2345 * 2346 * <code>optional string kind = 3292052;</code> 2347 * 2348 * @return Whether the kind field is set. 2349 */ 2350 @java.lang.Override hasKind()2351 public boolean hasKind() { 2352 return ((bitField0_ & 0x00008000) != 0); 2353 } 2354 /** 2355 * 2356 * 2357 * <pre> 2358 * [Output Only] Type of resource. Always compute#backendService for backend services. 2359 * </pre> 2360 * 2361 * <code>optional string kind = 3292052;</code> 2362 * 2363 * @return The kind. 2364 */ 2365 @java.lang.Override getKind()2366 public java.lang.String getKind() { 2367 java.lang.Object ref = kind_; 2368 if (ref instanceof java.lang.String) { 2369 return (java.lang.String) ref; 2370 } else { 2371 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2372 java.lang.String s = bs.toStringUtf8(); 2373 kind_ = s; 2374 return s; 2375 } 2376 } 2377 /** 2378 * 2379 * 2380 * <pre> 2381 * [Output Only] Type of resource. Always compute#backendService for backend services. 2382 * </pre> 2383 * 2384 * <code>optional string kind = 3292052;</code> 2385 * 2386 * @return The bytes for kind. 2387 */ 2388 @java.lang.Override getKindBytes()2389 public com.google.protobuf.ByteString getKindBytes() { 2390 java.lang.Object ref = kind_; 2391 if (ref instanceof java.lang.String) { 2392 com.google.protobuf.ByteString b = 2393 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2394 kind_ = b; 2395 return b; 2396 } else { 2397 return (com.google.protobuf.ByteString) ref; 2398 } 2399 } 2400 2401 public static final int LOAD_BALANCING_SCHEME_FIELD_NUMBER = 363890244; 2402 2403 @SuppressWarnings("serial") 2404 private volatile java.lang.Object loadBalancingScheme_ = ""; 2405 /** 2406 * 2407 * 2408 * <pre> 2409 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 2410 * Check the LoadBalancingScheme enum for the list of possible values. 2411 * </pre> 2412 * 2413 * <code>optional string load_balancing_scheme = 363890244;</code> 2414 * 2415 * @return Whether the loadBalancingScheme field is set. 2416 */ 2417 @java.lang.Override hasLoadBalancingScheme()2418 public boolean hasLoadBalancingScheme() { 2419 return ((bitField0_ & 0x00010000) != 0); 2420 } 2421 /** 2422 * 2423 * 2424 * <pre> 2425 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 2426 * Check the LoadBalancingScheme enum for the list of possible values. 2427 * </pre> 2428 * 2429 * <code>optional string load_balancing_scheme = 363890244;</code> 2430 * 2431 * @return The loadBalancingScheme. 2432 */ 2433 @java.lang.Override getLoadBalancingScheme()2434 public java.lang.String getLoadBalancingScheme() { 2435 java.lang.Object ref = loadBalancingScheme_; 2436 if (ref instanceof java.lang.String) { 2437 return (java.lang.String) ref; 2438 } else { 2439 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2440 java.lang.String s = bs.toStringUtf8(); 2441 loadBalancingScheme_ = s; 2442 return s; 2443 } 2444 } 2445 /** 2446 * 2447 * 2448 * <pre> 2449 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 2450 * Check the LoadBalancingScheme enum for the list of possible values. 2451 * </pre> 2452 * 2453 * <code>optional string load_balancing_scheme = 363890244;</code> 2454 * 2455 * @return The bytes for loadBalancingScheme. 2456 */ 2457 @java.lang.Override getLoadBalancingSchemeBytes()2458 public com.google.protobuf.ByteString getLoadBalancingSchemeBytes() { 2459 java.lang.Object ref = loadBalancingScheme_; 2460 if (ref instanceof java.lang.String) { 2461 com.google.protobuf.ByteString b = 2462 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2463 loadBalancingScheme_ = b; 2464 return b; 2465 } else { 2466 return (com.google.protobuf.ByteString) ref; 2467 } 2468 } 2469 2470 public static final int LOCALITY_LB_POLICIES_FIELD_NUMBER = 140982557; 2471 2472 @SuppressWarnings("serial") 2473 private java.util.List< 2474 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig> 2475 localityLbPolicies_; 2476 /** 2477 * 2478 * 2479 * <pre> 2480 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 2481 * </pre> 2482 * 2483 * <code> 2484 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 2485 * </code> 2486 */ 2487 @java.lang.Override 2488 public java.util.List<com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig> getLocalityLbPoliciesList()2489 getLocalityLbPoliciesList() { 2490 return localityLbPolicies_; 2491 } 2492 /** 2493 * 2494 * 2495 * <pre> 2496 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 2497 * </pre> 2498 * 2499 * <code> 2500 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 2501 * </code> 2502 */ 2503 @java.lang.Override 2504 public java.util.List< 2505 ? extends 2506 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder> getLocalityLbPoliciesOrBuilderList()2507 getLocalityLbPoliciesOrBuilderList() { 2508 return localityLbPolicies_; 2509 } 2510 /** 2511 * 2512 * 2513 * <pre> 2514 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 2515 * </pre> 2516 * 2517 * <code> 2518 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 2519 * </code> 2520 */ 2521 @java.lang.Override getLocalityLbPoliciesCount()2522 public int getLocalityLbPoliciesCount() { 2523 return localityLbPolicies_.size(); 2524 } 2525 /** 2526 * 2527 * 2528 * <pre> 2529 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 2530 * </pre> 2531 * 2532 * <code> 2533 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 2534 * </code> 2535 */ 2536 @java.lang.Override 2537 public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig getLocalityLbPolicies(int index)2538 getLocalityLbPolicies(int index) { 2539 return localityLbPolicies_.get(index); 2540 } 2541 /** 2542 * 2543 * 2544 * <pre> 2545 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 2546 * </pre> 2547 * 2548 * <code> 2549 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 2550 * </code> 2551 */ 2552 @java.lang.Override 2553 public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder getLocalityLbPoliciesOrBuilder(int index)2554 getLocalityLbPoliciesOrBuilder(int index) { 2555 return localityLbPolicies_.get(index); 2556 } 2557 2558 public static final int LOCALITY_LB_POLICY_FIELD_NUMBER = 131431487; 2559 2560 @SuppressWarnings("serial") 2561 private volatile java.lang.Object localityLbPolicy_ = ""; 2562 /** 2563 * 2564 * 2565 * <pre> 2566 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 2567 * Check the LocalityLbPolicy enum for the list of possible values. 2568 * </pre> 2569 * 2570 * <code>optional string locality_lb_policy = 131431487;</code> 2571 * 2572 * @return Whether the localityLbPolicy field is set. 2573 */ 2574 @java.lang.Override hasLocalityLbPolicy()2575 public boolean hasLocalityLbPolicy() { 2576 return ((bitField0_ & 0x00020000) != 0); 2577 } 2578 /** 2579 * 2580 * 2581 * <pre> 2582 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 2583 * Check the LocalityLbPolicy enum for the list of possible values. 2584 * </pre> 2585 * 2586 * <code>optional string locality_lb_policy = 131431487;</code> 2587 * 2588 * @return The localityLbPolicy. 2589 */ 2590 @java.lang.Override getLocalityLbPolicy()2591 public java.lang.String getLocalityLbPolicy() { 2592 java.lang.Object ref = localityLbPolicy_; 2593 if (ref instanceof java.lang.String) { 2594 return (java.lang.String) ref; 2595 } else { 2596 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2597 java.lang.String s = bs.toStringUtf8(); 2598 localityLbPolicy_ = s; 2599 return s; 2600 } 2601 } 2602 /** 2603 * 2604 * 2605 * <pre> 2606 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 2607 * Check the LocalityLbPolicy enum for the list of possible values. 2608 * </pre> 2609 * 2610 * <code>optional string locality_lb_policy = 131431487;</code> 2611 * 2612 * @return The bytes for localityLbPolicy. 2613 */ 2614 @java.lang.Override getLocalityLbPolicyBytes()2615 public com.google.protobuf.ByteString getLocalityLbPolicyBytes() { 2616 java.lang.Object ref = localityLbPolicy_; 2617 if (ref instanceof java.lang.String) { 2618 com.google.protobuf.ByteString b = 2619 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2620 localityLbPolicy_ = b; 2621 return b; 2622 } else { 2623 return (com.google.protobuf.ByteString) ref; 2624 } 2625 } 2626 2627 public static final int LOG_CONFIG_FIELD_NUMBER = 351299741; 2628 private com.google.cloud.compute.v1.BackendServiceLogConfig logConfig_; 2629 /** 2630 * 2631 * 2632 * <pre> 2633 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 2634 * </pre> 2635 * 2636 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;</code> 2637 * 2638 * @return Whether the logConfig field is set. 2639 */ 2640 @java.lang.Override hasLogConfig()2641 public boolean hasLogConfig() { 2642 return ((bitField0_ & 0x00040000) != 0); 2643 } 2644 /** 2645 * 2646 * 2647 * <pre> 2648 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 2649 * </pre> 2650 * 2651 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;</code> 2652 * 2653 * @return The logConfig. 2654 */ 2655 @java.lang.Override getLogConfig()2656 public com.google.cloud.compute.v1.BackendServiceLogConfig getLogConfig() { 2657 return logConfig_ == null 2658 ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance() 2659 : logConfig_; 2660 } 2661 /** 2662 * 2663 * 2664 * <pre> 2665 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 2666 * </pre> 2667 * 2668 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741;</code> 2669 */ 2670 @java.lang.Override getLogConfigOrBuilder()2671 public com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder getLogConfigOrBuilder() { 2672 return logConfig_ == null 2673 ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance() 2674 : logConfig_; 2675 } 2676 2677 public static final int MAX_STREAM_DURATION_FIELD_NUMBER = 61428376; 2678 private com.google.cloud.compute.v1.Duration maxStreamDuration_; 2679 /** 2680 * 2681 * 2682 * <pre> 2683 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 2684 * </pre> 2685 * 2686 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 2687 * 2688 * @return Whether the maxStreamDuration field is set. 2689 */ 2690 @java.lang.Override hasMaxStreamDuration()2691 public boolean hasMaxStreamDuration() { 2692 return ((bitField0_ & 0x00080000) != 0); 2693 } 2694 /** 2695 * 2696 * 2697 * <pre> 2698 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 2699 * </pre> 2700 * 2701 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 2702 * 2703 * @return The maxStreamDuration. 2704 */ 2705 @java.lang.Override getMaxStreamDuration()2706 public com.google.cloud.compute.v1.Duration getMaxStreamDuration() { 2707 return maxStreamDuration_ == null 2708 ? com.google.cloud.compute.v1.Duration.getDefaultInstance() 2709 : maxStreamDuration_; 2710 } 2711 /** 2712 * 2713 * 2714 * <pre> 2715 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 2716 * </pre> 2717 * 2718 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 2719 */ 2720 @java.lang.Override getMaxStreamDurationOrBuilder()2721 public com.google.cloud.compute.v1.DurationOrBuilder getMaxStreamDurationOrBuilder() { 2722 return maxStreamDuration_ == null 2723 ? com.google.cloud.compute.v1.Duration.getDefaultInstance() 2724 : maxStreamDuration_; 2725 } 2726 2727 public static final int NAME_FIELD_NUMBER = 3373707; 2728 2729 @SuppressWarnings("serial") 2730 private volatile java.lang.Object name_ = ""; 2731 /** 2732 * 2733 * 2734 * <pre> 2735 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 2736 * </pre> 2737 * 2738 * <code>optional string name = 3373707;</code> 2739 * 2740 * @return Whether the name field is set. 2741 */ 2742 @java.lang.Override hasName()2743 public boolean hasName() { 2744 return ((bitField0_ & 0x00100000) != 0); 2745 } 2746 /** 2747 * 2748 * 2749 * <pre> 2750 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 2751 * </pre> 2752 * 2753 * <code>optional string name = 3373707;</code> 2754 * 2755 * @return The name. 2756 */ 2757 @java.lang.Override getName()2758 public java.lang.String getName() { 2759 java.lang.Object ref = name_; 2760 if (ref instanceof java.lang.String) { 2761 return (java.lang.String) ref; 2762 } else { 2763 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2764 java.lang.String s = bs.toStringUtf8(); 2765 name_ = s; 2766 return s; 2767 } 2768 } 2769 /** 2770 * 2771 * 2772 * <pre> 2773 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 2774 * </pre> 2775 * 2776 * <code>optional string name = 3373707;</code> 2777 * 2778 * @return The bytes for name. 2779 */ 2780 @java.lang.Override getNameBytes()2781 public com.google.protobuf.ByteString getNameBytes() { 2782 java.lang.Object ref = name_; 2783 if (ref instanceof java.lang.String) { 2784 com.google.protobuf.ByteString b = 2785 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2786 name_ = b; 2787 return b; 2788 } else { 2789 return (com.google.protobuf.ByteString) ref; 2790 } 2791 } 2792 2793 public static final int NETWORK_FIELD_NUMBER = 232872494; 2794 2795 @SuppressWarnings("serial") 2796 private volatile java.lang.Object network_ = ""; 2797 /** 2798 * 2799 * 2800 * <pre> 2801 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 2802 * </pre> 2803 * 2804 * <code>optional string network = 232872494;</code> 2805 * 2806 * @return Whether the network field is set. 2807 */ 2808 @java.lang.Override hasNetwork()2809 public boolean hasNetwork() { 2810 return ((bitField0_ & 0x00200000) != 0); 2811 } 2812 /** 2813 * 2814 * 2815 * <pre> 2816 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 2817 * </pre> 2818 * 2819 * <code>optional string network = 232872494;</code> 2820 * 2821 * @return The network. 2822 */ 2823 @java.lang.Override getNetwork()2824 public java.lang.String getNetwork() { 2825 java.lang.Object ref = network_; 2826 if (ref instanceof java.lang.String) { 2827 return (java.lang.String) ref; 2828 } else { 2829 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2830 java.lang.String s = bs.toStringUtf8(); 2831 network_ = s; 2832 return s; 2833 } 2834 } 2835 /** 2836 * 2837 * 2838 * <pre> 2839 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 2840 * </pre> 2841 * 2842 * <code>optional string network = 232872494;</code> 2843 * 2844 * @return The bytes for network. 2845 */ 2846 @java.lang.Override getNetworkBytes()2847 public com.google.protobuf.ByteString getNetworkBytes() { 2848 java.lang.Object ref = network_; 2849 if (ref instanceof java.lang.String) { 2850 com.google.protobuf.ByteString b = 2851 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 2852 network_ = b; 2853 return b; 2854 } else { 2855 return (com.google.protobuf.ByteString) ref; 2856 } 2857 } 2858 2859 public static final int OUTLIER_DETECTION_FIELD_NUMBER = 354625086; 2860 private com.google.cloud.compute.v1.OutlierDetection outlierDetection_; 2861 /** 2862 * 2863 * 2864 * <pre> 2865 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 2866 * </pre> 2867 * 2868 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;</code> 2869 * 2870 * @return Whether the outlierDetection field is set. 2871 */ 2872 @java.lang.Override hasOutlierDetection()2873 public boolean hasOutlierDetection() { 2874 return ((bitField0_ & 0x00400000) != 0); 2875 } 2876 /** 2877 * 2878 * 2879 * <pre> 2880 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 2881 * </pre> 2882 * 2883 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;</code> 2884 * 2885 * @return The outlierDetection. 2886 */ 2887 @java.lang.Override getOutlierDetection()2888 public com.google.cloud.compute.v1.OutlierDetection getOutlierDetection() { 2889 return outlierDetection_ == null 2890 ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance() 2891 : outlierDetection_; 2892 } 2893 /** 2894 * 2895 * 2896 * <pre> 2897 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 2898 * </pre> 2899 * 2900 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086;</code> 2901 */ 2902 @java.lang.Override getOutlierDetectionOrBuilder()2903 public com.google.cloud.compute.v1.OutlierDetectionOrBuilder getOutlierDetectionOrBuilder() { 2904 return outlierDetection_ == null 2905 ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance() 2906 : outlierDetection_; 2907 } 2908 2909 public static final int PORT_FIELD_NUMBER = 3446913; 2910 private int port_ = 0; 2911 /** 2912 * 2913 * 2914 * <pre> 2915 * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port. 2916 * </pre> 2917 * 2918 * <code>optional int32 port = 3446913;</code> 2919 * 2920 * @return Whether the port field is set. 2921 */ 2922 @java.lang.Override hasPort()2923 public boolean hasPort() { 2924 return ((bitField0_ & 0x00800000) != 0); 2925 } 2926 /** 2927 * 2928 * 2929 * <pre> 2930 * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port. 2931 * </pre> 2932 * 2933 * <code>optional int32 port = 3446913;</code> 2934 * 2935 * @return The port. 2936 */ 2937 @java.lang.Override getPort()2938 public int getPort() { 2939 return port_; 2940 } 2941 2942 public static final int PORT_NAME_FIELD_NUMBER = 41534345; 2943 2944 @SuppressWarnings("serial") 2945 private volatile java.lang.Object portName_ = ""; 2946 /** 2947 * 2948 * 2949 * <pre> 2950 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 2951 * </pre> 2952 * 2953 * <code>optional string port_name = 41534345;</code> 2954 * 2955 * @return Whether the portName field is set. 2956 */ 2957 @java.lang.Override hasPortName()2958 public boolean hasPortName() { 2959 return ((bitField0_ & 0x01000000) != 0); 2960 } 2961 /** 2962 * 2963 * 2964 * <pre> 2965 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 2966 * </pre> 2967 * 2968 * <code>optional string port_name = 41534345;</code> 2969 * 2970 * @return The portName. 2971 */ 2972 @java.lang.Override getPortName()2973 public java.lang.String getPortName() { 2974 java.lang.Object ref = portName_; 2975 if (ref instanceof java.lang.String) { 2976 return (java.lang.String) ref; 2977 } else { 2978 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 2979 java.lang.String s = bs.toStringUtf8(); 2980 portName_ = s; 2981 return s; 2982 } 2983 } 2984 /** 2985 * 2986 * 2987 * <pre> 2988 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 2989 * </pre> 2990 * 2991 * <code>optional string port_name = 41534345;</code> 2992 * 2993 * @return The bytes for portName. 2994 */ 2995 @java.lang.Override getPortNameBytes()2996 public com.google.protobuf.ByteString getPortNameBytes() { 2997 java.lang.Object ref = portName_; 2998 if (ref instanceof java.lang.String) { 2999 com.google.protobuf.ByteString b = 3000 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 3001 portName_ = b; 3002 return b; 3003 } else { 3004 return (com.google.protobuf.ByteString) ref; 3005 } 3006 } 3007 3008 public static final int PROTOCOL_FIELD_NUMBER = 84577944; 3009 3010 @SuppressWarnings("serial") 3011 private volatile java.lang.Object protocol_ = ""; 3012 /** 3013 * 3014 * 3015 * <pre> 3016 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 3017 * Check the Protocol enum for the list of possible values. 3018 * </pre> 3019 * 3020 * <code>optional string protocol = 84577944;</code> 3021 * 3022 * @return Whether the protocol field is set. 3023 */ 3024 @java.lang.Override hasProtocol()3025 public boolean hasProtocol() { 3026 return ((bitField0_ & 0x02000000) != 0); 3027 } 3028 /** 3029 * 3030 * 3031 * <pre> 3032 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 3033 * Check the Protocol enum for the list of possible values. 3034 * </pre> 3035 * 3036 * <code>optional string protocol = 84577944;</code> 3037 * 3038 * @return The protocol. 3039 */ 3040 @java.lang.Override getProtocol()3041 public java.lang.String getProtocol() { 3042 java.lang.Object ref = protocol_; 3043 if (ref instanceof java.lang.String) { 3044 return (java.lang.String) ref; 3045 } else { 3046 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 3047 java.lang.String s = bs.toStringUtf8(); 3048 protocol_ = s; 3049 return s; 3050 } 3051 } 3052 /** 3053 * 3054 * 3055 * <pre> 3056 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 3057 * Check the Protocol enum for the list of possible values. 3058 * </pre> 3059 * 3060 * <code>optional string protocol = 84577944;</code> 3061 * 3062 * @return The bytes for protocol. 3063 */ 3064 @java.lang.Override getProtocolBytes()3065 public com.google.protobuf.ByteString getProtocolBytes() { 3066 java.lang.Object ref = protocol_; 3067 if (ref instanceof java.lang.String) { 3068 com.google.protobuf.ByteString b = 3069 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 3070 protocol_ = b; 3071 return b; 3072 } else { 3073 return (com.google.protobuf.ByteString) ref; 3074 } 3075 } 3076 3077 public static final int REGION_FIELD_NUMBER = 138946292; 3078 3079 @SuppressWarnings("serial") 3080 private volatile java.lang.Object region_ = ""; 3081 /** 3082 * 3083 * 3084 * <pre> 3085 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 3086 * </pre> 3087 * 3088 * <code>optional string region = 138946292;</code> 3089 * 3090 * @return Whether the region field is set. 3091 */ 3092 @java.lang.Override hasRegion()3093 public boolean hasRegion() { 3094 return ((bitField0_ & 0x04000000) != 0); 3095 } 3096 /** 3097 * 3098 * 3099 * <pre> 3100 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 3101 * </pre> 3102 * 3103 * <code>optional string region = 138946292;</code> 3104 * 3105 * @return The region. 3106 */ 3107 @java.lang.Override getRegion()3108 public java.lang.String getRegion() { 3109 java.lang.Object ref = region_; 3110 if (ref instanceof java.lang.String) { 3111 return (java.lang.String) ref; 3112 } else { 3113 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 3114 java.lang.String s = bs.toStringUtf8(); 3115 region_ = s; 3116 return s; 3117 } 3118 } 3119 /** 3120 * 3121 * 3122 * <pre> 3123 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 3124 * </pre> 3125 * 3126 * <code>optional string region = 138946292;</code> 3127 * 3128 * @return The bytes for region. 3129 */ 3130 @java.lang.Override getRegionBytes()3131 public com.google.protobuf.ByteString getRegionBytes() { 3132 java.lang.Object ref = region_; 3133 if (ref instanceof java.lang.String) { 3134 com.google.protobuf.ByteString b = 3135 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 3136 region_ = b; 3137 return b; 3138 } else { 3139 return (com.google.protobuf.ByteString) ref; 3140 } 3141 } 3142 3143 public static final int SECURITY_POLICY_FIELD_NUMBER = 171082513; 3144 3145 @SuppressWarnings("serial") 3146 private volatile java.lang.Object securityPolicy_ = ""; 3147 /** 3148 * 3149 * 3150 * <pre> 3151 * [Output Only] The resource URL for the security policy associated with this backend service. 3152 * </pre> 3153 * 3154 * <code>optional string security_policy = 171082513;</code> 3155 * 3156 * @return Whether the securityPolicy field is set. 3157 */ 3158 @java.lang.Override hasSecurityPolicy()3159 public boolean hasSecurityPolicy() { 3160 return ((bitField0_ & 0x08000000) != 0); 3161 } 3162 /** 3163 * 3164 * 3165 * <pre> 3166 * [Output Only] The resource URL for the security policy associated with this backend service. 3167 * </pre> 3168 * 3169 * <code>optional string security_policy = 171082513;</code> 3170 * 3171 * @return The securityPolicy. 3172 */ 3173 @java.lang.Override getSecurityPolicy()3174 public java.lang.String getSecurityPolicy() { 3175 java.lang.Object ref = securityPolicy_; 3176 if (ref instanceof java.lang.String) { 3177 return (java.lang.String) ref; 3178 } else { 3179 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 3180 java.lang.String s = bs.toStringUtf8(); 3181 securityPolicy_ = s; 3182 return s; 3183 } 3184 } 3185 /** 3186 * 3187 * 3188 * <pre> 3189 * [Output Only] The resource URL for the security policy associated with this backend service. 3190 * </pre> 3191 * 3192 * <code>optional string security_policy = 171082513;</code> 3193 * 3194 * @return The bytes for securityPolicy. 3195 */ 3196 @java.lang.Override getSecurityPolicyBytes()3197 public com.google.protobuf.ByteString getSecurityPolicyBytes() { 3198 java.lang.Object ref = securityPolicy_; 3199 if (ref instanceof java.lang.String) { 3200 com.google.protobuf.ByteString b = 3201 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 3202 securityPolicy_ = b; 3203 return b; 3204 } else { 3205 return (com.google.protobuf.ByteString) ref; 3206 } 3207 } 3208 3209 public static final int SECURITY_SETTINGS_FIELD_NUMBER = 478649922; 3210 private com.google.cloud.compute.v1.SecuritySettings securitySettings_; 3211 /** 3212 * 3213 * 3214 * <pre> 3215 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 3216 * </pre> 3217 * 3218 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;</code> 3219 * 3220 * @return Whether the securitySettings field is set. 3221 */ 3222 @java.lang.Override hasSecuritySettings()3223 public boolean hasSecuritySettings() { 3224 return ((bitField0_ & 0x10000000) != 0); 3225 } 3226 /** 3227 * 3228 * 3229 * <pre> 3230 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 3231 * </pre> 3232 * 3233 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;</code> 3234 * 3235 * @return The securitySettings. 3236 */ 3237 @java.lang.Override getSecuritySettings()3238 public com.google.cloud.compute.v1.SecuritySettings getSecuritySettings() { 3239 return securitySettings_ == null 3240 ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance() 3241 : securitySettings_; 3242 } 3243 /** 3244 * 3245 * 3246 * <pre> 3247 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 3248 * </pre> 3249 * 3250 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922;</code> 3251 */ 3252 @java.lang.Override getSecuritySettingsOrBuilder()3253 public com.google.cloud.compute.v1.SecuritySettingsOrBuilder getSecuritySettingsOrBuilder() { 3254 return securitySettings_ == null 3255 ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance() 3256 : securitySettings_; 3257 } 3258 3259 public static final int SELF_LINK_FIELD_NUMBER = 456214797; 3260 3261 @SuppressWarnings("serial") 3262 private volatile java.lang.Object selfLink_ = ""; 3263 /** 3264 * 3265 * 3266 * <pre> 3267 * [Output Only] Server-defined URL for the resource. 3268 * </pre> 3269 * 3270 * <code>optional string self_link = 456214797;</code> 3271 * 3272 * @return Whether the selfLink field is set. 3273 */ 3274 @java.lang.Override hasSelfLink()3275 public boolean hasSelfLink() { 3276 return ((bitField0_ & 0x20000000) != 0); 3277 } 3278 /** 3279 * 3280 * 3281 * <pre> 3282 * [Output Only] Server-defined URL for the resource. 3283 * </pre> 3284 * 3285 * <code>optional string self_link = 456214797;</code> 3286 * 3287 * @return The selfLink. 3288 */ 3289 @java.lang.Override getSelfLink()3290 public java.lang.String getSelfLink() { 3291 java.lang.Object ref = selfLink_; 3292 if (ref instanceof java.lang.String) { 3293 return (java.lang.String) ref; 3294 } else { 3295 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 3296 java.lang.String s = bs.toStringUtf8(); 3297 selfLink_ = s; 3298 return s; 3299 } 3300 } 3301 /** 3302 * 3303 * 3304 * <pre> 3305 * [Output Only] Server-defined URL for the resource. 3306 * </pre> 3307 * 3308 * <code>optional string self_link = 456214797;</code> 3309 * 3310 * @return The bytes for selfLink. 3311 */ 3312 @java.lang.Override getSelfLinkBytes()3313 public com.google.protobuf.ByteString getSelfLinkBytes() { 3314 java.lang.Object ref = selfLink_; 3315 if (ref instanceof java.lang.String) { 3316 com.google.protobuf.ByteString b = 3317 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 3318 selfLink_ = b; 3319 return b; 3320 } else { 3321 return (com.google.protobuf.ByteString) ref; 3322 } 3323 } 3324 3325 public static final int SERVICE_BINDINGS_FIELD_NUMBER = 133581016; 3326 3327 @SuppressWarnings("serial") 3328 private com.google.protobuf.LazyStringList serviceBindings_; 3329 /** 3330 * 3331 * 3332 * <pre> 3333 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 3334 * </pre> 3335 * 3336 * <code>repeated string service_bindings = 133581016;</code> 3337 * 3338 * @return A list containing the serviceBindings. 3339 */ getServiceBindingsList()3340 public com.google.protobuf.ProtocolStringList getServiceBindingsList() { 3341 return serviceBindings_; 3342 } 3343 /** 3344 * 3345 * 3346 * <pre> 3347 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 3348 * </pre> 3349 * 3350 * <code>repeated string service_bindings = 133581016;</code> 3351 * 3352 * @return The count of serviceBindings. 3353 */ getServiceBindingsCount()3354 public int getServiceBindingsCount() { 3355 return serviceBindings_.size(); 3356 } 3357 /** 3358 * 3359 * 3360 * <pre> 3361 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 3362 * </pre> 3363 * 3364 * <code>repeated string service_bindings = 133581016;</code> 3365 * 3366 * @param index The index of the element to return. 3367 * @return The serviceBindings at the given index. 3368 */ getServiceBindings(int index)3369 public java.lang.String getServiceBindings(int index) { 3370 return serviceBindings_.get(index); 3371 } 3372 /** 3373 * 3374 * 3375 * <pre> 3376 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 3377 * </pre> 3378 * 3379 * <code>repeated string service_bindings = 133581016;</code> 3380 * 3381 * @param index The index of the value to return. 3382 * @return The bytes of the serviceBindings at the given index. 3383 */ getServiceBindingsBytes(int index)3384 public com.google.protobuf.ByteString getServiceBindingsBytes(int index) { 3385 return serviceBindings_.getByteString(index); 3386 } 3387 3388 public static final int SESSION_AFFINITY_FIELD_NUMBER = 463888561; 3389 3390 @SuppressWarnings("serial") 3391 private volatile java.lang.Object sessionAffinity_ = ""; 3392 /** 3393 * 3394 * 3395 * <pre> 3396 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 3397 * Check the SessionAffinity enum for the list of possible values. 3398 * </pre> 3399 * 3400 * <code>optional string session_affinity = 463888561;</code> 3401 * 3402 * @return Whether the sessionAffinity field is set. 3403 */ 3404 @java.lang.Override hasSessionAffinity()3405 public boolean hasSessionAffinity() { 3406 return ((bitField0_ & 0x40000000) != 0); 3407 } 3408 /** 3409 * 3410 * 3411 * <pre> 3412 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 3413 * Check the SessionAffinity enum for the list of possible values. 3414 * </pre> 3415 * 3416 * <code>optional string session_affinity = 463888561;</code> 3417 * 3418 * @return The sessionAffinity. 3419 */ 3420 @java.lang.Override getSessionAffinity()3421 public java.lang.String getSessionAffinity() { 3422 java.lang.Object ref = sessionAffinity_; 3423 if (ref instanceof java.lang.String) { 3424 return (java.lang.String) ref; 3425 } else { 3426 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 3427 java.lang.String s = bs.toStringUtf8(); 3428 sessionAffinity_ = s; 3429 return s; 3430 } 3431 } 3432 /** 3433 * 3434 * 3435 * <pre> 3436 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 3437 * Check the SessionAffinity enum for the list of possible values. 3438 * </pre> 3439 * 3440 * <code>optional string session_affinity = 463888561;</code> 3441 * 3442 * @return The bytes for sessionAffinity. 3443 */ 3444 @java.lang.Override getSessionAffinityBytes()3445 public com.google.protobuf.ByteString getSessionAffinityBytes() { 3446 java.lang.Object ref = sessionAffinity_; 3447 if (ref instanceof java.lang.String) { 3448 com.google.protobuf.ByteString b = 3449 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 3450 sessionAffinity_ = b; 3451 return b; 3452 } else { 3453 return (com.google.protobuf.ByteString) ref; 3454 } 3455 } 3456 3457 public static final int SUBSETTING_FIELD_NUMBER = 450283536; 3458 private com.google.cloud.compute.v1.Subsetting subsetting_; 3459 /** 3460 * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> 3461 * 3462 * @return Whether the subsetting field is set. 3463 */ 3464 @java.lang.Override hasSubsetting()3465 public boolean hasSubsetting() { 3466 return ((bitField0_ & 0x80000000) != 0); 3467 } 3468 /** 3469 * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> 3470 * 3471 * @return The subsetting. 3472 */ 3473 @java.lang.Override getSubsetting()3474 public com.google.cloud.compute.v1.Subsetting getSubsetting() { 3475 return subsetting_ == null 3476 ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance() 3477 : subsetting_; 3478 } 3479 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ 3480 @java.lang.Override getSubsettingOrBuilder()3481 public com.google.cloud.compute.v1.SubsettingOrBuilder getSubsettingOrBuilder() { 3482 return subsetting_ == null 3483 ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance() 3484 : subsetting_; 3485 } 3486 3487 public static final int TIMEOUT_SEC_FIELD_NUMBER = 79994995; 3488 private int timeoutSec_ = 0; 3489 /** 3490 * 3491 * 3492 * <pre> 3493 * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration. 3494 * </pre> 3495 * 3496 * <code>optional int32 timeout_sec = 79994995;</code> 3497 * 3498 * @return Whether the timeoutSec field is set. 3499 */ 3500 @java.lang.Override hasTimeoutSec()3501 public boolean hasTimeoutSec() { 3502 return ((bitField1_ & 0x00000001) != 0); 3503 } 3504 /** 3505 * 3506 * 3507 * <pre> 3508 * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration. 3509 * </pre> 3510 * 3511 * <code>optional int32 timeout_sec = 79994995;</code> 3512 * 3513 * @return The timeoutSec. 3514 */ 3515 @java.lang.Override getTimeoutSec()3516 public int getTimeoutSec() { 3517 return timeoutSec_; 3518 } 3519 3520 private byte memoizedIsInitialized = -1; 3521 3522 @java.lang.Override isInitialized()3523 public final boolean isInitialized() { 3524 byte isInitialized = memoizedIsInitialized; 3525 if (isInitialized == 1) return true; 3526 if (isInitialized == 0) return false; 3527 3528 memoizedIsInitialized = 1; 3529 return true; 3530 } 3531 3532 @java.lang.Override writeTo(com.google.protobuf.CodedOutputStream output)3533 public void writeTo(com.google.protobuf.CodedOutputStream output) throws java.io.IOException { 3534 if (((bitField0_ & 0x00004000) != 0)) { 3535 output.writeUInt64(3355, id_); 3536 } 3537 if (((bitField0_ & 0x00002000) != 0)) { 3538 output.writeMessage(104024, getIap()); 3539 } 3540 if (((bitField0_ & 0x00000040) != 0)) { 3541 output.writeMessage(905883, getConsistentHash()); 3542 } 3543 if (((bitField0_ & 0x00008000) != 0)) { 3544 com.google.protobuf.GeneratedMessageV3.writeString(output, 3292052, kind_); 3545 } 3546 if (((bitField0_ & 0x00100000) != 0)) { 3547 com.google.protobuf.GeneratedMessageV3.writeString(output, 3373707, name_); 3548 } 3549 if (((bitField0_ & 0x00800000) != 0)) { 3550 output.writeInt32(3446913, port_); 3551 } 3552 for (int i = 0; i < customRequestHeaders_.size(); i++) { 3553 com.google.protobuf.GeneratedMessageV3.writeString( 3554 output, 27977992, customRequestHeaders_.getRaw(i)); 3555 } 3556 if (((bitField0_ & 0x00000080) != 0)) { 3557 com.google.protobuf.GeneratedMessageV3.writeString(output, 30525366, creationTimestamp_); 3558 } 3559 if (((bitField0_ & 0x00000200) != 0)) { 3560 com.google.protobuf.GeneratedMessageV3.writeString(output, 41036943, edgeSecurityPolicy_); 3561 } 3562 if (((bitField0_ & 0x01000000) != 0)) { 3563 com.google.protobuf.GeneratedMessageV3.writeString(output, 41534345, portName_); 3564 } 3565 if (((bitField0_ & 0x00080000) != 0)) { 3566 output.writeMessage(61428376, getMaxStreamDuration()); 3567 } 3568 if (((bitField1_ & 0x00000001) != 0)) { 3569 output.writeInt32(79994995, timeoutSec_); 3570 } 3571 if (((bitField0_ & 0x02000000) != 0)) { 3572 com.google.protobuf.GeneratedMessageV3.writeString(output, 84577944, protocol_); 3573 } 3574 if (((bitField0_ & 0x00000008) != 0)) { 3575 com.google.protobuf.GeneratedMessageV3.writeString(output, 95520988, compressionMode_); 3576 } 3577 if (((bitField0_ & 0x00000800) != 0)) { 3578 output.writeMessage(105658655, getFailoverPolicy()); 3579 } 3580 if (((bitField0_ & 0x00020000) != 0)) { 3581 com.google.protobuf.GeneratedMessageV3.writeString(output, 131431487, localityLbPolicy_); 3582 } 3583 for (int i = 0; i < serviceBindings_.size(); i++) { 3584 com.google.protobuf.GeneratedMessageV3.writeString( 3585 output, 133581016, serviceBindings_.getRaw(i)); 3586 } 3587 if (((bitField0_ & 0x04000000) != 0)) { 3588 com.google.protobuf.GeneratedMessageV3.writeString(output, 138946292, region_); 3589 } 3590 for (int i = 0; i < localityLbPolicies_.size(); i++) { 3591 output.writeMessage(140982557, localityLbPolicies_.get(i)); 3592 } 3593 if (((bitField0_ & 0x00000020) != 0)) { 3594 output.writeMessage(143994969, getConnectionTrackingPolicy()); 3595 } 3596 if (((bitField0_ & 0x08000000) != 0)) { 3597 com.google.protobuf.GeneratedMessageV3.writeString(output, 171082513, securityPolicy_); 3598 } 3599 if (((bitField0_ & 0x00000002) != 0)) { 3600 output.writeMessage(213976452, getCdnPolicy()); 3601 } 3602 if (((bitField0_ & 0x00200000) != 0)) { 3603 com.google.protobuf.GeneratedMessageV3.writeString(output, 232872494, network_); 3604 } 3605 if (((bitField0_ & 0x00001000) != 0)) { 3606 com.google.protobuf.GeneratedMessageV3.writeString(output, 234678500, fingerprint_); 3607 } 3608 if (((bitField0_ & 0x00000400) != 0)) { 3609 output.writeBool(250733499, enableCDN_); 3610 } 3611 if (((bitField0_ & 0x00040000) != 0)) { 3612 output.writeMessage(351299741, getLogConfig()); 3613 } 3614 if (((bitField0_ & 0x00400000) != 0)) { 3615 output.writeMessage(354625086, getOutlierDetection()); 3616 } 3617 if (((bitField0_ & 0x00010000) != 0)) { 3618 com.google.protobuf.GeneratedMessageV3.writeString(output, 363890244, loadBalancingScheme_); 3619 } 3620 if (((bitField0_ & 0x00000001) != 0)) { 3621 output.writeInt32(369996954, affinityCookieTtlSec_); 3622 } 3623 for (int i = 0; i < customResponseHeaders_.size(); i++) { 3624 com.google.protobuf.GeneratedMessageV3.writeString( 3625 output, 387539094, customResponseHeaders_.getRaw(i)); 3626 } 3627 if (((bitField0_ & 0x00000004) != 0)) { 3628 output.writeMessage(421340061, getCircuitBreakers()); 3629 } 3630 if (((bitField0_ & 0x00000100) != 0)) { 3631 com.google.protobuf.GeneratedMessageV3.writeString(output, 422937596, description_); 3632 } 3633 for (int i = 0; i < healthChecks_.size(); i++) { 3634 com.google.protobuf.GeneratedMessageV3.writeString( 3635 output, 448370606, healthChecks_.getRaw(i)); 3636 } 3637 if (((bitField0_ & 0x80000000) != 0)) { 3638 output.writeMessage(450283536, getSubsetting()); 3639 } 3640 if (((bitField0_ & 0x20000000) != 0)) { 3641 com.google.protobuf.GeneratedMessageV3.writeString(output, 456214797, selfLink_); 3642 } 3643 if (((bitField0_ & 0x00000010) != 0)) { 3644 output.writeMessage(461096747, getConnectionDraining()); 3645 } 3646 if (((bitField0_ & 0x40000000) != 0)) { 3647 com.google.protobuf.GeneratedMessageV3.writeString(output, 463888561, sessionAffinity_); 3648 } 3649 if (((bitField0_ & 0x10000000) != 0)) { 3650 output.writeMessage(478649922, getSecuritySettings()); 3651 } 3652 for (int i = 0; i < backends_.size(); i++) { 3653 output.writeMessage(510839903, backends_.get(i)); 3654 } 3655 getUnknownFields().writeTo(output); 3656 } 3657 3658 @java.lang.Override getSerializedSize()3659 public int getSerializedSize() { 3660 int size = memoizedSize; 3661 if (size != -1) return size; 3662 3663 size = 0; 3664 if (((bitField0_ & 0x00004000) != 0)) { 3665 size += com.google.protobuf.CodedOutputStream.computeUInt64Size(3355, id_); 3666 } 3667 if (((bitField0_ & 0x00002000) != 0)) { 3668 size += com.google.protobuf.CodedOutputStream.computeMessageSize(104024, getIap()); 3669 } 3670 if (((bitField0_ & 0x00000040) != 0)) { 3671 size += com.google.protobuf.CodedOutputStream.computeMessageSize(905883, getConsistentHash()); 3672 } 3673 if (((bitField0_ & 0x00008000) != 0)) { 3674 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3292052, kind_); 3675 } 3676 if (((bitField0_ & 0x00100000) != 0)) { 3677 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3373707, name_); 3678 } 3679 if (((bitField0_ & 0x00800000) != 0)) { 3680 size += com.google.protobuf.CodedOutputStream.computeInt32Size(3446913, port_); 3681 } 3682 { 3683 int dataSize = 0; 3684 for (int i = 0; i < customRequestHeaders_.size(); i++) { 3685 dataSize += computeStringSizeNoTag(customRequestHeaders_.getRaw(i)); 3686 } 3687 size += dataSize; 3688 size += 4 * getCustomRequestHeadersList().size(); 3689 } 3690 if (((bitField0_ & 0x00000080) != 0)) { 3691 size += 3692 com.google.protobuf.GeneratedMessageV3.computeStringSize(30525366, creationTimestamp_); 3693 } 3694 if (((bitField0_ & 0x00000200) != 0)) { 3695 size += 3696 com.google.protobuf.GeneratedMessageV3.computeStringSize(41036943, edgeSecurityPolicy_); 3697 } 3698 if (((bitField0_ & 0x01000000) != 0)) { 3699 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(41534345, portName_); 3700 } 3701 if (((bitField0_ & 0x00080000) != 0)) { 3702 size += 3703 com.google.protobuf.CodedOutputStream.computeMessageSize( 3704 61428376, getMaxStreamDuration()); 3705 } 3706 if (((bitField1_ & 0x00000001) != 0)) { 3707 size += com.google.protobuf.CodedOutputStream.computeInt32Size(79994995, timeoutSec_); 3708 } 3709 if (((bitField0_ & 0x02000000) != 0)) { 3710 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(84577944, protocol_); 3711 } 3712 if (((bitField0_ & 0x00000008) != 0)) { 3713 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(95520988, compressionMode_); 3714 } 3715 if (((bitField0_ & 0x00000800) != 0)) { 3716 size += 3717 com.google.protobuf.CodedOutputStream.computeMessageSize(105658655, getFailoverPolicy()); 3718 } 3719 if (((bitField0_ & 0x00020000) != 0)) { 3720 size += 3721 com.google.protobuf.GeneratedMessageV3.computeStringSize(131431487, localityLbPolicy_); 3722 } 3723 { 3724 int dataSize = 0; 3725 for (int i = 0; i < serviceBindings_.size(); i++) { 3726 dataSize += computeStringSizeNoTag(serviceBindings_.getRaw(i)); 3727 } 3728 size += dataSize; 3729 size += 5 * getServiceBindingsList().size(); 3730 } 3731 if (((bitField0_ & 0x04000000) != 0)) { 3732 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(138946292, region_); 3733 } 3734 for (int i = 0; i < localityLbPolicies_.size(); i++) { 3735 size += 3736 com.google.protobuf.CodedOutputStream.computeMessageSize( 3737 140982557, localityLbPolicies_.get(i)); 3738 } 3739 if (((bitField0_ & 0x00000020) != 0)) { 3740 size += 3741 com.google.protobuf.CodedOutputStream.computeMessageSize( 3742 143994969, getConnectionTrackingPolicy()); 3743 } 3744 if (((bitField0_ & 0x08000000) != 0)) { 3745 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(171082513, securityPolicy_); 3746 } 3747 if (((bitField0_ & 0x00000002) != 0)) { 3748 size += com.google.protobuf.CodedOutputStream.computeMessageSize(213976452, getCdnPolicy()); 3749 } 3750 if (((bitField0_ & 0x00200000) != 0)) { 3751 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(232872494, network_); 3752 } 3753 if (((bitField0_ & 0x00001000) != 0)) { 3754 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(234678500, fingerprint_); 3755 } 3756 if (((bitField0_ & 0x00000400) != 0)) { 3757 size += com.google.protobuf.CodedOutputStream.computeBoolSize(250733499, enableCDN_); 3758 } 3759 if (((bitField0_ & 0x00040000) != 0)) { 3760 size += com.google.protobuf.CodedOutputStream.computeMessageSize(351299741, getLogConfig()); 3761 } 3762 if (((bitField0_ & 0x00400000) != 0)) { 3763 size += 3764 com.google.protobuf.CodedOutputStream.computeMessageSize( 3765 354625086, getOutlierDetection()); 3766 } 3767 if (((bitField0_ & 0x00010000) != 0)) { 3768 size += 3769 com.google.protobuf.GeneratedMessageV3.computeStringSize(363890244, loadBalancingScheme_); 3770 } 3771 if (((bitField0_ & 0x00000001) != 0)) { 3772 size += 3773 com.google.protobuf.CodedOutputStream.computeInt32Size(369996954, affinityCookieTtlSec_); 3774 } 3775 { 3776 int dataSize = 0; 3777 for (int i = 0; i < customResponseHeaders_.size(); i++) { 3778 dataSize += computeStringSizeNoTag(customResponseHeaders_.getRaw(i)); 3779 } 3780 size += dataSize; 3781 size += 5 * getCustomResponseHeadersList().size(); 3782 } 3783 if (((bitField0_ & 0x00000004) != 0)) { 3784 size += 3785 com.google.protobuf.CodedOutputStream.computeMessageSize(421340061, getCircuitBreakers()); 3786 } 3787 if (((bitField0_ & 0x00000100) != 0)) { 3788 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(422937596, description_); 3789 } 3790 { 3791 int dataSize = 0; 3792 for (int i = 0; i < healthChecks_.size(); i++) { 3793 dataSize += computeStringSizeNoTag(healthChecks_.getRaw(i)); 3794 } 3795 size += dataSize; 3796 size += 5 * getHealthChecksList().size(); 3797 } 3798 if (((bitField0_ & 0x80000000) != 0)) { 3799 size += com.google.protobuf.CodedOutputStream.computeMessageSize(450283536, getSubsetting()); 3800 } 3801 if (((bitField0_ & 0x20000000) != 0)) { 3802 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(456214797, selfLink_); 3803 } 3804 if (((bitField0_ & 0x00000010) != 0)) { 3805 size += 3806 com.google.protobuf.CodedOutputStream.computeMessageSize( 3807 461096747, getConnectionDraining()); 3808 } 3809 if (((bitField0_ & 0x40000000) != 0)) { 3810 size += com.google.protobuf.GeneratedMessageV3.computeStringSize(463888561, sessionAffinity_); 3811 } 3812 if (((bitField0_ & 0x10000000) != 0)) { 3813 size += 3814 com.google.protobuf.CodedOutputStream.computeMessageSize( 3815 478649922, getSecuritySettings()); 3816 } 3817 for (int i = 0; i < backends_.size(); i++) { 3818 size += com.google.protobuf.CodedOutputStream.computeMessageSize(510839903, backends_.get(i)); 3819 } 3820 size += getUnknownFields().getSerializedSize(); 3821 memoizedSize = size; 3822 return size; 3823 } 3824 3825 @java.lang.Override equals(final java.lang.Object obj)3826 public boolean equals(final java.lang.Object obj) { 3827 if (obj == this) { 3828 return true; 3829 } 3830 if (!(obj instanceof com.google.cloud.compute.v1.BackendService)) { 3831 return super.equals(obj); 3832 } 3833 com.google.cloud.compute.v1.BackendService other = 3834 (com.google.cloud.compute.v1.BackendService) obj; 3835 3836 if (hasAffinityCookieTtlSec() != other.hasAffinityCookieTtlSec()) return false; 3837 if (hasAffinityCookieTtlSec()) { 3838 if (getAffinityCookieTtlSec() != other.getAffinityCookieTtlSec()) return false; 3839 } 3840 if (!getBackendsList().equals(other.getBackendsList())) return false; 3841 if (hasCdnPolicy() != other.hasCdnPolicy()) return false; 3842 if (hasCdnPolicy()) { 3843 if (!getCdnPolicy().equals(other.getCdnPolicy())) return false; 3844 } 3845 if (hasCircuitBreakers() != other.hasCircuitBreakers()) return false; 3846 if (hasCircuitBreakers()) { 3847 if (!getCircuitBreakers().equals(other.getCircuitBreakers())) return false; 3848 } 3849 if (hasCompressionMode() != other.hasCompressionMode()) return false; 3850 if (hasCompressionMode()) { 3851 if (!getCompressionMode().equals(other.getCompressionMode())) return false; 3852 } 3853 if (hasConnectionDraining() != other.hasConnectionDraining()) return false; 3854 if (hasConnectionDraining()) { 3855 if (!getConnectionDraining().equals(other.getConnectionDraining())) return false; 3856 } 3857 if (hasConnectionTrackingPolicy() != other.hasConnectionTrackingPolicy()) return false; 3858 if (hasConnectionTrackingPolicy()) { 3859 if (!getConnectionTrackingPolicy().equals(other.getConnectionTrackingPolicy())) return false; 3860 } 3861 if (hasConsistentHash() != other.hasConsistentHash()) return false; 3862 if (hasConsistentHash()) { 3863 if (!getConsistentHash().equals(other.getConsistentHash())) return false; 3864 } 3865 if (hasCreationTimestamp() != other.hasCreationTimestamp()) return false; 3866 if (hasCreationTimestamp()) { 3867 if (!getCreationTimestamp().equals(other.getCreationTimestamp())) return false; 3868 } 3869 if (!getCustomRequestHeadersList().equals(other.getCustomRequestHeadersList())) return false; 3870 if (!getCustomResponseHeadersList().equals(other.getCustomResponseHeadersList())) return false; 3871 if (hasDescription() != other.hasDescription()) return false; 3872 if (hasDescription()) { 3873 if (!getDescription().equals(other.getDescription())) return false; 3874 } 3875 if (hasEdgeSecurityPolicy() != other.hasEdgeSecurityPolicy()) return false; 3876 if (hasEdgeSecurityPolicy()) { 3877 if (!getEdgeSecurityPolicy().equals(other.getEdgeSecurityPolicy())) return false; 3878 } 3879 if (hasEnableCDN() != other.hasEnableCDN()) return false; 3880 if (hasEnableCDN()) { 3881 if (getEnableCDN() != other.getEnableCDN()) return false; 3882 } 3883 if (hasFailoverPolicy() != other.hasFailoverPolicy()) return false; 3884 if (hasFailoverPolicy()) { 3885 if (!getFailoverPolicy().equals(other.getFailoverPolicy())) return false; 3886 } 3887 if (hasFingerprint() != other.hasFingerprint()) return false; 3888 if (hasFingerprint()) { 3889 if (!getFingerprint().equals(other.getFingerprint())) return false; 3890 } 3891 if (!getHealthChecksList().equals(other.getHealthChecksList())) return false; 3892 if (hasIap() != other.hasIap()) return false; 3893 if (hasIap()) { 3894 if (!getIap().equals(other.getIap())) return false; 3895 } 3896 if (hasId() != other.hasId()) return false; 3897 if (hasId()) { 3898 if (getId() != other.getId()) return false; 3899 } 3900 if (hasKind() != other.hasKind()) return false; 3901 if (hasKind()) { 3902 if (!getKind().equals(other.getKind())) return false; 3903 } 3904 if (hasLoadBalancingScheme() != other.hasLoadBalancingScheme()) return false; 3905 if (hasLoadBalancingScheme()) { 3906 if (!getLoadBalancingScheme().equals(other.getLoadBalancingScheme())) return false; 3907 } 3908 if (!getLocalityLbPoliciesList().equals(other.getLocalityLbPoliciesList())) return false; 3909 if (hasLocalityLbPolicy() != other.hasLocalityLbPolicy()) return false; 3910 if (hasLocalityLbPolicy()) { 3911 if (!getLocalityLbPolicy().equals(other.getLocalityLbPolicy())) return false; 3912 } 3913 if (hasLogConfig() != other.hasLogConfig()) return false; 3914 if (hasLogConfig()) { 3915 if (!getLogConfig().equals(other.getLogConfig())) return false; 3916 } 3917 if (hasMaxStreamDuration() != other.hasMaxStreamDuration()) return false; 3918 if (hasMaxStreamDuration()) { 3919 if (!getMaxStreamDuration().equals(other.getMaxStreamDuration())) return false; 3920 } 3921 if (hasName() != other.hasName()) return false; 3922 if (hasName()) { 3923 if (!getName().equals(other.getName())) return false; 3924 } 3925 if (hasNetwork() != other.hasNetwork()) return false; 3926 if (hasNetwork()) { 3927 if (!getNetwork().equals(other.getNetwork())) return false; 3928 } 3929 if (hasOutlierDetection() != other.hasOutlierDetection()) return false; 3930 if (hasOutlierDetection()) { 3931 if (!getOutlierDetection().equals(other.getOutlierDetection())) return false; 3932 } 3933 if (hasPort() != other.hasPort()) return false; 3934 if (hasPort()) { 3935 if (getPort() != other.getPort()) return false; 3936 } 3937 if (hasPortName() != other.hasPortName()) return false; 3938 if (hasPortName()) { 3939 if (!getPortName().equals(other.getPortName())) return false; 3940 } 3941 if (hasProtocol() != other.hasProtocol()) return false; 3942 if (hasProtocol()) { 3943 if (!getProtocol().equals(other.getProtocol())) return false; 3944 } 3945 if (hasRegion() != other.hasRegion()) return false; 3946 if (hasRegion()) { 3947 if (!getRegion().equals(other.getRegion())) return false; 3948 } 3949 if (hasSecurityPolicy() != other.hasSecurityPolicy()) return false; 3950 if (hasSecurityPolicy()) { 3951 if (!getSecurityPolicy().equals(other.getSecurityPolicy())) return false; 3952 } 3953 if (hasSecuritySettings() != other.hasSecuritySettings()) return false; 3954 if (hasSecuritySettings()) { 3955 if (!getSecuritySettings().equals(other.getSecuritySettings())) return false; 3956 } 3957 if (hasSelfLink() != other.hasSelfLink()) return false; 3958 if (hasSelfLink()) { 3959 if (!getSelfLink().equals(other.getSelfLink())) return false; 3960 } 3961 if (!getServiceBindingsList().equals(other.getServiceBindingsList())) return false; 3962 if (hasSessionAffinity() != other.hasSessionAffinity()) return false; 3963 if (hasSessionAffinity()) { 3964 if (!getSessionAffinity().equals(other.getSessionAffinity())) return false; 3965 } 3966 if (hasSubsetting() != other.hasSubsetting()) return false; 3967 if (hasSubsetting()) { 3968 if (!getSubsetting().equals(other.getSubsetting())) return false; 3969 } 3970 if (hasTimeoutSec() != other.hasTimeoutSec()) return false; 3971 if (hasTimeoutSec()) { 3972 if (getTimeoutSec() != other.getTimeoutSec()) return false; 3973 } 3974 if (!getUnknownFields().equals(other.getUnknownFields())) return false; 3975 return true; 3976 } 3977 3978 @java.lang.Override hashCode()3979 public int hashCode() { 3980 if (memoizedHashCode != 0) { 3981 return memoizedHashCode; 3982 } 3983 int hash = 41; 3984 hash = (19 * hash) + getDescriptor().hashCode(); 3985 if (hasAffinityCookieTtlSec()) { 3986 hash = (37 * hash) + AFFINITY_COOKIE_TTL_SEC_FIELD_NUMBER; 3987 hash = (53 * hash) + getAffinityCookieTtlSec(); 3988 } 3989 if (getBackendsCount() > 0) { 3990 hash = (37 * hash) + BACKENDS_FIELD_NUMBER; 3991 hash = (53 * hash) + getBackendsList().hashCode(); 3992 } 3993 if (hasCdnPolicy()) { 3994 hash = (37 * hash) + CDN_POLICY_FIELD_NUMBER; 3995 hash = (53 * hash) + getCdnPolicy().hashCode(); 3996 } 3997 if (hasCircuitBreakers()) { 3998 hash = (37 * hash) + CIRCUIT_BREAKERS_FIELD_NUMBER; 3999 hash = (53 * hash) + getCircuitBreakers().hashCode(); 4000 } 4001 if (hasCompressionMode()) { 4002 hash = (37 * hash) + COMPRESSION_MODE_FIELD_NUMBER; 4003 hash = (53 * hash) + getCompressionMode().hashCode(); 4004 } 4005 if (hasConnectionDraining()) { 4006 hash = (37 * hash) + CONNECTION_DRAINING_FIELD_NUMBER; 4007 hash = (53 * hash) + getConnectionDraining().hashCode(); 4008 } 4009 if (hasConnectionTrackingPolicy()) { 4010 hash = (37 * hash) + CONNECTION_TRACKING_POLICY_FIELD_NUMBER; 4011 hash = (53 * hash) + getConnectionTrackingPolicy().hashCode(); 4012 } 4013 if (hasConsistentHash()) { 4014 hash = (37 * hash) + CONSISTENT_HASH_FIELD_NUMBER; 4015 hash = (53 * hash) + getConsistentHash().hashCode(); 4016 } 4017 if (hasCreationTimestamp()) { 4018 hash = (37 * hash) + CREATION_TIMESTAMP_FIELD_NUMBER; 4019 hash = (53 * hash) + getCreationTimestamp().hashCode(); 4020 } 4021 if (getCustomRequestHeadersCount() > 0) { 4022 hash = (37 * hash) + CUSTOM_REQUEST_HEADERS_FIELD_NUMBER; 4023 hash = (53 * hash) + getCustomRequestHeadersList().hashCode(); 4024 } 4025 if (getCustomResponseHeadersCount() > 0) { 4026 hash = (37 * hash) + CUSTOM_RESPONSE_HEADERS_FIELD_NUMBER; 4027 hash = (53 * hash) + getCustomResponseHeadersList().hashCode(); 4028 } 4029 if (hasDescription()) { 4030 hash = (37 * hash) + DESCRIPTION_FIELD_NUMBER; 4031 hash = (53 * hash) + getDescription().hashCode(); 4032 } 4033 if (hasEdgeSecurityPolicy()) { 4034 hash = (37 * hash) + EDGE_SECURITY_POLICY_FIELD_NUMBER; 4035 hash = (53 * hash) + getEdgeSecurityPolicy().hashCode(); 4036 } 4037 if (hasEnableCDN()) { 4038 hash = (37 * hash) + ENABLE_C_D_N_FIELD_NUMBER; 4039 hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean(getEnableCDN()); 4040 } 4041 if (hasFailoverPolicy()) { 4042 hash = (37 * hash) + FAILOVER_POLICY_FIELD_NUMBER; 4043 hash = (53 * hash) + getFailoverPolicy().hashCode(); 4044 } 4045 if (hasFingerprint()) { 4046 hash = (37 * hash) + FINGERPRINT_FIELD_NUMBER; 4047 hash = (53 * hash) + getFingerprint().hashCode(); 4048 } 4049 if (getHealthChecksCount() > 0) { 4050 hash = (37 * hash) + HEALTH_CHECKS_FIELD_NUMBER; 4051 hash = (53 * hash) + getHealthChecksList().hashCode(); 4052 } 4053 if (hasIap()) { 4054 hash = (37 * hash) + IAP_FIELD_NUMBER; 4055 hash = (53 * hash) + getIap().hashCode(); 4056 } 4057 if (hasId()) { 4058 hash = (37 * hash) + ID_FIELD_NUMBER; 4059 hash = (53 * hash) + com.google.protobuf.Internal.hashLong(getId()); 4060 } 4061 if (hasKind()) { 4062 hash = (37 * hash) + KIND_FIELD_NUMBER; 4063 hash = (53 * hash) + getKind().hashCode(); 4064 } 4065 if (hasLoadBalancingScheme()) { 4066 hash = (37 * hash) + LOAD_BALANCING_SCHEME_FIELD_NUMBER; 4067 hash = (53 * hash) + getLoadBalancingScheme().hashCode(); 4068 } 4069 if (getLocalityLbPoliciesCount() > 0) { 4070 hash = (37 * hash) + LOCALITY_LB_POLICIES_FIELD_NUMBER; 4071 hash = (53 * hash) + getLocalityLbPoliciesList().hashCode(); 4072 } 4073 if (hasLocalityLbPolicy()) { 4074 hash = (37 * hash) + LOCALITY_LB_POLICY_FIELD_NUMBER; 4075 hash = (53 * hash) + getLocalityLbPolicy().hashCode(); 4076 } 4077 if (hasLogConfig()) { 4078 hash = (37 * hash) + LOG_CONFIG_FIELD_NUMBER; 4079 hash = (53 * hash) + getLogConfig().hashCode(); 4080 } 4081 if (hasMaxStreamDuration()) { 4082 hash = (37 * hash) + MAX_STREAM_DURATION_FIELD_NUMBER; 4083 hash = (53 * hash) + getMaxStreamDuration().hashCode(); 4084 } 4085 if (hasName()) { 4086 hash = (37 * hash) + NAME_FIELD_NUMBER; 4087 hash = (53 * hash) + getName().hashCode(); 4088 } 4089 if (hasNetwork()) { 4090 hash = (37 * hash) + NETWORK_FIELD_NUMBER; 4091 hash = (53 * hash) + getNetwork().hashCode(); 4092 } 4093 if (hasOutlierDetection()) { 4094 hash = (37 * hash) + OUTLIER_DETECTION_FIELD_NUMBER; 4095 hash = (53 * hash) + getOutlierDetection().hashCode(); 4096 } 4097 if (hasPort()) { 4098 hash = (37 * hash) + PORT_FIELD_NUMBER; 4099 hash = (53 * hash) + getPort(); 4100 } 4101 if (hasPortName()) { 4102 hash = (37 * hash) + PORT_NAME_FIELD_NUMBER; 4103 hash = (53 * hash) + getPortName().hashCode(); 4104 } 4105 if (hasProtocol()) { 4106 hash = (37 * hash) + PROTOCOL_FIELD_NUMBER; 4107 hash = (53 * hash) + getProtocol().hashCode(); 4108 } 4109 if (hasRegion()) { 4110 hash = (37 * hash) + REGION_FIELD_NUMBER; 4111 hash = (53 * hash) + getRegion().hashCode(); 4112 } 4113 if (hasSecurityPolicy()) { 4114 hash = (37 * hash) + SECURITY_POLICY_FIELD_NUMBER; 4115 hash = (53 * hash) + getSecurityPolicy().hashCode(); 4116 } 4117 if (hasSecuritySettings()) { 4118 hash = (37 * hash) + SECURITY_SETTINGS_FIELD_NUMBER; 4119 hash = (53 * hash) + getSecuritySettings().hashCode(); 4120 } 4121 if (hasSelfLink()) { 4122 hash = (37 * hash) + SELF_LINK_FIELD_NUMBER; 4123 hash = (53 * hash) + getSelfLink().hashCode(); 4124 } 4125 if (getServiceBindingsCount() > 0) { 4126 hash = (37 * hash) + SERVICE_BINDINGS_FIELD_NUMBER; 4127 hash = (53 * hash) + getServiceBindingsList().hashCode(); 4128 } 4129 if (hasSessionAffinity()) { 4130 hash = (37 * hash) + SESSION_AFFINITY_FIELD_NUMBER; 4131 hash = (53 * hash) + getSessionAffinity().hashCode(); 4132 } 4133 if (hasSubsetting()) { 4134 hash = (37 * hash) + SUBSETTING_FIELD_NUMBER; 4135 hash = (53 * hash) + getSubsetting().hashCode(); 4136 } 4137 if (hasTimeoutSec()) { 4138 hash = (37 * hash) + TIMEOUT_SEC_FIELD_NUMBER; 4139 hash = (53 * hash) + getTimeoutSec(); 4140 } 4141 hash = (29 * hash) + getUnknownFields().hashCode(); 4142 memoizedHashCode = hash; 4143 return hash; 4144 } 4145 parseFrom(java.nio.ByteBuffer data)4146 public static com.google.cloud.compute.v1.BackendService parseFrom(java.nio.ByteBuffer data) 4147 throws com.google.protobuf.InvalidProtocolBufferException { 4148 return PARSER.parseFrom(data); 4149 } 4150 parseFrom( java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4151 public static com.google.cloud.compute.v1.BackendService parseFrom( 4152 java.nio.ByteBuffer data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4153 throws com.google.protobuf.InvalidProtocolBufferException { 4154 return PARSER.parseFrom(data, extensionRegistry); 4155 } 4156 parseFrom( com.google.protobuf.ByteString data)4157 public static com.google.cloud.compute.v1.BackendService parseFrom( 4158 com.google.protobuf.ByteString data) 4159 throws com.google.protobuf.InvalidProtocolBufferException { 4160 return PARSER.parseFrom(data); 4161 } 4162 parseFrom( com.google.protobuf.ByteString data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4163 public static com.google.cloud.compute.v1.BackendService parseFrom( 4164 com.google.protobuf.ByteString data, 4165 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4166 throws com.google.protobuf.InvalidProtocolBufferException { 4167 return PARSER.parseFrom(data, extensionRegistry); 4168 } 4169 parseFrom(byte[] data)4170 public static com.google.cloud.compute.v1.BackendService parseFrom(byte[] data) 4171 throws com.google.protobuf.InvalidProtocolBufferException { 4172 return PARSER.parseFrom(data); 4173 } 4174 parseFrom( byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4175 public static com.google.cloud.compute.v1.BackendService parseFrom( 4176 byte[] data, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4177 throws com.google.protobuf.InvalidProtocolBufferException { 4178 return PARSER.parseFrom(data, extensionRegistry); 4179 } 4180 parseFrom(java.io.InputStream input)4181 public static com.google.cloud.compute.v1.BackendService parseFrom(java.io.InputStream input) 4182 throws java.io.IOException { 4183 return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); 4184 } 4185 parseFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4186 public static com.google.cloud.compute.v1.BackendService parseFrom( 4187 java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4188 throws java.io.IOException { 4189 return com.google.protobuf.GeneratedMessageV3.parseWithIOException( 4190 PARSER, input, extensionRegistry); 4191 } 4192 parseDelimitedFrom( java.io.InputStream input)4193 public static com.google.cloud.compute.v1.BackendService parseDelimitedFrom( 4194 java.io.InputStream input) throws java.io.IOException { 4195 return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException(PARSER, input); 4196 } 4197 parseDelimitedFrom( java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4198 public static com.google.cloud.compute.v1.BackendService parseDelimitedFrom( 4199 java.io.InputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4200 throws java.io.IOException { 4201 return com.google.protobuf.GeneratedMessageV3.parseDelimitedWithIOException( 4202 PARSER, input, extensionRegistry); 4203 } 4204 parseFrom( com.google.protobuf.CodedInputStream input)4205 public static com.google.cloud.compute.v1.BackendService parseFrom( 4206 com.google.protobuf.CodedInputStream input) throws java.io.IOException { 4207 return com.google.protobuf.GeneratedMessageV3.parseWithIOException(PARSER, input); 4208 } 4209 parseFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4210 public static com.google.cloud.compute.v1.BackendService parseFrom( 4211 com.google.protobuf.CodedInputStream input, 4212 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4213 throws java.io.IOException { 4214 return com.google.protobuf.GeneratedMessageV3.parseWithIOException( 4215 PARSER, input, extensionRegistry); 4216 } 4217 4218 @java.lang.Override newBuilderForType()4219 public Builder newBuilderForType() { 4220 return newBuilder(); 4221 } 4222 newBuilder()4223 public static Builder newBuilder() { 4224 return DEFAULT_INSTANCE.toBuilder(); 4225 } 4226 newBuilder(com.google.cloud.compute.v1.BackendService prototype)4227 public static Builder newBuilder(com.google.cloud.compute.v1.BackendService prototype) { 4228 return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); 4229 } 4230 4231 @java.lang.Override toBuilder()4232 public Builder toBuilder() { 4233 return this == DEFAULT_INSTANCE ? new Builder() : new Builder().mergeFrom(this); 4234 } 4235 4236 @java.lang.Override newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)4237 protected Builder newBuilderForType(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { 4238 Builder builder = new Builder(parent); 4239 return builder; 4240 } 4241 /** 4242 * 4243 * 4244 * <pre> 4245 * Represents a Backend Service resource. A backend service defines how Google Cloud load balancers distribute traffic. The backend service configuration contains a set of values, such as the protocol used to connect to backends, various distribution and session settings, health checks, and timeouts. These settings provide fine-grained control over how your load balancer behaves. Most of the settings have default values that allow for easy configuration if you need to get started quickly. Backend services in Google Compute Engine can be either regionally or globally scoped. * [Global](https://cloud.google.com/compute/docs/reference/rest/v1/backendServices) * [Regional](https://cloud.google.com/compute/docs/reference/rest/v1/regionBackendServices) For more information, see Backend Services. 4246 * </pre> 4247 * 4248 * Protobuf type {@code google.cloud.compute.v1.BackendService} 4249 */ 4250 public static final class Builder extends com.google.protobuf.GeneratedMessageV3.Builder<Builder> 4251 implements 4252 // @@protoc_insertion_point(builder_implements:google.cloud.compute.v1.BackendService) 4253 com.google.cloud.compute.v1.BackendServiceOrBuilder { getDescriptor()4254 public static final com.google.protobuf.Descriptors.Descriptor getDescriptor() { 4255 return com.google.cloud.compute.v1.Compute 4256 .internal_static_google_cloud_compute_v1_BackendService_descriptor; 4257 } 4258 4259 @java.lang.Override 4260 protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable internalGetFieldAccessorTable()4261 internalGetFieldAccessorTable() { 4262 return com.google.cloud.compute.v1.Compute 4263 .internal_static_google_cloud_compute_v1_BackendService_fieldAccessorTable 4264 .ensureFieldAccessorsInitialized( 4265 com.google.cloud.compute.v1.BackendService.class, 4266 com.google.cloud.compute.v1.BackendService.Builder.class); 4267 } 4268 4269 // Construct using com.google.cloud.compute.v1.BackendService.newBuilder() Builder()4270 private Builder() { 4271 maybeForceBuilderInitialization(); 4272 } 4273 Builder(com.google.protobuf.GeneratedMessageV3.BuilderParent parent)4274 private Builder(com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { 4275 super(parent); 4276 maybeForceBuilderInitialization(); 4277 } 4278 maybeForceBuilderInitialization()4279 private void maybeForceBuilderInitialization() { 4280 if (com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders) { 4281 getBackendsFieldBuilder(); 4282 getCdnPolicyFieldBuilder(); 4283 getCircuitBreakersFieldBuilder(); 4284 getConnectionDrainingFieldBuilder(); 4285 getConnectionTrackingPolicyFieldBuilder(); 4286 getConsistentHashFieldBuilder(); 4287 getFailoverPolicyFieldBuilder(); 4288 getIapFieldBuilder(); 4289 getLocalityLbPoliciesFieldBuilder(); 4290 getLogConfigFieldBuilder(); 4291 getMaxStreamDurationFieldBuilder(); 4292 getOutlierDetectionFieldBuilder(); 4293 getSecuritySettingsFieldBuilder(); 4294 getSubsettingFieldBuilder(); 4295 } 4296 } 4297 4298 @java.lang.Override clear()4299 public Builder clear() { 4300 super.clear(); 4301 bitField0_ = 0; 4302 bitField1_ = 0; 4303 affinityCookieTtlSec_ = 0; 4304 if (backendsBuilder_ == null) { 4305 backends_ = java.util.Collections.emptyList(); 4306 } else { 4307 backends_ = null; 4308 backendsBuilder_.clear(); 4309 } 4310 bitField0_ = (bitField0_ & ~0x00000002); 4311 cdnPolicy_ = null; 4312 if (cdnPolicyBuilder_ != null) { 4313 cdnPolicyBuilder_.dispose(); 4314 cdnPolicyBuilder_ = null; 4315 } 4316 circuitBreakers_ = null; 4317 if (circuitBreakersBuilder_ != null) { 4318 circuitBreakersBuilder_.dispose(); 4319 circuitBreakersBuilder_ = null; 4320 } 4321 compressionMode_ = ""; 4322 connectionDraining_ = null; 4323 if (connectionDrainingBuilder_ != null) { 4324 connectionDrainingBuilder_.dispose(); 4325 connectionDrainingBuilder_ = null; 4326 } 4327 connectionTrackingPolicy_ = null; 4328 if (connectionTrackingPolicyBuilder_ != null) { 4329 connectionTrackingPolicyBuilder_.dispose(); 4330 connectionTrackingPolicyBuilder_ = null; 4331 } 4332 consistentHash_ = null; 4333 if (consistentHashBuilder_ != null) { 4334 consistentHashBuilder_.dispose(); 4335 consistentHashBuilder_ = null; 4336 } 4337 creationTimestamp_ = ""; 4338 customRequestHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY; 4339 bitField0_ = (bitField0_ & ~0x00000200); 4340 customResponseHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY; 4341 bitField0_ = (bitField0_ & ~0x00000400); 4342 description_ = ""; 4343 edgeSecurityPolicy_ = ""; 4344 enableCDN_ = false; 4345 failoverPolicy_ = null; 4346 if (failoverPolicyBuilder_ != null) { 4347 failoverPolicyBuilder_.dispose(); 4348 failoverPolicyBuilder_ = null; 4349 } 4350 fingerprint_ = ""; 4351 healthChecks_ = com.google.protobuf.LazyStringArrayList.EMPTY; 4352 bitField0_ = (bitField0_ & ~0x00010000); 4353 iap_ = null; 4354 if (iapBuilder_ != null) { 4355 iapBuilder_.dispose(); 4356 iapBuilder_ = null; 4357 } 4358 id_ = 0L; 4359 kind_ = ""; 4360 loadBalancingScheme_ = ""; 4361 if (localityLbPoliciesBuilder_ == null) { 4362 localityLbPolicies_ = java.util.Collections.emptyList(); 4363 } else { 4364 localityLbPolicies_ = null; 4365 localityLbPoliciesBuilder_.clear(); 4366 } 4367 bitField0_ = (bitField0_ & ~0x00200000); 4368 localityLbPolicy_ = ""; 4369 logConfig_ = null; 4370 if (logConfigBuilder_ != null) { 4371 logConfigBuilder_.dispose(); 4372 logConfigBuilder_ = null; 4373 } 4374 maxStreamDuration_ = null; 4375 if (maxStreamDurationBuilder_ != null) { 4376 maxStreamDurationBuilder_.dispose(); 4377 maxStreamDurationBuilder_ = null; 4378 } 4379 name_ = ""; 4380 network_ = ""; 4381 outlierDetection_ = null; 4382 if (outlierDetectionBuilder_ != null) { 4383 outlierDetectionBuilder_.dispose(); 4384 outlierDetectionBuilder_ = null; 4385 } 4386 port_ = 0; 4387 portName_ = ""; 4388 protocol_ = ""; 4389 region_ = ""; 4390 securityPolicy_ = ""; 4391 securitySettings_ = null; 4392 if (securitySettingsBuilder_ != null) { 4393 securitySettingsBuilder_.dispose(); 4394 securitySettingsBuilder_ = null; 4395 } 4396 selfLink_ = ""; 4397 serviceBindings_ = com.google.protobuf.LazyStringArrayList.EMPTY; 4398 bitField1_ = (bitField1_ & ~0x00000008); 4399 sessionAffinity_ = ""; 4400 subsetting_ = null; 4401 if (subsettingBuilder_ != null) { 4402 subsettingBuilder_.dispose(); 4403 subsettingBuilder_ = null; 4404 } 4405 timeoutSec_ = 0; 4406 return this; 4407 } 4408 4409 @java.lang.Override getDescriptorForType()4410 public com.google.protobuf.Descriptors.Descriptor getDescriptorForType() { 4411 return com.google.cloud.compute.v1.Compute 4412 .internal_static_google_cloud_compute_v1_BackendService_descriptor; 4413 } 4414 4415 @java.lang.Override getDefaultInstanceForType()4416 public com.google.cloud.compute.v1.BackendService getDefaultInstanceForType() { 4417 return com.google.cloud.compute.v1.BackendService.getDefaultInstance(); 4418 } 4419 4420 @java.lang.Override build()4421 public com.google.cloud.compute.v1.BackendService build() { 4422 com.google.cloud.compute.v1.BackendService result = buildPartial(); 4423 if (!result.isInitialized()) { 4424 throw newUninitializedMessageException(result); 4425 } 4426 return result; 4427 } 4428 4429 @java.lang.Override buildPartial()4430 public com.google.cloud.compute.v1.BackendService buildPartial() { 4431 com.google.cloud.compute.v1.BackendService result = 4432 new com.google.cloud.compute.v1.BackendService(this); 4433 buildPartialRepeatedFields(result); 4434 if (bitField0_ != 0) { 4435 buildPartial0(result); 4436 } 4437 if (bitField1_ != 0) { 4438 buildPartial1(result); 4439 } 4440 onBuilt(); 4441 return result; 4442 } 4443 buildPartialRepeatedFields(com.google.cloud.compute.v1.BackendService result)4444 private void buildPartialRepeatedFields(com.google.cloud.compute.v1.BackendService result) { 4445 if (backendsBuilder_ == null) { 4446 if (((bitField0_ & 0x00000002) != 0)) { 4447 backends_ = java.util.Collections.unmodifiableList(backends_); 4448 bitField0_ = (bitField0_ & ~0x00000002); 4449 } 4450 result.backends_ = backends_; 4451 } else { 4452 result.backends_ = backendsBuilder_.build(); 4453 } 4454 if (((bitField0_ & 0x00000200) != 0)) { 4455 customRequestHeaders_ = customRequestHeaders_.getUnmodifiableView(); 4456 bitField0_ = (bitField0_ & ~0x00000200); 4457 } 4458 result.customRequestHeaders_ = customRequestHeaders_; 4459 if (((bitField0_ & 0x00000400) != 0)) { 4460 customResponseHeaders_ = customResponseHeaders_.getUnmodifiableView(); 4461 bitField0_ = (bitField0_ & ~0x00000400); 4462 } 4463 result.customResponseHeaders_ = customResponseHeaders_; 4464 if (((bitField0_ & 0x00010000) != 0)) { 4465 healthChecks_ = healthChecks_.getUnmodifiableView(); 4466 bitField0_ = (bitField0_ & ~0x00010000); 4467 } 4468 result.healthChecks_ = healthChecks_; 4469 if (localityLbPoliciesBuilder_ == null) { 4470 if (((bitField0_ & 0x00200000) != 0)) { 4471 localityLbPolicies_ = java.util.Collections.unmodifiableList(localityLbPolicies_); 4472 bitField0_ = (bitField0_ & ~0x00200000); 4473 } 4474 result.localityLbPolicies_ = localityLbPolicies_; 4475 } else { 4476 result.localityLbPolicies_ = localityLbPoliciesBuilder_.build(); 4477 } 4478 if (((bitField1_ & 0x00000008) != 0)) { 4479 serviceBindings_ = serviceBindings_.getUnmodifiableView(); 4480 bitField1_ = (bitField1_ & ~0x00000008); 4481 } 4482 result.serviceBindings_ = serviceBindings_; 4483 } 4484 buildPartial0(com.google.cloud.compute.v1.BackendService result)4485 private void buildPartial0(com.google.cloud.compute.v1.BackendService result) { 4486 int from_bitField0_ = bitField0_; 4487 int to_bitField0_ = 0; 4488 if (((from_bitField0_ & 0x00000001) != 0)) { 4489 result.affinityCookieTtlSec_ = affinityCookieTtlSec_; 4490 to_bitField0_ |= 0x00000001; 4491 } 4492 if (((from_bitField0_ & 0x00000004) != 0)) { 4493 result.cdnPolicy_ = cdnPolicyBuilder_ == null ? cdnPolicy_ : cdnPolicyBuilder_.build(); 4494 to_bitField0_ |= 0x00000002; 4495 } 4496 if (((from_bitField0_ & 0x00000008) != 0)) { 4497 result.circuitBreakers_ = 4498 circuitBreakersBuilder_ == null ? circuitBreakers_ : circuitBreakersBuilder_.build(); 4499 to_bitField0_ |= 0x00000004; 4500 } 4501 if (((from_bitField0_ & 0x00000010) != 0)) { 4502 result.compressionMode_ = compressionMode_; 4503 to_bitField0_ |= 0x00000008; 4504 } 4505 if (((from_bitField0_ & 0x00000020) != 0)) { 4506 result.connectionDraining_ = 4507 connectionDrainingBuilder_ == null 4508 ? connectionDraining_ 4509 : connectionDrainingBuilder_.build(); 4510 to_bitField0_ |= 0x00000010; 4511 } 4512 if (((from_bitField0_ & 0x00000040) != 0)) { 4513 result.connectionTrackingPolicy_ = 4514 connectionTrackingPolicyBuilder_ == null 4515 ? connectionTrackingPolicy_ 4516 : connectionTrackingPolicyBuilder_.build(); 4517 to_bitField0_ |= 0x00000020; 4518 } 4519 if (((from_bitField0_ & 0x00000080) != 0)) { 4520 result.consistentHash_ = 4521 consistentHashBuilder_ == null ? consistentHash_ : consistentHashBuilder_.build(); 4522 to_bitField0_ |= 0x00000040; 4523 } 4524 if (((from_bitField0_ & 0x00000100) != 0)) { 4525 result.creationTimestamp_ = creationTimestamp_; 4526 to_bitField0_ |= 0x00000080; 4527 } 4528 if (((from_bitField0_ & 0x00000800) != 0)) { 4529 result.description_ = description_; 4530 to_bitField0_ |= 0x00000100; 4531 } 4532 if (((from_bitField0_ & 0x00001000) != 0)) { 4533 result.edgeSecurityPolicy_ = edgeSecurityPolicy_; 4534 to_bitField0_ |= 0x00000200; 4535 } 4536 if (((from_bitField0_ & 0x00002000) != 0)) { 4537 result.enableCDN_ = enableCDN_; 4538 to_bitField0_ |= 0x00000400; 4539 } 4540 if (((from_bitField0_ & 0x00004000) != 0)) { 4541 result.failoverPolicy_ = 4542 failoverPolicyBuilder_ == null ? failoverPolicy_ : failoverPolicyBuilder_.build(); 4543 to_bitField0_ |= 0x00000800; 4544 } 4545 if (((from_bitField0_ & 0x00008000) != 0)) { 4546 result.fingerprint_ = fingerprint_; 4547 to_bitField0_ |= 0x00001000; 4548 } 4549 if (((from_bitField0_ & 0x00020000) != 0)) { 4550 result.iap_ = iapBuilder_ == null ? iap_ : iapBuilder_.build(); 4551 to_bitField0_ |= 0x00002000; 4552 } 4553 if (((from_bitField0_ & 0x00040000) != 0)) { 4554 result.id_ = id_; 4555 to_bitField0_ |= 0x00004000; 4556 } 4557 if (((from_bitField0_ & 0x00080000) != 0)) { 4558 result.kind_ = kind_; 4559 to_bitField0_ |= 0x00008000; 4560 } 4561 if (((from_bitField0_ & 0x00100000) != 0)) { 4562 result.loadBalancingScheme_ = loadBalancingScheme_; 4563 to_bitField0_ |= 0x00010000; 4564 } 4565 if (((from_bitField0_ & 0x00400000) != 0)) { 4566 result.localityLbPolicy_ = localityLbPolicy_; 4567 to_bitField0_ |= 0x00020000; 4568 } 4569 if (((from_bitField0_ & 0x00800000) != 0)) { 4570 result.logConfig_ = logConfigBuilder_ == null ? logConfig_ : logConfigBuilder_.build(); 4571 to_bitField0_ |= 0x00040000; 4572 } 4573 if (((from_bitField0_ & 0x01000000) != 0)) { 4574 result.maxStreamDuration_ = 4575 maxStreamDurationBuilder_ == null 4576 ? maxStreamDuration_ 4577 : maxStreamDurationBuilder_.build(); 4578 to_bitField0_ |= 0x00080000; 4579 } 4580 if (((from_bitField0_ & 0x02000000) != 0)) { 4581 result.name_ = name_; 4582 to_bitField0_ |= 0x00100000; 4583 } 4584 if (((from_bitField0_ & 0x04000000) != 0)) { 4585 result.network_ = network_; 4586 to_bitField0_ |= 0x00200000; 4587 } 4588 if (((from_bitField0_ & 0x08000000) != 0)) { 4589 result.outlierDetection_ = 4590 outlierDetectionBuilder_ == null ? outlierDetection_ : outlierDetectionBuilder_.build(); 4591 to_bitField0_ |= 0x00400000; 4592 } 4593 if (((from_bitField0_ & 0x10000000) != 0)) { 4594 result.port_ = port_; 4595 to_bitField0_ |= 0x00800000; 4596 } 4597 if (((from_bitField0_ & 0x20000000) != 0)) { 4598 result.portName_ = portName_; 4599 to_bitField0_ |= 0x01000000; 4600 } 4601 if (((from_bitField0_ & 0x40000000) != 0)) { 4602 result.protocol_ = protocol_; 4603 to_bitField0_ |= 0x02000000; 4604 } 4605 if (((from_bitField0_ & 0x80000000) != 0)) { 4606 result.region_ = region_; 4607 to_bitField0_ |= 0x04000000; 4608 } 4609 result.bitField0_ |= to_bitField0_; 4610 } 4611 buildPartial1(com.google.cloud.compute.v1.BackendService result)4612 private void buildPartial1(com.google.cloud.compute.v1.BackendService result) { 4613 int from_bitField1_ = bitField1_; 4614 int to_bitField0_ = 0; 4615 if (((from_bitField1_ & 0x00000001) != 0)) { 4616 result.securityPolicy_ = securityPolicy_; 4617 to_bitField0_ |= 0x08000000; 4618 } 4619 if (((from_bitField1_ & 0x00000002) != 0)) { 4620 result.securitySettings_ = 4621 securitySettingsBuilder_ == null ? securitySettings_ : securitySettingsBuilder_.build(); 4622 to_bitField0_ |= 0x10000000; 4623 } 4624 if (((from_bitField1_ & 0x00000004) != 0)) { 4625 result.selfLink_ = selfLink_; 4626 to_bitField0_ |= 0x20000000; 4627 } 4628 if (((from_bitField1_ & 0x00000010) != 0)) { 4629 result.sessionAffinity_ = sessionAffinity_; 4630 to_bitField0_ |= 0x40000000; 4631 } 4632 if (((from_bitField1_ & 0x00000020) != 0)) { 4633 result.subsetting_ = subsettingBuilder_ == null ? subsetting_ : subsettingBuilder_.build(); 4634 to_bitField0_ |= 0x80000000; 4635 } 4636 int to_bitField1_ = 0; 4637 if (((from_bitField1_ & 0x00000040) != 0)) { 4638 result.timeoutSec_ = timeoutSec_; 4639 to_bitField1_ |= 0x00000001; 4640 } 4641 result.bitField0_ |= to_bitField0_; 4642 result.bitField1_ |= to_bitField1_; 4643 } 4644 4645 @java.lang.Override clone()4646 public Builder clone() { 4647 return super.clone(); 4648 } 4649 4650 @java.lang.Override setField( com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)4651 public Builder setField( 4652 com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { 4653 return super.setField(field, value); 4654 } 4655 4656 @java.lang.Override clearField(com.google.protobuf.Descriptors.FieldDescriptor field)4657 public Builder clearField(com.google.protobuf.Descriptors.FieldDescriptor field) { 4658 return super.clearField(field); 4659 } 4660 4661 @java.lang.Override clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof)4662 public Builder clearOneof(com.google.protobuf.Descriptors.OneofDescriptor oneof) { 4663 return super.clearOneof(oneof); 4664 } 4665 4666 @java.lang.Override setRepeatedField( com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value)4667 public Builder setRepeatedField( 4668 com.google.protobuf.Descriptors.FieldDescriptor field, int index, java.lang.Object value) { 4669 return super.setRepeatedField(field, index, value); 4670 } 4671 4672 @java.lang.Override addRepeatedField( com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value)4673 public Builder addRepeatedField( 4674 com.google.protobuf.Descriptors.FieldDescriptor field, java.lang.Object value) { 4675 return super.addRepeatedField(field, value); 4676 } 4677 4678 @java.lang.Override mergeFrom(com.google.protobuf.Message other)4679 public Builder mergeFrom(com.google.protobuf.Message other) { 4680 if (other instanceof com.google.cloud.compute.v1.BackendService) { 4681 return mergeFrom((com.google.cloud.compute.v1.BackendService) other); 4682 } else { 4683 super.mergeFrom(other); 4684 return this; 4685 } 4686 } 4687 mergeFrom(com.google.cloud.compute.v1.BackendService other)4688 public Builder mergeFrom(com.google.cloud.compute.v1.BackendService other) { 4689 if (other == com.google.cloud.compute.v1.BackendService.getDefaultInstance()) return this; 4690 if (other.hasAffinityCookieTtlSec()) { 4691 setAffinityCookieTtlSec(other.getAffinityCookieTtlSec()); 4692 } 4693 if (backendsBuilder_ == null) { 4694 if (!other.backends_.isEmpty()) { 4695 if (backends_.isEmpty()) { 4696 backends_ = other.backends_; 4697 bitField0_ = (bitField0_ & ~0x00000002); 4698 } else { 4699 ensureBackendsIsMutable(); 4700 backends_.addAll(other.backends_); 4701 } 4702 onChanged(); 4703 } 4704 } else { 4705 if (!other.backends_.isEmpty()) { 4706 if (backendsBuilder_.isEmpty()) { 4707 backendsBuilder_.dispose(); 4708 backendsBuilder_ = null; 4709 backends_ = other.backends_; 4710 bitField0_ = (bitField0_ & ~0x00000002); 4711 backendsBuilder_ = 4712 com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders 4713 ? getBackendsFieldBuilder() 4714 : null; 4715 } else { 4716 backendsBuilder_.addAllMessages(other.backends_); 4717 } 4718 } 4719 } 4720 if (other.hasCdnPolicy()) { 4721 mergeCdnPolicy(other.getCdnPolicy()); 4722 } 4723 if (other.hasCircuitBreakers()) { 4724 mergeCircuitBreakers(other.getCircuitBreakers()); 4725 } 4726 if (other.hasCompressionMode()) { 4727 compressionMode_ = other.compressionMode_; 4728 bitField0_ |= 0x00000010; 4729 onChanged(); 4730 } 4731 if (other.hasConnectionDraining()) { 4732 mergeConnectionDraining(other.getConnectionDraining()); 4733 } 4734 if (other.hasConnectionTrackingPolicy()) { 4735 mergeConnectionTrackingPolicy(other.getConnectionTrackingPolicy()); 4736 } 4737 if (other.hasConsistentHash()) { 4738 mergeConsistentHash(other.getConsistentHash()); 4739 } 4740 if (other.hasCreationTimestamp()) { 4741 creationTimestamp_ = other.creationTimestamp_; 4742 bitField0_ |= 0x00000100; 4743 onChanged(); 4744 } 4745 if (!other.customRequestHeaders_.isEmpty()) { 4746 if (customRequestHeaders_.isEmpty()) { 4747 customRequestHeaders_ = other.customRequestHeaders_; 4748 bitField0_ = (bitField0_ & ~0x00000200); 4749 } else { 4750 ensureCustomRequestHeadersIsMutable(); 4751 customRequestHeaders_.addAll(other.customRequestHeaders_); 4752 } 4753 onChanged(); 4754 } 4755 if (!other.customResponseHeaders_.isEmpty()) { 4756 if (customResponseHeaders_.isEmpty()) { 4757 customResponseHeaders_ = other.customResponseHeaders_; 4758 bitField0_ = (bitField0_ & ~0x00000400); 4759 } else { 4760 ensureCustomResponseHeadersIsMutable(); 4761 customResponseHeaders_.addAll(other.customResponseHeaders_); 4762 } 4763 onChanged(); 4764 } 4765 if (other.hasDescription()) { 4766 description_ = other.description_; 4767 bitField0_ |= 0x00000800; 4768 onChanged(); 4769 } 4770 if (other.hasEdgeSecurityPolicy()) { 4771 edgeSecurityPolicy_ = other.edgeSecurityPolicy_; 4772 bitField0_ |= 0x00001000; 4773 onChanged(); 4774 } 4775 if (other.hasEnableCDN()) { 4776 setEnableCDN(other.getEnableCDN()); 4777 } 4778 if (other.hasFailoverPolicy()) { 4779 mergeFailoverPolicy(other.getFailoverPolicy()); 4780 } 4781 if (other.hasFingerprint()) { 4782 fingerprint_ = other.fingerprint_; 4783 bitField0_ |= 0x00008000; 4784 onChanged(); 4785 } 4786 if (!other.healthChecks_.isEmpty()) { 4787 if (healthChecks_.isEmpty()) { 4788 healthChecks_ = other.healthChecks_; 4789 bitField0_ = (bitField0_ & ~0x00010000); 4790 } else { 4791 ensureHealthChecksIsMutable(); 4792 healthChecks_.addAll(other.healthChecks_); 4793 } 4794 onChanged(); 4795 } 4796 if (other.hasIap()) { 4797 mergeIap(other.getIap()); 4798 } 4799 if (other.hasId()) { 4800 setId(other.getId()); 4801 } 4802 if (other.hasKind()) { 4803 kind_ = other.kind_; 4804 bitField0_ |= 0x00080000; 4805 onChanged(); 4806 } 4807 if (other.hasLoadBalancingScheme()) { 4808 loadBalancingScheme_ = other.loadBalancingScheme_; 4809 bitField0_ |= 0x00100000; 4810 onChanged(); 4811 } 4812 if (localityLbPoliciesBuilder_ == null) { 4813 if (!other.localityLbPolicies_.isEmpty()) { 4814 if (localityLbPolicies_.isEmpty()) { 4815 localityLbPolicies_ = other.localityLbPolicies_; 4816 bitField0_ = (bitField0_ & ~0x00200000); 4817 } else { 4818 ensureLocalityLbPoliciesIsMutable(); 4819 localityLbPolicies_.addAll(other.localityLbPolicies_); 4820 } 4821 onChanged(); 4822 } 4823 } else { 4824 if (!other.localityLbPolicies_.isEmpty()) { 4825 if (localityLbPoliciesBuilder_.isEmpty()) { 4826 localityLbPoliciesBuilder_.dispose(); 4827 localityLbPoliciesBuilder_ = null; 4828 localityLbPolicies_ = other.localityLbPolicies_; 4829 bitField0_ = (bitField0_ & ~0x00200000); 4830 localityLbPoliciesBuilder_ = 4831 com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders 4832 ? getLocalityLbPoliciesFieldBuilder() 4833 : null; 4834 } else { 4835 localityLbPoliciesBuilder_.addAllMessages(other.localityLbPolicies_); 4836 } 4837 } 4838 } 4839 if (other.hasLocalityLbPolicy()) { 4840 localityLbPolicy_ = other.localityLbPolicy_; 4841 bitField0_ |= 0x00400000; 4842 onChanged(); 4843 } 4844 if (other.hasLogConfig()) { 4845 mergeLogConfig(other.getLogConfig()); 4846 } 4847 if (other.hasMaxStreamDuration()) { 4848 mergeMaxStreamDuration(other.getMaxStreamDuration()); 4849 } 4850 if (other.hasName()) { 4851 name_ = other.name_; 4852 bitField0_ |= 0x02000000; 4853 onChanged(); 4854 } 4855 if (other.hasNetwork()) { 4856 network_ = other.network_; 4857 bitField0_ |= 0x04000000; 4858 onChanged(); 4859 } 4860 if (other.hasOutlierDetection()) { 4861 mergeOutlierDetection(other.getOutlierDetection()); 4862 } 4863 if (other.hasPort()) { 4864 setPort(other.getPort()); 4865 } 4866 if (other.hasPortName()) { 4867 portName_ = other.portName_; 4868 bitField0_ |= 0x20000000; 4869 onChanged(); 4870 } 4871 if (other.hasProtocol()) { 4872 protocol_ = other.protocol_; 4873 bitField0_ |= 0x40000000; 4874 onChanged(); 4875 } 4876 if (other.hasRegion()) { 4877 region_ = other.region_; 4878 bitField0_ |= 0x80000000; 4879 onChanged(); 4880 } 4881 if (other.hasSecurityPolicy()) { 4882 securityPolicy_ = other.securityPolicy_; 4883 bitField1_ |= 0x00000001; 4884 onChanged(); 4885 } 4886 if (other.hasSecuritySettings()) { 4887 mergeSecuritySettings(other.getSecuritySettings()); 4888 } 4889 if (other.hasSelfLink()) { 4890 selfLink_ = other.selfLink_; 4891 bitField1_ |= 0x00000004; 4892 onChanged(); 4893 } 4894 if (!other.serviceBindings_.isEmpty()) { 4895 if (serviceBindings_.isEmpty()) { 4896 serviceBindings_ = other.serviceBindings_; 4897 bitField1_ = (bitField1_ & ~0x00000008); 4898 } else { 4899 ensureServiceBindingsIsMutable(); 4900 serviceBindings_.addAll(other.serviceBindings_); 4901 } 4902 onChanged(); 4903 } 4904 if (other.hasSessionAffinity()) { 4905 sessionAffinity_ = other.sessionAffinity_; 4906 bitField1_ |= 0x00000010; 4907 onChanged(); 4908 } 4909 if (other.hasSubsetting()) { 4910 mergeSubsetting(other.getSubsetting()); 4911 } 4912 if (other.hasTimeoutSec()) { 4913 setTimeoutSec(other.getTimeoutSec()); 4914 } 4915 this.mergeUnknownFields(other.getUnknownFields()); 4916 onChanged(); 4917 return this; 4918 } 4919 4920 @java.lang.Override isInitialized()4921 public final boolean isInitialized() { 4922 return true; 4923 } 4924 4925 @java.lang.Override mergeFrom( com.google.protobuf.CodedInputStream input, com.google.protobuf.ExtensionRegistryLite extensionRegistry)4926 public Builder mergeFrom( 4927 com.google.protobuf.CodedInputStream input, 4928 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 4929 throws java.io.IOException { 4930 if (extensionRegistry == null) { 4931 throw new java.lang.NullPointerException(); 4932 } 4933 try { 4934 boolean done = false; 4935 while (!done) { 4936 int tag = input.readTag(); 4937 switch (tag) { 4938 case 0: 4939 done = true; 4940 break; 4941 case 26840: 4942 { 4943 id_ = input.readUInt64(); 4944 bitField0_ |= 0x00040000; 4945 break; 4946 } // case 26840 4947 case 832194: 4948 { 4949 input.readMessage(getIapFieldBuilder().getBuilder(), extensionRegistry); 4950 bitField0_ |= 0x00020000; 4951 break; 4952 } // case 832194 4953 case 7247066: 4954 { 4955 input.readMessage(getConsistentHashFieldBuilder().getBuilder(), extensionRegistry); 4956 bitField0_ |= 0x00000080; 4957 break; 4958 } // case 7247066 4959 case 26336418: 4960 { 4961 kind_ = input.readStringRequireUtf8(); 4962 bitField0_ |= 0x00080000; 4963 break; 4964 } // case 26336418 4965 case 26989658: 4966 { 4967 name_ = input.readStringRequireUtf8(); 4968 bitField0_ |= 0x02000000; 4969 break; 4970 } // case 26989658 4971 case 27575304: 4972 { 4973 port_ = input.readInt32(); 4974 bitField0_ |= 0x10000000; 4975 break; 4976 } // case 27575304 4977 case 223823938: 4978 { 4979 java.lang.String s = input.readStringRequireUtf8(); 4980 ensureCustomRequestHeadersIsMutable(); 4981 customRequestHeaders_.add(s); 4982 break; 4983 } // case 223823938 4984 case 244202930: 4985 { 4986 creationTimestamp_ = input.readStringRequireUtf8(); 4987 bitField0_ |= 0x00000100; 4988 break; 4989 } // case 244202930 4990 case 328295546: 4991 { 4992 edgeSecurityPolicy_ = input.readStringRequireUtf8(); 4993 bitField0_ |= 0x00001000; 4994 break; 4995 } // case 328295546 4996 case 332274762: 4997 { 4998 portName_ = input.readStringRequireUtf8(); 4999 bitField0_ |= 0x20000000; 5000 break; 5001 } // case 332274762 5002 case 491427010: 5003 { 5004 input.readMessage( 5005 getMaxStreamDurationFieldBuilder().getBuilder(), extensionRegistry); 5006 bitField0_ |= 0x01000000; 5007 break; 5008 } // case 491427010 5009 case 639959960: 5010 { 5011 timeoutSec_ = input.readInt32(); 5012 bitField1_ |= 0x00000040; 5013 break; 5014 } // case 639959960 5015 case 676623554: 5016 { 5017 protocol_ = input.readStringRequireUtf8(); 5018 bitField0_ |= 0x40000000; 5019 break; 5020 } // case 676623554 5021 case 764167906: 5022 { 5023 compressionMode_ = input.readStringRequireUtf8(); 5024 bitField0_ |= 0x00000010; 5025 break; 5026 } // case 764167906 5027 case 845269242: 5028 { 5029 input.readMessage(getFailoverPolicyFieldBuilder().getBuilder(), extensionRegistry); 5030 bitField0_ |= 0x00004000; 5031 break; 5032 } // case 845269242 5033 case 1051451898: 5034 { 5035 localityLbPolicy_ = input.readStringRequireUtf8(); 5036 bitField0_ |= 0x00400000; 5037 break; 5038 } // case 1051451898 5039 case 1068648130: 5040 { 5041 java.lang.String s = input.readStringRequireUtf8(); 5042 ensureServiceBindingsIsMutable(); 5043 serviceBindings_.add(s); 5044 break; 5045 } // case 1068648130 5046 case 1111570338: 5047 { 5048 region_ = input.readStringRequireUtf8(); 5049 bitField0_ |= 0x80000000; 5050 break; 5051 } // case 1111570338 5052 case 1127860458: 5053 { 5054 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig m = 5055 input.readMessage( 5056 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig 5057 .parser(), 5058 extensionRegistry); 5059 if (localityLbPoliciesBuilder_ == null) { 5060 ensureLocalityLbPoliciesIsMutable(); 5061 localityLbPolicies_.add(m); 5062 } else { 5063 localityLbPoliciesBuilder_.addMessage(m); 5064 } 5065 break; 5066 } // case 1127860458 5067 case 1151959754: 5068 { 5069 input.readMessage( 5070 getConnectionTrackingPolicyFieldBuilder().getBuilder(), extensionRegistry); 5071 bitField0_ |= 0x00000040; 5072 break; 5073 } // case 1151959754 5074 case 1368660106: 5075 { 5076 securityPolicy_ = input.readStringRequireUtf8(); 5077 bitField1_ |= 0x00000001; 5078 break; 5079 } // case 1368660106 5080 case 1711811618: 5081 { 5082 input.readMessage(getCdnPolicyFieldBuilder().getBuilder(), extensionRegistry); 5083 bitField0_ |= 0x00000004; 5084 break; 5085 } // case 1711811618 5086 case 1862979954: 5087 { 5088 network_ = input.readStringRequireUtf8(); 5089 bitField0_ |= 0x04000000; 5090 break; 5091 } // case 1862979954 5092 case 1877428002: 5093 { 5094 fingerprint_ = input.readStringRequireUtf8(); 5095 bitField0_ |= 0x00008000; 5096 break; 5097 } // case 1877428002 5098 case 2005867992: 5099 { 5100 enableCDN_ = input.readBool(); 5101 bitField0_ |= 0x00002000; 5102 break; 5103 } // case 2005867992 5104 case -1484569366: 5105 { 5106 input.readMessage(getLogConfigFieldBuilder().getBuilder(), extensionRegistry); 5107 bitField0_ |= 0x00800000; 5108 break; 5109 } // case -1484569366 5110 case -1457966606: 5111 { 5112 input.readMessage( 5113 getOutlierDetectionFieldBuilder().getBuilder(), extensionRegistry); 5114 bitField0_ |= 0x08000000; 5115 break; 5116 } // case -1457966606 5117 case -1383845342: 5118 { 5119 loadBalancingScheme_ = input.readStringRequireUtf8(); 5120 bitField0_ |= 0x00100000; 5121 break; 5122 } // case -1383845342 5123 case -1334991664: 5124 { 5125 affinityCookieTtlSec_ = input.readInt32(); 5126 bitField0_ |= 0x00000001; 5127 break; 5128 } // case -1334991664 5129 case -1194654542: 5130 { 5131 java.lang.String s = input.readStringRequireUtf8(); 5132 ensureCustomResponseHeadersIsMutable(); 5133 customResponseHeaders_.add(s); 5134 break; 5135 } // case -1194654542 5136 case -924246806: 5137 { 5138 input.readMessage(getCircuitBreakersFieldBuilder().getBuilder(), extensionRegistry); 5139 bitField0_ |= 0x00000008; 5140 break; 5141 } // case -924246806 5142 case -911466526: 5143 { 5144 description_ = input.readStringRequireUtf8(); 5145 bitField0_ |= 0x00000800; 5146 break; 5147 } // case -911466526 5148 case -708002446: 5149 { 5150 java.lang.String s = input.readStringRequireUtf8(); 5151 ensureHealthChecksIsMutable(); 5152 healthChecks_.add(s); 5153 break; 5154 } // case -708002446 5155 case -692699006: 5156 { 5157 input.readMessage(getSubsettingFieldBuilder().getBuilder(), extensionRegistry); 5158 bitField1_ |= 0x00000020; 5159 break; 5160 } // case -692699006 5161 case -645248918: 5162 { 5163 selfLink_ = input.readStringRequireUtf8(); 5164 bitField1_ |= 0x00000004; 5165 break; 5166 } // case -645248918 5167 case -606193318: 5168 { 5169 input.readMessage( 5170 getConnectionDrainingFieldBuilder().getBuilder(), extensionRegistry); 5171 bitField0_ |= 0x00000020; 5172 break; 5173 } // case -606193318 5174 case -583858806: 5175 { 5176 sessionAffinity_ = input.readStringRequireUtf8(); 5177 bitField1_ |= 0x00000010; 5178 break; 5179 } // case -583858806 5180 case -465767918: 5181 { 5182 input.readMessage( 5183 getSecuritySettingsFieldBuilder().getBuilder(), extensionRegistry); 5184 bitField1_ |= 0x00000002; 5185 break; 5186 } // case -465767918 5187 case -208248070: 5188 { 5189 com.google.cloud.compute.v1.Backend m = 5190 input.readMessage( 5191 com.google.cloud.compute.v1.Backend.parser(), extensionRegistry); 5192 if (backendsBuilder_ == null) { 5193 ensureBackendsIsMutable(); 5194 backends_.add(m); 5195 } else { 5196 backendsBuilder_.addMessage(m); 5197 } 5198 break; 5199 } // case -208248070 5200 default: 5201 { 5202 if (!super.parseUnknownField(input, extensionRegistry, tag)) { 5203 done = true; // was an endgroup tag 5204 } 5205 break; 5206 } // default: 5207 } // switch (tag) 5208 } // while (!done) 5209 } catch (com.google.protobuf.InvalidProtocolBufferException e) { 5210 throw e.unwrapIOException(); 5211 } finally { 5212 onChanged(); 5213 } // finally 5214 return this; 5215 } 5216 5217 private int bitField0_; 5218 private int bitField1_; 5219 5220 private int affinityCookieTtlSec_; 5221 /** 5222 * 5223 * 5224 * <pre> 5225 * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 5226 * </pre> 5227 * 5228 * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code> 5229 * 5230 * @return Whether the affinityCookieTtlSec field is set. 5231 */ 5232 @java.lang.Override hasAffinityCookieTtlSec()5233 public boolean hasAffinityCookieTtlSec() { 5234 return ((bitField0_ & 0x00000001) != 0); 5235 } 5236 /** 5237 * 5238 * 5239 * <pre> 5240 * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 5241 * </pre> 5242 * 5243 * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code> 5244 * 5245 * @return The affinityCookieTtlSec. 5246 */ 5247 @java.lang.Override getAffinityCookieTtlSec()5248 public int getAffinityCookieTtlSec() { 5249 return affinityCookieTtlSec_; 5250 } 5251 /** 5252 * 5253 * 5254 * <pre> 5255 * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 5256 * </pre> 5257 * 5258 * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code> 5259 * 5260 * @param value The affinityCookieTtlSec to set. 5261 * @return This builder for chaining. 5262 */ setAffinityCookieTtlSec(int value)5263 public Builder setAffinityCookieTtlSec(int value) { 5264 5265 affinityCookieTtlSec_ = value; 5266 bitField0_ |= 0x00000001; 5267 onChanged(); 5268 return this; 5269 } 5270 /** 5271 * 5272 * 5273 * <pre> 5274 * Lifetime of cookies in seconds. This setting is applicable to external and internal HTTP(S) load balancers and Traffic Director and requires GENERATED_COOKIE or HTTP_COOKIE session affinity. If set to 0, the cookie is non-persistent and lasts only until the end of the browser session (or equivalent). The maximum allowed value is two weeks (1,209,600). Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 5275 * </pre> 5276 * 5277 * <code>optional int32 affinity_cookie_ttl_sec = 369996954;</code> 5278 * 5279 * @return This builder for chaining. 5280 */ clearAffinityCookieTtlSec()5281 public Builder clearAffinityCookieTtlSec() { 5282 bitField0_ = (bitField0_ & ~0x00000001); 5283 affinityCookieTtlSec_ = 0; 5284 onChanged(); 5285 return this; 5286 } 5287 5288 private java.util.List<com.google.cloud.compute.v1.Backend> backends_ = 5289 java.util.Collections.emptyList(); 5290 ensureBackendsIsMutable()5291 private void ensureBackendsIsMutable() { 5292 if (!((bitField0_ & 0x00000002) != 0)) { 5293 backends_ = new java.util.ArrayList<com.google.cloud.compute.v1.Backend>(backends_); 5294 bitField0_ |= 0x00000002; 5295 } 5296 } 5297 5298 private com.google.protobuf.RepeatedFieldBuilderV3< 5299 com.google.cloud.compute.v1.Backend, 5300 com.google.cloud.compute.v1.Backend.Builder, 5301 com.google.cloud.compute.v1.BackendOrBuilder> 5302 backendsBuilder_; 5303 5304 /** 5305 * 5306 * 5307 * <pre> 5308 * The list of backends that serve this BackendService. 5309 * </pre> 5310 * 5311 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5312 */ getBackendsList()5313 public java.util.List<com.google.cloud.compute.v1.Backend> getBackendsList() { 5314 if (backendsBuilder_ == null) { 5315 return java.util.Collections.unmodifiableList(backends_); 5316 } else { 5317 return backendsBuilder_.getMessageList(); 5318 } 5319 } 5320 /** 5321 * 5322 * 5323 * <pre> 5324 * The list of backends that serve this BackendService. 5325 * </pre> 5326 * 5327 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5328 */ getBackendsCount()5329 public int getBackendsCount() { 5330 if (backendsBuilder_ == null) { 5331 return backends_.size(); 5332 } else { 5333 return backendsBuilder_.getCount(); 5334 } 5335 } 5336 /** 5337 * 5338 * 5339 * <pre> 5340 * The list of backends that serve this BackendService. 5341 * </pre> 5342 * 5343 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5344 */ getBackends(int index)5345 public com.google.cloud.compute.v1.Backend getBackends(int index) { 5346 if (backendsBuilder_ == null) { 5347 return backends_.get(index); 5348 } else { 5349 return backendsBuilder_.getMessage(index); 5350 } 5351 } 5352 /** 5353 * 5354 * 5355 * <pre> 5356 * The list of backends that serve this BackendService. 5357 * </pre> 5358 * 5359 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5360 */ setBackends(int index, com.google.cloud.compute.v1.Backend value)5361 public Builder setBackends(int index, com.google.cloud.compute.v1.Backend value) { 5362 if (backendsBuilder_ == null) { 5363 if (value == null) { 5364 throw new NullPointerException(); 5365 } 5366 ensureBackendsIsMutable(); 5367 backends_.set(index, value); 5368 onChanged(); 5369 } else { 5370 backendsBuilder_.setMessage(index, value); 5371 } 5372 return this; 5373 } 5374 /** 5375 * 5376 * 5377 * <pre> 5378 * The list of backends that serve this BackendService. 5379 * </pre> 5380 * 5381 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5382 */ setBackends( int index, com.google.cloud.compute.v1.Backend.Builder builderForValue)5383 public Builder setBackends( 5384 int index, com.google.cloud.compute.v1.Backend.Builder builderForValue) { 5385 if (backendsBuilder_ == null) { 5386 ensureBackendsIsMutable(); 5387 backends_.set(index, builderForValue.build()); 5388 onChanged(); 5389 } else { 5390 backendsBuilder_.setMessage(index, builderForValue.build()); 5391 } 5392 return this; 5393 } 5394 /** 5395 * 5396 * 5397 * <pre> 5398 * The list of backends that serve this BackendService. 5399 * </pre> 5400 * 5401 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5402 */ addBackends(com.google.cloud.compute.v1.Backend value)5403 public Builder addBackends(com.google.cloud.compute.v1.Backend value) { 5404 if (backendsBuilder_ == null) { 5405 if (value == null) { 5406 throw new NullPointerException(); 5407 } 5408 ensureBackendsIsMutable(); 5409 backends_.add(value); 5410 onChanged(); 5411 } else { 5412 backendsBuilder_.addMessage(value); 5413 } 5414 return this; 5415 } 5416 /** 5417 * 5418 * 5419 * <pre> 5420 * The list of backends that serve this BackendService. 5421 * </pre> 5422 * 5423 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5424 */ addBackends(int index, com.google.cloud.compute.v1.Backend value)5425 public Builder addBackends(int index, com.google.cloud.compute.v1.Backend value) { 5426 if (backendsBuilder_ == null) { 5427 if (value == null) { 5428 throw new NullPointerException(); 5429 } 5430 ensureBackendsIsMutable(); 5431 backends_.add(index, value); 5432 onChanged(); 5433 } else { 5434 backendsBuilder_.addMessage(index, value); 5435 } 5436 return this; 5437 } 5438 /** 5439 * 5440 * 5441 * <pre> 5442 * The list of backends that serve this BackendService. 5443 * </pre> 5444 * 5445 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5446 */ addBackends(com.google.cloud.compute.v1.Backend.Builder builderForValue)5447 public Builder addBackends(com.google.cloud.compute.v1.Backend.Builder builderForValue) { 5448 if (backendsBuilder_ == null) { 5449 ensureBackendsIsMutable(); 5450 backends_.add(builderForValue.build()); 5451 onChanged(); 5452 } else { 5453 backendsBuilder_.addMessage(builderForValue.build()); 5454 } 5455 return this; 5456 } 5457 /** 5458 * 5459 * 5460 * <pre> 5461 * The list of backends that serve this BackendService. 5462 * </pre> 5463 * 5464 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5465 */ addBackends( int index, com.google.cloud.compute.v1.Backend.Builder builderForValue)5466 public Builder addBackends( 5467 int index, com.google.cloud.compute.v1.Backend.Builder builderForValue) { 5468 if (backendsBuilder_ == null) { 5469 ensureBackendsIsMutable(); 5470 backends_.add(index, builderForValue.build()); 5471 onChanged(); 5472 } else { 5473 backendsBuilder_.addMessage(index, builderForValue.build()); 5474 } 5475 return this; 5476 } 5477 /** 5478 * 5479 * 5480 * <pre> 5481 * The list of backends that serve this BackendService. 5482 * </pre> 5483 * 5484 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5485 */ addAllBackends( java.lang.Iterable<? extends com.google.cloud.compute.v1.Backend> values)5486 public Builder addAllBackends( 5487 java.lang.Iterable<? extends com.google.cloud.compute.v1.Backend> values) { 5488 if (backendsBuilder_ == null) { 5489 ensureBackendsIsMutable(); 5490 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, backends_); 5491 onChanged(); 5492 } else { 5493 backendsBuilder_.addAllMessages(values); 5494 } 5495 return this; 5496 } 5497 /** 5498 * 5499 * 5500 * <pre> 5501 * The list of backends that serve this BackendService. 5502 * </pre> 5503 * 5504 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5505 */ clearBackends()5506 public Builder clearBackends() { 5507 if (backendsBuilder_ == null) { 5508 backends_ = java.util.Collections.emptyList(); 5509 bitField0_ = (bitField0_ & ~0x00000002); 5510 onChanged(); 5511 } else { 5512 backendsBuilder_.clear(); 5513 } 5514 return this; 5515 } 5516 /** 5517 * 5518 * 5519 * <pre> 5520 * The list of backends that serve this BackendService. 5521 * </pre> 5522 * 5523 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5524 */ removeBackends(int index)5525 public Builder removeBackends(int index) { 5526 if (backendsBuilder_ == null) { 5527 ensureBackendsIsMutable(); 5528 backends_.remove(index); 5529 onChanged(); 5530 } else { 5531 backendsBuilder_.remove(index); 5532 } 5533 return this; 5534 } 5535 /** 5536 * 5537 * 5538 * <pre> 5539 * The list of backends that serve this BackendService. 5540 * </pre> 5541 * 5542 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5543 */ getBackendsBuilder(int index)5544 public com.google.cloud.compute.v1.Backend.Builder getBackendsBuilder(int index) { 5545 return getBackendsFieldBuilder().getBuilder(index); 5546 } 5547 /** 5548 * 5549 * 5550 * <pre> 5551 * The list of backends that serve this BackendService. 5552 * </pre> 5553 * 5554 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5555 */ getBackendsOrBuilder(int index)5556 public com.google.cloud.compute.v1.BackendOrBuilder getBackendsOrBuilder(int index) { 5557 if (backendsBuilder_ == null) { 5558 return backends_.get(index); 5559 } else { 5560 return backendsBuilder_.getMessageOrBuilder(index); 5561 } 5562 } 5563 /** 5564 * 5565 * 5566 * <pre> 5567 * The list of backends that serve this BackendService. 5568 * </pre> 5569 * 5570 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5571 */ 5572 public java.util.List<? extends com.google.cloud.compute.v1.BackendOrBuilder> getBackendsOrBuilderList()5573 getBackendsOrBuilderList() { 5574 if (backendsBuilder_ != null) { 5575 return backendsBuilder_.getMessageOrBuilderList(); 5576 } else { 5577 return java.util.Collections.unmodifiableList(backends_); 5578 } 5579 } 5580 /** 5581 * 5582 * 5583 * <pre> 5584 * The list of backends that serve this BackendService. 5585 * </pre> 5586 * 5587 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5588 */ addBackendsBuilder()5589 public com.google.cloud.compute.v1.Backend.Builder addBackendsBuilder() { 5590 return getBackendsFieldBuilder() 5591 .addBuilder(com.google.cloud.compute.v1.Backend.getDefaultInstance()); 5592 } 5593 /** 5594 * 5595 * 5596 * <pre> 5597 * The list of backends that serve this BackendService. 5598 * </pre> 5599 * 5600 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5601 */ addBackendsBuilder(int index)5602 public com.google.cloud.compute.v1.Backend.Builder addBackendsBuilder(int index) { 5603 return getBackendsFieldBuilder() 5604 .addBuilder(index, com.google.cloud.compute.v1.Backend.getDefaultInstance()); 5605 } 5606 /** 5607 * 5608 * 5609 * <pre> 5610 * The list of backends that serve this BackendService. 5611 * </pre> 5612 * 5613 * <code>repeated .google.cloud.compute.v1.Backend backends = 510839903;</code> 5614 */ getBackendsBuilderList()5615 public java.util.List<com.google.cloud.compute.v1.Backend.Builder> getBackendsBuilderList() { 5616 return getBackendsFieldBuilder().getBuilderList(); 5617 } 5618 5619 private com.google.protobuf.RepeatedFieldBuilderV3< 5620 com.google.cloud.compute.v1.Backend, 5621 com.google.cloud.compute.v1.Backend.Builder, 5622 com.google.cloud.compute.v1.BackendOrBuilder> getBackendsFieldBuilder()5623 getBackendsFieldBuilder() { 5624 if (backendsBuilder_ == null) { 5625 backendsBuilder_ = 5626 new com.google.protobuf.RepeatedFieldBuilderV3< 5627 com.google.cloud.compute.v1.Backend, 5628 com.google.cloud.compute.v1.Backend.Builder, 5629 com.google.cloud.compute.v1.BackendOrBuilder>( 5630 backends_, ((bitField0_ & 0x00000002) != 0), getParentForChildren(), isClean()); 5631 backends_ = null; 5632 } 5633 return backendsBuilder_; 5634 } 5635 5636 private com.google.cloud.compute.v1.BackendServiceCdnPolicy cdnPolicy_; 5637 private com.google.protobuf.SingleFieldBuilderV3< 5638 com.google.cloud.compute.v1.BackendServiceCdnPolicy, 5639 com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder, 5640 com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder> 5641 cdnPolicyBuilder_; 5642 /** 5643 * 5644 * 5645 * <pre> 5646 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5647 * </pre> 5648 * 5649 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5650 * </code> 5651 * 5652 * @return Whether the cdnPolicy field is set. 5653 */ hasCdnPolicy()5654 public boolean hasCdnPolicy() { 5655 return ((bitField0_ & 0x00000004) != 0); 5656 } 5657 /** 5658 * 5659 * 5660 * <pre> 5661 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5662 * </pre> 5663 * 5664 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5665 * </code> 5666 * 5667 * @return The cdnPolicy. 5668 */ getCdnPolicy()5669 public com.google.cloud.compute.v1.BackendServiceCdnPolicy getCdnPolicy() { 5670 if (cdnPolicyBuilder_ == null) { 5671 return cdnPolicy_ == null 5672 ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance() 5673 : cdnPolicy_; 5674 } else { 5675 return cdnPolicyBuilder_.getMessage(); 5676 } 5677 } 5678 /** 5679 * 5680 * 5681 * <pre> 5682 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5683 * </pre> 5684 * 5685 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5686 * </code> 5687 */ setCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value)5688 public Builder setCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value) { 5689 if (cdnPolicyBuilder_ == null) { 5690 if (value == null) { 5691 throw new NullPointerException(); 5692 } 5693 cdnPolicy_ = value; 5694 } else { 5695 cdnPolicyBuilder_.setMessage(value); 5696 } 5697 bitField0_ |= 0x00000004; 5698 onChanged(); 5699 return this; 5700 } 5701 /** 5702 * 5703 * 5704 * <pre> 5705 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5706 * </pre> 5707 * 5708 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5709 * </code> 5710 */ setCdnPolicy( com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder builderForValue)5711 public Builder setCdnPolicy( 5712 com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder builderForValue) { 5713 if (cdnPolicyBuilder_ == null) { 5714 cdnPolicy_ = builderForValue.build(); 5715 } else { 5716 cdnPolicyBuilder_.setMessage(builderForValue.build()); 5717 } 5718 bitField0_ |= 0x00000004; 5719 onChanged(); 5720 return this; 5721 } 5722 /** 5723 * 5724 * 5725 * <pre> 5726 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5727 * </pre> 5728 * 5729 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5730 * </code> 5731 */ mergeCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value)5732 public Builder mergeCdnPolicy(com.google.cloud.compute.v1.BackendServiceCdnPolicy value) { 5733 if (cdnPolicyBuilder_ == null) { 5734 if (((bitField0_ & 0x00000004) != 0) 5735 && cdnPolicy_ != null 5736 && cdnPolicy_ 5737 != com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance()) { 5738 getCdnPolicyBuilder().mergeFrom(value); 5739 } else { 5740 cdnPolicy_ = value; 5741 } 5742 } else { 5743 cdnPolicyBuilder_.mergeFrom(value); 5744 } 5745 bitField0_ |= 0x00000004; 5746 onChanged(); 5747 return this; 5748 } 5749 /** 5750 * 5751 * 5752 * <pre> 5753 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5754 * </pre> 5755 * 5756 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5757 * </code> 5758 */ clearCdnPolicy()5759 public Builder clearCdnPolicy() { 5760 bitField0_ = (bitField0_ & ~0x00000004); 5761 cdnPolicy_ = null; 5762 if (cdnPolicyBuilder_ != null) { 5763 cdnPolicyBuilder_.dispose(); 5764 cdnPolicyBuilder_ = null; 5765 } 5766 onChanged(); 5767 return this; 5768 } 5769 /** 5770 * 5771 * 5772 * <pre> 5773 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5774 * </pre> 5775 * 5776 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5777 * </code> 5778 */ getCdnPolicyBuilder()5779 public com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder getCdnPolicyBuilder() { 5780 bitField0_ |= 0x00000004; 5781 onChanged(); 5782 return getCdnPolicyFieldBuilder().getBuilder(); 5783 } 5784 /** 5785 * 5786 * 5787 * <pre> 5788 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5789 * </pre> 5790 * 5791 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5792 * </code> 5793 */ getCdnPolicyOrBuilder()5794 public com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder getCdnPolicyOrBuilder() { 5795 if (cdnPolicyBuilder_ != null) { 5796 return cdnPolicyBuilder_.getMessageOrBuilder(); 5797 } else { 5798 return cdnPolicy_ == null 5799 ? com.google.cloud.compute.v1.BackendServiceCdnPolicy.getDefaultInstance() 5800 : cdnPolicy_; 5801 } 5802 } 5803 /** 5804 * 5805 * 5806 * <pre> 5807 * Cloud CDN configuration for this BackendService. Only available for specified load balancer types. 5808 * </pre> 5809 * 5810 * <code>optional .google.cloud.compute.v1.BackendServiceCdnPolicy cdn_policy = 213976452; 5811 * </code> 5812 */ 5813 private com.google.protobuf.SingleFieldBuilderV3< 5814 com.google.cloud.compute.v1.BackendServiceCdnPolicy, 5815 com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder, 5816 com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder> getCdnPolicyFieldBuilder()5817 getCdnPolicyFieldBuilder() { 5818 if (cdnPolicyBuilder_ == null) { 5819 cdnPolicyBuilder_ = 5820 new com.google.protobuf.SingleFieldBuilderV3< 5821 com.google.cloud.compute.v1.BackendServiceCdnPolicy, 5822 com.google.cloud.compute.v1.BackendServiceCdnPolicy.Builder, 5823 com.google.cloud.compute.v1.BackendServiceCdnPolicyOrBuilder>( 5824 getCdnPolicy(), getParentForChildren(), isClean()); 5825 cdnPolicy_ = null; 5826 } 5827 return cdnPolicyBuilder_; 5828 } 5829 5830 private com.google.cloud.compute.v1.CircuitBreakers circuitBreakers_; 5831 private com.google.protobuf.SingleFieldBuilderV3< 5832 com.google.cloud.compute.v1.CircuitBreakers, 5833 com.google.cloud.compute.v1.CircuitBreakers.Builder, 5834 com.google.cloud.compute.v1.CircuitBreakersOrBuilder> 5835 circuitBreakersBuilder_; 5836 /** 5837 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5838 * 5839 * @return Whether the circuitBreakers field is set. 5840 */ hasCircuitBreakers()5841 public boolean hasCircuitBreakers() { 5842 return ((bitField0_ & 0x00000008) != 0); 5843 } 5844 /** 5845 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5846 * 5847 * @return The circuitBreakers. 5848 */ getCircuitBreakers()5849 public com.google.cloud.compute.v1.CircuitBreakers getCircuitBreakers() { 5850 if (circuitBreakersBuilder_ == null) { 5851 return circuitBreakers_ == null 5852 ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance() 5853 : circuitBreakers_; 5854 } else { 5855 return circuitBreakersBuilder_.getMessage(); 5856 } 5857 } 5858 /** 5859 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5860 */ setCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value)5861 public Builder setCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value) { 5862 if (circuitBreakersBuilder_ == null) { 5863 if (value == null) { 5864 throw new NullPointerException(); 5865 } 5866 circuitBreakers_ = value; 5867 } else { 5868 circuitBreakersBuilder_.setMessage(value); 5869 } 5870 bitField0_ |= 0x00000008; 5871 onChanged(); 5872 return this; 5873 } 5874 /** 5875 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5876 */ setCircuitBreakers( com.google.cloud.compute.v1.CircuitBreakers.Builder builderForValue)5877 public Builder setCircuitBreakers( 5878 com.google.cloud.compute.v1.CircuitBreakers.Builder builderForValue) { 5879 if (circuitBreakersBuilder_ == null) { 5880 circuitBreakers_ = builderForValue.build(); 5881 } else { 5882 circuitBreakersBuilder_.setMessage(builderForValue.build()); 5883 } 5884 bitField0_ |= 0x00000008; 5885 onChanged(); 5886 return this; 5887 } 5888 /** 5889 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5890 */ mergeCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value)5891 public Builder mergeCircuitBreakers(com.google.cloud.compute.v1.CircuitBreakers value) { 5892 if (circuitBreakersBuilder_ == null) { 5893 if (((bitField0_ & 0x00000008) != 0) 5894 && circuitBreakers_ != null 5895 && circuitBreakers_ 5896 != com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance()) { 5897 getCircuitBreakersBuilder().mergeFrom(value); 5898 } else { 5899 circuitBreakers_ = value; 5900 } 5901 } else { 5902 circuitBreakersBuilder_.mergeFrom(value); 5903 } 5904 bitField0_ |= 0x00000008; 5905 onChanged(); 5906 return this; 5907 } 5908 /** 5909 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5910 */ clearCircuitBreakers()5911 public Builder clearCircuitBreakers() { 5912 bitField0_ = (bitField0_ & ~0x00000008); 5913 circuitBreakers_ = null; 5914 if (circuitBreakersBuilder_ != null) { 5915 circuitBreakersBuilder_.dispose(); 5916 circuitBreakersBuilder_ = null; 5917 } 5918 onChanged(); 5919 return this; 5920 } 5921 /** 5922 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5923 */ getCircuitBreakersBuilder()5924 public com.google.cloud.compute.v1.CircuitBreakers.Builder getCircuitBreakersBuilder() { 5925 bitField0_ |= 0x00000008; 5926 onChanged(); 5927 return getCircuitBreakersFieldBuilder().getBuilder(); 5928 } 5929 /** 5930 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5931 */ getCircuitBreakersOrBuilder()5932 public com.google.cloud.compute.v1.CircuitBreakersOrBuilder getCircuitBreakersOrBuilder() { 5933 if (circuitBreakersBuilder_ != null) { 5934 return circuitBreakersBuilder_.getMessageOrBuilder(); 5935 } else { 5936 return circuitBreakers_ == null 5937 ? com.google.cloud.compute.v1.CircuitBreakers.getDefaultInstance() 5938 : circuitBreakers_; 5939 } 5940 } 5941 /** 5942 * <code>optional .google.cloud.compute.v1.CircuitBreakers circuit_breakers = 421340061;</code> 5943 */ 5944 private com.google.protobuf.SingleFieldBuilderV3< 5945 com.google.cloud.compute.v1.CircuitBreakers, 5946 com.google.cloud.compute.v1.CircuitBreakers.Builder, 5947 com.google.cloud.compute.v1.CircuitBreakersOrBuilder> getCircuitBreakersFieldBuilder()5948 getCircuitBreakersFieldBuilder() { 5949 if (circuitBreakersBuilder_ == null) { 5950 circuitBreakersBuilder_ = 5951 new com.google.protobuf.SingleFieldBuilderV3< 5952 com.google.cloud.compute.v1.CircuitBreakers, 5953 com.google.cloud.compute.v1.CircuitBreakers.Builder, 5954 com.google.cloud.compute.v1.CircuitBreakersOrBuilder>( 5955 getCircuitBreakers(), getParentForChildren(), isClean()); 5956 circuitBreakers_ = null; 5957 } 5958 return circuitBreakersBuilder_; 5959 } 5960 5961 private java.lang.Object compressionMode_ = ""; 5962 /** 5963 * 5964 * 5965 * <pre> 5966 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 5967 * Check the CompressionMode enum for the list of possible values. 5968 * </pre> 5969 * 5970 * <code>optional string compression_mode = 95520988;</code> 5971 * 5972 * @return Whether the compressionMode field is set. 5973 */ hasCompressionMode()5974 public boolean hasCompressionMode() { 5975 return ((bitField0_ & 0x00000010) != 0); 5976 } 5977 /** 5978 * 5979 * 5980 * <pre> 5981 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 5982 * Check the CompressionMode enum for the list of possible values. 5983 * </pre> 5984 * 5985 * <code>optional string compression_mode = 95520988;</code> 5986 * 5987 * @return The compressionMode. 5988 */ getCompressionMode()5989 public java.lang.String getCompressionMode() { 5990 java.lang.Object ref = compressionMode_; 5991 if (!(ref instanceof java.lang.String)) { 5992 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 5993 java.lang.String s = bs.toStringUtf8(); 5994 compressionMode_ = s; 5995 return s; 5996 } else { 5997 return (java.lang.String) ref; 5998 } 5999 } 6000 /** 6001 * 6002 * 6003 * <pre> 6004 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 6005 * Check the CompressionMode enum for the list of possible values. 6006 * </pre> 6007 * 6008 * <code>optional string compression_mode = 95520988;</code> 6009 * 6010 * @return The bytes for compressionMode. 6011 */ getCompressionModeBytes()6012 public com.google.protobuf.ByteString getCompressionModeBytes() { 6013 java.lang.Object ref = compressionMode_; 6014 if (ref instanceof String) { 6015 com.google.protobuf.ByteString b = 6016 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 6017 compressionMode_ = b; 6018 return b; 6019 } else { 6020 return (com.google.protobuf.ByteString) ref; 6021 } 6022 } 6023 /** 6024 * 6025 * 6026 * <pre> 6027 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 6028 * Check the CompressionMode enum for the list of possible values. 6029 * </pre> 6030 * 6031 * <code>optional string compression_mode = 95520988;</code> 6032 * 6033 * @param value The compressionMode to set. 6034 * @return This builder for chaining. 6035 */ setCompressionMode(java.lang.String value)6036 public Builder setCompressionMode(java.lang.String value) { 6037 if (value == null) { 6038 throw new NullPointerException(); 6039 } 6040 compressionMode_ = value; 6041 bitField0_ |= 0x00000010; 6042 onChanged(); 6043 return this; 6044 } 6045 /** 6046 * 6047 * 6048 * <pre> 6049 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 6050 * Check the CompressionMode enum for the list of possible values. 6051 * </pre> 6052 * 6053 * <code>optional string compression_mode = 95520988;</code> 6054 * 6055 * @return This builder for chaining. 6056 */ clearCompressionMode()6057 public Builder clearCompressionMode() { 6058 compressionMode_ = getDefaultInstance().getCompressionMode(); 6059 bitField0_ = (bitField0_ & ~0x00000010); 6060 onChanged(); 6061 return this; 6062 } 6063 /** 6064 * 6065 * 6066 * <pre> 6067 * Compress text responses using Brotli or gzip compression, based on the client's Accept-Encoding header. 6068 * Check the CompressionMode enum for the list of possible values. 6069 * </pre> 6070 * 6071 * <code>optional string compression_mode = 95520988;</code> 6072 * 6073 * @param value The bytes for compressionMode to set. 6074 * @return This builder for chaining. 6075 */ setCompressionModeBytes(com.google.protobuf.ByteString value)6076 public Builder setCompressionModeBytes(com.google.protobuf.ByteString value) { 6077 if (value == null) { 6078 throw new NullPointerException(); 6079 } 6080 checkByteStringIsUtf8(value); 6081 compressionMode_ = value; 6082 bitField0_ |= 0x00000010; 6083 onChanged(); 6084 return this; 6085 } 6086 6087 private com.google.cloud.compute.v1.ConnectionDraining connectionDraining_; 6088 private com.google.protobuf.SingleFieldBuilderV3< 6089 com.google.cloud.compute.v1.ConnectionDraining, 6090 com.google.cloud.compute.v1.ConnectionDraining.Builder, 6091 com.google.cloud.compute.v1.ConnectionDrainingOrBuilder> 6092 connectionDrainingBuilder_; 6093 /** 6094 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6095 * </code> 6096 * 6097 * @return Whether the connectionDraining field is set. 6098 */ hasConnectionDraining()6099 public boolean hasConnectionDraining() { 6100 return ((bitField0_ & 0x00000020) != 0); 6101 } 6102 /** 6103 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6104 * </code> 6105 * 6106 * @return The connectionDraining. 6107 */ getConnectionDraining()6108 public com.google.cloud.compute.v1.ConnectionDraining getConnectionDraining() { 6109 if (connectionDrainingBuilder_ == null) { 6110 return connectionDraining_ == null 6111 ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance() 6112 : connectionDraining_; 6113 } else { 6114 return connectionDrainingBuilder_.getMessage(); 6115 } 6116 } 6117 /** 6118 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6119 * </code> 6120 */ setConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value)6121 public Builder setConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value) { 6122 if (connectionDrainingBuilder_ == null) { 6123 if (value == null) { 6124 throw new NullPointerException(); 6125 } 6126 connectionDraining_ = value; 6127 } else { 6128 connectionDrainingBuilder_.setMessage(value); 6129 } 6130 bitField0_ |= 0x00000020; 6131 onChanged(); 6132 return this; 6133 } 6134 /** 6135 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6136 * </code> 6137 */ setConnectionDraining( com.google.cloud.compute.v1.ConnectionDraining.Builder builderForValue)6138 public Builder setConnectionDraining( 6139 com.google.cloud.compute.v1.ConnectionDraining.Builder builderForValue) { 6140 if (connectionDrainingBuilder_ == null) { 6141 connectionDraining_ = builderForValue.build(); 6142 } else { 6143 connectionDrainingBuilder_.setMessage(builderForValue.build()); 6144 } 6145 bitField0_ |= 0x00000020; 6146 onChanged(); 6147 return this; 6148 } 6149 /** 6150 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6151 * </code> 6152 */ mergeConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value)6153 public Builder mergeConnectionDraining(com.google.cloud.compute.v1.ConnectionDraining value) { 6154 if (connectionDrainingBuilder_ == null) { 6155 if (((bitField0_ & 0x00000020) != 0) 6156 && connectionDraining_ != null 6157 && connectionDraining_ 6158 != com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance()) { 6159 getConnectionDrainingBuilder().mergeFrom(value); 6160 } else { 6161 connectionDraining_ = value; 6162 } 6163 } else { 6164 connectionDrainingBuilder_.mergeFrom(value); 6165 } 6166 bitField0_ |= 0x00000020; 6167 onChanged(); 6168 return this; 6169 } 6170 /** 6171 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6172 * </code> 6173 */ clearConnectionDraining()6174 public Builder clearConnectionDraining() { 6175 bitField0_ = (bitField0_ & ~0x00000020); 6176 connectionDraining_ = null; 6177 if (connectionDrainingBuilder_ != null) { 6178 connectionDrainingBuilder_.dispose(); 6179 connectionDrainingBuilder_ = null; 6180 } 6181 onChanged(); 6182 return this; 6183 } 6184 /** 6185 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6186 * </code> 6187 */ getConnectionDrainingBuilder()6188 public com.google.cloud.compute.v1.ConnectionDraining.Builder getConnectionDrainingBuilder() { 6189 bitField0_ |= 0x00000020; 6190 onChanged(); 6191 return getConnectionDrainingFieldBuilder().getBuilder(); 6192 } 6193 /** 6194 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6195 * </code> 6196 */ 6197 public com.google.cloud.compute.v1.ConnectionDrainingOrBuilder getConnectionDrainingOrBuilder()6198 getConnectionDrainingOrBuilder() { 6199 if (connectionDrainingBuilder_ != null) { 6200 return connectionDrainingBuilder_.getMessageOrBuilder(); 6201 } else { 6202 return connectionDraining_ == null 6203 ? com.google.cloud.compute.v1.ConnectionDraining.getDefaultInstance() 6204 : connectionDraining_; 6205 } 6206 } 6207 /** 6208 * <code>optional .google.cloud.compute.v1.ConnectionDraining connection_draining = 461096747; 6209 * </code> 6210 */ 6211 private com.google.protobuf.SingleFieldBuilderV3< 6212 com.google.cloud.compute.v1.ConnectionDraining, 6213 com.google.cloud.compute.v1.ConnectionDraining.Builder, 6214 com.google.cloud.compute.v1.ConnectionDrainingOrBuilder> getConnectionDrainingFieldBuilder()6215 getConnectionDrainingFieldBuilder() { 6216 if (connectionDrainingBuilder_ == null) { 6217 connectionDrainingBuilder_ = 6218 new com.google.protobuf.SingleFieldBuilderV3< 6219 com.google.cloud.compute.v1.ConnectionDraining, 6220 com.google.cloud.compute.v1.ConnectionDraining.Builder, 6221 com.google.cloud.compute.v1.ConnectionDrainingOrBuilder>( 6222 getConnectionDraining(), getParentForChildren(), isClean()); 6223 connectionDraining_ = null; 6224 } 6225 return connectionDrainingBuilder_; 6226 } 6227 6228 private com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy 6229 connectionTrackingPolicy_; 6230 private com.google.protobuf.SingleFieldBuilderV3< 6231 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy, 6232 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder, 6233 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder> 6234 connectionTrackingPolicyBuilder_; 6235 /** 6236 * 6237 * 6238 * <pre> 6239 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6240 * </pre> 6241 * 6242 * <code> 6243 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6244 * </code> 6245 * 6246 * @return Whether the connectionTrackingPolicy field is set. 6247 */ hasConnectionTrackingPolicy()6248 public boolean hasConnectionTrackingPolicy() { 6249 return ((bitField0_ & 0x00000040) != 0); 6250 } 6251 /** 6252 * 6253 * 6254 * <pre> 6255 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6256 * </pre> 6257 * 6258 * <code> 6259 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6260 * </code> 6261 * 6262 * @return The connectionTrackingPolicy. 6263 */ 6264 public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy getConnectionTrackingPolicy()6265 getConnectionTrackingPolicy() { 6266 if (connectionTrackingPolicyBuilder_ == null) { 6267 return connectionTrackingPolicy_ == null 6268 ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy 6269 .getDefaultInstance() 6270 : connectionTrackingPolicy_; 6271 } else { 6272 return connectionTrackingPolicyBuilder_.getMessage(); 6273 } 6274 } 6275 /** 6276 * 6277 * 6278 * <pre> 6279 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6280 * </pre> 6281 * 6282 * <code> 6283 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6284 * </code> 6285 */ setConnectionTrackingPolicy( com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value)6286 public Builder setConnectionTrackingPolicy( 6287 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value) { 6288 if (connectionTrackingPolicyBuilder_ == null) { 6289 if (value == null) { 6290 throw new NullPointerException(); 6291 } 6292 connectionTrackingPolicy_ = value; 6293 } else { 6294 connectionTrackingPolicyBuilder_.setMessage(value); 6295 } 6296 bitField0_ |= 0x00000040; 6297 onChanged(); 6298 return this; 6299 } 6300 /** 6301 * 6302 * 6303 * <pre> 6304 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6305 * </pre> 6306 * 6307 * <code> 6308 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6309 * </code> 6310 */ setConnectionTrackingPolicy( com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder builderForValue)6311 public Builder setConnectionTrackingPolicy( 6312 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder 6313 builderForValue) { 6314 if (connectionTrackingPolicyBuilder_ == null) { 6315 connectionTrackingPolicy_ = builderForValue.build(); 6316 } else { 6317 connectionTrackingPolicyBuilder_.setMessage(builderForValue.build()); 6318 } 6319 bitField0_ |= 0x00000040; 6320 onChanged(); 6321 return this; 6322 } 6323 /** 6324 * 6325 * 6326 * <pre> 6327 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6328 * </pre> 6329 * 6330 * <code> 6331 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6332 * </code> 6333 */ mergeConnectionTrackingPolicy( com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value)6334 public Builder mergeConnectionTrackingPolicy( 6335 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy value) { 6336 if (connectionTrackingPolicyBuilder_ == null) { 6337 if (((bitField0_ & 0x00000040) != 0) 6338 && connectionTrackingPolicy_ != null 6339 && connectionTrackingPolicy_ 6340 != com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy 6341 .getDefaultInstance()) { 6342 getConnectionTrackingPolicyBuilder().mergeFrom(value); 6343 } else { 6344 connectionTrackingPolicy_ = value; 6345 } 6346 } else { 6347 connectionTrackingPolicyBuilder_.mergeFrom(value); 6348 } 6349 bitField0_ |= 0x00000040; 6350 onChanged(); 6351 return this; 6352 } 6353 /** 6354 * 6355 * 6356 * <pre> 6357 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6358 * </pre> 6359 * 6360 * <code> 6361 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6362 * </code> 6363 */ clearConnectionTrackingPolicy()6364 public Builder clearConnectionTrackingPolicy() { 6365 bitField0_ = (bitField0_ & ~0x00000040); 6366 connectionTrackingPolicy_ = null; 6367 if (connectionTrackingPolicyBuilder_ != null) { 6368 connectionTrackingPolicyBuilder_.dispose(); 6369 connectionTrackingPolicyBuilder_ = null; 6370 } 6371 onChanged(); 6372 return this; 6373 } 6374 /** 6375 * 6376 * 6377 * <pre> 6378 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6379 * </pre> 6380 * 6381 * <code> 6382 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6383 * </code> 6384 */ 6385 public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder getConnectionTrackingPolicyBuilder()6386 getConnectionTrackingPolicyBuilder() { 6387 bitField0_ |= 0x00000040; 6388 onChanged(); 6389 return getConnectionTrackingPolicyFieldBuilder().getBuilder(); 6390 } 6391 /** 6392 * 6393 * 6394 * <pre> 6395 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6396 * </pre> 6397 * 6398 * <code> 6399 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6400 * </code> 6401 */ 6402 public com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder getConnectionTrackingPolicyOrBuilder()6403 getConnectionTrackingPolicyOrBuilder() { 6404 if (connectionTrackingPolicyBuilder_ != null) { 6405 return connectionTrackingPolicyBuilder_.getMessageOrBuilder(); 6406 } else { 6407 return connectionTrackingPolicy_ == null 6408 ? com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy 6409 .getDefaultInstance() 6410 : connectionTrackingPolicy_; 6411 } 6412 } 6413 /** 6414 * 6415 * 6416 * <pre> 6417 * Connection Tracking configuration for this BackendService. Connection tracking policy settings are only available for Network Load Balancing and Internal TCP/UDP Load Balancing. 6418 * </pre> 6419 * 6420 * <code> 6421 * optional .google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy connection_tracking_policy = 143994969; 6422 * </code> 6423 */ 6424 private com.google.protobuf.SingleFieldBuilderV3< 6425 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy, 6426 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder, 6427 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder> getConnectionTrackingPolicyFieldBuilder()6428 getConnectionTrackingPolicyFieldBuilder() { 6429 if (connectionTrackingPolicyBuilder_ == null) { 6430 connectionTrackingPolicyBuilder_ = 6431 new com.google.protobuf.SingleFieldBuilderV3< 6432 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy, 6433 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicy.Builder, 6434 com.google.cloud.compute.v1.BackendServiceConnectionTrackingPolicyOrBuilder>( 6435 getConnectionTrackingPolicy(), getParentForChildren(), isClean()); 6436 connectionTrackingPolicy_ = null; 6437 } 6438 return connectionTrackingPolicyBuilder_; 6439 } 6440 6441 private com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistentHash_; 6442 private com.google.protobuf.SingleFieldBuilderV3< 6443 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings, 6444 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder, 6445 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder> 6446 consistentHashBuilder_; 6447 /** 6448 * 6449 * 6450 * <pre> 6451 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6452 * </pre> 6453 * 6454 * <code> 6455 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6456 * </code> 6457 * 6458 * @return Whether the consistentHash field is set. 6459 */ hasConsistentHash()6460 public boolean hasConsistentHash() { 6461 return ((bitField0_ & 0x00000080) != 0); 6462 } 6463 /** 6464 * 6465 * 6466 * <pre> 6467 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6468 * </pre> 6469 * 6470 * <code> 6471 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6472 * </code> 6473 * 6474 * @return The consistentHash. 6475 */ getConsistentHash()6476 public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings getConsistentHash() { 6477 if (consistentHashBuilder_ == null) { 6478 return consistentHash_ == null 6479 ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance() 6480 : consistentHash_; 6481 } else { 6482 return consistentHashBuilder_.getMessage(); 6483 } 6484 } 6485 /** 6486 * 6487 * 6488 * <pre> 6489 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6490 * </pre> 6491 * 6492 * <code> 6493 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6494 * </code> 6495 */ setConsistentHash( com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value)6496 public Builder setConsistentHash( 6497 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value) { 6498 if (consistentHashBuilder_ == null) { 6499 if (value == null) { 6500 throw new NullPointerException(); 6501 } 6502 consistentHash_ = value; 6503 } else { 6504 consistentHashBuilder_.setMessage(value); 6505 } 6506 bitField0_ |= 0x00000080; 6507 onChanged(); 6508 return this; 6509 } 6510 /** 6511 * 6512 * 6513 * <pre> 6514 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6515 * </pre> 6516 * 6517 * <code> 6518 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6519 * </code> 6520 */ setConsistentHash( com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder builderForValue)6521 public Builder setConsistentHash( 6522 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder builderForValue) { 6523 if (consistentHashBuilder_ == null) { 6524 consistentHash_ = builderForValue.build(); 6525 } else { 6526 consistentHashBuilder_.setMessage(builderForValue.build()); 6527 } 6528 bitField0_ |= 0x00000080; 6529 onChanged(); 6530 return this; 6531 } 6532 /** 6533 * 6534 * 6535 * <pre> 6536 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6537 * </pre> 6538 * 6539 * <code> 6540 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6541 * </code> 6542 */ mergeConsistentHash( com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value)6543 public Builder mergeConsistentHash( 6544 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings value) { 6545 if (consistentHashBuilder_ == null) { 6546 if (((bitField0_ & 0x00000080) != 0) 6547 && consistentHash_ != null 6548 && consistentHash_ 6549 != com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings 6550 .getDefaultInstance()) { 6551 getConsistentHashBuilder().mergeFrom(value); 6552 } else { 6553 consistentHash_ = value; 6554 } 6555 } else { 6556 consistentHashBuilder_.mergeFrom(value); 6557 } 6558 bitField0_ |= 0x00000080; 6559 onChanged(); 6560 return this; 6561 } 6562 /** 6563 * 6564 * 6565 * <pre> 6566 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6567 * </pre> 6568 * 6569 * <code> 6570 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6571 * </code> 6572 */ clearConsistentHash()6573 public Builder clearConsistentHash() { 6574 bitField0_ = (bitField0_ & ~0x00000080); 6575 consistentHash_ = null; 6576 if (consistentHashBuilder_ != null) { 6577 consistentHashBuilder_.dispose(); 6578 consistentHashBuilder_ = null; 6579 } 6580 onChanged(); 6581 return this; 6582 } 6583 /** 6584 * 6585 * 6586 * <pre> 6587 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6588 * </pre> 6589 * 6590 * <code> 6591 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6592 * </code> 6593 */ 6594 public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder getConsistentHashBuilder()6595 getConsistentHashBuilder() { 6596 bitField0_ |= 0x00000080; 6597 onChanged(); 6598 return getConsistentHashFieldBuilder().getBuilder(); 6599 } 6600 /** 6601 * 6602 * 6603 * <pre> 6604 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6605 * </pre> 6606 * 6607 * <code> 6608 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6609 * </code> 6610 */ 6611 public com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder getConsistentHashOrBuilder()6612 getConsistentHashOrBuilder() { 6613 if (consistentHashBuilder_ != null) { 6614 return consistentHashBuilder_.getMessageOrBuilder(); 6615 } else { 6616 return consistentHash_ == null 6617 ? com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.getDefaultInstance() 6618 : consistentHash_; 6619 } 6620 } 6621 /** 6622 * 6623 * 6624 * <pre> 6625 * Consistent Hash-based load balancing can be used to provide soft session affinity based on HTTP headers, cookies or other properties. This load balancing policy is applicable only for HTTP connections. The affinity to a particular destination host will be lost when one or more hosts are added/removed from the destination service. This field specifies parameters that control consistent hashing. This field is only applicable when localityLbPolicy is set to MAGLEV or RING_HASH. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 6626 * </pre> 6627 * 6628 * <code> 6629 * optional .google.cloud.compute.v1.ConsistentHashLoadBalancerSettings consistent_hash = 905883; 6630 * </code> 6631 */ 6632 private com.google.protobuf.SingleFieldBuilderV3< 6633 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings, 6634 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder, 6635 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder> getConsistentHashFieldBuilder()6636 getConsistentHashFieldBuilder() { 6637 if (consistentHashBuilder_ == null) { 6638 consistentHashBuilder_ = 6639 new com.google.protobuf.SingleFieldBuilderV3< 6640 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings, 6641 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettings.Builder, 6642 com.google.cloud.compute.v1.ConsistentHashLoadBalancerSettingsOrBuilder>( 6643 getConsistentHash(), getParentForChildren(), isClean()); 6644 consistentHash_ = null; 6645 } 6646 return consistentHashBuilder_; 6647 } 6648 6649 private java.lang.Object creationTimestamp_ = ""; 6650 /** 6651 * 6652 * 6653 * <pre> 6654 * [Output Only] Creation timestamp in RFC3339 text format. 6655 * </pre> 6656 * 6657 * <code>optional string creation_timestamp = 30525366;</code> 6658 * 6659 * @return Whether the creationTimestamp field is set. 6660 */ hasCreationTimestamp()6661 public boolean hasCreationTimestamp() { 6662 return ((bitField0_ & 0x00000100) != 0); 6663 } 6664 /** 6665 * 6666 * 6667 * <pre> 6668 * [Output Only] Creation timestamp in RFC3339 text format. 6669 * </pre> 6670 * 6671 * <code>optional string creation_timestamp = 30525366;</code> 6672 * 6673 * @return The creationTimestamp. 6674 */ getCreationTimestamp()6675 public java.lang.String getCreationTimestamp() { 6676 java.lang.Object ref = creationTimestamp_; 6677 if (!(ref instanceof java.lang.String)) { 6678 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 6679 java.lang.String s = bs.toStringUtf8(); 6680 creationTimestamp_ = s; 6681 return s; 6682 } else { 6683 return (java.lang.String) ref; 6684 } 6685 } 6686 /** 6687 * 6688 * 6689 * <pre> 6690 * [Output Only] Creation timestamp in RFC3339 text format. 6691 * </pre> 6692 * 6693 * <code>optional string creation_timestamp = 30525366;</code> 6694 * 6695 * @return The bytes for creationTimestamp. 6696 */ getCreationTimestampBytes()6697 public com.google.protobuf.ByteString getCreationTimestampBytes() { 6698 java.lang.Object ref = creationTimestamp_; 6699 if (ref instanceof String) { 6700 com.google.protobuf.ByteString b = 6701 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 6702 creationTimestamp_ = b; 6703 return b; 6704 } else { 6705 return (com.google.protobuf.ByteString) ref; 6706 } 6707 } 6708 /** 6709 * 6710 * 6711 * <pre> 6712 * [Output Only] Creation timestamp in RFC3339 text format. 6713 * </pre> 6714 * 6715 * <code>optional string creation_timestamp = 30525366;</code> 6716 * 6717 * @param value The creationTimestamp to set. 6718 * @return This builder for chaining. 6719 */ setCreationTimestamp(java.lang.String value)6720 public Builder setCreationTimestamp(java.lang.String value) { 6721 if (value == null) { 6722 throw new NullPointerException(); 6723 } 6724 creationTimestamp_ = value; 6725 bitField0_ |= 0x00000100; 6726 onChanged(); 6727 return this; 6728 } 6729 /** 6730 * 6731 * 6732 * <pre> 6733 * [Output Only] Creation timestamp in RFC3339 text format. 6734 * </pre> 6735 * 6736 * <code>optional string creation_timestamp = 30525366;</code> 6737 * 6738 * @return This builder for chaining. 6739 */ clearCreationTimestamp()6740 public Builder clearCreationTimestamp() { 6741 creationTimestamp_ = getDefaultInstance().getCreationTimestamp(); 6742 bitField0_ = (bitField0_ & ~0x00000100); 6743 onChanged(); 6744 return this; 6745 } 6746 /** 6747 * 6748 * 6749 * <pre> 6750 * [Output Only] Creation timestamp in RFC3339 text format. 6751 * </pre> 6752 * 6753 * <code>optional string creation_timestamp = 30525366;</code> 6754 * 6755 * @param value The bytes for creationTimestamp to set. 6756 * @return This builder for chaining. 6757 */ setCreationTimestampBytes(com.google.protobuf.ByteString value)6758 public Builder setCreationTimestampBytes(com.google.protobuf.ByteString value) { 6759 if (value == null) { 6760 throw new NullPointerException(); 6761 } 6762 checkByteStringIsUtf8(value); 6763 creationTimestamp_ = value; 6764 bitField0_ |= 0x00000100; 6765 onChanged(); 6766 return this; 6767 } 6768 6769 private com.google.protobuf.LazyStringList customRequestHeaders_ = 6770 com.google.protobuf.LazyStringArrayList.EMPTY; 6771 ensureCustomRequestHeadersIsMutable()6772 private void ensureCustomRequestHeadersIsMutable() { 6773 if (!((bitField0_ & 0x00000200) != 0)) { 6774 customRequestHeaders_ = new com.google.protobuf.LazyStringArrayList(customRequestHeaders_); 6775 bitField0_ |= 0x00000200; 6776 } 6777 } 6778 /** 6779 * 6780 * 6781 * <pre> 6782 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6783 * </pre> 6784 * 6785 * <code>repeated string custom_request_headers = 27977992;</code> 6786 * 6787 * @return A list containing the customRequestHeaders. 6788 */ getCustomRequestHeadersList()6789 public com.google.protobuf.ProtocolStringList getCustomRequestHeadersList() { 6790 return customRequestHeaders_.getUnmodifiableView(); 6791 } 6792 /** 6793 * 6794 * 6795 * <pre> 6796 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6797 * </pre> 6798 * 6799 * <code>repeated string custom_request_headers = 27977992;</code> 6800 * 6801 * @return The count of customRequestHeaders. 6802 */ getCustomRequestHeadersCount()6803 public int getCustomRequestHeadersCount() { 6804 return customRequestHeaders_.size(); 6805 } 6806 /** 6807 * 6808 * 6809 * <pre> 6810 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6811 * </pre> 6812 * 6813 * <code>repeated string custom_request_headers = 27977992;</code> 6814 * 6815 * @param index The index of the element to return. 6816 * @return The customRequestHeaders at the given index. 6817 */ getCustomRequestHeaders(int index)6818 public java.lang.String getCustomRequestHeaders(int index) { 6819 return customRequestHeaders_.get(index); 6820 } 6821 /** 6822 * 6823 * 6824 * <pre> 6825 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6826 * </pre> 6827 * 6828 * <code>repeated string custom_request_headers = 27977992;</code> 6829 * 6830 * @param index The index of the value to return. 6831 * @return The bytes of the customRequestHeaders at the given index. 6832 */ getCustomRequestHeadersBytes(int index)6833 public com.google.protobuf.ByteString getCustomRequestHeadersBytes(int index) { 6834 return customRequestHeaders_.getByteString(index); 6835 } 6836 /** 6837 * 6838 * 6839 * <pre> 6840 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6841 * </pre> 6842 * 6843 * <code>repeated string custom_request_headers = 27977992;</code> 6844 * 6845 * @param index The index to set the value at. 6846 * @param value The customRequestHeaders to set. 6847 * @return This builder for chaining. 6848 */ setCustomRequestHeaders(int index, java.lang.String value)6849 public Builder setCustomRequestHeaders(int index, java.lang.String value) { 6850 if (value == null) { 6851 throw new NullPointerException(); 6852 } 6853 ensureCustomRequestHeadersIsMutable(); 6854 customRequestHeaders_.set(index, value); 6855 onChanged(); 6856 return this; 6857 } 6858 /** 6859 * 6860 * 6861 * <pre> 6862 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6863 * </pre> 6864 * 6865 * <code>repeated string custom_request_headers = 27977992;</code> 6866 * 6867 * @param value The customRequestHeaders to add. 6868 * @return This builder for chaining. 6869 */ addCustomRequestHeaders(java.lang.String value)6870 public Builder addCustomRequestHeaders(java.lang.String value) { 6871 if (value == null) { 6872 throw new NullPointerException(); 6873 } 6874 ensureCustomRequestHeadersIsMutable(); 6875 customRequestHeaders_.add(value); 6876 onChanged(); 6877 return this; 6878 } 6879 /** 6880 * 6881 * 6882 * <pre> 6883 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6884 * </pre> 6885 * 6886 * <code>repeated string custom_request_headers = 27977992;</code> 6887 * 6888 * @param values The customRequestHeaders to add. 6889 * @return This builder for chaining. 6890 */ addAllCustomRequestHeaders(java.lang.Iterable<java.lang.String> values)6891 public Builder addAllCustomRequestHeaders(java.lang.Iterable<java.lang.String> values) { 6892 ensureCustomRequestHeadersIsMutable(); 6893 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, customRequestHeaders_); 6894 onChanged(); 6895 return this; 6896 } 6897 /** 6898 * 6899 * 6900 * <pre> 6901 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6902 * </pre> 6903 * 6904 * <code>repeated string custom_request_headers = 27977992;</code> 6905 * 6906 * @return This builder for chaining. 6907 */ clearCustomRequestHeaders()6908 public Builder clearCustomRequestHeaders() { 6909 customRequestHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY; 6910 bitField0_ = (bitField0_ & ~0x00000200); 6911 onChanged(); 6912 return this; 6913 } 6914 /** 6915 * 6916 * 6917 * <pre> 6918 * Headers that the load balancer adds to proxied requests. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6919 * </pre> 6920 * 6921 * <code>repeated string custom_request_headers = 27977992;</code> 6922 * 6923 * @param value The bytes of the customRequestHeaders to add. 6924 * @return This builder for chaining. 6925 */ addCustomRequestHeadersBytes(com.google.protobuf.ByteString value)6926 public Builder addCustomRequestHeadersBytes(com.google.protobuf.ByteString value) { 6927 if (value == null) { 6928 throw new NullPointerException(); 6929 } 6930 checkByteStringIsUtf8(value); 6931 ensureCustomRequestHeadersIsMutable(); 6932 customRequestHeaders_.add(value); 6933 onChanged(); 6934 return this; 6935 } 6936 6937 private com.google.protobuf.LazyStringList customResponseHeaders_ = 6938 com.google.protobuf.LazyStringArrayList.EMPTY; 6939 ensureCustomResponseHeadersIsMutable()6940 private void ensureCustomResponseHeadersIsMutable() { 6941 if (!((bitField0_ & 0x00000400) != 0)) { 6942 customResponseHeaders_ = 6943 new com.google.protobuf.LazyStringArrayList(customResponseHeaders_); 6944 bitField0_ |= 0x00000400; 6945 } 6946 } 6947 /** 6948 * 6949 * 6950 * <pre> 6951 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6952 * </pre> 6953 * 6954 * <code>repeated string custom_response_headers = 387539094;</code> 6955 * 6956 * @return A list containing the customResponseHeaders. 6957 */ getCustomResponseHeadersList()6958 public com.google.protobuf.ProtocolStringList getCustomResponseHeadersList() { 6959 return customResponseHeaders_.getUnmodifiableView(); 6960 } 6961 /** 6962 * 6963 * 6964 * <pre> 6965 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6966 * </pre> 6967 * 6968 * <code>repeated string custom_response_headers = 387539094;</code> 6969 * 6970 * @return The count of customResponseHeaders. 6971 */ getCustomResponseHeadersCount()6972 public int getCustomResponseHeadersCount() { 6973 return customResponseHeaders_.size(); 6974 } 6975 /** 6976 * 6977 * 6978 * <pre> 6979 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6980 * </pre> 6981 * 6982 * <code>repeated string custom_response_headers = 387539094;</code> 6983 * 6984 * @param index The index of the element to return. 6985 * @return The customResponseHeaders at the given index. 6986 */ getCustomResponseHeaders(int index)6987 public java.lang.String getCustomResponseHeaders(int index) { 6988 return customResponseHeaders_.get(index); 6989 } 6990 /** 6991 * 6992 * 6993 * <pre> 6994 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 6995 * </pre> 6996 * 6997 * <code>repeated string custom_response_headers = 387539094;</code> 6998 * 6999 * @param index The index of the value to return. 7000 * @return The bytes of the customResponseHeaders at the given index. 7001 */ getCustomResponseHeadersBytes(int index)7002 public com.google.protobuf.ByteString getCustomResponseHeadersBytes(int index) { 7003 return customResponseHeaders_.getByteString(index); 7004 } 7005 /** 7006 * 7007 * 7008 * <pre> 7009 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 7010 * </pre> 7011 * 7012 * <code>repeated string custom_response_headers = 387539094;</code> 7013 * 7014 * @param index The index to set the value at. 7015 * @param value The customResponseHeaders to set. 7016 * @return This builder for chaining. 7017 */ setCustomResponseHeaders(int index, java.lang.String value)7018 public Builder setCustomResponseHeaders(int index, java.lang.String value) { 7019 if (value == null) { 7020 throw new NullPointerException(); 7021 } 7022 ensureCustomResponseHeadersIsMutable(); 7023 customResponseHeaders_.set(index, value); 7024 onChanged(); 7025 return this; 7026 } 7027 /** 7028 * 7029 * 7030 * <pre> 7031 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 7032 * </pre> 7033 * 7034 * <code>repeated string custom_response_headers = 387539094;</code> 7035 * 7036 * @param value The customResponseHeaders to add. 7037 * @return This builder for chaining. 7038 */ addCustomResponseHeaders(java.lang.String value)7039 public Builder addCustomResponseHeaders(java.lang.String value) { 7040 if (value == null) { 7041 throw new NullPointerException(); 7042 } 7043 ensureCustomResponseHeadersIsMutable(); 7044 customResponseHeaders_.add(value); 7045 onChanged(); 7046 return this; 7047 } 7048 /** 7049 * 7050 * 7051 * <pre> 7052 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 7053 * </pre> 7054 * 7055 * <code>repeated string custom_response_headers = 387539094;</code> 7056 * 7057 * @param values The customResponseHeaders to add. 7058 * @return This builder for chaining. 7059 */ addAllCustomResponseHeaders(java.lang.Iterable<java.lang.String> values)7060 public Builder addAllCustomResponseHeaders(java.lang.Iterable<java.lang.String> values) { 7061 ensureCustomResponseHeadersIsMutable(); 7062 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, customResponseHeaders_); 7063 onChanged(); 7064 return this; 7065 } 7066 /** 7067 * 7068 * 7069 * <pre> 7070 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 7071 * </pre> 7072 * 7073 * <code>repeated string custom_response_headers = 387539094;</code> 7074 * 7075 * @return This builder for chaining. 7076 */ clearCustomResponseHeaders()7077 public Builder clearCustomResponseHeaders() { 7078 customResponseHeaders_ = com.google.protobuf.LazyStringArrayList.EMPTY; 7079 bitField0_ = (bitField0_ & ~0x00000400); 7080 onChanged(); 7081 return this; 7082 } 7083 /** 7084 * 7085 * 7086 * <pre> 7087 * Headers that the load balancer adds to proxied responses. See [Creating custom headers](https://cloud.google.com/load-balancing/docs/custom-headers). 7088 * </pre> 7089 * 7090 * <code>repeated string custom_response_headers = 387539094;</code> 7091 * 7092 * @param value The bytes of the customResponseHeaders to add. 7093 * @return This builder for chaining. 7094 */ addCustomResponseHeadersBytes(com.google.protobuf.ByteString value)7095 public Builder addCustomResponseHeadersBytes(com.google.protobuf.ByteString value) { 7096 if (value == null) { 7097 throw new NullPointerException(); 7098 } 7099 checkByteStringIsUtf8(value); 7100 ensureCustomResponseHeadersIsMutable(); 7101 customResponseHeaders_.add(value); 7102 onChanged(); 7103 return this; 7104 } 7105 7106 private java.lang.Object description_ = ""; 7107 /** 7108 * 7109 * 7110 * <pre> 7111 * An optional description of this resource. Provide this property when you create the resource. 7112 * </pre> 7113 * 7114 * <code>optional string description = 422937596;</code> 7115 * 7116 * @return Whether the description field is set. 7117 */ hasDescription()7118 public boolean hasDescription() { 7119 return ((bitField0_ & 0x00000800) != 0); 7120 } 7121 /** 7122 * 7123 * 7124 * <pre> 7125 * An optional description of this resource. Provide this property when you create the resource. 7126 * </pre> 7127 * 7128 * <code>optional string description = 422937596;</code> 7129 * 7130 * @return The description. 7131 */ getDescription()7132 public java.lang.String getDescription() { 7133 java.lang.Object ref = description_; 7134 if (!(ref instanceof java.lang.String)) { 7135 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 7136 java.lang.String s = bs.toStringUtf8(); 7137 description_ = s; 7138 return s; 7139 } else { 7140 return (java.lang.String) ref; 7141 } 7142 } 7143 /** 7144 * 7145 * 7146 * <pre> 7147 * An optional description of this resource. Provide this property when you create the resource. 7148 * </pre> 7149 * 7150 * <code>optional string description = 422937596;</code> 7151 * 7152 * @return The bytes for description. 7153 */ getDescriptionBytes()7154 public com.google.protobuf.ByteString getDescriptionBytes() { 7155 java.lang.Object ref = description_; 7156 if (ref instanceof String) { 7157 com.google.protobuf.ByteString b = 7158 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 7159 description_ = b; 7160 return b; 7161 } else { 7162 return (com.google.protobuf.ByteString) ref; 7163 } 7164 } 7165 /** 7166 * 7167 * 7168 * <pre> 7169 * An optional description of this resource. Provide this property when you create the resource. 7170 * </pre> 7171 * 7172 * <code>optional string description = 422937596;</code> 7173 * 7174 * @param value The description to set. 7175 * @return This builder for chaining. 7176 */ setDescription(java.lang.String value)7177 public Builder setDescription(java.lang.String value) { 7178 if (value == null) { 7179 throw new NullPointerException(); 7180 } 7181 description_ = value; 7182 bitField0_ |= 0x00000800; 7183 onChanged(); 7184 return this; 7185 } 7186 /** 7187 * 7188 * 7189 * <pre> 7190 * An optional description of this resource. Provide this property when you create the resource. 7191 * </pre> 7192 * 7193 * <code>optional string description = 422937596;</code> 7194 * 7195 * @return This builder for chaining. 7196 */ clearDescription()7197 public Builder clearDescription() { 7198 description_ = getDefaultInstance().getDescription(); 7199 bitField0_ = (bitField0_ & ~0x00000800); 7200 onChanged(); 7201 return this; 7202 } 7203 /** 7204 * 7205 * 7206 * <pre> 7207 * An optional description of this resource. Provide this property when you create the resource. 7208 * </pre> 7209 * 7210 * <code>optional string description = 422937596;</code> 7211 * 7212 * @param value The bytes for description to set. 7213 * @return This builder for chaining. 7214 */ setDescriptionBytes(com.google.protobuf.ByteString value)7215 public Builder setDescriptionBytes(com.google.protobuf.ByteString value) { 7216 if (value == null) { 7217 throw new NullPointerException(); 7218 } 7219 checkByteStringIsUtf8(value); 7220 description_ = value; 7221 bitField0_ |= 0x00000800; 7222 onChanged(); 7223 return this; 7224 } 7225 7226 private java.lang.Object edgeSecurityPolicy_ = ""; 7227 /** 7228 * 7229 * 7230 * <pre> 7231 * [Output Only] The resource URL for the edge security policy associated with this backend service. 7232 * </pre> 7233 * 7234 * <code>optional string edge_security_policy = 41036943;</code> 7235 * 7236 * @return Whether the edgeSecurityPolicy field is set. 7237 */ hasEdgeSecurityPolicy()7238 public boolean hasEdgeSecurityPolicy() { 7239 return ((bitField0_ & 0x00001000) != 0); 7240 } 7241 /** 7242 * 7243 * 7244 * <pre> 7245 * [Output Only] The resource URL for the edge security policy associated with this backend service. 7246 * </pre> 7247 * 7248 * <code>optional string edge_security_policy = 41036943;</code> 7249 * 7250 * @return The edgeSecurityPolicy. 7251 */ getEdgeSecurityPolicy()7252 public java.lang.String getEdgeSecurityPolicy() { 7253 java.lang.Object ref = edgeSecurityPolicy_; 7254 if (!(ref instanceof java.lang.String)) { 7255 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 7256 java.lang.String s = bs.toStringUtf8(); 7257 edgeSecurityPolicy_ = s; 7258 return s; 7259 } else { 7260 return (java.lang.String) ref; 7261 } 7262 } 7263 /** 7264 * 7265 * 7266 * <pre> 7267 * [Output Only] The resource URL for the edge security policy associated with this backend service. 7268 * </pre> 7269 * 7270 * <code>optional string edge_security_policy = 41036943;</code> 7271 * 7272 * @return The bytes for edgeSecurityPolicy. 7273 */ getEdgeSecurityPolicyBytes()7274 public com.google.protobuf.ByteString getEdgeSecurityPolicyBytes() { 7275 java.lang.Object ref = edgeSecurityPolicy_; 7276 if (ref instanceof String) { 7277 com.google.protobuf.ByteString b = 7278 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 7279 edgeSecurityPolicy_ = b; 7280 return b; 7281 } else { 7282 return (com.google.protobuf.ByteString) ref; 7283 } 7284 } 7285 /** 7286 * 7287 * 7288 * <pre> 7289 * [Output Only] The resource URL for the edge security policy associated with this backend service. 7290 * </pre> 7291 * 7292 * <code>optional string edge_security_policy = 41036943;</code> 7293 * 7294 * @param value The edgeSecurityPolicy to set. 7295 * @return This builder for chaining. 7296 */ setEdgeSecurityPolicy(java.lang.String value)7297 public Builder setEdgeSecurityPolicy(java.lang.String value) { 7298 if (value == null) { 7299 throw new NullPointerException(); 7300 } 7301 edgeSecurityPolicy_ = value; 7302 bitField0_ |= 0x00001000; 7303 onChanged(); 7304 return this; 7305 } 7306 /** 7307 * 7308 * 7309 * <pre> 7310 * [Output Only] The resource URL for the edge security policy associated with this backend service. 7311 * </pre> 7312 * 7313 * <code>optional string edge_security_policy = 41036943;</code> 7314 * 7315 * @return This builder for chaining. 7316 */ clearEdgeSecurityPolicy()7317 public Builder clearEdgeSecurityPolicy() { 7318 edgeSecurityPolicy_ = getDefaultInstance().getEdgeSecurityPolicy(); 7319 bitField0_ = (bitField0_ & ~0x00001000); 7320 onChanged(); 7321 return this; 7322 } 7323 /** 7324 * 7325 * 7326 * <pre> 7327 * [Output Only] The resource URL for the edge security policy associated with this backend service. 7328 * </pre> 7329 * 7330 * <code>optional string edge_security_policy = 41036943;</code> 7331 * 7332 * @param value The bytes for edgeSecurityPolicy to set. 7333 * @return This builder for chaining. 7334 */ setEdgeSecurityPolicyBytes(com.google.protobuf.ByteString value)7335 public Builder setEdgeSecurityPolicyBytes(com.google.protobuf.ByteString value) { 7336 if (value == null) { 7337 throw new NullPointerException(); 7338 } 7339 checkByteStringIsUtf8(value); 7340 edgeSecurityPolicy_ = value; 7341 bitField0_ |= 0x00001000; 7342 onChanged(); 7343 return this; 7344 } 7345 7346 private boolean enableCDN_; 7347 /** 7348 * 7349 * 7350 * <pre> 7351 * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer. 7352 * </pre> 7353 * 7354 * <code>optional bool enable_c_d_n = 250733499;</code> 7355 * 7356 * @return Whether the enableCDN field is set. 7357 */ 7358 @java.lang.Override hasEnableCDN()7359 public boolean hasEnableCDN() { 7360 return ((bitField0_ & 0x00002000) != 0); 7361 } 7362 /** 7363 * 7364 * 7365 * <pre> 7366 * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer. 7367 * </pre> 7368 * 7369 * <code>optional bool enable_c_d_n = 250733499;</code> 7370 * 7371 * @return The enableCDN. 7372 */ 7373 @java.lang.Override getEnableCDN()7374 public boolean getEnableCDN() { 7375 return enableCDN_; 7376 } 7377 /** 7378 * 7379 * 7380 * <pre> 7381 * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer. 7382 * </pre> 7383 * 7384 * <code>optional bool enable_c_d_n = 250733499;</code> 7385 * 7386 * @param value The enableCDN to set. 7387 * @return This builder for chaining. 7388 */ setEnableCDN(boolean value)7389 public Builder setEnableCDN(boolean value) { 7390 7391 enableCDN_ = value; 7392 bitField0_ |= 0x00002000; 7393 onChanged(); 7394 return this; 7395 } 7396 /** 7397 * 7398 * 7399 * <pre> 7400 * If true, enables Cloud CDN for the backend service of an external HTTP(S) load balancer. 7401 * </pre> 7402 * 7403 * <code>optional bool enable_c_d_n = 250733499;</code> 7404 * 7405 * @return This builder for chaining. 7406 */ clearEnableCDN()7407 public Builder clearEnableCDN() { 7408 bitField0_ = (bitField0_ & ~0x00002000); 7409 enableCDN_ = false; 7410 onChanged(); 7411 return this; 7412 } 7413 7414 private com.google.cloud.compute.v1.BackendServiceFailoverPolicy failoverPolicy_; 7415 private com.google.protobuf.SingleFieldBuilderV3< 7416 com.google.cloud.compute.v1.BackendServiceFailoverPolicy, 7417 com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder, 7418 com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder> 7419 failoverPolicyBuilder_; 7420 /** 7421 * 7422 * 7423 * <pre> 7424 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7425 * </pre> 7426 * 7427 * <code> 7428 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7429 * </code> 7430 * 7431 * @return Whether the failoverPolicy field is set. 7432 */ hasFailoverPolicy()7433 public boolean hasFailoverPolicy() { 7434 return ((bitField0_ & 0x00004000) != 0); 7435 } 7436 /** 7437 * 7438 * 7439 * <pre> 7440 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7441 * </pre> 7442 * 7443 * <code> 7444 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7445 * </code> 7446 * 7447 * @return The failoverPolicy. 7448 */ getFailoverPolicy()7449 public com.google.cloud.compute.v1.BackendServiceFailoverPolicy getFailoverPolicy() { 7450 if (failoverPolicyBuilder_ == null) { 7451 return failoverPolicy_ == null 7452 ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance() 7453 : failoverPolicy_; 7454 } else { 7455 return failoverPolicyBuilder_.getMessage(); 7456 } 7457 } 7458 /** 7459 * 7460 * 7461 * <pre> 7462 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7463 * </pre> 7464 * 7465 * <code> 7466 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7467 * </code> 7468 */ setFailoverPolicy( com.google.cloud.compute.v1.BackendServiceFailoverPolicy value)7469 public Builder setFailoverPolicy( 7470 com.google.cloud.compute.v1.BackendServiceFailoverPolicy value) { 7471 if (failoverPolicyBuilder_ == null) { 7472 if (value == null) { 7473 throw new NullPointerException(); 7474 } 7475 failoverPolicy_ = value; 7476 } else { 7477 failoverPolicyBuilder_.setMessage(value); 7478 } 7479 bitField0_ |= 0x00004000; 7480 onChanged(); 7481 return this; 7482 } 7483 /** 7484 * 7485 * 7486 * <pre> 7487 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7488 * </pre> 7489 * 7490 * <code> 7491 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7492 * </code> 7493 */ setFailoverPolicy( com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder builderForValue)7494 public Builder setFailoverPolicy( 7495 com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder builderForValue) { 7496 if (failoverPolicyBuilder_ == null) { 7497 failoverPolicy_ = builderForValue.build(); 7498 } else { 7499 failoverPolicyBuilder_.setMessage(builderForValue.build()); 7500 } 7501 bitField0_ |= 0x00004000; 7502 onChanged(); 7503 return this; 7504 } 7505 /** 7506 * 7507 * 7508 * <pre> 7509 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7510 * </pre> 7511 * 7512 * <code> 7513 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7514 * </code> 7515 */ mergeFailoverPolicy( com.google.cloud.compute.v1.BackendServiceFailoverPolicy value)7516 public Builder mergeFailoverPolicy( 7517 com.google.cloud.compute.v1.BackendServiceFailoverPolicy value) { 7518 if (failoverPolicyBuilder_ == null) { 7519 if (((bitField0_ & 0x00004000) != 0) 7520 && failoverPolicy_ != null 7521 && failoverPolicy_ 7522 != com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance()) { 7523 getFailoverPolicyBuilder().mergeFrom(value); 7524 } else { 7525 failoverPolicy_ = value; 7526 } 7527 } else { 7528 failoverPolicyBuilder_.mergeFrom(value); 7529 } 7530 bitField0_ |= 0x00004000; 7531 onChanged(); 7532 return this; 7533 } 7534 /** 7535 * 7536 * 7537 * <pre> 7538 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7539 * </pre> 7540 * 7541 * <code> 7542 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7543 * </code> 7544 */ clearFailoverPolicy()7545 public Builder clearFailoverPolicy() { 7546 bitField0_ = (bitField0_ & ~0x00004000); 7547 failoverPolicy_ = null; 7548 if (failoverPolicyBuilder_ != null) { 7549 failoverPolicyBuilder_.dispose(); 7550 failoverPolicyBuilder_ = null; 7551 } 7552 onChanged(); 7553 return this; 7554 } 7555 /** 7556 * 7557 * 7558 * <pre> 7559 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7560 * </pre> 7561 * 7562 * <code> 7563 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7564 * </code> 7565 */ 7566 public com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder getFailoverPolicyBuilder()7567 getFailoverPolicyBuilder() { 7568 bitField0_ |= 0x00004000; 7569 onChanged(); 7570 return getFailoverPolicyFieldBuilder().getBuilder(); 7571 } 7572 /** 7573 * 7574 * 7575 * <pre> 7576 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7577 * </pre> 7578 * 7579 * <code> 7580 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7581 * </code> 7582 */ 7583 public com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder getFailoverPolicyOrBuilder()7584 getFailoverPolicyOrBuilder() { 7585 if (failoverPolicyBuilder_ != null) { 7586 return failoverPolicyBuilder_.getMessageOrBuilder(); 7587 } else { 7588 return failoverPolicy_ == null 7589 ? com.google.cloud.compute.v1.BackendServiceFailoverPolicy.getDefaultInstance() 7590 : failoverPolicy_; 7591 } 7592 } 7593 /** 7594 * 7595 * 7596 * <pre> 7597 * Requires at least one backend instance group to be defined as a backup (failover) backend. For load balancers that have configurable failover: [Internal TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/internal/failover-overview) and [external TCP/UDP Load Balancing](https://cloud.google.com/load-balancing/docs/network/networklb-failover-overview). 7598 * </pre> 7599 * 7600 * <code> 7601 * optional .google.cloud.compute.v1.BackendServiceFailoverPolicy failover_policy = 105658655; 7602 * </code> 7603 */ 7604 private com.google.protobuf.SingleFieldBuilderV3< 7605 com.google.cloud.compute.v1.BackendServiceFailoverPolicy, 7606 com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder, 7607 com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder> getFailoverPolicyFieldBuilder()7608 getFailoverPolicyFieldBuilder() { 7609 if (failoverPolicyBuilder_ == null) { 7610 failoverPolicyBuilder_ = 7611 new com.google.protobuf.SingleFieldBuilderV3< 7612 com.google.cloud.compute.v1.BackendServiceFailoverPolicy, 7613 com.google.cloud.compute.v1.BackendServiceFailoverPolicy.Builder, 7614 com.google.cloud.compute.v1.BackendServiceFailoverPolicyOrBuilder>( 7615 getFailoverPolicy(), getParentForChildren(), isClean()); 7616 failoverPolicy_ = null; 7617 } 7618 return failoverPolicyBuilder_; 7619 } 7620 7621 private java.lang.Object fingerprint_ = ""; 7622 /** 7623 * 7624 * 7625 * <pre> 7626 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 7627 * </pre> 7628 * 7629 * <code>optional string fingerprint = 234678500;</code> 7630 * 7631 * @return Whether the fingerprint field is set. 7632 */ hasFingerprint()7633 public boolean hasFingerprint() { 7634 return ((bitField0_ & 0x00008000) != 0); 7635 } 7636 /** 7637 * 7638 * 7639 * <pre> 7640 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 7641 * </pre> 7642 * 7643 * <code>optional string fingerprint = 234678500;</code> 7644 * 7645 * @return The fingerprint. 7646 */ getFingerprint()7647 public java.lang.String getFingerprint() { 7648 java.lang.Object ref = fingerprint_; 7649 if (!(ref instanceof java.lang.String)) { 7650 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 7651 java.lang.String s = bs.toStringUtf8(); 7652 fingerprint_ = s; 7653 return s; 7654 } else { 7655 return (java.lang.String) ref; 7656 } 7657 } 7658 /** 7659 * 7660 * 7661 * <pre> 7662 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 7663 * </pre> 7664 * 7665 * <code>optional string fingerprint = 234678500;</code> 7666 * 7667 * @return The bytes for fingerprint. 7668 */ getFingerprintBytes()7669 public com.google.protobuf.ByteString getFingerprintBytes() { 7670 java.lang.Object ref = fingerprint_; 7671 if (ref instanceof String) { 7672 com.google.protobuf.ByteString b = 7673 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 7674 fingerprint_ = b; 7675 return b; 7676 } else { 7677 return (com.google.protobuf.ByteString) ref; 7678 } 7679 } 7680 /** 7681 * 7682 * 7683 * <pre> 7684 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 7685 * </pre> 7686 * 7687 * <code>optional string fingerprint = 234678500;</code> 7688 * 7689 * @param value The fingerprint to set. 7690 * @return This builder for chaining. 7691 */ setFingerprint(java.lang.String value)7692 public Builder setFingerprint(java.lang.String value) { 7693 if (value == null) { 7694 throw new NullPointerException(); 7695 } 7696 fingerprint_ = value; 7697 bitField0_ |= 0x00008000; 7698 onChanged(); 7699 return this; 7700 } 7701 /** 7702 * 7703 * 7704 * <pre> 7705 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 7706 * </pre> 7707 * 7708 * <code>optional string fingerprint = 234678500;</code> 7709 * 7710 * @return This builder for chaining. 7711 */ clearFingerprint()7712 public Builder clearFingerprint() { 7713 fingerprint_ = getDefaultInstance().getFingerprint(); 7714 bitField0_ = (bitField0_ & ~0x00008000); 7715 onChanged(); 7716 return this; 7717 } 7718 /** 7719 * 7720 * 7721 * <pre> 7722 * Fingerprint of this resource. A hash of the contents stored in this object. This field is used in optimistic locking. This field will be ignored when inserting a BackendService. An up-to-date fingerprint must be provided in order to update the BackendService, otherwise the request will fail with error 412 conditionNotMet. To see the latest fingerprint, make a get() request to retrieve a BackendService. 7723 * </pre> 7724 * 7725 * <code>optional string fingerprint = 234678500;</code> 7726 * 7727 * @param value The bytes for fingerprint to set. 7728 * @return This builder for chaining. 7729 */ setFingerprintBytes(com.google.protobuf.ByteString value)7730 public Builder setFingerprintBytes(com.google.protobuf.ByteString value) { 7731 if (value == null) { 7732 throw new NullPointerException(); 7733 } 7734 checkByteStringIsUtf8(value); 7735 fingerprint_ = value; 7736 bitField0_ |= 0x00008000; 7737 onChanged(); 7738 return this; 7739 } 7740 7741 private com.google.protobuf.LazyStringList healthChecks_ = 7742 com.google.protobuf.LazyStringArrayList.EMPTY; 7743 ensureHealthChecksIsMutable()7744 private void ensureHealthChecksIsMutable() { 7745 if (!((bitField0_ & 0x00010000) != 0)) { 7746 healthChecks_ = new com.google.protobuf.LazyStringArrayList(healthChecks_); 7747 bitField0_ |= 0x00010000; 7748 } 7749 } 7750 /** 7751 * 7752 * 7753 * <pre> 7754 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7755 * </pre> 7756 * 7757 * <code>repeated string health_checks = 448370606;</code> 7758 * 7759 * @return A list containing the healthChecks. 7760 */ getHealthChecksList()7761 public com.google.protobuf.ProtocolStringList getHealthChecksList() { 7762 return healthChecks_.getUnmodifiableView(); 7763 } 7764 /** 7765 * 7766 * 7767 * <pre> 7768 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7769 * </pre> 7770 * 7771 * <code>repeated string health_checks = 448370606;</code> 7772 * 7773 * @return The count of healthChecks. 7774 */ getHealthChecksCount()7775 public int getHealthChecksCount() { 7776 return healthChecks_.size(); 7777 } 7778 /** 7779 * 7780 * 7781 * <pre> 7782 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7783 * </pre> 7784 * 7785 * <code>repeated string health_checks = 448370606;</code> 7786 * 7787 * @param index The index of the element to return. 7788 * @return The healthChecks at the given index. 7789 */ getHealthChecks(int index)7790 public java.lang.String getHealthChecks(int index) { 7791 return healthChecks_.get(index); 7792 } 7793 /** 7794 * 7795 * 7796 * <pre> 7797 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7798 * </pre> 7799 * 7800 * <code>repeated string health_checks = 448370606;</code> 7801 * 7802 * @param index The index of the value to return. 7803 * @return The bytes of the healthChecks at the given index. 7804 */ getHealthChecksBytes(int index)7805 public com.google.protobuf.ByteString getHealthChecksBytes(int index) { 7806 return healthChecks_.getByteString(index); 7807 } 7808 /** 7809 * 7810 * 7811 * <pre> 7812 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7813 * </pre> 7814 * 7815 * <code>repeated string health_checks = 448370606;</code> 7816 * 7817 * @param index The index to set the value at. 7818 * @param value The healthChecks to set. 7819 * @return This builder for chaining. 7820 */ setHealthChecks(int index, java.lang.String value)7821 public Builder setHealthChecks(int index, java.lang.String value) { 7822 if (value == null) { 7823 throw new NullPointerException(); 7824 } 7825 ensureHealthChecksIsMutable(); 7826 healthChecks_.set(index, value); 7827 onChanged(); 7828 return this; 7829 } 7830 /** 7831 * 7832 * 7833 * <pre> 7834 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7835 * </pre> 7836 * 7837 * <code>repeated string health_checks = 448370606;</code> 7838 * 7839 * @param value The healthChecks to add. 7840 * @return This builder for chaining. 7841 */ addHealthChecks(java.lang.String value)7842 public Builder addHealthChecks(java.lang.String value) { 7843 if (value == null) { 7844 throw new NullPointerException(); 7845 } 7846 ensureHealthChecksIsMutable(); 7847 healthChecks_.add(value); 7848 onChanged(); 7849 return this; 7850 } 7851 /** 7852 * 7853 * 7854 * <pre> 7855 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7856 * </pre> 7857 * 7858 * <code>repeated string health_checks = 448370606;</code> 7859 * 7860 * @param values The healthChecks to add. 7861 * @return This builder for chaining. 7862 */ addAllHealthChecks(java.lang.Iterable<java.lang.String> values)7863 public Builder addAllHealthChecks(java.lang.Iterable<java.lang.String> values) { 7864 ensureHealthChecksIsMutable(); 7865 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, healthChecks_); 7866 onChanged(); 7867 return this; 7868 } 7869 /** 7870 * 7871 * 7872 * <pre> 7873 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7874 * </pre> 7875 * 7876 * <code>repeated string health_checks = 448370606;</code> 7877 * 7878 * @return This builder for chaining. 7879 */ clearHealthChecks()7880 public Builder clearHealthChecks() { 7881 healthChecks_ = com.google.protobuf.LazyStringArrayList.EMPTY; 7882 bitField0_ = (bitField0_ & ~0x00010000); 7883 onChanged(); 7884 return this; 7885 } 7886 /** 7887 * 7888 * 7889 * <pre> 7890 * The list of URLs to the healthChecks, httpHealthChecks (legacy), or httpsHealthChecks (legacy) resource for health checking this backend service. Not all backend services support legacy health checks. See Load balancer guide. Currently, at most one health check can be specified for each backend service. Backend services with instance group or zonal NEG backends must have a health check. Backend services with internet or serverless NEG backends must not have a health check. 7891 * </pre> 7892 * 7893 * <code>repeated string health_checks = 448370606;</code> 7894 * 7895 * @param value The bytes of the healthChecks to add. 7896 * @return This builder for chaining. 7897 */ addHealthChecksBytes(com.google.protobuf.ByteString value)7898 public Builder addHealthChecksBytes(com.google.protobuf.ByteString value) { 7899 if (value == null) { 7900 throw new NullPointerException(); 7901 } 7902 checkByteStringIsUtf8(value); 7903 ensureHealthChecksIsMutable(); 7904 healthChecks_.add(value); 7905 onChanged(); 7906 return this; 7907 } 7908 7909 private com.google.cloud.compute.v1.BackendServiceIAP iap_; 7910 private com.google.protobuf.SingleFieldBuilderV3< 7911 com.google.cloud.compute.v1.BackendServiceIAP, 7912 com.google.cloud.compute.v1.BackendServiceIAP.Builder, 7913 com.google.cloud.compute.v1.BackendServiceIAPOrBuilder> 7914 iapBuilder_; 7915 /** 7916 * 7917 * 7918 * <pre> 7919 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 7920 * </pre> 7921 * 7922 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 7923 * 7924 * @return Whether the iap field is set. 7925 */ hasIap()7926 public boolean hasIap() { 7927 return ((bitField0_ & 0x00020000) != 0); 7928 } 7929 /** 7930 * 7931 * 7932 * <pre> 7933 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 7934 * </pre> 7935 * 7936 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 7937 * 7938 * @return The iap. 7939 */ getIap()7940 public com.google.cloud.compute.v1.BackendServiceIAP getIap() { 7941 if (iapBuilder_ == null) { 7942 return iap_ == null 7943 ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance() 7944 : iap_; 7945 } else { 7946 return iapBuilder_.getMessage(); 7947 } 7948 } 7949 /** 7950 * 7951 * 7952 * <pre> 7953 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 7954 * </pre> 7955 * 7956 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 7957 */ setIap(com.google.cloud.compute.v1.BackendServiceIAP value)7958 public Builder setIap(com.google.cloud.compute.v1.BackendServiceIAP value) { 7959 if (iapBuilder_ == null) { 7960 if (value == null) { 7961 throw new NullPointerException(); 7962 } 7963 iap_ = value; 7964 } else { 7965 iapBuilder_.setMessage(value); 7966 } 7967 bitField0_ |= 0x00020000; 7968 onChanged(); 7969 return this; 7970 } 7971 /** 7972 * 7973 * 7974 * <pre> 7975 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 7976 * </pre> 7977 * 7978 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 7979 */ setIap(com.google.cloud.compute.v1.BackendServiceIAP.Builder builderForValue)7980 public Builder setIap(com.google.cloud.compute.v1.BackendServiceIAP.Builder builderForValue) { 7981 if (iapBuilder_ == null) { 7982 iap_ = builderForValue.build(); 7983 } else { 7984 iapBuilder_.setMessage(builderForValue.build()); 7985 } 7986 bitField0_ |= 0x00020000; 7987 onChanged(); 7988 return this; 7989 } 7990 /** 7991 * 7992 * 7993 * <pre> 7994 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 7995 * </pre> 7996 * 7997 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 7998 */ mergeIap(com.google.cloud.compute.v1.BackendServiceIAP value)7999 public Builder mergeIap(com.google.cloud.compute.v1.BackendServiceIAP value) { 8000 if (iapBuilder_ == null) { 8001 if (((bitField0_ & 0x00020000) != 0) 8002 && iap_ != null 8003 && iap_ != com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance()) { 8004 getIapBuilder().mergeFrom(value); 8005 } else { 8006 iap_ = value; 8007 } 8008 } else { 8009 iapBuilder_.mergeFrom(value); 8010 } 8011 bitField0_ |= 0x00020000; 8012 onChanged(); 8013 return this; 8014 } 8015 /** 8016 * 8017 * 8018 * <pre> 8019 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 8020 * </pre> 8021 * 8022 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 8023 */ clearIap()8024 public Builder clearIap() { 8025 bitField0_ = (bitField0_ & ~0x00020000); 8026 iap_ = null; 8027 if (iapBuilder_ != null) { 8028 iapBuilder_.dispose(); 8029 iapBuilder_ = null; 8030 } 8031 onChanged(); 8032 return this; 8033 } 8034 /** 8035 * 8036 * 8037 * <pre> 8038 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 8039 * </pre> 8040 * 8041 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 8042 */ getIapBuilder()8043 public com.google.cloud.compute.v1.BackendServiceIAP.Builder getIapBuilder() { 8044 bitField0_ |= 0x00020000; 8045 onChanged(); 8046 return getIapFieldBuilder().getBuilder(); 8047 } 8048 /** 8049 * 8050 * 8051 * <pre> 8052 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 8053 * </pre> 8054 * 8055 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 8056 */ getIapOrBuilder()8057 public com.google.cloud.compute.v1.BackendServiceIAPOrBuilder getIapOrBuilder() { 8058 if (iapBuilder_ != null) { 8059 return iapBuilder_.getMessageOrBuilder(); 8060 } else { 8061 return iap_ == null 8062 ? com.google.cloud.compute.v1.BackendServiceIAP.getDefaultInstance() 8063 : iap_; 8064 } 8065 } 8066 /** 8067 * 8068 * 8069 * <pre> 8070 * The configurations for Identity-Aware Proxy on this resource. Not available for Internal TCP/UDP Load Balancing and Network Load Balancing. 8071 * </pre> 8072 * 8073 * <code>optional .google.cloud.compute.v1.BackendServiceIAP iap = 104024;</code> 8074 */ 8075 private com.google.protobuf.SingleFieldBuilderV3< 8076 com.google.cloud.compute.v1.BackendServiceIAP, 8077 com.google.cloud.compute.v1.BackendServiceIAP.Builder, 8078 com.google.cloud.compute.v1.BackendServiceIAPOrBuilder> getIapFieldBuilder()8079 getIapFieldBuilder() { 8080 if (iapBuilder_ == null) { 8081 iapBuilder_ = 8082 new com.google.protobuf.SingleFieldBuilderV3< 8083 com.google.cloud.compute.v1.BackendServiceIAP, 8084 com.google.cloud.compute.v1.BackendServiceIAP.Builder, 8085 com.google.cloud.compute.v1.BackendServiceIAPOrBuilder>( 8086 getIap(), getParentForChildren(), isClean()); 8087 iap_ = null; 8088 } 8089 return iapBuilder_; 8090 } 8091 8092 private long id_; 8093 /** 8094 * 8095 * 8096 * <pre> 8097 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 8098 * </pre> 8099 * 8100 * <code>optional uint64 id = 3355;</code> 8101 * 8102 * @return Whether the id field is set. 8103 */ 8104 @java.lang.Override hasId()8105 public boolean hasId() { 8106 return ((bitField0_ & 0x00040000) != 0); 8107 } 8108 /** 8109 * 8110 * 8111 * <pre> 8112 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 8113 * </pre> 8114 * 8115 * <code>optional uint64 id = 3355;</code> 8116 * 8117 * @return The id. 8118 */ 8119 @java.lang.Override getId()8120 public long getId() { 8121 return id_; 8122 } 8123 /** 8124 * 8125 * 8126 * <pre> 8127 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 8128 * </pre> 8129 * 8130 * <code>optional uint64 id = 3355;</code> 8131 * 8132 * @param value The id to set. 8133 * @return This builder for chaining. 8134 */ setId(long value)8135 public Builder setId(long value) { 8136 8137 id_ = value; 8138 bitField0_ |= 0x00040000; 8139 onChanged(); 8140 return this; 8141 } 8142 /** 8143 * 8144 * 8145 * <pre> 8146 * [Output Only] The unique identifier for the resource. This identifier is defined by the server. 8147 * </pre> 8148 * 8149 * <code>optional uint64 id = 3355;</code> 8150 * 8151 * @return This builder for chaining. 8152 */ clearId()8153 public Builder clearId() { 8154 bitField0_ = (bitField0_ & ~0x00040000); 8155 id_ = 0L; 8156 onChanged(); 8157 return this; 8158 } 8159 8160 private java.lang.Object kind_ = ""; 8161 /** 8162 * 8163 * 8164 * <pre> 8165 * [Output Only] Type of resource. Always compute#backendService for backend services. 8166 * </pre> 8167 * 8168 * <code>optional string kind = 3292052;</code> 8169 * 8170 * @return Whether the kind field is set. 8171 */ hasKind()8172 public boolean hasKind() { 8173 return ((bitField0_ & 0x00080000) != 0); 8174 } 8175 /** 8176 * 8177 * 8178 * <pre> 8179 * [Output Only] Type of resource. Always compute#backendService for backend services. 8180 * </pre> 8181 * 8182 * <code>optional string kind = 3292052;</code> 8183 * 8184 * @return The kind. 8185 */ getKind()8186 public java.lang.String getKind() { 8187 java.lang.Object ref = kind_; 8188 if (!(ref instanceof java.lang.String)) { 8189 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 8190 java.lang.String s = bs.toStringUtf8(); 8191 kind_ = s; 8192 return s; 8193 } else { 8194 return (java.lang.String) ref; 8195 } 8196 } 8197 /** 8198 * 8199 * 8200 * <pre> 8201 * [Output Only] Type of resource. Always compute#backendService for backend services. 8202 * </pre> 8203 * 8204 * <code>optional string kind = 3292052;</code> 8205 * 8206 * @return The bytes for kind. 8207 */ getKindBytes()8208 public com.google.protobuf.ByteString getKindBytes() { 8209 java.lang.Object ref = kind_; 8210 if (ref instanceof String) { 8211 com.google.protobuf.ByteString b = 8212 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 8213 kind_ = b; 8214 return b; 8215 } else { 8216 return (com.google.protobuf.ByteString) ref; 8217 } 8218 } 8219 /** 8220 * 8221 * 8222 * <pre> 8223 * [Output Only] Type of resource. Always compute#backendService for backend services. 8224 * </pre> 8225 * 8226 * <code>optional string kind = 3292052;</code> 8227 * 8228 * @param value The kind to set. 8229 * @return This builder for chaining. 8230 */ setKind(java.lang.String value)8231 public Builder setKind(java.lang.String value) { 8232 if (value == null) { 8233 throw new NullPointerException(); 8234 } 8235 kind_ = value; 8236 bitField0_ |= 0x00080000; 8237 onChanged(); 8238 return this; 8239 } 8240 /** 8241 * 8242 * 8243 * <pre> 8244 * [Output Only] Type of resource. Always compute#backendService for backend services. 8245 * </pre> 8246 * 8247 * <code>optional string kind = 3292052;</code> 8248 * 8249 * @return This builder for chaining. 8250 */ clearKind()8251 public Builder clearKind() { 8252 kind_ = getDefaultInstance().getKind(); 8253 bitField0_ = (bitField0_ & ~0x00080000); 8254 onChanged(); 8255 return this; 8256 } 8257 /** 8258 * 8259 * 8260 * <pre> 8261 * [Output Only] Type of resource. Always compute#backendService for backend services. 8262 * </pre> 8263 * 8264 * <code>optional string kind = 3292052;</code> 8265 * 8266 * @param value The bytes for kind to set. 8267 * @return This builder for chaining. 8268 */ setKindBytes(com.google.protobuf.ByteString value)8269 public Builder setKindBytes(com.google.protobuf.ByteString value) { 8270 if (value == null) { 8271 throw new NullPointerException(); 8272 } 8273 checkByteStringIsUtf8(value); 8274 kind_ = value; 8275 bitField0_ |= 0x00080000; 8276 onChanged(); 8277 return this; 8278 } 8279 8280 private java.lang.Object loadBalancingScheme_ = ""; 8281 /** 8282 * 8283 * 8284 * <pre> 8285 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 8286 * Check the LoadBalancingScheme enum for the list of possible values. 8287 * </pre> 8288 * 8289 * <code>optional string load_balancing_scheme = 363890244;</code> 8290 * 8291 * @return Whether the loadBalancingScheme field is set. 8292 */ hasLoadBalancingScheme()8293 public boolean hasLoadBalancingScheme() { 8294 return ((bitField0_ & 0x00100000) != 0); 8295 } 8296 /** 8297 * 8298 * 8299 * <pre> 8300 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 8301 * Check the LoadBalancingScheme enum for the list of possible values. 8302 * </pre> 8303 * 8304 * <code>optional string load_balancing_scheme = 363890244;</code> 8305 * 8306 * @return The loadBalancingScheme. 8307 */ getLoadBalancingScheme()8308 public java.lang.String getLoadBalancingScheme() { 8309 java.lang.Object ref = loadBalancingScheme_; 8310 if (!(ref instanceof java.lang.String)) { 8311 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 8312 java.lang.String s = bs.toStringUtf8(); 8313 loadBalancingScheme_ = s; 8314 return s; 8315 } else { 8316 return (java.lang.String) ref; 8317 } 8318 } 8319 /** 8320 * 8321 * 8322 * <pre> 8323 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 8324 * Check the LoadBalancingScheme enum for the list of possible values. 8325 * </pre> 8326 * 8327 * <code>optional string load_balancing_scheme = 363890244;</code> 8328 * 8329 * @return The bytes for loadBalancingScheme. 8330 */ getLoadBalancingSchemeBytes()8331 public com.google.protobuf.ByteString getLoadBalancingSchemeBytes() { 8332 java.lang.Object ref = loadBalancingScheme_; 8333 if (ref instanceof String) { 8334 com.google.protobuf.ByteString b = 8335 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 8336 loadBalancingScheme_ = b; 8337 return b; 8338 } else { 8339 return (com.google.protobuf.ByteString) ref; 8340 } 8341 } 8342 /** 8343 * 8344 * 8345 * <pre> 8346 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 8347 * Check the LoadBalancingScheme enum for the list of possible values. 8348 * </pre> 8349 * 8350 * <code>optional string load_balancing_scheme = 363890244;</code> 8351 * 8352 * @param value The loadBalancingScheme to set. 8353 * @return This builder for chaining. 8354 */ setLoadBalancingScheme(java.lang.String value)8355 public Builder setLoadBalancingScheme(java.lang.String value) { 8356 if (value == null) { 8357 throw new NullPointerException(); 8358 } 8359 loadBalancingScheme_ = value; 8360 bitField0_ |= 0x00100000; 8361 onChanged(); 8362 return this; 8363 } 8364 /** 8365 * 8366 * 8367 * <pre> 8368 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 8369 * Check the LoadBalancingScheme enum for the list of possible values. 8370 * </pre> 8371 * 8372 * <code>optional string load_balancing_scheme = 363890244;</code> 8373 * 8374 * @return This builder for chaining. 8375 */ clearLoadBalancingScheme()8376 public Builder clearLoadBalancingScheme() { 8377 loadBalancingScheme_ = getDefaultInstance().getLoadBalancingScheme(); 8378 bitField0_ = (bitField0_ & ~0x00100000); 8379 onChanged(); 8380 return this; 8381 } 8382 /** 8383 * 8384 * 8385 * <pre> 8386 * Specifies the load balancer type. A backend service created for one type of load balancer cannot be used with another. For more information, refer to Choosing a load balancer. 8387 * Check the LoadBalancingScheme enum for the list of possible values. 8388 * </pre> 8389 * 8390 * <code>optional string load_balancing_scheme = 363890244;</code> 8391 * 8392 * @param value The bytes for loadBalancingScheme to set. 8393 * @return This builder for chaining. 8394 */ setLoadBalancingSchemeBytes(com.google.protobuf.ByteString value)8395 public Builder setLoadBalancingSchemeBytes(com.google.protobuf.ByteString value) { 8396 if (value == null) { 8397 throw new NullPointerException(); 8398 } 8399 checkByteStringIsUtf8(value); 8400 loadBalancingScheme_ = value; 8401 bitField0_ |= 0x00100000; 8402 onChanged(); 8403 return this; 8404 } 8405 8406 private java.util.List< 8407 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig> 8408 localityLbPolicies_ = java.util.Collections.emptyList(); 8409 ensureLocalityLbPoliciesIsMutable()8410 private void ensureLocalityLbPoliciesIsMutable() { 8411 if (!((bitField0_ & 0x00200000) != 0)) { 8412 localityLbPolicies_ = 8413 new java.util.ArrayList< 8414 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig>( 8415 localityLbPolicies_); 8416 bitField0_ |= 0x00200000; 8417 } 8418 } 8419 8420 private com.google.protobuf.RepeatedFieldBuilderV3< 8421 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig, 8422 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder, 8423 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder> 8424 localityLbPoliciesBuilder_; 8425 8426 /** 8427 * 8428 * 8429 * <pre> 8430 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8431 * </pre> 8432 * 8433 * <code> 8434 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8435 * </code> 8436 */ 8437 public java.util.List< 8438 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig> getLocalityLbPoliciesList()8439 getLocalityLbPoliciesList() { 8440 if (localityLbPoliciesBuilder_ == null) { 8441 return java.util.Collections.unmodifiableList(localityLbPolicies_); 8442 } else { 8443 return localityLbPoliciesBuilder_.getMessageList(); 8444 } 8445 } 8446 /** 8447 * 8448 * 8449 * <pre> 8450 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8451 * </pre> 8452 * 8453 * <code> 8454 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8455 * </code> 8456 */ getLocalityLbPoliciesCount()8457 public int getLocalityLbPoliciesCount() { 8458 if (localityLbPoliciesBuilder_ == null) { 8459 return localityLbPolicies_.size(); 8460 } else { 8461 return localityLbPoliciesBuilder_.getCount(); 8462 } 8463 } 8464 /** 8465 * 8466 * 8467 * <pre> 8468 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8469 * </pre> 8470 * 8471 * <code> 8472 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8473 * </code> 8474 */ 8475 public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig getLocalityLbPolicies(int index)8476 getLocalityLbPolicies(int index) { 8477 if (localityLbPoliciesBuilder_ == null) { 8478 return localityLbPolicies_.get(index); 8479 } else { 8480 return localityLbPoliciesBuilder_.getMessage(index); 8481 } 8482 } 8483 /** 8484 * 8485 * 8486 * <pre> 8487 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8488 * </pre> 8489 * 8490 * <code> 8491 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8492 * </code> 8493 */ setLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value)8494 public Builder setLocalityLbPolicies( 8495 int index, 8496 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value) { 8497 if (localityLbPoliciesBuilder_ == null) { 8498 if (value == null) { 8499 throw new NullPointerException(); 8500 } 8501 ensureLocalityLbPoliciesIsMutable(); 8502 localityLbPolicies_.set(index, value); 8503 onChanged(); 8504 } else { 8505 localityLbPoliciesBuilder_.setMessage(index, value); 8506 } 8507 return this; 8508 } 8509 /** 8510 * 8511 * 8512 * <pre> 8513 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8514 * </pre> 8515 * 8516 * <code> 8517 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8518 * </code> 8519 */ setLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder builderForValue)8520 public Builder setLocalityLbPolicies( 8521 int index, 8522 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder 8523 builderForValue) { 8524 if (localityLbPoliciesBuilder_ == null) { 8525 ensureLocalityLbPoliciesIsMutable(); 8526 localityLbPolicies_.set(index, builderForValue.build()); 8527 onChanged(); 8528 } else { 8529 localityLbPoliciesBuilder_.setMessage(index, builderForValue.build()); 8530 } 8531 return this; 8532 } 8533 /** 8534 * 8535 * 8536 * <pre> 8537 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8538 * </pre> 8539 * 8540 * <code> 8541 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8542 * </code> 8543 */ addLocalityLbPolicies( com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value)8544 public Builder addLocalityLbPolicies( 8545 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value) { 8546 if (localityLbPoliciesBuilder_ == null) { 8547 if (value == null) { 8548 throw new NullPointerException(); 8549 } 8550 ensureLocalityLbPoliciesIsMutable(); 8551 localityLbPolicies_.add(value); 8552 onChanged(); 8553 } else { 8554 localityLbPoliciesBuilder_.addMessage(value); 8555 } 8556 return this; 8557 } 8558 /** 8559 * 8560 * 8561 * <pre> 8562 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8563 * </pre> 8564 * 8565 * <code> 8566 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8567 * </code> 8568 */ addLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value)8569 public Builder addLocalityLbPolicies( 8570 int index, 8571 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig value) { 8572 if (localityLbPoliciesBuilder_ == null) { 8573 if (value == null) { 8574 throw new NullPointerException(); 8575 } 8576 ensureLocalityLbPoliciesIsMutable(); 8577 localityLbPolicies_.add(index, value); 8578 onChanged(); 8579 } else { 8580 localityLbPoliciesBuilder_.addMessage(index, value); 8581 } 8582 return this; 8583 } 8584 /** 8585 * 8586 * 8587 * <pre> 8588 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8589 * </pre> 8590 * 8591 * <code> 8592 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8593 * </code> 8594 */ addLocalityLbPolicies( com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder builderForValue)8595 public Builder addLocalityLbPolicies( 8596 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder 8597 builderForValue) { 8598 if (localityLbPoliciesBuilder_ == null) { 8599 ensureLocalityLbPoliciesIsMutable(); 8600 localityLbPolicies_.add(builderForValue.build()); 8601 onChanged(); 8602 } else { 8603 localityLbPoliciesBuilder_.addMessage(builderForValue.build()); 8604 } 8605 return this; 8606 } 8607 /** 8608 * 8609 * 8610 * <pre> 8611 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8612 * </pre> 8613 * 8614 * <code> 8615 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8616 * </code> 8617 */ addLocalityLbPolicies( int index, com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder builderForValue)8618 public Builder addLocalityLbPolicies( 8619 int index, 8620 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder 8621 builderForValue) { 8622 if (localityLbPoliciesBuilder_ == null) { 8623 ensureLocalityLbPoliciesIsMutable(); 8624 localityLbPolicies_.add(index, builderForValue.build()); 8625 onChanged(); 8626 } else { 8627 localityLbPoliciesBuilder_.addMessage(index, builderForValue.build()); 8628 } 8629 return this; 8630 } 8631 /** 8632 * 8633 * 8634 * <pre> 8635 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8636 * </pre> 8637 * 8638 * <code> 8639 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8640 * </code> 8641 */ addAllLocalityLbPolicies( java.lang.Iterable< ? extends com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig> values)8642 public Builder addAllLocalityLbPolicies( 8643 java.lang.Iterable< 8644 ? extends 8645 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig> 8646 values) { 8647 if (localityLbPoliciesBuilder_ == null) { 8648 ensureLocalityLbPoliciesIsMutable(); 8649 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, localityLbPolicies_); 8650 onChanged(); 8651 } else { 8652 localityLbPoliciesBuilder_.addAllMessages(values); 8653 } 8654 return this; 8655 } 8656 /** 8657 * 8658 * 8659 * <pre> 8660 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8661 * </pre> 8662 * 8663 * <code> 8664 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8665 * </code> 8666 */ clearLocalityLbPolicies()8667 public Builder clearLocalityLbPolicies() { 8668 if (localityLbPoliciesBuilder_ == null) { 8669 localityLbPolicies_ = java.util.Collections.emptyList(); 8670 bitField0_ = (bitField0_ & ~0x00200000); 8671 onChanged(); 8672 } else { 8673 localityLbPoliciesBuilder_.clear(); 8674 } 8675 return this; 8676 } 8677 /** 8678 * 8679 * 8680 * <pre> 8681 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8682 * </pre> 8683 * 8684 * <code> 8685 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8686 * </code> 8687 */ removeLocalityLbPolicies(int index)8688 public Builder removeLocalityLbPolicies(int index) { 8689 if (localityLbPoliciesBuilder_ == null) { 8690 ensureLocalityLbPoliciesIsMutable(); 8691 localityLbPolicies_.remove(index); 8692 onChanged(); 8693 } else { 8694 localityLbPoliciesBuilder_.remove(index); 8695 } 8696 return this; 8697 } 8698 /** 8699 * 8700 * 8701 * <pre> 8702 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8703 * </pre> 8704 * 8705 * <code> 8706 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8707 * </code> 8708 */ 8709 public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder getLocalityLbPoliciesBuilder(int index)8710 getLocalityLbPoliciesBuilder(int index) { 8711 return getLocalityLbPoliciesFieldBuilder().getBuilder(index); 8712 } 8713 /** 8714 * 8715 * 8716 * <pre> 8717 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8718 * </pre> 8719 * 8720 * <code> 8721 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8722 * </code> 8723 */ 8724 public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder getLocalityLbPoliciesOrBuilder(int index)8725 getLocalityLbPoliciesOrBuilder(int index) { 8726 if (localityLbPoliciesBuilder_ == null) { 8727 return localityLbPolicies_.get(index); 8728 } else { 8729 return localityLbPoliciesBuilder_.getMessageOrBuilder(index); 8730 } 8731 } 8732 /** 8733 * 8734 * 8735 * <pre> 8736 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8737 * </pre> 8738 * 8739 * <code> 8740 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8741 * </code> 8742 */ 8743 public java.util.List< 8744 ? extends 8745 com.google.cloud.compute.v1 8746 .BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder> getLocalityLbPoliciesOrBuilderList()8747 getLocalityLbPoliciesOrBuilderList() { 8748 if (localityLbPoliciesBuilder_ != null) { 8749 return localityLbPoliciesBuilder_.getMessageOrBuilderList(); 8750 } else { 8751 return java.util.Collections.unmodifiableList(localityLbPolicies_); 8752 } 8753 } 8754 /** 8755 * 8756 * 8757 * <pre> 8758 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8759 * </pre> 8760 * 8761 * <code> 8762 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8763 * </code> 8764 */ 8765 public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder addLocalityLbPoliciesBuilder()8766 addLocalityLbPoliciesBuilder() { 8767 return getLocalityLbPoliciesFieldBuilder() 8768 .addBuilder( 8769 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig 8770 .getDefaultInstance()); 8771 } 8772 /** 8773 * 8774 * 8775 * <pre> 8776 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8777 * </pre> 8778 * 8779 * <code> 8780 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8781 * </code> 8782 */ 8783 public com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder addLocalityLbPoliciesBuilder(int index)8784 addLocalityLbPoliciesBuilder(int index) { 8785 return getLocalityLbPoliciesFieldBuilder() 8786 .addBuilder( 8787 index, 8788 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig 8789 .getDefaultInstance()); 8790 } 8791 /** 8792 * 8793 * 8794 * <pre> 8795 * A list of locality load-balancing policies to be used in order of preference. When you use localityLbPolicies, you must set at least one value for either the localityLbPolicies[].policy or the localityLbPolicies[].customPolicy field. localityLbPolicies overrides any value set in the localityLbPolicy field. For an example of how to use this field, see Define a list of preferred policies. Caution: This field and its children are intended for use in a service mesh that includes gRPC clients only. Envoy proxies can't use backend services that have this configuration. 8796 * </pre> 8797 * 8798 * <code> 8799 * repeated .google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig locality_lb_policies = 140982557; 8800 * </code> 8801 */ 8802 public java.util.List< 8803 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder> getLocalityLbPoliciesBuilderList()8804 getLocalityLbPoliciesBuilderList() { 8805 return getLocalityLbPoliciesFieldBuilder().getBuilderList(); 8806 } 8807 8808 private com.google.protobuf.RepeatedFieldBuilderV3< 8809 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig, 8810 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder, 8811 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder> getLocalityLbPoliciesFieldBuilder()8812 getLocalityLbPoliciesFieldBuilder() { 8813 if (localityLbPoliciesBuilder_ == null) { 8814 localityLbPoliciesBuilder_ = 8815 new com.google.protobuf.RepeatedFieldBuilderV3< 8816 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig, 8817 com.google.cloud.compute.v1.BackendServiceLocalityLoadBalancingPolicyConfig.Builder, 8818 com.google.cloud.compute.v1 8819 .BackendServiceLocalityLoadBalancingPolicyConfigOrBuilder>( 8820 localityLbPolicies_, 8821 ((bitField0_ & 0x00200000) != 0), 8822 getParentForChildren(), 8823 isClean()); 8824 localityLbPolicies_ = null; 8825 } 8826 return localityLbPoliciesBuilder_; 8827 } 8828 8829 private java.lang.Object localityLbPolicy_ = ""; 8830 /** 8831 * 8832 * 8833 * <pre> 8834 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 8835 * Check the LocalityLbPolicy enum for the list of possible values. 8836 * </pre> 8837 * 8838 * <code>optional string locality_lb_policy = 131431487;</code> 8839 * 8840 * @return Whether the localityLbPolicy field is set. 8841 */ hasLocalityLbPolicy()8842 public boolean hasLocalityLbPolicy() { 8843 return ((bitField0_ & 0x00400000) != 0); 8844 } 8845 /** 8846 * 8847 * 8848 * <pre> 8849 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 8850 * Check the LocalityLbPolicy enum for the list of possible values. 8851 * </pre> 8852 * 8853 * <code>optional string locality_lb_policy = 131431487;</code> 8854 * 8855 * @return The localityLbPolicy. 8856 */ getLocalityLbPolicy()8857 public java.lang.String getLocalityLbPolicy() { 8858 java.lang.Object ref = localityLbPolicy_; 8859 if (!(ref instanceof java.lang.String)) { 8860 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 8861 java.lang.String s = bs.toStringUtf8(); 8862 localityLbPolicy_ = s; 8863 return s; 8864 } else { 8865 return (java.lang.String) ref; 8866 } 8867 } 8868 /** 8869 * 8870 * 8871 * <pre> 8872 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 8873 * Check the LocalityLbPolicy enum for the list of possible values. 8874 * </pre> 8875 * 8876 * <code>optional string locality_lb_policy = 131431487;</code> 8877 * 8878 * @return The bytes for localityLbPolicy. 8879 */ getLocalityLbPolicyBytes()8880 public com.google.protobuf.ByteString getLocalityLbPolicyBytes() { 8881 java.lang.Object ref = localityLbPolicy_; 8882 if (ref instanceof String) { 8883 com.google.protobuf.ByteString b = 8884 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 8885 localityLbPolicy_ = b; 8886 return b; 8887 } else { 8888 return (com.google.protobuf.ByteString) ref; 8889 } 8890 } 8891 /** 8892 * 8893 * 8894 * <pre> 8895 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 8896 * Check the LocalityLbPolicy enum for the list of possible values. 8897 * </pre> 8898 * 8899 * <code>optional string locality_lb_policy = 131431487;</code> 8900 * 8901 * @param value The localityLbPolicy to set. 8902 * @return This builder for chaining. 8903 */ setLocalityLbPolicy(java.lang.String value)8904 public Builder setLocalityLbPolicy(java.lang.String value) { 8905 if (value == null) { 8906 throw new NullPointerException(); 8907 } 8908 localityLbPolicy_ = value; 8909 bitField0_ |= 0x00400000; 8910 onChanged(); 8911 return this; 8912 } 8913 /** 8914 * 8915 * 8916 * <pre> 8917 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 8918 * Check the LocalityLbPolicy enum for the list of possible values. 8919 * </pre> 8920 * 8921 * <code>optional string locality_lb_policy = 131431487;</code> 8922 * 8923 * @return This builder for chaining. 8924 */ clearLocalityLbPolicy()8925 public Builder clearLocalityLbPolicy() { 8926 localityLbPolicy_ = getDefaultInstance().getLocalityLbPolicy(); 8927 bitField0_ = (bitField0_ & ~0x00400000); 8928 onChanged(); 8929 return this; 8930 } 8931 /** 8932 * 8933 * 8934 * <pre> 8935 * The load balancing algorithm used within the scope of the locality. The possible values are: - ROUND_ROBIN: This is a simple policy in which each healthy backend is selected in round robin order. This is the default. - LEAST_REQUEST: An O(1) algorithm which selects two random healthy hosts and picks the host which has fewer active requests. - RING_HASH: The ring/modulo hash load balancer implements consistent hashing to backends. The algorithm has the property that the addition/removal of a host from a set of N hosts only affects 1/N of the requests. - RANDOM: The load balancer selects a random healthy host. - ORIGINAL_DESTINATION: Backend host is selected based on the client connection metadata, i.e., connections are opened to the same address as the destination address of the incoming connection before the connection was redirected to the load balancer. - MAGLEV: used as a drop in replacement for the ring hash load balancer. Maglev is not as stable as ring hash but has faster table lookup build times and host selection times. For more information about Maglev, see https://ai.google/research/pubs/pub44824 This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. If sessionAffinity is not NONE, and this field is not set to MAGLEV or RING_HASH, session affinity settings will not take effect. Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. 8936 * Check the LocalityLbPolicy enum for the list of possible values. 8937 * </pre> 8938 * 8939 * <code>optional string locality_lb_policy = 131431487;</code> 8940 * 8941 * @param value The bytes for localityLbPolicy to set. 8942 * @return This builder for chaining. 8943 */ setLocalityLbPolicyBytes(com.google.protobuf.ByteString value)8944 public Builder setLocalityLbPolicyBytes(com.google.protobuf.ByteString value) { 8945 if (value == null) { 8946 throw new NullPointerException(); 8947 } 8948 checkByteStringIsUtf8(value); 8949 localityLbPolicy_ = value; 8950 bitField0_ |= 0x00400000; 8951 onChanged(); 8952 return this; 8953 } 8954 8955 private com.google.cloud.compute.v1.BackendServiceLogConfig logConfig_; 8956 private com.google.protobuf.SingleFieldBuilderV3< 8957 com.google.cloud.compute.v1.BackendServiceLogConfig, 8958 com.google.cloud.compute.v1.BackendServiceLogConfig.Builder, 8959 com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder> 8960 logConfigBuilder_; 8961 /** 8962 * 8963 * 8964 * <pre> 8965 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 8966 * </pre> 8967 * 8968 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 8969 * </code> 8970 * 8971 * @return Whether the logConfig field is set. 8972 */ hasLogConfig()8973 public boolean hasLogConfig() { 8974 return ((bitField0_ & 0x00800000) != 0); 8975 } 8976 /** 8977 * 8978 * 8979 * <pre> 8980 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 8981 * </pre> 8982 * 8983 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 8984 * </code> 8985 * 8986 * @return The logConfig. 8987 */ getLogConfig()8988 public com.google.cloud.compute.v1.BackendServiceLogConfig getLogConfig() { 8989 if (logConfigBuilder_ == null) { 8990 return logConfig_ == null 8991 ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance() 8992 : logConfig_; 8993 } else { 8994 return logConfigBuilder_.getMessage(); 8995 } 8996 } 8997 /** 8998 * 8999 * 9000 * <pre> 9001 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 9002 * </pre> 9003 * 9004 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 9005 * </code> 9006 */ setLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value)9007 public Builder setLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value) { 9008 if (logConfigBuilder_ == null) { 9009 if (value == null) { 9010 throw new NullPointerException(); 9011 } 9012 logConfig_ = value; 9013 } else { 9014 logConfigBuilder_.setMessage(value); 9015 } 9016 bitField0_ |= 0x00800000; 9017 onChanged(); 9018 return this; 9019 } 9020 /** 9021 * 9022 * 9023 * <pre> 9024 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 9025 * </pre> 9026 * 9027 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 9028 * </code> 9029 */ setLogConfig( com.google.cloud.compute.v1.BackendServiceLogConfig.Builder builderForValue)9030 public Builder setLogConfig( 9031 com.google.cloud.compute.v1.BackendServiceLogConfig.Builder builderForValue) { 9032 if (logConfigBuilder_ == null) { 9033 logConfig_ = builderForValue.build(); 9034 } else { 9035 logConfigBuilder_.setMessage(builderForValue.build()); 9036 } 9037 bitField0_ |= 0x00800000; 9038 onChanged(); 9039 return this; 9040 } 9041 /** 9042 * 9043 * 9044 * <pre> 9045 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 9046 * </pre> 9047 * 9048 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 9049 * </code> 9050 */ mergeLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value)9051 public Builder mergeLogConfig(com.google.cloud.compute.v1.BackendServiceLogConfig value) { 9052 if (logConfigBuilder_ == null) { 9053 if (((bitField0_ & 0x00800000) != 0) 9054 && logConfig_ != null 9055 && logConfig_ 9056 != com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance()) { 9057 getLogConfigBuilder().mergeFrom(value); 9058 } else { 9059 logConfig_ = value; 9060 } 9061 } else { 9062 logConfigBuilder_.mergeFrom(value); 9063 } 9064 bitField0_ |= 0x00800000; 9065 onChanged(); 9066 return this; 9067 } 9068 /** 9069 * 9070 * 9071 * <pre> 9072 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 9073 * </pre> 9074 * 9075 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 9076 * </code> 9077 */ clearLogConfig()9078 public Builder clearLogConfig() { 9079 bitField0_ = (bitField0_ & ~0x00800000); 9080 logConfig_ = null; 9081 if (logConfigBuilder_ != null) { 9082 logConfigBuilder_.dispose(); 9083 logConfigBuilder_ = null; 9084 } 9085 onChanged(); 9086 return this; 9087 } 9088 /** 9089 * 9090 * 9091 * <pre> 9092 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 9093 * </pre> 9094 * 9095 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 9096 * </code> 9097 */ getLogConfigBuilder()9098 public com.google.cloud.compute.v1.BackendServiceLogConfig.Builder getLogConfigBuilder() { 9099 bitField0_ |= 0x00800000; 9100 onChanged(); 9101 return getLogConfigFieldBuilder().getBuilder(); 9102 } 9103 /** 9104 * 9105 * 9106 * <pre> 9107 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 9108 * </pre> 9109 * 9110 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 9111 * </code> 9112 */ getLogConfigOrBuilder()9113 public com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder getLogConfigOrBuilder() { 9114 if (logConfigBuilder_ != null) { 9115 return logConfigBuilder_.getMessageOrBuilder(); 9116 } else { 9117 return logConfig_ == null 9118 ? com.google.cloud.compute.v1.BackendServiceLogConfig.getDefaultInstance() 9119 : logConfig_; 9120 } 9121 } 9122 /** 9123 * 9124 * 9125 * <pre> 9126 * This field denotes the logging options for the load balancer traffic served by this backend service. If logging is enabled, logs will be exported to Stackdriver. 9127 * </pre> 9128 * 9129 * <code>optional .google.cloud.compute.v1.BackendServiceLogConfig log_config = 351299741; 9130 * </code> 9131 */ 9132 private com.google.protobuf.SingleFieldBuilderV3< 9133 com.google.cloud.compute.v1.BackendServiceLogConfig, 9134 com.google.cloud.compute.v1.BackendServiceLogConfig.Builder, 9135 com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder> getLogConfigFieldBuilder()9136 getLogConfigFieldBuilder() { 9137 if (logConfigBuilder_ == null) { 9138 logConfigBuilder_ = 9139 new com.google.protobuf.SingleFieldBuilderV3< 9140 com.google.cloud.compute.v1.BackendServiceLogConfig, 9141 com.google.cloud.compute.v1.BackendServiceLogConfig.Builder, 9142 com.google.cloud.compute.v1.BackendServiceLogConfigOrBuilder>( 9143 getLogConfig(), getParentForChildren(), isClean()); 9144 logConfig_ = null; 9145 } 9146 return logConfigBuilder_; 9147 } 9148 9149 private com.google.cloud.compute.v1.Duration maxStreamDuration_; 9150 private com.google.protobuf.SingleFieldBuilderV3< 9151 com.google.cloud.compute.v1.Duration, 9152 com.google.cloud.compute.v1.Duration.Builder, 9153 com.google.cloud.compute.v1.DurationOrBuilder> 9154 maxStreamDurationBuilder_; 9155 /** 9156 * 9157 * 9158 * <pre> 9159 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9160 * </pre> 9161 * 9162 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9163 * 9164 * @return Whether the maxStreamDuration field is set. 9165 */ hasMaxStreamDuration()9166 public boolean hasMaxStreamDuration() { 9167 return ((bitField0_ & 0x01000000) != 0); 9168 } 9169 /** 9170 * 9171 * 9172 * <pre> 9173 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9174 * </pre> 9175 * 9176 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9177 * 9178 * @return The maxStreamDuration. 9179 */ getMaxStreamDuration()9180 public com.google.cloud.compute.v1.Duration getMaxStreamDuration() { 9181 if (maxStreamDurationBuilder_ == null) { 9182 return maxStreamDuration_ == null 9183 ? com.google.cloud.compute.v1.Duration.getDefaultInstance() 9184 : maxStreamDuration_; 9185 } else { 9186 return maxStreamDurationBuilder_.getMessage(); 9187 } 9188 } 9189 /** 9190 * 9191 * 9192 * <pre> 9193 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9194 * </pre> 9195 * 9196 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9197 */ setMaxStreamDuration(com.google.cloud.compute.v1.Duration value)9198 public Builder setMaxStreamDuration(com.google.cloud.compute.v1.Duration value) { 9199 if (maxStreamDurationBuilder_ == null) { 9200 if (value == null) { 9201 throw new NullPointerException(); 9202 } 9203 maxStreamDuration_ = value; 9204 } else { 9205 maxStreamDurationBuilder_.setMessage(value); 9206 } 9207 bitField0_ |= 0x01000000; 9208 onChanged(); 9209 return this; 9210 } 9211 /** 9212 * 9213 * 9214 * <pre> 9215 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9216 * </pre> 9217 * 9218 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9219 */ setMaxStreamDuration( com.google.cloud.compute.v1.Duration.Builder builderForValue)9220 public Builder setMaxStreamDuration( 9221 com.google.cloud.compute.v1.Duration.Builder builderForValue) { 9222 if (maxStreamDurationBuilder_ == null) { 9223 maxStreamDuration_ = builderForValue.build(); 9224 } else { 9225 maxStreamDurationBuilder_.setMessage(builderForValue.build()); 9226 } 9227 bitField0_ |= 0x01000000; 9228 onChanged(); 9229 return this; 9230 } 9231 /** 9232 * 9233 * 9234 * <pre> 9235 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9236 * </pre> 9237 * 9238 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9239 */ mergeMaxStreamDuration(com.google.cloud.compute.v1.Duration value)9240 public Builder mergeMaxStreamDuration(com.google.cloud.compute.v1.Duration value) { 9241 if (maxStreamDurationBuilder_ == null) { 9242 if (((bitField0_ & 0x01000000) != 0) 9243 && maxStreamDuration_ != null 9244 && maxStreamDuration_ != com.google.cloud.compute.v1.Duration.getDefaultInstance()) { 9245 getMaxStreamDurationBuilder().mergeFrom(value); 9246 } else { 9247 maxStreamDuration_ = value; 9248 } 9249 } else { 9250 maxStreamDurationBuilder_.mergeFrom(value); 9251 } 9252 bitField0_ |= 0x01000000; 9253 onChanged(); 9254 return this; 9255 } 9256 /** 9257 * 9258 * 9259 * <pre> 9260 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9261 * </pre> 9262 * 9263 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9264 */ clearMaxStreamDuration()9265 public Builder clearMaxStreamDuration() { 9266 bitField0_ = (bitField0_ & ~0x01000000); 9267 maxStreamDuration_ = null; 9268 if (maxStreamDurationBuilder_ != null) { 9269 maxStreamDurationBuilder_.dispose(); 9270 maxStreamDurationBuilder_ = null; 9271 } 9272 onChanged(); 9273 return this; 9274 } 9275 /** 9276 * 9277 * 9278 * <pre> 9279 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9280 * </pre> 9281 * 9282 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9283 */ getMaxStreamDurationBuilder()9284 public com.google.cloud.compute.v1.Duration.Builder getMaxStreamDurationBuilder() { 9285 bitField0_ |= 0x01000000; 9286 onChanged(); 9287 return getMaxStreamDurationFieldBuilder().getBuilder(); 9288 } 9289 /** 9290 * 9291 * 9292 * <pre> 9293 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9294 * </pre> 9295 * 9296 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9297 */ getMaxStreamDurationOrBuilder()9298 public com.google.cloud.compute.v1.DurationOrBuilder getMaxStreamDurationOrBuilder() { 9299 if (maxStreamDurationBuilder_ != null) { 9300 return maxStreamDurationBuilder_.getMessageOrBuilder(); 9301 } else { 9302 return maxStreamDuration_ == null 9303 ? com.google.cloud.compute.v1.Duration.getDefaultInstance() 9304 : maxStreamDuration_; 9305 } 9306 } 9307 /** 9308 * 9309 * 9310 * <pre> 9311 * Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the beginning of the stream until the response has been completely processed, including all retries. A stream that does not complete in this duration is closed. If not specified, there will be no timeout limit, i.e. the maximum duration is infinite. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED. 9312 * </pre> 9313 * 9314 * <code>optional .google.cloud.compute.v1.Duration max_stream_duration = 61428376;</code> 9315 */ 9316 private com.google.protobuf.SingleFieldBuilderV3< 9317 com.google.cloud.compute.v1.Duration, 9318 com.google.cloud.compute.v1.Duration.Builder, 9319 com.google.cloud.compute.v1.DurationOrBuilder> getMaxStreamDurationFieldBuilder()9320 getMaxStreamDurationFieldBuilder() { 9321 if (maxStreamDurationBuilder_ == null) { 9322 maxStreamDurationBuilder_ = 9323 new com.google.protobuf.SingleFieldBuilderV3< 9324 com.google.cloud.compute.v1.Duration, 9325 com.google.cloud.compute.v1.Duration.Builder, 9326 com.google.cloud.compute.v1.DurationOrBuilder>( 9327 getMaxStreamDuration(), getParentForChildren(), isClean()); 9328 maxStreamDuration_ = null; 9329 } 9330 return maxStreamDurationBuilder_; 9331 } 9332 9333 private java.lang.Object name_ = ""; 9334 /** 9335 * 9336 * 9337 * <pre> 9338 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 9339 * </pre> 9340 * 9341 * <code>optional string name = 3373707;</code> 9342 * 9343 * @return Whether the name field is set. 9344 */ hasName()9345 public boolean hasName() { 9346 return ((bitField0_ & 0x02000000) != 0); 9347 } 9348 /** 9349 * 9350 * 9351 * <pre> 9352 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 9353 * </pre> 9354 * 9355 * <code>optional string name = 3373707;</code> 9356 * 9357 * @return The name. 9358 */ getName()9359 public java.lang.String getName() { 9360 java.lang.Object ref = name_; 9361 if (!(ref instanceof java.lang.String)) { 9362 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 9363 java.lang.String s = bs.toStringUtf8(); 9364 name_ = s; 9365 return s; 9366 } else { 9367 return (java.lang.String) ref; 9368 } 9369 } 9370 /** 9371 * 9372 * 9373 * <pre> 9374 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 9375 * </pre> 9376 * 9377 * <code>optional string name = 3373707;</code> 9378 * 9379 * @return The bytes for name. 9380 */ getNameBytes()9381 public com.google.protobuf.ByteString getNameBytes() { 9382 java.lang.Object ref = name_; 9383 if (ref instanceof String) { 9384 com.google.protobuf.ByteString b = 9385 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 9386 name_ = b; 9387 return b; 9388 } else { 9389 return (com.google.protobuf.ByteString) ref; 9390 } 9391 } 9392 /** 9393 * 9394 * 9395 * <pre> 9396 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 9397 * </pre> 9398 * 9399 * <code>optional string name = 3373707;</code> 9400 * 9401 * @param value The name to set. 9402 * @return This builder for chaining. 9403 */ setName(java.lang.String value)9404 public Builder setName(java.lang.String value) { 9405 if (value == null) { 9406 throw new NullPointerException(); 9407 } 9408 name_ = value; 9409 bitField0_ |= 0x02000000; 9410 onChanged(); 9411 return this; 9412 } 9413 /** 9414 * 9415 * 9416 * <pre> 9417 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 9418 * </pre> 9419 * 9420 * <code>optional string name = 3373707;</code> 9421 * 9422 * @return This builder for chaining. 9423 */ clearName()9424 public Builder clearName() { 9425 name_ = getDefaultInstance().getName(); 9426 bitField0_ = (bitField0_ & ~0x02000000); 9427 onChanged(); 9428 return this; 9429 } 9430 /** 9431 * 9432 * 9433 * <pre> 9434 * Name of the resource. Provided by the client when the resource is created. The name must be 1-63 characters long, and comply with RFC1035. Specifically, the name must be 1-63 characters long and match the regular expression `[a-z]([-a-z0-9]*[a-z0-9])?` which means the first character must be a lowercase letter, and all following characters must be a dash, lowercase letter, or digit, except the last character, which cannot be a dash. 9435 * </pre> 9436 * 9437 * <code>optional string name = 3373707;</code> 9438 * 9439 * @param value The bytes for name to set. 9440 * @return This builder for chaining. 9441 */ setNameBytes(com.google.protobuf.ByteString value)9442 public Builder setNameBytes(com.google.protobuf.ByteString value) { 9443 if (value == null) { 9444 throw new NullPointerException(); 9445 } 9446 checkByteStringIsUtf8(value); 9447 name_ = value; 9448 bitField0_ |= 0x02000000; 9449 onChanged(); 9450 return this; 9451 } 9452 9453 private java.lang.Object network_ = ""; 9454 /** 9455 * 9456 * 9457 * <pre> 9458 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 9459 * </pre> 9460 * 9461 * <code>optional string network = 232872494;</code> 9462 * 9463 * @return Whether the network field is set. 9464 */ hasNetwork()9465 public boolean hasNetwork() { 9466 return ((bitField0_ & 0x04000000) != 0); 9467 } 9468 /** 9469 * 9470 * 9471 * <pre> 9472 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 9473 * </pre> 9474 * 9475 * <code>optional string network = 232872494;</code> 9476 * 9477 * @return The network. 9478 */ getNetwork()9479 public java.lang.String getNetwork() { 9480 java.lang.Object ref = network_; 9481 if (!(ref instanceof java.lang.String)) { 9482 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 9483 java.lang.String s = bs.toStringUtf8(); 9484 network_ = s; 9485 return s; 9486 } else { 9487 return (java.lang.String) ref; 9488 } 9489 } 9490 /** 9491 * 9492 * 9493 * <pre> 9494 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 9495 * </pre> 9496 * 9497 * <code>optional string network = 232872494;</code> 9498 * 9499 * @return The bytes for network. 9500 */ getNetworkBytes()9501 public com.google.protobuf.ByteString getNetworkBytes() { 9502 java.lang.Object ref = network_; 9503 if (ref instanceof String) { 9504 com.google.protobuf.ByteString b = 9505 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 9506 network_ = b; 9507 return b; 9508 } else { 9509 return (com.google.protobuf.ByteString) ref; 9510 } 9511 } 9512 /** 9513 * 9514 * 9515 * <pre> 9516 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 9517 * </pre> 9518 * 9519 * <code>optional string network = 232872494;</code> 9520 * 9521 * @param value The network to set. 9522 * @return This builder for chaining. 9523 */ setNetwork(java.lang.String value)9524 public Builder setNetwork(java.lang.String value) { 9525 if (value == null) { 9526 throw new NullPointerException(); 9527 } 9528 network_ = value; 9529 bitField0_ |= 0x04000000; 9530 onChanged(); 9531 return this; 9532 } 9533 /** 9534 * 9535 * 9536 * <pre> 9537 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 9538 * </pre> 9539 * 9540 * <code>optional string network = 232872494;</code> 9541 * 9542 * @return This builder for chaining. 9543 */ clearNetwork()9544 public Builder clearNetwork() { 9545 network_ = getDefaultInstance().getNetwork(); 9546 bitField0_ = (bitField0_ & ~0x04000000); 9547 onChanged(); 9548 return this; 9549 } 9550 /** 9551 * 9552 * 9553 * <pre> 9554 * The URL of the network to which this backend service belongs. This field can only be specified when the load balancing scheme is set to INTERNAL. 9555 * </pre> 9556 * 9557 * <code>optional string network = 232872494;</code> 9558 * 9559 * @param value The bytes for network to set. 9560 * @return This builder for chaining. 9561 */ setNetworkBytes(com.google.protobuf.ByteString value)9562 public Builder setNetworkBytes(com.google.protobuf.ByteString value) { 9563 if (value == null) { 9564 throw new NullPointerException(); 9565 } 9566 checkByteStringIsUtf8(value); 9567 network_ = value; 9568 bitField0_ |= 0x04000000; 9569 onChanged(); 9570 return this; 9571 } 9572 9573 private com.google.cloud.compute.v1.OutlierDetection outlierDetection_; 9574 private com.google.protobuf.SingleFieldBuilderV3< 9575 com.google.cloud.compute.v1.OutlierDetection, 9576 com.google.cloud.compute.v1.OutlierDetection.Builder, 9577 com.google.cloud.compute.v1.OutlierDetectionOrBuilder> 9578 outlierDetectionBuilder_; 9579 /** 9580 * 9581 * 9582 * <pre> 9583 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9584 * </pre> 9585 * 9586 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9587 * </code> 9588 * 9589 * @return Whether the outlierDetection field is set. 9590 */ hasOutlierDetection()9591 public boolean hasOutlierDetection() { 9592 return ((bitField0_ & 0x08000000) != 0); 9593 } 9594 /** 9595 * 9596 * 9597 * <pre> 9598 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9599 * </pre> 9600 * 9601 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9602 * </code> 9603 * 9604 * @return The outlierDetection. 9605 */ getOutlierDetection()9606 public com.google.cloud.compute.v1.OutlierDetection getOutlierDetection() { 9607 if (outlierDetectionBuilder_ == null) { 9608 return outlierDetection_ == null 9609 ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance() 9610 : outlierDetection_; 9611 } else { 9612 return outlierDetectionBuilder_.getMessage(); 9613 } 9614 } 9615 /** 9616 * 9617 * 9618 * <pre> 9619 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9620 * </pre> 9621 * 9622 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9623 * </code> 9624 */ setOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value)9625 public Builder setOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value) { 9626 if (outlierDetectionBuilder_ == null) { 9627 if (value == null) { 9628 throw new NullPointerException(); 9629 } 9630 outlierDetection_ = value; 9631 } else { 9632 outlierDetectionBuilder_.setMessage(value); 9633 } 9634 bitField0_ |= 0x08000000; 9635 onChanged(); 9636 return this; 9637 } 9638 /** 9639 * 9640 * 9641 * <pre> 9642 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9643 * </pre> 9644 * 9645 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9646 * </code> 9647 */ setOutlierDetection( com.google.cloud.compute.v1.OutlierDetection.Builder builderForValue)9648 public Builder setOutlierDetection( 9649 com.google.cloud.compute.v1.OutlierDetection.Builder builderForValue) { 9650 if (outlierDetectionBuilder_ == null) { 9651 outlierDetection_ = builderForValue.build(); 9652 } else { 9653 outlierDetectionBuilder_.setMessage(builderForValue.build()); 9654 } 9655 bitField0_ |= 0x08000000; 9656 onChanged(); 9657 return this; 9658 } 9659 /** 9660 * 9661 * 9662 * <pre> 9663 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9664 * </pre> 9665 * 9666 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9667 * </code> 9668 */ mergeOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value)9669 public Builder mergeOutlierDetection(com.google.cloud.compute.v1.OutlierDetection value) { 9670 if (outlierDetectionBuilder_ == null) { 9671 if (((bitField0_ & 0x08000000) != 0) 9672 && outlierDetection_ != null 9673 && outlierDetection_ 9674 != com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance()) { 9675 getOutlierDetectionBuilder().mergeFrom(value); 9676 } else { 9677 outlierDetection_ = value; 9678 } 9679 } else { 9680 outlierDetectionBuilder_.mergeFrom(value); 9681 } 9682 bitField0_ |= 0x08000000; 9683 onChanged(); 9684 return this; 9685 } 9686 /** 9687 * 9688 * 9689 * <pre> 9690 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9691 * </pre> 9692 * 9693 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9694 * </code> 9695 */ clearOutlierDetection()9696 public Builder clearOutlierDetection() { 9697 bitField0_ = (bitField0_ & ~0x08000000); 9698 outlierDetection_ = null; 9699 if (outlierDetectionBuilder_ != null) { 9700 outlierDetectionBuilder_.dispose(); 9701 outlierDetectionBuilder_ = null; 9702 } 9703 onChanged(); 9704 return this; 9705 } 9706 /** 9707 * 9708 * 9709 * <pre> 9710 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9711 * </pre> 9712 * 9713 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9714 * </code> 9715 */ getOutlierDetectionBuilder()9716 public com.google.cloud.compute.v1.OutlierDetection.Builder getOutlierDetectionBuilder() { 9717 bitField0_ |= 0x08000000; 9718 onChanged(); 9719 return getOutlierDetectionFieldBuilder().getBuilder(); 9720 } 9721 /** 9722 * 9723 * 9724 * <pre> 9725 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9726 * </pre> 9727 * 9728 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9729 * </code> 9730 */ getOutlierDetectionOrBuilder()9731 public com.google.cloud.compute.v1.OutlierDetectionOrBuilder getOutlierDetectionOrBuilder() { 9732 if (outlierDetectionBuilder_ != null) { 9733 return outlierDetectionBuilder_.getMessageOrBuilder(); 9734 } else { 9735 return outlierDetection_ == null 9736 ? com.google.cloud.compute.v1.OutlierDetection.getDefaultInstance() 9737 : outlierDetection_; 9738 } 9739 } 9740 /** 9741 * 9742 * 9743 * <pre> 9744 * Settings controlling the eviction of unhealthy hosts from the load balancing pool for the backend service. If not set, this feature is considered disabled. This field is applicable to either: - A regional backend service with the service_protocol set to HTTP, HTTPS, HTTP2, or GRPC, and load_balancing_scheme set to INTERNAL_MANAGED. - A global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 9745 * </pre> 9746 * 9747 * <code>optional .google.cloud.compute.v1.OutlierDetection outlier_detection = 354625086; 9748 * </code> 9749 */ 9750 private com.google.protobuf.SingleFieldBuilderV3< 9751 com.google.cloud.compute.v1.OutlierDetection, 9752 com.google.cloud.compute.v1.OutlierDetection.Builder, 9753 com.google.cloud.compute.v1.OutlierDetectionOrBuilder> getOutlierDetectionFieldBuilder()9754 getOutlierDetectionFieldBuilder() { 9755 if (outlierDetectionBuilder_ == null) { 9756 outlierDetectionBuilder_ = 9757 new com.google.protobuf.SingleFieldBuilderV3< 9758 com.google.cloud.compute.v1.OutlierDetection, 9759 com.google.cloud.compute.v1.OutlierDetection.Builder, 9760 com.google.cloud.compute.v1.OutlierDetectionOrBuilder>( 9761 getOutlierDetection(), getParentForChildren(), isClean()); 9762 outlierDetection_ = null; 9763 } 9764 return outlierDetectionBuilder_; 9765 } 9766 9767 private int port_; 9768 /** 9769 * 9770 * 9771 * <pre> 9772 * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port. 9773 * </pre> 9774 * 9775 * <code>optional int32 port = 3446913;</code> 9776 * 9777 * @return Whether the port field is set. 9778 */ 9779 @java.lang.Override hasPort()9780 public boolean hasPort() { 9781 return ((bitField0_ & 0x10000000) != 0); 9782 } 9783 /** 9784 * 9785 * 9786 * <pre> 9787 * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port. 9788 * </pre> 9789 * 9790 * <code>optional int32 port = 3446913;</code> 9791 * 9792 * @return The port. 9793 */ 9794 @java.lang.Override getPort()9795 public int getPort() { 9796 return port_; 9797 } 9798 /** 9799 * 9800 * 9801 * <pre> 9802 * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port. 9803 * </pre> 9804 * 9805 * <code>optional int32 port = 3446913;</code> 9806 * 9807 * @param value The port to set. 9808 * @return This builder for chaining. 9809 */ setPort(int value)9810 public Builder setPort(int value) { 9811 9812 port_ = value; 9813 bitField0_ |= 0x10000000; 9814 onChanged(); 9815 return this; 9816 } 9817 /** 9818 * 9819 * 9820 * <pre> 9821 * Deprecated in favor of portName. The TCP port to connect on the backend. The default value is 80. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port. 9822 * </pre> 9823 * 9824 * <code>optional int32 port = 3446913;</code> 9825 * 9826 * @return This builder for chaining. 9827 */ clearPort()9828 public Builder clearPort() { 9829 bitField0_ = (bitField0_ & ~0x10000000); 9830 port_ = 0; 9831 onChanged(); 9832 return this; 9833 } 9834 9835 private java.lang.Object portName_ = ""; 9836 /** 9837 * 9838 * 9839 * <pre> 9840 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 9841 * </pre> 9842 * 9843 * <code>optional string port_name = 41534345;</code> 9844 * 9845 * @return Whether the portName field is set. 9846 */ hasPortName()9847 public boolean hasPortName() { 9848 return ((bitField0_ & 0x20000000) != 0); 9849 } 9850 /** 9851 * 9852 * 9853 * <pre> 9854 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 9855 * </pre> 9856 * 9857 * <code>optional string port_name = 41534345;</code> 9858 * 9859 * @return The portName. 9860 */ getPortName()9861 public java.lang.String getPortName() { 9862 java.lang.Object ref = portName_; 9863 if (!(ref instanceof java.lang.String)) { 9864 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 9865 java.lang.String s = bs.toStringUtf8(); 9866 portName_ = s; 9867 return s; 9868 } else { 9869 return (java.lang.String) ref; 9870 } 9871 } 9872 /** 9873 * 9874 * 9875 * <pre> 9876 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 9877 * </pre> 9878 * 9879 * <code>optional string port_name = 41534345;</code> 9880 * 9881 * @return The bytes for portName. 9882 */ getPortNameBytes()9883 public com.google.protobuf.ByteString getPortNameBytes() { 9884 java.lang.Object ref = portName_; 9885 if (ref instanceof String) { 9886 com.google.protobuf.ByteString b = 9887 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 9888 portName_ = b; 9889 return b; 9890 } else { 9891 return (com.google.protobuf.ByteString) ref; 9892 } 9893 } 9894 /** 9895 * 9896 * 9897 * <pre> 9898 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 9899 * </pre> 9900 * 9901 * <code>optional string port_name = 41534345;</code> 9902 * 9903 * @param value The portName to set. 9904 * @return This builder for chaining. 9905 */ setPortName(java.lang.String value)9906 public Builder setPortName(java.lang.String value) { 9907 if (value == null) { 9908 throw new NullPointerException(); 9909 } 9910 portName_ = value; 9911 bitField0_ |= 0x20000000; 9912 onChanged(); 9913 return this; 9914 } 9915 /** 9916 * 9917 * 9918 * <pre> 9919 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 9920 * </pre> 9921 * 9922 * <code>optional string port_name = 41534345;</code> 9923 * 9924 * @return This builder for chaining. 9925 */ clearPortName()9926 public Builder clearPortName() { 9927 portName_ = getDefaultInstance().getPortName(); 9928 bitField0_ = (bitField0_ & ~0x20000000); 9929 onChanged(); 9930 return this; 9931 } 9932 /** 9933 * 9934 * 9935 * <pre> 9936 * A named port on a backend instance group representing the port for communication to the backend VMs in that group. The named port must be [defined on each backend instance group](https://cloud.google.com/load-balancing/docs/backend-service#named_ports). This parameter has no meaning if the backends are NEGs. For Internal TCP/UDP Load Balancing and Network Load Balancing, omit port_name. 9937 * </pre> 9938 * 9939 * <code>optional string port_name = 41534345;</code> 9940 * 9941 * @param value The bytes for portName to set. 9942 * @return This builder for chaining. 9943 */ setPortNameBytes(com.google.protobuf.ByteString value)9944 public Builder setPortNameBytes(com.google.protobuf.ByteString value) { 9945 if (value == null) { 9946 throw new NullPointerException(); 9947 } 9948 checkByteStringIsUtf8(value); 9949 portName_ = value; 9950 bitField0_ |= 0x20000000; 9951 onChanged(); 9952 return this; 9953 } 9954 9955 private java.lang.Object protocol_ = ""; 9956 /** 9957 * 9958 * 9959 * <pre> 9960 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 9961 * Check the Protocol enum for the list of possible values. 9962 * </pre> 9963 * 9964 * <code>optional string protocol = 84577944;</code> 9965 * 9966 * @return Whether the protocol field is set. 9967 */ hasProtocol()9968 public boolean hasProtocol() { 9969 return ((bitField0_ & 0x40000000) != 0); 9970 } 9971 /** 9972 * 9973 * 9974 * <pre> 9975 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 9976 * Check the Protocol enum for the list of possible values. 9977 * </pre> 9978 * 9979 * <code>optional string protocol = 84577944;</code> 9980 * 9981 * @return The protocol. 9982 */ getProtocol()9983 public java.lang.String getProtocol() { 9984 java.lang.Object ref = protocol_; 9985 if (!(ref instanceof java.lang.String)) { 9986 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 9987 java.lang.String s = bs.toStringUtf8(); 9988 protocol_ = s; 9989 return s; 9990 } else { 9991 return (java.lang.String) ref; 9992 } 9993 } 9994 /** 9995 * 9996 * 9997 * <pre> 9998 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 9999 * Check the Protocol enum for the list of possible values. 10000 * </pre> 10001 * 10002 * <code>optional string protocol = 84577944;</code> 10003 * 10004 * @return The bytes for protocol. 10005 */ getProtocolBytes()10006 public com.google.protobuf.ByteString getProtocolBytes() { 10007 java.lang.Object ref = protocol_; 10008 if (ref instanceof String) { 10009 com.google.protobuf.ByteString b = 10010 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 10011 protocol_ = b; 10012 return b; 10013 } else { 10014 return (com.google.protobuf.ByteString) ref; 10015 } 10016 } 10017 /** 10018 * 10019 * 10020 * <pre> 10021 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 10022 * Check the Protocol enum for the list of possible values. 10023 * </pre> 10024 * 10025 * <code>optional string protocol = 84577944;</code> 10026 * 10027 * @param value The protocol to set. 10028 * @return This builder for chaining. 10029 */ setProtocol(java.lang.String value)10030 public Builder setProtocol(java.lang.String value) { 10031 if (value == null) { 10032 throw new NullPointerException(); 10033 } 10034 protocol_ = value; 10035 bitField0_ |= 0x40000000; 10036 onChanged(); 10037 return this; 10038 } 10039 /** 10040 * 10041 * 10042 * <pre> 10043 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 10044 * Check the Protocol enum for the list of possible values. 10045 * </pre> 10046 * 10047 * <code>optional string protocol = 84577944;</code> 10048 * 10049 * @return This builder for chaining. 10050 */ clearProtocol()10051 public Builder clearProtocol() { 10052 protocol_ = getDefaultInstance().getProtocol(); 10053 bitField0_ = (bitField0_ & ~0x40000000); 10054 onChanged(); 10055 return this; 10056 } 10057 /** 10058 * 10059 * 10060 * <pre> 10061 * The protocol this BackendService uses to communicate with backends. Possible values are HTTP, HTTPS, HTTP2, TCP, SSL, UDP or GRPC. depending on the chosen load balancer or Traffic Director configuration. Refer to the documentation for the load balancers or for Traffic Director for more information. Must be set to GRPC when the backend service is referenced by a URL map that is bound to target gRPC proxy. 10062 * Check the Protocol enum for the list of possible values. 10063 * </pre> 10064 * 10065 * <code>optional string protocol = 84577944;</code> 10066 * 10067 * @param value The bytes for protocol to set. 10068 * @return This builder for chaining. 10069 */ setProtocolBytes(com.google.protobuf.ByteString value)10070 public Builder setProtocolBytes(com.google.protobuf.ByteString value) { 10071 if (value == null) { 10072 throw new NullPointerException(); 10073 } 10074 checkByteStringIsUtf8(value); 10075 protocol_ = value; 10076 bitField0_ |= 0x40000000; 10077 onChanged(); 10078 return this; 10079 } 10080 10081 private java.lang.Object region_ = ""; 10082 /** 10083 * 10084 * 10085 * <pre> 10086 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 10087 * </pre> 10088 * 10089 * <code>optional string region = 138946292;</code> 10090 * 10091 * @return Whether the region field is set. 10092 */ hasRegion()10093 public boolean hasRegion() { 10094 return ((bitField0_ & 0x80000000) != 0); 10095 } 10096 /** 10097 * 10098 * 10099 * <pre> 10100 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 10101 * </pre> 10102 * 10103 * <code>optional string region = 138946292;</code> 10104 * 10105 * @return The region. 10106 */ getRegion()10107 public java.lang.String getRegion() { 10108 java.lang.Object ref = region_; 10109 if (!(ref instanceof java.lang.String)) { 10110 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 10111 java.lang.String s = bs.toStringUtf8(); 10112 region_ = s; 10113 return s; 10114 } else { 10115 return (java.lang.String) ref; 10116 } 10117 } 10118 /** 10119 * 10120 * 10121 * <pre> 10122 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 10123 * </pre> 10124 * 10125 * <code>optional string region = 138946292;</code> 10126 * 10127 * @return The bytes for region. 10128 */ getRegionBytes()10129 public com.google.protobuf.ByteString getRegionBytes() { 10130 java.lang.Object ref = region_; 10131 if (ref instanceof String) { 10132 com.google.protobuf.ByteString b = 10133 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 10134 region_ = b; 10135 return b; 10136 } else { 10137 return (com.google.protobuf.ByteString) ref; 10138 } 10139 } 10140 /** 10141 * 10142 * 10143 * <pre> 10144 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 10145 * </pre> 10146 * 10147 * <code>optional string region = 138946292;</code> 10148 * 10149 * @param value The region to set. 10150 * @return This builder for chaining. 10151 */ setRegion(java.lang.String value)10152 public Builder setRegion(java.lang.String value) { 10153 if (value == null) { 10154 throw new NullPointerException(); 10155 } 10156 region_ = value; 10157 bitField0_ |= 0x80000000; 10158 onChanged(); 10159 return this; 10160 } 10161 /** 10162 * 10163 * 10164 * <pre> 10165 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 10166 * </pre> 10167 * 10168 * <code>optional string region = 138946292;</code> 10169 * 10170 * @return This builder for chaining. 10171 */ clearRegion()10172 public Builder clearRegion() { 10173 region_ = getDefaultInstance().getRegion(); 10174 bitField0_ = (bitField0_ & ~0x80000000); 10175 onChanged(); 10176 return this; 10177 } 10178 /** 10179 * 10180 * 10181 * <pre> 10182 * [Output Only] URL of the region where the regional backend service resides. This field is not applicable to global backend services. You must specify this field as part of the HTTP request URL. It is not settable as a field in the request body. 10183 * </pre> 10184 * 10185 * <code>optional string region = 138946292;</code> 10186 * 10187 * @param value The bytes for region to set. 10188 * @return This builder for chaining. 10189 */ setRegionBytes(com.google.protobuf.ByteString value)10190 public Builder setRegionBytes(com.google.protobuf.ByteString value) { 10191 if (value == null) { 10192 throw new NullPointerException(); 10193 } 10194 checkByteStringIsUtf8(value); 10195 region_ = value; 10196 bitField0_ |= 0x80000000; 10197 onChanged(); 10198 return this; 10199 } 10200 10201 private java.lang.Object securityPolicy_ = ""; 10202 /** 10203 * 10204 * 10205 * <pre> 10206 * [Output Only] The resource URL for the security policy associated with this backend service. 10207 * </pre> 10208 * 10209 * <code>optional string security_policy = 171082513;</code> 10210 * 10211 * @return Whether the securityPolicy field is set. 10212 */ hasSecurityPolicy()10213 public boolean hasSecurityPolicy() { 10214 return ((bitField1_ & 0x00000001) != 0); 10215 } 10216 /** 10217 * 10218 * 10219 * <pre> 10220 * [Output Only] The resource URL for the security policy associated with this backend service. 10221 * </pre> 10222 * 10223 * <code>optional string security_policy = 171082513;</code> 10224 * 10225 * @return The securityPolicy. 10226 */ getSecurityPolicy()10227 public java.lang.String getSecurityPolicy() { 10228 java.lang.Object ref = securityPolicy_; 10229 if (!(ref instanceof java.lang.String)) { 10230 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 10231 java.lang.String s = bs.toStringUtf8(); 10232 securityPolicy_ = s; 10233 return s; 10234 } else { 10235 return (java.lang.String) ref; 10236 } 10237 } 10238 /** 10239 * 10240 * 10241 * <pre> 10242 * [Output Only] The resource URL for the security policy associated with this backend service. 10243 * </pre> 10244 * 10245 * <code>optional string security_policy = 171082513;</code> 10246 * 10247 * @return The bytes for securityPolicy. 10248 */ getSecurityPolicyBytes()10249 public com.google.protobuf.ByteString getSecurityPolicyBytes() { 10250 java.lang.Object ref = securityPolicy_; 10251 if (ref instanceof String) { 10252 com.google.protobuf.ByteString b = 10253 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 10254 securityPolicy_ = b; 10255 return b; 10256 } else { 10257 return (com.google.protobuf.ByteString) ref; 10258 } 10259 } 10260 /** 10261 * 10262 * 10263 * <pre> 10264 * [Output Only] The resource URL for the security policy associated with this backend service. 10265 * </pre> 10266 * 10267 * <code>optional string security_policy = 171082513;</code> 10268 * 10269 * @param value The securityPolicy to set. 10270 * @return This builder for chaining. 10271 */ setSecurityPolicy(java.lang.String value)10272 public Builder setSecurityPolicy(java.lang.String value) { 10273 if (value == null) { 10274 throw new NullPointerException(); 10275 } 10276 securityPolicy_ = value; 10277 bitField1_ |= 0x00000001; 10278 onChanged(); 10279 return this; 10280 } 10281 /** 10282 * 10283 * 10284 * <pre> 10285 * [Output Only] The resource URL for the security policy associated with this backend service. 10286 * </pre> 10287 * 10288 * <code>optional string security_policy = 171082513;</code> 10289 * 10290 * @return This builder for chaining. 10291 */ clearSecurityPolicy()10292 public Builder clearSecurityPolicy() { 10293 securityPolicy_ = getDefaultInstance().getSecurityPolicy(); 10294 bitField1_ = (bitField1_ & ~0x00000001); 10295 onChanged(); 10296 return this; 10297 } 10298 /** 10299 * 10300 * 10301 * <pre> 10302 * [Output Only] The resource URL for the security policy associated with this backend service. 10303 * </pre> 10304 * 10305 * <code>optional string security_policy = 171082513;</code> 10306 * 10307 * @param value The bytes for securityPolicy to set. 10308 * @return This builder for chaining. 10309 */ setSecurityPolicyBytes(com.google.protobuf.ByteString value)10310 public Builder setSecurityPolicyBytes(com.google.protobuf.ByteString value) { 10311 if (value == null) { 10312 throw new NullPointerException(); 10313 } 10314 checkByteStringIsUtf8(value); 10315 securityPolicy_ = value; 10316 bitField1_ |= 0x00000001; 10317 onChanged(); 10318 return this; 10319 } 10320 10321 private com.google.cloud.compute.v1.SecuritySettings securitySettings_; 10322 private com.google.protobuf.SingleFieldBuilderV3< 10323 com.google.cloud.compute.v1.SecuritySettings, 10324 com.google.cloud.compute.v1.SecuritySettings.Builder, 10325 com.google.cloud.compute.v1.SecuritySettingsOrBuilder> 10326 securitySettingsBuilder_; 10327 /** 10328 * 10329 * 10330 * <pre> 10331 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10332 * </pre> 10333 * 10334 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10335 * </code> 10336 * 10337 * @return Whether the securitySettings field is set. 10338 */ hasSecuritySettings()10339 public boolean hasSecuritySettings() { 10340 return ((bitField1_ & 0x00000002) != 0); 10341 } 10342 /** 10343 * 10344 * 10345 * <pre> 10346 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10347 * </pre> 10348 * 10349 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10350 * </code> 10351 * 10352 * @return The securitySettings. 10353 */ getSecuritySettings()10354 public com.google.cloud.compute.v1.SecuritySettings getSecuritySettings() { 10355 if (securitySettingsBuilder_ == null) { 10356 return securitySettings_ == null 10357 ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance() 10358 : securitySettings_; 10359 } else { 10360 return securitySettingsBuilder_.getMessage(); 10361 } 10362 } 10363 /** 10364 * 10365 * 10366 * <pre> 10367 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10368 * </pre> 10369 * 10370 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10371 * </code> 10372 */ setSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value)10373 public Builder setSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value) { 10374 if (securitySettingsBuilder_ == null) { 10375 if (value == null) { 10376 throw new NullPointerException(); 10377 } 10378 securitySettings_ = value; 10379 } else { 10380 securitySettingsBuilder_.setMessage(value); 10381 } 10382 bitField1_ |= 0x00000002; 10383 onChanged(); 10384 return this; 10385 } 10386 /** 10387 * 10388 * 10389 * <pre> 10390 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10391 * </pre> 10392 * 10393 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10394 * </code> 10395 */ setSecuritySettings( com.google.cloud.compute.v1.SecuritySettings.Builder builderForValue)10396 public Builder setSecuritySettings( 10397 com.google.cloud.compute.v1.SecuritySettings.Builder builderForValue) { 10398 if (securitySettingsBuilder_ == null) { 10399 securitySettings_ = builderForValue.build(); 10400 } else { 10401 securitySettingsBuilder_.setMessage(builderForValue.build()); 10402 } 10403 bitField1_ |= 0x00000002; 10404 onChanged(); 10405 return this; 10406 } 10407 /** 10408 * 10409 * 10410 * <pre> 10411 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10412 * </pre> 10413 * 10414 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10415 * </code> 10416 */ mergeSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value)10417 public Builder mergeSecuritySettings(com.google.cloud.compute.v1.SecuritySettings value) { 10418 if (securitySettingsBuilder_ == null) { 10419 if (((bitField1_ & 0x00000002) != 0) 10420 && securitySettings_ != null 10421 && securitySettings_ 10422 != com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance()) { 10423 getSecuritySettingsBuilder().mergeFrom(value); 10424 } else { 10425 securitySettings_ = value; 10426 } 10427 } else { 10428 securitySettingsBuilder_.mergeFrom(value); 10429 } 10430 bitField1_ |= 0x00000002; 10431 onChanged(); 10432 return this; 10433 } 10434 /** 10435 * 10436 * 10437 * <pre> 10438 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10439 * </pre> 10440 * 10441 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10442 * </code> 10443 */ clearSecuritySettings()10444 public Builder clearSecuritySettings() { 10445 bitField1_ = (bitField1_ & ~0x00000002); 10446 securitySettings_ = null; 10447 if (securitySettingsBuilder_ != null) { 10448 securitySettingsBuilder_.dispose(); 10449 securitySettingsBuilder_ = null; 10450 } 10451 onChanged(); 10452 return this; 10453 } 10454 /** 10455 * 10456 * 10457 * <pre> 10458 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10459 * </pre> 10460 * 10461 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10462 * </code> 10463 */ getSecuritySettingsBuilder()10464 public com.google.cloud.compute.v1.SecuritySettings.Builder getSecuritySettingsBuilder() { 10465 bitField1_ |= 0x00000002; 10466 onChanged(); 10467 return getSecuritySettingsFieldBuilder().getBuilder(); 10468 } 10469 /** 10470 * 10471 * 10472 * <pre> 10473 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10474 * </pre> 10475 * 10476 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10477 * </code> 10478 */ getSecuritySettingsOrBuilder()10479 public com.google.cloud.compute.v1.SecuritySettingsOrBuilder getSecuritySettingsOrBuilder() { 10480 if (securitySettingsBuilder_ != null) { 10481 return securitySettingsBuilder_.getMessageOrBuilder(); 10482 } else { 10483 return securitySettings_ == null 10484 ? com.google.cloud.compute.v1.SecuritySettings.getDefaultInstance() 10485 : securitySettings_; 10486 } 10487 } 10488 /** 10489 * 10490 * 10491 * <pre> 10492 * This field specifies the security settings that apply to this backend service. This field is applicable to a global backend service with the load_balancing_scheme set to INTERNAL_SELF_MANAGED. 10493 * </pre> 10494 * 10495 * <code>optional .google.cloud.compute.v1.SecuritySettings security_settings = 478649922; 10496 * </code> 10497 */ 10498 private com.google.protobuf.SingleFieldBuilderV3< 10499 com.google.cloud.compute.v1.SecuritySettings, 10500 com.google.cloud.compute.v1.SecuritySettings.Builder, 10501 com.google.cloud.compute.v1.SecuritySettingsOrBuilder> getSecuritySettingsFieldBuilder()10502 getSecuritySettingsFieldBuilder() { 10503 if (securitySettingsBuilder_ == null) { 10504 securitySettingsBuilder_ = 10505 new com.google.protobuf.SingleFieldBuilderV3< 10506 com.google.cloud.compute.v1.SecuritySettings, 10507 com.google.cloud.compute.v1.SecuritySettings.Builder, 10508 com.google.cloud.compute.v1.SecuritySettingsOrBuilder>( 10509 getSecuritySettings(), getParentForChildren(), isClean()); 10510 securitySettings_ = null; 10511 } 10512 return securitySettingsBuilder_; 10513 } 10514 10515 private java.lang.Object selfLink_ = ""; 10516 /** 10517 * 10518 * 10519 * <pre> 10520 * [Output Only] Server-defined URL for the resource. 10521 * </pre> 10522 * 10523 * <code>optional string self_link = 456214797;</code> 10524 * 10525 * @return Whether the selfLink field is set. 10526 */ hasSelfLink()10527 public boolean hasSelfLink() { 10528 return ((bitField1_ & 0x00000004) != 0); 10529 } 10530 /** 10531 * 10532 * 10533 * <pre> 10534 * [Output Only] Server-defined URL for the resource. 10535 * </pre> 10536 * 10537 * <code>optional string self_link = 456214797;</code> 10538 * 10539 * @return The selfLink. 10540 */ getSelfLink()10541 public java.lang.String getSelfLink() { 10542 java.lang.Object ref = selfLink_; 10543 if (!(ref instanceof java.lang.String)) { 10544 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 10545 java.lang.String s = bs.toStringUtf8(); 10546 selfLink_ = s; 10547 return s; 10548 } else { 10549 return (java.lang.String) ref; 10550 } 10551 } 10552 /** 10553 * 10554 * 10555 * <pre> 10556 * [Output Only] Server-defined URL for the resource. 10557 * </pre> 10558 * 10559 * <code>optional string self_link = 456214797;</code> 10560 * 10561 * @return The bytes for selfLink. 10562 */ getSelfLinkBytes()10563 public com.google.protobuf.ByteString getSelfLinkBytes() { 10564 java.lang.Object ref = selfLink_; 10565 if (ref instanceof String) { 10566 com.google.protobuf.ByteString b = 10567 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 10568 selfLink_ = b; 10569 return b; 10570 } else { 10571 return (com.google.protobuf.ByteString) ref; 10572 } 10573 } 10574 /** 10575 * 10576 * 10577 * <pre> 10578 * [Output Only] Server-defined URL for the resource. 10579 * </pre> 10580 * 10581 * <code>optional string self_link = 456214797;</code> 10582 * 10583 * @param value The selfLink to set. 10584 * @return This builder for chaining. 10585 */ setSelfLink(java.lang.String value)10586 public Builder setSelfLink(java.lang.String value) { 10587 if (value == null) { 10588 throw new NullPointerException(); 10589 } 10590 selfLink_ = value; 10591 bitField1_ |= 0x00000004; 10592 onChanged(); 10593 return this; 10594 } 10595 /** 10596 * 10597 * 10598 * <pre> 10599 * [Output Only] Server-defined URL for the resource. 10600 * </pre> 10601 * 10602 * <code>optional string self_link = 456214797;</code> 10603 * 10604 * @return This builder for chaining. 10605 */ clearSelfLink()10606 public Builder clearSelfLink() { 10607 selfLink_ = getDefaultInstance().getSelfLink(); 10608 bitField1_ = (bitField1_ & ~0x00000004); 10609 onChanged(); 10610 return this; 10611 } 10612 /** 10613 * 10614 * 10615 * <pre> 10616 * [Output Only] Server-defined URL for the resource. 10617 * </pre> 10618 * 10619 * <code>optional string self_link = 456214797;</code> 10620 * 10621 * @param value The bytes for selfLink to set. 10622 * @return This builder for chaining. 10623 */ setSelfLinkBytes(com.google.protobuf.ByteString value)10624 public Builder setSelfLinkBytes(com.google.protobuf.ByteString value) { 10625 if (value == null) { 10626 throw new NullPointerException(); 10627 } 10628 checkByteStringIsUtf8(value); 10629 selfLink_ = value; 10630 bitField1_ |= 0x00000004; 10631 onChanged(); 10632 return this; 10633 } 10634 10635 private com.google.protobuf.LazyStringList serviceBindings_ = 10636 com.google.protobuf.LazyStringArrayList.EMPTY; 10637 ensureServiceBindingsIsMutable()10638 private void ensureServiceBindingsIsMutable() { 10639 if (!((bitField1_ & 0x00000008) != 0)) { 10640 serviceBindings_ = new com.google.protobuf.LazyStringArrayList(serviceBindings_); 10641 bitField1_ |= 0x00000008; 10642 } 10643 } 10644 /** 10645 * 10646 * 10647 * <pre> 10648 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10649 * </pre> 10650 * 10651 * <code>repeated string service_bindings = 133581016;</code> 10652 * 10653 * @return A list containing the serviceBindings. 10654 */ getServiceBindingsList()10655 public com.google.protobuf.ProtocolStringList getServiceBindingsList() { 10656 return serviceBindings_.getUnmodifiableView(); 10657 } 10658 /** 10659 * 10660 * 10661 * <pre> 10662 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10663 * </pre> 10664 * 10665 * <code>repeated string service_bindings = 133581016;</code> 10666 * 10667 * @return The count of serviceBindings. 10668 */ getServiceBindingsCount()10669 public int getServiceBindingsCount() { 10670 return serviceBindings_.size(); 10671 } 10672 /** 10673 * 10674 * 10675 * <pre> 10676 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10677 * </pre> 10678 * 10679 * <code>repeated string service_bindings = 133581016;</code> 10680 * 10681 * @param index The index of the element to return. 10682 * @return The serviceBindings at the given index. 10683 */ getServiceBindings(int index)10684 public java.lang.String getServiceBindings(int index) { 10685 return serviceBindings_.get(index); 10686 } 10687 /** 10688 * 10689 * 10690 * <pre> 10691 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10692 * </pre> 10693 * 10694 * <code>repeated string service_bindings = 133581016;</code> 10695 * 10696 * @param index The index of the value to return. 10697 * @return The bytes of the serviceBindings at the given index. 10698 */ getServiceBindingsBytes(int index)10699 public com.google.protobuf.ByteString getServiceBindingsBytes(int index) { 10700 return serviceBindings_.getByteString(index); 10701 } 10702 /** 10703 * 10704 * 10705 * <pre> 10706 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10707 * </pre> 10708 * 10709 * <code>repeated string service_bindings = 133581016;</code> 10710 * 10711 * @param index The index to set the value at. 10712 * @param value The serviceBindings to set. 10713 * @return This builder for chaining. 10714 */ setServiceBindings(int index, java.lang.String value)10715 public Builder setServiceBindings(int index, java.lang.String value) { 10716 if (value == null) { 10717 throw new NullPointerException(); 10718 } 10719 ensureServiceBindingsIsMutable(); 10720 serviceBindings_.set(index, value); 10721 onChanged(); 10722 return this; 10723 } 10724 /** 10725 * 10726 * 10727 * <pre> 10728 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10729 * </pre> 10730 * 10731 * <code>repeated string service_bindings = 133581016;</code> 10732 * 10733 * @param value The serviceBindings to add. 10734 * @return This builder for chaining. 10735 */ addServiceBindings(java.lang.String value)10736 public Builder addServiceBindings(java.lang.String value) { 10737 if (value == null) { 10738 throw new NullPointerException(); 10739 } 10740 ensureServiceBindingsIsMutable(); 10741 serviceBindings_.add(value); 10742 onChanged(); 10743 return this; 10744 } 10745 /** 10746 * 10747 * 10748 * <pre> 10749 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10750 * </pre> 10751 * 10752 * <code>repeated string service_bindings = 133581016;</code> 10753 * 10754 * @param values The serviceBindings to add. 10755 * @return This builder for chaining. 10756 */ addAllServiceBindings(java.lang.Iterable<java.lang.String> values)10757 public Builder addAllServiceBindings(java.lang.Iterable<java.lang.String> values) { 10758 ensureServiceBindingsIsMutable(); 10759 com.google.protobuf.AbstractMessageLite.Builder.addAll(values, serviceBindings_); 10760 onChanged(); 10761 return this; 10762 } 10763 /** 10764 * 10765 * 10766 * <pre> 10767 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10768 * </pre> 10769 * 10770 * <code>repeated string service_bindings = 133581016;</code> 10771 * 10772 * @return This builder for chaining. 10773 */ clearServiceBindings()10774 public Builder clearServiceBindings() { 10775 serviceBindings_ = com.google.protobuf.LazyStringArrayList.EMPTY; 10776 bitField1_ = (bitField1_ & ~0x00000008); 10777 onChanged(); 10778 return this; 10779 } 10780 /** 10781 * 10782 * 10783 * <pre> 10784 * URLs of networkservices.ServiceBinding resources. Can only be set if load balancing scheme is INTERNAL_SELF_MANAGED. If set, lists of backends and health checks must be both empty. 10785 * </pre> 10786 * 10787 * <code>repeated string service_bindings = 133581016;</code> 10788 * 10789 * @param value The bytes of the serviceBindings to add. 10790 * @return This builder for chaining. 10791 */ addServiceBindingsBytes(com.google.protobuf.ByteString value)10792 public Builder addServiceBindingsBytes(com.google.protobuf.ByteString value) { 10793 if (value == null) { 10794 throw new NullPointerException(); 10795 } 10796 checkByteStringIsUtf8(value); 10797 ensureServiceBindingsIsMutable(); 10798 serviceBindings_.add(value); 10799 onChanged(); 10800 return this; 10801 } 10802 10803 private java.lang.Object sessionAffinity_ = ""; 10804 /** 10805 * 10806 * 10807 * <pre> 10808 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 10809 * Check the SessionAffinity enum for the list of possible values. 10810 * </pre> 10811 * 10812 * <code>optional string session_affinity = 463888561;</code> 10813 * 10814 * @return Whether the sessionAffinity field is set. 10815 */ hasSessionAffinity()10816 public boolean hasSessionAffinity() { 10817 return ((bitField1_ & 0x00000010) != 0); 10818 } 10819 /** 10820 * 10821 * 10822 * <pre> 10823 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 10824 * Check the SessionAffinity enum for the list of possible values. 10825 * </pre> 10826 * 10827 * <code>optional string session_affinity = 463888561;</code> 10828 * 10829 * @return The sessionAffinity. 10830 */ getSessionAffinity()10831 public java.lang.String getSessionAffinity() { 10832 java.lang.Object ref = sessionAffinity_; 10833 if (!(ref instanceof java.lang.String)) { 10834 com.google.protobuf.ByteString bs = (com.google.protobuf.ByteString) ref; 10835 java.lang.String s = bs.toStringUtf8(); 10836 sessionAffinity_ = s; 10837 return s; 10838 } else { 10839 return (java.lang.String) ref; 10840 } 10841 } 10842 /** 10843 * 10844 * 10845 * <pre> 10846 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 10847 * Check the SessionAffinity enum for the list of possible values. 10848 * </pre> 10849 * 10850 * <code>optional string session_affinity = 463888561;</code> 10851 * 10852 * @return The bytes for sessionAffinity. 10853 */ getSessionAffinityBytes()10854 public com.google.protobuf.ByteString getSessionAffinityBytes() { 10855 java.lang.Object ref = sessionAffinity_; 10856 if (ref instanceof String) { 10857 com.google.protobuf.ByteString b = 10858 com.google.protobuf.ByteString.copyFromUtf8((java.lang.String) ref); 10859 sessionAffinity_ = b; 10860 return b; 10861 } else { 10862 return (com.google.protobuf.ByteString) ref; 10863 } 10864 } 10865 /** 10866 * 10867 * 10868 * <pre> 10869 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 10870 * Check the SessionAffinity enum for the list of possible values. 10871 * </pre> 10872 * 10873 * <code>optional string session_affinity = 463888561;</code> 10874 * 10875 * @param value The sessionAffinity to set. 10876 * @return This builder for chaining. 10877 */ setSessionAffinity(java.lang.String value)10878 public Builder setSessionAffinity(java.lang.String value) { 10879 if (value == null) { 10880 throw new NullPointerException(); 10881 } 10882 sessionAffinity_ = value; 10883 bitField1_ |= 0x00000010; 10884 onChanged(); 10885 return this; 10886 } 10887 /** 10888 * 10889 * 10890 * <pre> 10891 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 10892 * Check the SessionAffinity enum for the list of possible values. 10893 * </pre> 10894 * 10895 * <code>optional string session_affinity = 463888561;</code> 10896 * 10897 * @return This builder for chaining. 10898 */ clearSessionAffinity()10899 public Builder clearSessionAffinity() { 10900 sessionAffinity_ = getDefaultInstance().getSessionAffinity(); 10901 bitField1_ = (bitField1_ & ~0x00000010); 10902 onChanged(); 10903 return this; 10904 } 10905 /** 10906 * 10907 * 10908 * <pre> 10909 * Type of session affinity to use. The default is NONE. Only NONE and HEADER_FIELD are supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. For more details, see: [Session Affinity](https://cloud.google.com/load-balancing/docs/backend-service#session_affinity). 10910 * Check the SessionAffinity enum for the list of possible values. 10911 * </pre> 10912 * 10913 * <code>optional string session_affinity = 463888561;</code> 10914 * 10915 * @param value The bytes for sessionAffinity to set. 10916 * @return This builder for chaining. 10917 */ setSessionAffinityBytes(com.google.protobuf.ByteString value)10918 public Builder setSessionAffinityBytes(com.google.protobuf.ByteString value) { 10919 if (value == null) { 10920 throw new NullPointerException(); 10921 } 10922 checkByteStringIsUtf8(value); 10923 sessionAffinity_ = value; 10924 bitField1_ |= 0x00000010; 10925 onChanged(); 10926 return this; 10927 } 10928 10929 private com.google.cloud.compute.v1.Subsetting subsetting_; 10930 private com.google.protobuf.SingleFieldBuilderV3< 10931 com.google.cloud.compute.v1.Subsetting, 10932 com.google.cloud.compute.v1.Subsetting.Builder, 10933 com.google.cloud.compute.v1.SubsettingOrBuilder> 10934 subsettingBuilder_; 10935 /** 10936 * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> 10937 * 10938 * @return Whether the subsetting field is set. 10939 */ hasSubsetting()10940 public boolean hasSubsetting() { 10941 return ((bitField1_ & 0x00000020) != 0); 10942 } 10943 /** 10944 * <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> 10945 * 10946 * @return The subsetting. 10947 */ getSubsetting()10948 public com.google.cloud.compute.v1.Subsetting getSubsetting() { 10949 if (subsettingBuilder_ == null) { 10950 return subsetting_ == null 10951 ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance() 10952 : subsetting_; 10953 } else { 10954 return subsettingBuilder_.getMessage(); 10955 } 10956 } 10957 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ setSubsetting(com.google.cloud.compute.v1.Subsetting value)10958 public Builder setSubsetting(com.google.cloud.compute.v1.Subsetting value) { 10959 if (subsettingBuilder_ == null) { 10960 if (value == null) { 10961 throw new NullPointerException(); 10962 } 10963 subsetting_ = value; 10964 } else { 10965 subsettingBuilder_.setMessage(value); 10966 } 10967 bitField1_ |= 0x00000020; 10968 onChanged(); 10969 return this; 10970 } 10971 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ setSubsetting(com.google.cloud.compute.v1.Subsetting.Builder builderForValue)10972 public Builder setSubsetting(com.google.cloud.compute.v1.Subsetting.Builder builderForValue) { 10973 if (subsettingBuilder_ == null) { 10974 subsetting_ = builderForValue.build(); 10975 } else { 10976 subsettingBuilder_.setMessage(builderForValue.build()); 10977 } 10978 bitField1_ |= 0x00000020; 10979 onChanged(); 10980 return this; 10981 } 10982 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ mergeSubsetting(com.google.cloud.compute.v1.Subsetting value)10983 public Builder mergeSubsetting(com.google.cloud.compute.v1.Subsetting value) { 10984 if (subsettingBuilder_ == null) { 10985 if (((bitField1_ & 0x00000020) != 0) 10986 && subsetting_ != null 10987 && subsetting_ != com.google.cloud.compute.v1.Subsetting.getDefaultInstance()) { 10988 getSubsettingBuilder().mergeFrom(value); 10989 } else { 10990 subsetting_ = value; 10991 } 10992 } else { 10993 subsettingBuilder_.mergeFrom(value); 10994 } 10995 bitField1_ |= 0x00000020; 10996 onChanged(); 10997 return this; 10998 } 10999 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ clearSubsetting()11000 public Builder clearSubsetting() { 11001 bitField1_ = (bitField1_ & ~0x00000020); 11002 subsetting_ = null; 11003 if (subsettingBuilder_ != null) { 11004 subsettingBuilder_.dispose(); 11005 subsettingBuilder_ = null; 11006 } 11007 onChanged(); 11008 return this; 11009 } 11010 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ getSubsettingBuilder()11011 public com.google.cloud.compute.v1.Subsetting.Builder getSubsettingBuilder() { 11012 bitField1_ |= 0x00000020; 11013 onChanged(); 11014 return getSubsettingFieldBuilder().getBuilder(); 11015 } 11016 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ getSubsettingOrBuilder()11017 public com.google.cloud.compute.v1.SubsettingOrBuilder getSubsettingOrBuilder() { 11018 if (subsettingBuilder_ != null) { 11019 return subsettingBuilder_.getMessageOrBuilder(); 11020 } else { 11021 return subsetting_ == null 11022 ? com.google.cloud.compute.v1.Subsetting.getDefaultInstance() 11023 : subsetting_; 11024 } 11025 } 11026 /** <code>optional .google.cloud.compute.v1.Subsetting subsetting = 450283536;</code> */ 11027 private com.google.protobuf.SingleFieldBuilderV3< 11028 com.google.cloud.compute.v1.Subsetting, 11029 com.google.cloud.compute.v1.Subsetting.Builder, 11030 com.google.cloud.compute.v1.SubsettingOrBuilder> getSubsettingFieldBuilder()11031 getSubsettingFieldBuilder() { 11032 if (subsettingBuilder_ == null) { 11033 subsettingBuilder_ = 11034 new com.google.protobuf.SingleFieldBuilderV3< 11035 com.google.cloud.compute.v1.Subsetting, 11036 com.google.cloud.compute.v1.Subsetting.Builder, 11037 com.google.cloud.compute.v1.SubsettingOrBuilder>( 11038 getSubsetting(), getParentForChildren(), isClean()); 11039 subsetting_ = null; 11040 } 11041 return subsettingBuilder_; 11042 } 11043 11044 private int timeoutSec_; 11045 /** 11046 * 11047 * 11048 * <pre> 11049 * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration. 11050 * </pre> 11051 * 11052 * <code>optional int32 timeout_sec = 79994995;</code> 11053 * 11054 * @return Whether the timeoutSec field is set. 11055 */ 11056 @java.lang.Override hasTimeoutSec()11057 public boolean hasTimeoutSec() { 11058 return ((bitField1_ & 0x00000040) != 0); 11059 } 11060 /** 11061 * 11062 * 11063 * <pre> 11064 * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration. 11065 * </pre> 11066 * 11067 * <code>optional int32 timeout_sec = 79994995;</code> 11068 * 11069 * @return The timeoutSec. 11070 */ 11071 @java.lang.Override getTimeoutSec()11072 public int getTimeoutSec() { 11073 return timeoutSec_; 11074 } 11075 /** 11076 * 11077 * 11078 * <pre> 11079 * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration. 11080 * </pre> 11081 * 11082 * <code>optional int32 timeout_sec = 79994995;</code> 11083 * 11084 * @param value The timeoutSec to set. 11085 * @return This builder for chaining. 11086 */ setTimeoutSec(int value)11087 public Builder setTimeoutSec(int value) { 11088 11089 timeoutSec_ = value; 11090 bitField1_ |= 0x00000040; 11091 onChanged(); 11092 return this; 11093 } 11094 /** 11095 * 11096 * 11097 * <pre> 11098 * The backend service timeout has a different meaning depending on the type of load balancer. For more information see, Backend service settings. The default is 30 seconds. The full range of timeout values allowed goes from 1 through 2,147,483,647 seconds. This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service. Not supported when the backend service is referenced by a URL map that is bound to target gRPC proxy that has validateForProxyless field set to true. Instead, use maxStreamDuration. 11099 * </pre> 11100 * 11101 * <code>optional int32 timeout_sec = 79994995;</code> 11102 * 11103 * @return This builder for chaining. 11104 */ clearTimeoutSec()11105 public Builder clearTimeoutSec() { 11106 bitField1_ = (bitField1_ & ~0x00000040); 11107 timeoutSec_ = 0; 11108 onChanged(); 11109 return this; 11110 } 11111 11112 @java.lang.Override setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields)11113 public final Builder setUnknownFields(final com.google.protobuf.UnknownFieldSet unknownFields) { 11114 return super.setUnknownFields(unknownFields); 11115 } 11116 11117 @java.lang.Override mergeUnknownFields( final com.google.protobuf.UnknownFieldSet unknownFields)11118 public final Builder mergeUnknownFields( 11119 final com.google.protobuf.UnknownFieldSet unknownFields) { 11120 return super.mergeUnknownFields(unknownFields); 11121 } 11122 11123 // @@protoc_insertion_point(builder_scope:google.cloud.compute.v1.BackendService) 11124 } 11125 11126 // @@protoc_insertion_point(class_scope:google.cloud.compute.v1.BackendService) 11127 private static final com.google.cloud.compute.v1.BackendService DEFAULT_INSTANCE; 11128 11129 static { 11130 DEFAULT_INSTANCE = new com.google.cloud.compute.v1.BackendService(); 11131 } 11132 getDefaultInstance()11133 public static com.google.cloud.compute.v1.BackendService getDefaultInstance() { 11134 return DEFAULT_INSTANCE; 11135 } 11136 11137 private static final com.google.protobuf.Parser<BackendService> PARSER = 11138 new com.google.protobuf.AbstractParser<BackendService>() { 11139 @java.lang.Override 11140 public BackendService parsePartialFrom( 11141 com.google.protobuf.CodedInputStream input, 11142 com.google.protobuf.ExtensionRegistryLite extensionRegistry) 11143 throws com.google.protobuf.InvalidProtocolBufferException { 11144 Builder builder = newBuilder(); 11145 try { 11146 builder.mergeFrom(input, extensionRegistry); 11147 } catch (com.google.protobuf.InvalidProtocolBufferException e) { 11148 throw e.setUnfinishedMessage(builder.buildPartial()); 11149 } catch (com.google.protobuf.UninitializedMessageException e) { 11150 throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); 11151 } catch (java.io.IOException e) { 11152 throw new com.google.protobuf.InvalidProtocolBufferException(e) 11153 .setUnfinishedMessage(builder.buildPartial()); 11154 } 11155 return builder.buildPartial(); 11156 } 11157 }; 11158 parser()11159 public static com.google.protobuf.Parser<BackendService> parser() { 11160 return PARSER; 11161 } 11162 11163 @java.lang.Override getParserForType()11164 public com.google.protobuf.Parser<BackendService> getParserForType() { 11165 return PARSER; 11166 } 11167 11168 @java.lang.Override getDefaultInstanceForType()11169 public com.google.cloud.compute.v1.BackendService getDefaultInstanceForType() { 11170 return DEFAULT_INSTANCE; 11171 } 11172 } 11173