1 /* 2 * Copyright 2022 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 17 package com.google.cloud.compute.v1.stub; 18 19 import static com.google.cloud.compute.v1.RegionUrlMapsClient.ListPagedResponse; 20 21 import com.google.api.core.BetaApi; 22 import com.google.api.core.InternalApi; 23 import com.google.api.gax.core.BackgroundResource; 24 import com.google.api.gax.core.BackgroundResourceAggregation; 25 import com.google.api.gax.httpjson.ApiMethodDescriptor; 26 import com.google.api.gax.httpjson.HttpJsonCallSettings; 27 import com.google.api.gax.httpjson.HttpJsonOperationSnapshot; 28 import com.google.api.gax.httpjson.HttpJsonStubCallableFactory; 29 import com.google.api.gax.httpjson.ProtoMessageRequestFormatter; 30 import com.google.api.gax.httpjson.ProtoMessageResponseParser; 31 import com.google.api.gax.httpjson.ProtoRestSerializer; 32 import com.google.api.gax.rpc.ClientContext; 33 import com.google.api.gax.rpc.OperationCallable; 34 import com.google.api.gax.rpc.UnaryCallable; 35 import com.google.cloud.compute.v1.DeleteRegionUrlMapRequest; 36 import com.google.cloud.compute.v1.GetRegionUrlMapRequest; 37 import com.google.cloud.compute.v1.InsertRegionUrlMapRequest; 38 import com.google.cloud.compute.v1.ListRegionUrlMapsRequest; 39 import com.google.cloud.compute.v1.Operation; 40 import com.google.cloud.compute.v1.Operation.Status; 41 import com.google.cloud.compute.v1.PatchRegionUrlMapRequest; 42 import com.google.cloud.compute.v1.UpdateRegionUrlMapRequest; 43 import com.google.cloud.compute.v1.UrlMap; 44 import com.google.cloud.compute.v1.UrlMapList; 45 import com.google.cloud.compute.v1.UrlMapsValidateResponse; 46 import com.google.cloud.compute.v1.ValidateRegionUrlMapRequest; 47 import com.google.protobuf.TypeRegistry; 48 import java.io.IOException; 49 import java.util.ArrayList; 50 import java.util.HashMap; 51 import java.util.List; 52 import java.util.Map; 53 import java.util.concurrent.TimeUnit; 54 import javax.annotation.Generated; 55 56 // AUTO-GENERATED DOCUMENTATION AND CLASS. 57 /** 58 * REST stub implementation for the RegionUrlMaps service API. 59 * 60 * <p>This class is for advanced usage and reflects the underlying API directly. 61 */ 62 @Generated("by gapic-generator-java") 63 @BetaApi 64 public class HttpJsonRegionUrlMapsStub extends RegionUrlMapsStub { 65 private static final TypeRegistry typeRegistry = 66 TypeRegistry.newBuilder().add(Operation.getDescriptor()).build(); 67 68 private static final ApiMethodDescriptor<DeleteRegionUrlMapRequest, Operation> 69 deleteMethodDescriptor = 70 ApiMethodDescriptor.<DeleteRegionUrlMapRequest, Operation>newBuilder() 71 .setFullMethodName("google.cloud.compute.v1.RegionUrlMaps/Delete") 72 .setHttpMethod("DELETE") 73 .setType(ApiMethodDescriptor.MethodType.UNARY) 74 .setRequestFormatter( 75 ProtoMessageRequestFormatter.<DeleteRegionUrlMapRequest>newBuilder() 76 .setPath( 77 "/compute/v1/projects/{project}/regions/{region}/urlMaps/{urlMap}", 78 request -> { 79 Map<String, String> fields = new HashMap<>(); 80 ProtoRestSerializer<DeleteRegionUrlMapRequest> serializer = 81 ProtoRestSerializer.create(); 82 serializer.putPathParam(fields, "project", request.getProject()); 83 serializer.putPathParam(fields, "region", request.getRegion()); 84 serializer.putPathParam(fields, "urlMap", request.getUrlMap()); 85 return fields; 86 }) 87 .setQueryParamsExtractor( 88 request -> { 89 Map<String, List<String>> fields = new HashMap<>(); 90 ProtoRestSerializer<DeleteRegionUrlMapRequest> serializer = 91 ProtoRestSerializer.create(); 92 if (request.hasRequestId()) { 93 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 94 } 95 return fields; 96 }) 97 .setRequestBodyExtractor(request -> null) 98 .build()) 99 .setResponseParser( 100 ProtoMessageResponseParser.<Operation>newBuilder() 101 .setDefaultInstance(Operation.getDefaultInstance()) 102 .setDefaultTypeRegistry(typeRegistry) 103 .build()) 104 .setOperationSnapshotFactory( 105 (DeleteRegionUrlMapRequest request, Operation response) -> { 106 StringBuilder opName = new StringBuilder(response.getName()); 107 opName.append(":").append(request.getProject()); 108 opName.append(":").append(request.getRegion()); 109 return HttpJsonOperationSnapshot.newBuilder() 110 .setName(opName.toString()) 111 .setMetadata(response) 112 .setDone(Status.DONE.equals(response.getStatus())) 113 .setResponse(response) 114 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 115 .build(); 116 }) 117 .build(); 118 119 private static final ApiMethodDescriptor<GetRegionUrlMapRequest, UrlMap> getMethodDescriptor = 120 ApiMethodDescriptor.<GetRegionUrlMapRequest, UrlMap>newBuilder() 121 .setFullMethodName("google.cloud.compute.v1.RegionUrlMaps/Get") 122 .setHttpMethod("GET") 123 .setType(ApiMethodDescriptor.MethodType.UNARY) 124 .setRequestFormatter( 125 ProtoMessageRequestFormatter.<GetRegionUrlMapRequest>newBuilder() 126 .setPath( 127 "/compute/v1/projects/{project}/regions/{region}/urlMaps/{urlMap}", 128 request -> { 129 Map<String, String> fields = new HashMap<>(); 130 ProtoRestSerializer<GetRegionUrlMapRequest> serializer = 131 ProtoRestSerializer.create(); 132 serializer.putPathParam(fields, "project", request.getProject()); 133 serializer.putPathParam(fields, "region", request.getRegion()); 134 serializer.putPathParam(fields, "urlMap", request.getUrlMap()); 135 return fields; 136 }) 137 .setQueryParamsExtractor( 138 request -> { 139 Map<String, List<String>> fields = new HashMap<>(); 140 ProtoRestSerializer<GetRegionUrlMapRequest> serializer = 141 ProtoRestSerializer.create(); 142 return fields; 143 }) 144 .setRequestBodyExtractor(request -> null) 145 .build()) 146 .setResponseParser( 147 ProtoMessageResponseParser.<UrlMap>newBuilder() 148 .setDefaultInstance(UrlMap.getDefaultInstance()) 149 .setDefaultTypeRegistry(typeRegistry) 150 .build()) 151 .build(); 152 153 private static final ApiMethodDescriptor<InsertRegionUrlMapRequest, Operation> 154 insertMethodDescriptor = 155 ApiMethodDescriptor.<InsertRegionUrlMapRequest, Operation>newBuilder() 156 .setFullMethodName("google.cloud.compute.v1.RegionUrlMaps/Insert") 157 .setHttpMethod("POST") 158 .setType(ApiMethodDescriptor.MethodType.UNARY) 159 .setRequestFormatter( 160 ProtoMessageRequestFormatter.<InsertRegionUrlMapRequest>newBuilder() 161 .setPath( 162 "/compute/v1/projects/{project}/regions/{region}/urlMaps", 163 request -> { 164 Map<String, String> fields = new HashMap<>(); 165 ProtoRestSerializer<InsertRegionUrlMapRequest> serializer = 166 ProtoRestSerializer.create(); 167 serializer.putPathParam(fields, "project", request.getProject()); 168 serializer.putPathParam(fields, "region", request.getRegion()); 169 return fields; 170 }) 171 .setQueryParamsExtractor( 172 request -> { 173 Map<String, List<String>> fields = new HashMap<>(); 174 ProtoRestSerializer<InsertRegionUrlMapRequest> serializer = 175 ProtoRestSerializer.create(); 176 if (request.hasRequestId()) { 177 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 178 } 179 return fields; 180 }) 181 .setRequestBodyExtractor( 182 request -> 183 ProtoRestSerializer.create() 184 .toBody("urlMapResource", request.getUrlMapResource(), false)) 185 .build()) 186 .setResponseParser( 187 ProtoMessageResponseParser.<Operation>newBuilder() 188 .setDefaultInstance(Operation.getDefaultInstance()) 189 .setDefaultTypeRegistry(typeRegistry) 190 .build()) 191 .setOperationSnapshotFactory( 192 (InsertRegionUrlMapRequest request, Operation response) -> { 193 StringBuilder opName = new StringBuilder(response.getName()); 194 opName.append(":").append(request.getProject()); 195 opName.append(":").append(request.getRegion()); 196 return HttpJsonOperationSnapshot.newBuilder() 197 .setName(opName.toString()) 198 .setMetadata(response) 199 .setDone(Status.DONE.equals(response.getStatus())) 200 .setResponse(response) 201 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 202 .build(); 203 }) 204 .build(); 205 206 private static final ApiMethodDescriptor<ListRegionUrlMapsRequest, UrlMapList> 207 listMethodDescriptor = 208 ApiMethodDescriptor.<ListRegionUrlMapsRequest, UrlMapList>newBuilder() 209 .setFullMethodName("google.cloud.compute.v1.RegionUrlMaps/List") 210 .setHttpMethod("GET") 211 .setType(ApiMethodDescriptor.MethodType.UNARY) 212 .setRequestFormatter( 213 ProtoMessageRequestFormatter.<ListRegionUrlMapsRequest>newBuilder() 214 .setPath( 215 "/compute/v1/projects/{project}/regions/{region}/urlMaps", 216 request -> { 217 Map<String, String> fields = new HashMap<>(); 218 ProtoRestSerializer<ListRegionUrlMapsRequest> serializer = 219 ProtoRestSerializer.create(); 220 serializer.putPathParam(fields, "project", request.getProject()); 221 serializer.putPathParam(fields, "region", request.getRegion()); 222 return fields; 223 }) 224 .setQueryParamsExtractor( 225 request -> { 226 Map<String, List<String>> fields = new HashMap<>(); 227 ProtoRestSerializer<ListRegionUrlMapsRequest> serializer = 228 ProtoRestSerializer.create(); 229 if (request.hasFilter()) { 230 serializer.putQueryParam(fields, "filter", request.getFilter()); 231 } 232 if (request.hasMaxResults()) { 233 serializer.putQueryParam( 234 fields, "maxResults", request.getMaxResults()); 235 } 236 if (request.hasOrderBy()) { 237 serializer.putQueryParam(fields, "orderBy", request.getOrderBy()); 238 } 239 if (request.hasPageToken()) { 240 serializer.putQueryParam(fields, "pageToken", request.getPageToken()); 241 } 242 if (request.hasReturnPartialSuccess()) { 243 serializer.putQueryParam( 244 fields, 245 "returnPartialSuccess", 246 request.getReturnPartialSuccess()); 247 } 248 return fields; 249 }) 250 .setRequestBodyExtractor(request -> null) 251 .build()) 252 .setResponseParser( 253 ProtoMessageResponseParser.<UrlMapList>newBuilder() 254 .setDefaultInstance(UrlMapList.getDefaultInstance()) 255 .setDefaultTypeRegistry(typeRegistry) 256 .build()) 257 .build(); 258 259 private static final ApiMethodDescriptor<PatchRegionUrlMapRequest, Operation> 260 patchMethodDescriptor = 261 ApiMethodDescriptor.<PatchRegionUrlMapRequest, Operation>newBuilder() 262 .setFullMethodName("google.cloud.compute.v1.RegionUrlMaps/Patch") 263 .setHttpMethod("PATCH") 264 .setType(ApiMethodDescriptor.MethodType.UNARY) 265 .setRequestFormatter( 266 ProtoMessageRequestFormatter.<PatchRegionUrlMapRequest>newBuilder() 267 .setPath( 268 "/compute/v1/projects/{project}/regions/{region}/urlMaps/{urlMap}", 269 request -> { 270 Map<String, String> fields = new HashMap<>(); 271 ProtoRestSerializer<PatchRegionUrlMapRequest> serializer = 272 ProtoRestSerializer.create(); 273 serializer.putPathParam(fields, "project", request.getProject()); 274 serializer.putPathParam(fields, "region", request.getRegion()); 275 serializer.putPathParam(fields, "urlMap", request.getUrlMap()); 276 return fields; 277 }) 278 .setQueryParamsExtractor( 279 request -> { 280 Map<String, List<String>> fields = new HashMap<>(); 281 ProtoRestSerializer<PatchRegionUrlMapRequest> serializer = 282 ProtoRestSerializer.create(); 283 if (request.hasRequestId()) { 284 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 285 } 286 return fields; 287 }) 288 .setRequestBodyExtractor( 289 request -> 290 ProtoRestSerializer.create() 291 .toBody("urlMapResource", request.getUrlMapResource(), false)) 292 .build()) 293 .setResponseParser( 294 ProtoMessageResponseParser.<Operation>newBuilder() 295 .setDefaultInstance(Operation.getDefaultInstance()) 296 .setDefaultTypeRegistry(typeRegistry) 297 .build()) 298 .setOperationSnapshotFactory( 299 (PatchRegionUrlMapRequest request, Operation response) -> { 300 StringBuilder opName = new StringBuilder(response.getName()); 301 opName.append(":").append(request.getProject()); 302 opName.append(":").append(request.getRegion()); 303 return HttpJsonOperationSnapshot.newBuilder() 304 .setName(opName.toString()) 305 .setMetadata(response) 306 .setDone(Status.DONE.equals(response.getStatus())) 307 .setResponse(response) 308 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 309 .build(); 310 }) 311 .build(); 312 313 private static final ApiMethodDescriptor<UpdateRegionUrlMapRequest, Operation> 314 updateMethodDescriptor = 315 ApiMethodDescriptor.<UpdateRegionUrlMapRequest, Operation>newBuilder() 316 .setFullMethodName("google.cloud.compute.v1.RegionUrlMaps/Update") 317 .setHttpMethod("PUT") 318 .setType(ApiMethodDescriptor.MethodType.UNARY) 319 .setRequestFormatter( 320 ProtoMessageRequestFormatter.<UpdateRegionUrlMapRequest>newBuilder() 321 .setPath( 322 "/compute/v1/projects/{project}/regions/{region}/urlMaps/{urlMap}", 323 request -> { 324 Map<String, String> fields = new HashMap<>(); 325 ProtoRestSerializer<UpdateRegionUrlMapRequest> serializer = 326 ProtoRestSerializer.create(); 327 serializer.putPathParam(fields, "project", request.getProject()); 328 serializer.putPathParam(fields, "region", request.getRegion()); 329 serializer.putPathParam(fields, "urlMap", request.getUrlMap()); 330 return fields; 331 }) 332 .setQueryParamsExtractor( 333 request -> { 334 Map<String, List<String>> fields = new HashMap<>(); 335 ProtoRestSerializer<UpdateRegionUrlMapRequest> serializer = 336 ProtoRestSerializer.create(); 337 if (request.hasRequestId()) { 338 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 339 } 340 return fields; 341 }) 342 .setRequestBodyExtractor( 343 request -> 344 ProtoRestSerializer.create() 345 .toBody("urlMapResource", request.getUrlMapResource(), false)) 346 .build()) 347 .setResponseParser( 348 ProtoMessageResponseParser.<Operation>newBuilder() 349 .setDefaultInstance(Operation.getDefaultInstance()) 350 .setDefaultTypeRegistry(typeRegistry) 351 .build()) 352 .setOperationSnapshotFactory( 353 (UpdateRegionUrlMapRequest request, Operation response) -> { 354 StringBuilder opName = new StringBuilder(response.getName()); 355 opName.append(":").append(request.getProject()); 356 opName.append(":").append(request.getRegion()); 357 return HttpJsonOperationSnapshot.newBuilder() 358 .setName(opName.toString()) 359 .setMetadata(response) 360 .setDone(Status.DONE.equals(response.getStatus())) 361 .setResponse(response) 362 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 363 .build(); 364 }) 365 .build(); 366 367 private static final ApiMethodDescriptor<ValidateRegionUrlMapRequest, UrlMapsValidateResponse> 368 validateMethodDescriptor = 369 ApiMethodDescriptor.<ValidateRegionUrlMapRequest, UrlMapsValidateResponse>newBuilder() 370 .setFullMethodName("google.cloud.compute.v1.RegionUrlMaps/Validate") 371 .setHttpMethod("POST") 372 .setType(ApiMethodDescriptor.MethodType.UNARY) 373 .setRequestFormatter( 374 ProtoMessageRequestFormatter.<ValidateRegionUrlMapRequest>newBuilder() 375 .setPath( 376 "/compute/v1/projects/{project}/regions/{region}/urlMaps/{urlMap}/validate", 377 request -> { 378 Map<String, String> fields = new HashMap<>(); 379 ProtoRestSerializer<ValidateRegionUrlMapRequest> serializer = 380 ProtoRestSerializer.create(); 381 serializer.putPathParam(fields, "project", request.getProject()); 382 serializer.putPathParam(fields, "region", request.getRegion()); 383 serializer.putPathParam(fields, "urlMap", request.getUrlMap()); 384 return fields; 385 }) 386 .setQueryParamsExtractor( 387 request -> { 388 Map<String, List<String>> fields = new HashMap<>(); 389 ProtoRestSerializer<ValidateRegionUrlMapRequest> serializer = 390 ProtoRestSerializer.create(); 391 return fields; 392 }) 393 .setRequestBodyExtractor( 394 request -> 395 ProtoRestSerializer.create() 396 .toBody( 397 "regionUrlMapsValidateRequestResource", 398 request.getRegionUrlMapsValidateRequestResource(), 399 false)) 400 .build()) 401 .setResponseParser( 402 ProtoMessageResponseParser.<UrlMapsValidateResponse>newBuilder() 403 .setDefaultInstance(UrlMapsValidateResponse.getDefaultInstance()) 404 .setDefaultTypeRegistry(typeRegistry) 405 .build()) 406 .build(); 407 408 private final UnaryCallable<DeleteRegionUrlMapRequest, Operation> deleteCallable; 409 private final OperationCallable<DeleteRegionUrlMapRequest, Operation, Operation> 410 deleteOperationCallable; 411 private final UnaryCallable<GetRegionUrlMapRequest, UrlMap> getCallable; 412 private final UnaryCallable<InsertRegionUrlMapRequest, Operation> insertCallable; 413 private final OperationCallable<InsertRegionUrlMapRequest, Operation, Operation> 414 insertOperationCallable; 415 private final UnaryCallable<ListRegionUrlMapsRequest, UrlMapList> listCallable; 416 private final UnaryCallable<ListRegionUrlMapsRequest, ListPagedResponse> listPagedCallable; 417 private final UnaryCallable<PatchRegionUrlMapRequest, Operation> patchCallable; 418 private final OperationCallable<PatchRegionUrlMapRequest, Operation, Operation> 419 patchOperationCallable; 420 private final UnaryCallable<UpdateRegionUrlMapRequest, Operation> updateCallable; 421 private final OperationCallable<UpdateRegionUrlMapRequest, Operation, Operation> 422 updateOperationCallable; 423 private final UnaryCallable<ValidateRegionUrlMapRequest, UrlMapsValidateResponse> 424 validateCallable; 425 426 private final BackgroundResource backgroundResources; 427 private final HttpJsonRegionOperationsStub httpJsonOperationsStub; 428 private final HttpJsonStubCallableFactory callableFactory; 429 create(RegionUrlMapsStubSettings settings)430 public static final HttpJsonRegionUrlMapsStub create(RegionUrlMapsStubSettings settings) 431 throws IOException { 432 return new HttpJsonRegionUrlMapsStub(settings, ClientContext.create(settings)); 433 } 434 create(ClientContext clientContext)435 public static final HttpJsonRegionUrlMapsStub create(ClientContext clientContext) 436 throws IOException { 437 return new HttpJsonRegionUrlMapsStub( 438 RegionUrlMapsStubSettings.newBuilder().build(), clientContext); 439 } 440 create( ClientContext clientContext, HttpJsonStubCallableFactory callableFactory)441 public static final HttpJsonRegionUrlMapsStub create( 442 ClientContext clientContext, HttpJsonStubCallableFactory callableFactory) throws IOException { 443 return new HttpJsonRegionUrlMapsStub( 444 RegionUrlMapsStubSettings.newBuilder().build(), clientContext, callableFactory); 445 } 446 447 /** 448 * Constructs an instance of HttpJsonRegionUrlMapsStub, using the given settings. This is 449 * protected so that it is easy to make a subclass, but otherwise, the static factory methods 450 * should be preferred. 451 */ HttpJsonRegionUrlMapsStub( RegionUrlMapsStubSettings settings, ClientContext clientContext)452 protected HttpJsonRegionUrlMapsStub( 453 RegionUrlMapsStubSettings settings, ClientContext clientContext) throws IOException { 454 this(settings, clientContext, new HttpJsonRegionUrlMapsCallableFactory()); 455 } 456 457 /** 458 * Constructs an instance of HttpJsonRegionUrlMapsStub, using the given settings. This is 459 * protected so that it is easy to make a subclass, but otherwise, the static factory methods 460 * should be preferred. 461 */ HttpJsonRegionUrlMapsStub( RegionUrlMapsStubSettings settings, ClientContext clientContext, HttpJsonStubCallableFactory callableFactory)462 protected HttpJsonRegionUrlMapsStub( 463 RegionUrlMapsStubSettings settings, 464 ClientContext clientContext, 465 HttpJsonStubCallableFactory callableFactory) 466 throws IOException { 467 this.callableFactory = callableFactory; 468 this.httpJsonOperationsStub = 469 HttpJsonRegionOperationsStub.create(clientContext, callableFactory); 470 471 HttpJsonCallSettings<DeleteRegionUrlMapRequest, Operation> deleteTransportSettings = 472 HttpJsonCallSettings.<DeleteRegionUrlMapRequest, Operation>newBuilder() 473 .setMethodDescriptor(deleteMethodDescriptor) 474 .setTypeRegistry(typeRegistry) 475 .build(); 476 HttpJsonCallSettings<GetRegionUrlMapRequest, UrlMap> getTransportSettings = 477 HttpJsonCallSettings.<GetRegionUrlMapRequest, UrlMap>newBuilder() 478 .setMethodDescriptor(getMethodDescriptor) 479 .setTypeRegistry(typeRegistry) 480 .build(); 481 HttpJsonCallSettings<InsertRegionUrlMapRequest, Operation> insertTransportSettings = 482 HttpJsonCallSettings.<InsertRegionUrlMapRequest, Operation>newBuilder() 483 .setMethodDescriptor(insertMethodDescriptor) 484 .setTypeRegistry(typeRegistry) 485 .build(); 486 HttpJsonCallSettings<ListRegionUrlMapsRequest, UrlMapList> listTransportSettings = 487 HttpJsonCallSettings.<ListRegionUrlMapsRequest, UrlMapList>newBuilder() 488 .setMethodDescriptor(listMethodDescriptor) 489 .setTypeRegistry(typeRegistry) 490 .build(); 491 HttpJsonCallSettings<PatchRegionUrlMapRequest, Operation> patchTransportSettings = 492 HttpJsonCallSettings.<PatchRegionUrlMapRequest, Operation>newBuilder() 493 .setMethodDescriptor(patchMethodDescriptor) 494 .setTypeRegistry(typeRegistry) 495 .build(); 496 HttpJsonCallSettings<UpdateRegionUrlMapRequest, Operation> updateTransportSettings = 497 HttpJsonCallSettings.<UpdateRegionUrlMapRequest, Operation>newBuilder() 498 .setMethodDescriptor(updateMethodDescriptor) 499 .setTypeRegistry(typeRegistry) 500 .build(); 501 HttpJsonCallSettings<ValidateRegionUrlMapRequest, UrlMapsValidateResponse> 502 validateTransportSettings = 503 HttpJsonCallSettings.<ValidateRegionUrlMapRequest, UrlMapsValidateResponse>newBuilder() 504 .setMethodDescriptor(validateMethodDescriptor) 505 .setTypeRegistry(typeRegistry) 506 .build(); 507 508 this.deleteCallable = 509 callableFactory.createUnaryCallable( 510 deleteTransportSettings, settings.deleteSettings(), clientContext); 511 this.deleteOperationCallable = 512 callableFactory.createOperationCallable( 513 deleteTransportSettings, 514 settings.deleteOperationSettings(), 515 clientContext, 516 httpJsonOperationsStub); 517 this.getCallable = 518 callableFactory.createUnaryCallable( 519 getTransportSettings, settings.getSettings(), clientContext); 520 this.insertCallable = 521 callableFactory.createUnaryCallable( 522 insertTransportSettings, settings.insertSettings(), clientContext); 523 this.insertOperationCallable = 524 callableFactory.createOperationCallable( 525 insertTransportSettings, 526 settings.insertOperationSettings(), 527 clientContext, 528 httpJsonOperationsStub); 529 this.listCallable = 530 callableFactory.createUnaryCallable( 531 listTransportSettings, settings.listSettings(), clientContext); 532 this.listPagedCallable = 533 callableFactory.createPagedCallable( 534 listTransportSettings, settings.listSettings(), clientContext); 535 this.patchCallable = 536 callableFactory.createUnaryCallable( 537 patchTransportSettings, settings.patchSettings(), clientContext); 538 this.patchOperationCallable = 539 callableFactory.createOperationCallable( 540 patchTransportSettings, 541 settings.patchOperationSettings(), 542 clientContext, 543 httpJsonOperationsStub); 544 this.updateCallable = 545 callableFactory.createUnaryCallable( 546 updateTransportSettings, settings.updateSettings(), clientContext); 547 this.updateOperationCallable = 548 callableFactory.createOperationCallable( 549 updateTransportSettings, 550 settings.updateOperationSettings(), 551 clientContext, 552 httpJsonOperationsStub); 553 this.validateCallable = 554 callableFactory.createUnaryCallable( 555 validateTransportSettings, settings.validateSettings(), clientContext); 556 557 this.backgroundResources = 558 new BackgroundResourceAggregation(clientContext.getBackgroundResources()); 559 } 560 561 @InternalApi getMethodDescriptors()562 public static List<ApiMethodDescriptor> getMethodDescriptors() { 563 List<ApiMethodDescriptor> methodDescriptors = new ArrayList<>(); 564 methodDescriptors.add(deleteMethodDescriptor); 565 methodDescriptors.add(getMethodDescriptor); 566 methodDescriptors.add(insertMethodDescriptor); 567 methodDescriptors.add(listMethodDescriptor); 568 methodDescriptors.add(patchMethodDescriptor); 569 methodDescriptors.add(updateMethodDescriptor); 570 methodDescriptors.add(validateMethodDescriptor); 571 return methodDescriptors; 572 } 573 574 @Override deleteCallable()575 public UnaryCallable<DeleteRegionUrlMapRequest, Operation> deleteCallable() { 576 return deleteCallable; 577 } 578 579 @Override 580 public OperationCallable<DeleteRegionUrlMapRequest, Operation, Operation> deleteOperationCallable()581 deleteOperationCallable() { 582 return deleteOperationCallable; 583 } 584 585 @Override getCallable()586 public UnaryCallable<GetRegionUrlMapRequest, UrlMap> getCallable() { 587 return getCallable; 588 } 589 590 @Override insertCallable()591 public UnaryCallable<InsertRegionUrlMapRequest, Operation> insertCallable() { 592 return insertCallable; 593 } 594 595 @Override 596 public OperationCallable<InsertRegionUrlMapRequest, Operation, Operation> insertOperationCallable()597 insertOperationCallable() { 598 return insertOperationCallable; 599 } 600 601 @Override listCallable()602 public UnaryCallable<ListRegionUrlMapsRequest, UrlMapList> listCallable() { 603 return listCallable; 604 } 605 606 @Override listPagedCallable()607 public UnaryCallable<ListRegionUrlMapsRequest, ListPagedResponse> listPagedCallable() { 608 return listPagedCallable; 609 } 610 611 @Override patchCallable()612 public UnaryCallable<PatchRegionUrlMapRequest, Operation> patchCallable() { 613 return patchCallable; 614 } 615 616 @Override 617 public OperationCallable<PatchRegionUrlMapRequest, Operation, Operation> patchOperationCallable()618 patchOperationCallable() { 619 return patchOperationCallable; 620 } 621 622 @Override updateCallable()623 public UnaryCallable<UpdateRegionUrlMapRequest, Operation> updateCallable() { 624 return updateCallable; 625 } 626 627 @Override 628 public OperationCallable<UpdateRegionUrlMapRequest, Operation, Operation> updateOperationCallable()629 updateOperationCallable() { 630 return updateOperationCallable; 631 } 632 633 @Override validateCallable()634 public UnaryCallable<ValidateRegionUrlMapRequest, UrlMapsValidateResponse> validateCallable() { 635 return validateCallable; 636 } 637 638 @Override close()639 public final void close() { 640 try { 641 backgroundResources.close(); 642 } catch (RuntimeException e) { 643 throw e; 644 } catch (Exception e) { 645 throw new IllegalStateException("Failed to close resource", e); 646 } 647 } 648 649 @Override shutdown()650 public void shutdown() { 651 backgroundResources.shutdown(); 652 } 653 654 @Override isShutdown()655 public boolean isShutdown() { 656 return backgroundResources.isShutdown(); 657 } 658 659 @Override isTerminated()660 public boolean isTerminated() { 661 return backgroundResources.isTerminated(); 662 } 663 664 @Override shutdownNow()665 public void shutdownNow() { 666 backgroundResources.shutdownNow(); 667 } 668 669 @Override awaitTermination(long duration, TimeUnit unit)670 public boolean awaitTermination(long duration, TimeUnit unit) throws InterruptedException { 671 return backgroundResources.awaitTermination(duration, unit); 672 } 673 } 674