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.RegionDisksClient.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.AddResourcePoliciesRegionDiskRequest; 36 import com.google.cloud.compute.v1.CreateSnapshotRegionDiskRequest; 37 import com.google.cloud.compute.v1.DeleteRegionDiskRequest; 38 import com.google.cloud.compute.v1.Disk; 39 import com.google.cloud.compute.v1.DiskList; 40 import com.google.cloud.compute.v1.GetIamPolicyRegionDiskRequest; 41 import com.google.cloud.compute.v1.GetRegionDiskRequest; 42 import com.google.cloud.compute.v1.InsertRegionDiskRequest; 43 import com.google.cloud.compute.v1.ListRegionDisksRequest; 44 import com.google.cloud.compute.v1.Operation; 45 import com.google.cloud.compute.v1.Operation.Status; 46 import com.google.cloud.compute.v1.Policy; 47 import com.google.cloud.compute.v1.RemoveResourcePoliciesRegionDiskRequest; 48 import com.google.cloud.compute.v1.ResizeRegionDiskRequest; 49 import com.google.cloud.compute.v1.SetIamPolicyRegionDiskRequest; 50 import com.google.cloud.compute.v1.SetLabelsRegionDiskRequest; 51 import com.google.cloud.compute.v1.TestIamPermissionsRegionDiskRequest; 52 import com.google.cloud.compute.v1.TestPermissionsResponse; 53 import com.google.cloud.compute.v1.UpdateRegionDiskRequest; 54 import com.google.protobuf.TypeRegistry; 55 import java.io.IOException; 56 import java.util.ArrayList; 57 import java.util.HashMap; 58 import java.util.List; 59 import java.util.Map; 60 import java.util.concurrent.TimeUnit; 61 import javax.annotation.Generated; 62 63 // AUTO-GENERATED DOCUMENTATION AND CLASS. 64 /** 65 * REST stub implementation for the RegionDisks service API. 66 * 67 * <p>This class is for advanced usage and reflects the underlying API directly. 68 */ 69 @Generated("by gapic-generator-java") 70 @BetaApi 71 public class HttpJsonRegionDisksStub extends RegionDisksStub { 72 private static final TypeRegistry typeRegistry = 73 TypeRegistry.newBuilder().add(Operation.getDescriptor()).build(); 74 75 private static final ApiMethodDescriptor<AddResourcePoliciesRegionDiskRequest, Operation> 76 addResourcePoliciesMethodDescriptor = 77 ApiMethodDescriptor.<AddResourcePoliciesRegionDiskRequest, Operation>newBuilder() 78 .setFullMethodName("google.cloud.compute.v1.RegionDisks/AddResourcePolicies") 79 .setHttpMethod("POST") 80 .setType(ApiMethodDescriptor.MethodType.UNARY) 81 .setRequestFormatter( 82 ProtoMessageRequestFormatter.<AddResourcePoliciesRegionDiskRequest>newBuilder() 83 .setPath( 84 "/compute/v1/projects/{project}/regions/{region}/disks/{disk}/addResourcePolicies", 85 request -> { 86 Map<String, String> fields = new HashMap<>(); 87 ProtoRestSerializer<AddResourcePoliciesRegionDiskRequest> serializer = 88 ProtoRestSerializer.create(); 89 serializer.putPathParam(fields, "disk", request.getDisk()); 90 serializer.putPathParam(fields, "project", request.getProject()); 91 serializer.putPathParam(fields, "region", request.getRegion()); 92 return fields; 93 }) 94 .setQueryParamsExtractor( 95 request -> { 96 Map<String, List<String>> fields = new HashMap<>(); 97 ProtoRestSerializer<AddResourcePoliciesRegionDiskRequest> serializer = 98 ProtoRestSerializer.create(); 99 if (request.hasRequestId()) { 100 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 101 } 102 return fields; 103 }) 104 .setRequestBodyExtractor( 105 request -> 106 ProtoRestSerializer.create() 107 .toBody( 108 "regionDisksAddResourcePoliciesRequestResource", 109 request.getRegionDisksAddResourcePoliciesRequestResource(), 110 false)) 111 .build()) 112 .setResponseParser( 113 ProtoMessageResponseParser.<Operation>newBuilder() 114 .setDefaultInstance(Operation.getDefaultInstance()) 115 .setDefaultTypeRegistry(typeRegistry) 116 .build()) 117 .setOperationSnapshotFactory( 118 (AddResourcePoliciesRegionDiskRequest request, Operation response) -> { 119 StringBuilder opName = new StringBuilder(response.getName()); 120 opName.append(":").append(request.getProject()); 121 opName.append(":").append(request.getRegion()); 122 return HttpJsonOperationSnapshot.newBuilder() 123 .setName(opName.toString()) 124 .setMetadata(response) 125 .setDone(Status.DONE.equals(response.getStatus())) 126 .setResponse(response) 127 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 128 .build(); 129 }) 130 .build(); 131 132 private static final ApiMethodDescriptor<CreateSnapshotRegionDiskRequest, Operation> 133 createSnapshotMethodDescriptor = 134 ApiMethodDescriptor.<CreateSnapshotRegionDiskRequest, Operation>newBuilder() 135 .setFullMethodName("google.cloud.compute.v1.RegionDisks/CreateSnapshot") 136 .setHttpMethod("POST") 137 .setType(ApiMethodDescriptor.MethodType.UNARY) 138 .setRequestFormatter( 139 ProtoMessageRequestFormatter.<CreateSnapshotRegionDiskRequest>newBuilder() 140 .setPath( 141 "/compute/v1/projects/{project}/regions/{region}/disks/{disk}/createSnapshot", 142 request -> { 143 Map<String, String> fields = new HashMap<>(); 144 ProtoRestSerializer<CreateSnapshotRegionDiskRequest> serializer = 145 ProtoRestSerializer.create(); 146 serializer.putPathParam(fields, "disk", request.getDisk()); 147 serializer.putPathParam(fields, "project", request.getProject()); 148 serializer.putPathParam(fields, "region", request.getRegion()); 149 return fields; 150 }) 151 .setQueryParamsExtractor( 152 request -> { 153 Map<String, List<String>> fields = new HashMap<>(); 154 ProtoRestSerializer<CreateSnapshotRegionDiskRequest> serializer = 155 ProtoRestSerializer.create(); 156 if (request.hasRequestId()) { 157 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 158 } 159 return fields; 160 }) 161 .setRequestBodyExtractor( 162 request -> 163 ProtoRestSerializer.create() 164 .toBody("snapshotResource", request.getSnapshotResource(), false)) 165 .build()) 166 .setResponseParser( 167 ProtoMessageResponseParser.<Operation>newBuilder() 168 .setDefaultInstance(Operation.getDefaultInstance()) 169 .setDefaultTypeRegistry(typeRegistry) 170 .build()) 171 .setOperationSnapshotFactory( 172 (CreateSnapshotRegionDiskRequest request, Operation response) -> { 173 StringBuilder opName = new StringBuilder(response.getName()); 174 opName.append(":").append(request.getProject()); 175 opName.append(":").append(request.getRegion()); 176 return HttpJsonOperationSnapshot.newBuilder() 177 .setName(opName.toString()) 178 .setMetadata(response) 179 .setDone(Status.DONE.equals(response.getStatus())) 180 .setResponse(response) 181 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 182 .build(); 183 }) 184 .build(); 185 186 private static final ApiMethodDescriptor<DeleteRegionDiskRequest, Operation> 187 deleteMethodDescriptor = 188 ApiMethodDescriptor.<DeleteRegionDiskRequest, Operation>newBuilder() 189 .setFullMethodName("google.cloud.compute.v1.RegionDisks/Delete") 190 .setHttpMethod("DELETE") 191 .setType(ApiMethodDescriptor.MethodType.UNARY) 192 .setRequestFormatter( 193 ProtoMessageRequestFormatter.<DeleteRegionDiskRequest>newBuilder() 194 .setPath( 195 "/compute/v1/projects/{project}/regions/{region}/disks/{disk}", 196 request -> { 197 Map<String, String> fields = new HashMap<>(); 198 ProtoRestSerializer<DeleteRegionDiskRequest> serializer = 199 ProtoRestSerializer.create(); 200 serializer.putPathParam(fields, "disk", request.getDisk()); 201 serializer.putPathParam(fields, "project", request.getProject()); 202 serializer.putPathParam(fields, "region", request.getRegion()); 203 return fields; 204 }) 205 .setQueryParamsExtractor( 206 request -> { 207 Map<String, List<String>> fields = new HashMap<>(); 208 ProtoRestSerializer<DeleteRegionDiskRequest> serializer = 209 ProtoRestSerializer.create(); 210 if (request.hasRequestId()) { 211 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 212 } 213 return fields; 214 }) 215 .setRequestBodyExtractor(request -> null) 216 .build()) 217 .setResponseParser( 218 ProtoMessageResponseParser.<Operation>newBuilder() 219 .setDefaultInstance(Operation.getDefaultInstance()) 220 .setDefaultTypeRegistry(typeRegistry) 221 .build()) 222 .setOperationSnapshotFactory( 223 (DeleteRegionDiskRequest request, Operation response) -> { 224 StringBuilder opName = new StringBuilder(response.getName()); 225 opName.append(":").append(request.getProject()); 226 opName.append(":").append(request.getRegion()); 227 return HttpJsonOperationSnapshot.newBuilder() 228 .setName(opName.toString()) 229 .setMetadata(response) 230 .setDone(Status.DONE.equals(response.getStatus())) 231 .setResponse(response) 232 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 233 .build(); 234 }) 235 .build(); 236 237 private static final ApiMethodDescriptor<GetRegionDiskRequest, Disk> getMethodDescriptor = 238 ApiMethodDescriptor.<GetRegionDiskRequest, Disk>newBuilder() 239 .setFullMethodName("google.cloud.compute.v1.RegionDisks/Get") 240 .setHttpMethod("GET") 241 .setType(ApiMethodDescriptor.MethodType.UNARY) 242 .setRequestFormatter( 243 ProtoMessageRequestFormatter.<GetRegionDiskRequest>newBuilder() 244 .setPath( 245 "/compute/v1/projects/{project}/regions/{region}/disks/{disk}", 246 request -> { 247 Map<String, String> fields = new HashMap<>(); 248 ProtoRestSerializer<GetRegionDiskRequest> serializer = 249 ProtoRestSerializer.create(); 250 serializer.putPathParam(fields, "disk", request.getDisk()); 251 serializer.putPathParam(fields, "project", request.getProject()); 252 serializer.putPathParam(fields, "region", request.getRegion()); 253 return fields; 254 }) 255 .setQueryParamsExtractor( 256 request -> { 257 Map<String, List<String>> fields = new HashMap<>(); 258 ProtoRestSerializer<GetRegionDiskRequest> serializer = 259 ProtoRestSerializer.create(); 260 return fields; 261 }) 262 .setRequestBodyExtractor(request -> null) 263 .build()) 264 .setResponseParser( 265 ProtoMessageResponseParser.<Disk>newBuilder() 266 .setDefaultInstance(Disk.getDefaultInstance()) 267 .setDefaultTypeRegistry(typeRegistry) 268 .build()) 269 .build(); 270 271 private static final ApiMethodDescriptor<GetIamPolicyRegionDiskRequest, Policy> 272 getIamPolicyMethodDescriptor = 273 ApiMethodDescriptor.<GetIamPolicyRegionDiskRequest, Policy>newBuilder() 274 .setFullMethodName("google.cloud.compute.v1.RegionDisks/GetIamPolicy") 275 .setHttpMethod("GET") 276 .setType(ApiMethodDescriptor.MethodType.UNARY) 277 .setRequestFormatter( 278 ProtoMessageRequestFormatter.<GetIamPolicyRegionDiskRequest>newBuilder() 279 .setPath( 280 "/compute/v1/projects/{project}/regions/{region}/disks/{resource}/getIamPolicy", 281 request -> { 282 Map<String, String> fields = new HashMap<>(); 283 ProtoRestSerializer<GetIamPolicyRegionDiskRequest> serializer = 284 ProtoRestSerializer.create(); 285 serializer.putPathParam(fields, "project", request.getProject()); 286 serializer.putPathParam(fields, "region", request.getRegion()); 287 serializer.putPathParam(fields, "resource", request.getResource()); 288 return fields; 289 }) 290 .setQueryParamsExtractor( 291 request -> { 292 Map<String, List<String>> fields = new HashMap<>(); 293 ProtoRestSerializer<GetIamPolicyRegionDiskRequest> serializer = 294 ProtoRestSerializer.create(); 295 if (request.hasOptionsRequestedPolicyVersion()) { 296 serializer.putQueryParam( 297 fields, 298 "optionsRequestedPolicyVersion", 299 request.getOptionsRequestedPolicyVersion()); 300 } 301 return fields; 302 }) 303 .setRequestBodyExtractor(request -> null) 304 .build()) 305 .setResponseParser( 306 ProtoMessageResponseParser.<Policy>newBuilder() 307 .setDefaultInstance(Policy.getDefaultInstance()) 308 .setDefaultTypeRegistry(typeRegistry) 309 .build()) 310 .build(); 311 312 private static final ApiMethodDescriptor<InsertRegionDiskRequest, Operation> 313 insertMethodDescriptor = 314 ApiMethodDescriptor.<InsertRegionDiskRequest, Operation>newBuilder() 315 .setFullMethodName("google.cloud.compute.v1.RegionDisks/Insert") 316 .setHttpMethod("POST") 317 .setType(ApiMethodDescriptor.MethodType.UNARY) 318 .setRequestFormatter( 319 ProtoMessageRequestFormatter.<InsertRegionDiskRequest>newBuilder() 320 .setPath( 321 "/compute/v1/projects/{project}/regions/{region}/disks", 322 request -> { 323 Map<String, String> fields = new HashMap<>(); 324 ProtoRestSerializer<InsertRegionDiskRequest> serializer = 325 ProtoRestSerializer.create(); 326 serializer.putPathParam(fields, "project", request.getProject()); 327 serializer.putPathParam(fields, "region", request.getRegion()); 328 return fields; 329 }) 330 .setQueryParamsExtractor( 331 request -> { 332 Map<String, List<String>> fields = new HashMap<>(); 333 ProtoRestSerializer<InsertRegionDiskRequest> serializer = 334 ProtoRestSerializer.create(); 335 if (request.hasRequestId()) { 336 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 337 } 338 if (request.hasSourceImage()) { 339 serializer.putQueryParam( 340 fields, "sourceImage", request.getSourceImage()); 341 } 342 return fields; 343 }) 344 .setRequestBodyExtractor( 345 request -> 346 ProtoRestSerializer.create() 347 .toBody("diskResource", request.getDiskResource(), false)) 348 .build()) 349 .setResponseParser( 350 ProtoMessageResponseParser.<Operation>newBuilder() 351 .setDefaultInstance(Operation.getDefaultInstance()) 352 .setDefaultTypeRegistry(typeRegistry) 353 .build()) 354 .setOperationSnapshotFactory( 355 (InsertRegionDiskRequest request, Operation response) -> { 356 StringBuilder opName = new StringBuilder(response.getName()); 357 opName.append(":").append(request.getProject()); 358 opName.append(":").append(request.getRegion()); 359 return HttpJsonOperationSnapshot.newBuilder() 360 .setName(opName.toString()) 361 .setMetadata(response) 362 .setDone(Status.DONE.equals(response.getStatus())) 363 .setResponse(response) 364 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 365 .build(); 366 }) 367 .build(); 368 369 private static final ApiMethodDescriptor<ListRegionDisksRequest, DiskList> listMethodDescriptor = 370 ApiMethodDescriptor.<ListRegionDisksRequest, DiskList>newBuilder() 371 .setFullMethodName("google.cloud.compute.v1.RegionDisks/List") 372 .setHttpMethod("GET") 373 .setType(ApiMethodDescriptor.MethodType.UNARY) 374 .setRequestFormatter( 375 ProtoMessageRequestFormatter.<ListRegionDisksRequest>newBuilder() 376 .setPath( 377 "/compute/v1/projects/{project}/regions/{region}/disks", 378 request -> { 379 Map<String, String> fields = new HashMap<>(); 380 ProtoRestSerializer<ListRegionDisksRequest> serializer = 381 ProtoRestSerializer.create(); 382 serializer.putPathParam(fields, "project", request.getProject()); 383 serializer.putPathParam(fields, "region", request.getRegion()); 384 return fields; 385 }) 386 .setQueryParamsExtractor( 387 request -> { 388 Map<String, List<String>> fields = new HashMap<>(); 389 ProtoRestSerializer<ListRegionDisksRequest> serializer = 390 ProtoRestSerializer.create(); 391 if (request.hasFilter()) { 392 serializer.putQueryParam(fields, "filter", request.getFilter()); 393 } 394 if (request.hasMaxResults()) { 395 serializer.putQueryParam(fields, "maxResults", request.getMaxResults()); 396 } 397 if (request.hasOrderBy()) { 398 serializer.putQueryParam(fields, "orderBy", request.getOrderBy()); 399 } 400 if (request.hasPageToken()) { 401 serializer.putQueryParam(fields, "pageToken", request.getPageToken()); 402 } 403 if (request.hasReturnPartialSuccess()) { 404 serializer.putQueryParam( 405 fields, "returnPartialSuccess", request.getReturnPartialSuccess()); 406 } 407 return fields; 408 }) 409 .setRequestBodyExtractor(request -> null) 410 .build()) 411 .setResponseParser( 412 ProtoMessageResponseParser.<DiskList>newBuilder() 413 .setDefaultInstance(DiskList.getDefaultInstance()) 414 .setDefaultTypeRegistry(typeRegistry) 415 .build()) 416 .build(); 417 418 private static final ApiMethodDescriptor<RemoveResourcePoliciesRegionDiskRequest, Operation> 419 removeResourcePoliciesMethodDescriptor = 420 ApiMethodDescriptor.<RemoveResourcePoliciesRegionDiskRequest, Operation>newBuilder() 421 .setFullMethodName("google.cloud.compute.v1.RegionDisks/RemoveResourcePolicies") 422 .setHttpMethod("POST") 423 .setType(ApiMethodDescriptor.MethodType.UNARY) 424 .setRequestFormatter( 425 ProtoMessageRequestFormatter.<RemoveResourcePoliciesRegionDiskRequest>newBuilder() 426 .setPath( 427 "/compute/v1/projects/{project}/regions/{region}/disks/{disk}/removeResourcePolicies", 428 request -> { 429 Map<String, String> fields = new HashMap<>(); 430 ProtoRestSerializer<RemoveResourcePoliciesRegionDiskRequest> 431 serializer = ProtoRestSerializer.create(); 432 serializer.putPathParam(fields, "disk", request.getDisk()); 433 serializer.putPathParam(fields, "project", request.getProject()); 434 serializer.putPathParam(fields, "region", request.getRegion()); 435 return fields; 436 }) 437 .setQueryParamsExtractor( 438 request -> { 439 Map<String, List<String>> fields = new HashMap<>(); 440 ProtoRestSerializer<RemoveResourcePoliciesRegionDiskRequest> 441 serializer = ProtoRestSerializer.create(); 442 if (request.hasRequestId()) { 443 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 444 } 445 return fields; 446 }) 447 .setRequestBodyExtractor( 448 request -> 449 ProtoRestSerializer.create() 450 .toBody( 451 "regionDisksRemoveResourcePoliciesRequestResource", 452 request.getRegionDisksRemoveResourcePoliciesRequestResource(), 453 false)) 454 .build()) 455 .setResponseParser( 456 ProtoMessageResponseParser.<Operation>newBuilder() 457 .setDefaultInstance(Operation.getDefaultInstance()) 458 .setDefaultTypeRegistry(typeRegistry) 459 .build()) 460 .setOperationSnapshotFactory( 461 (RemoveResourcePoliciesRegionDiskRequest request, Operation response) -> { 462 StringBuilder opName = new StringBuilder(response.getName()); 463 opName.append(":").append(request.getProject()); 464 opName.append(":").append(request.getRegion()); 465 return HttpJsonOperationSnapshot.newBuilder() 466 .setName(opName.toString()) 467 .setMetadata(response) 468 .setDone(Status.DONE.equals(response.getStatus())) 469 .setResponse(response) 470 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 471 .build(); 472 }) 473 .build(); 474 475 private static final ApiMethodDescriptor<ResizeRegionDiskRequest, Operation> 476 resizeMethodDescriptor = 477 ApiMethodDescriptor.<ResizeRegionDiskRequest, Operation>newBuilder() 478 .setFullMethodName("google.cloud.compute.v1.RegionDisks/Resize") 479 .setHttpMethod("POST") 480 .setType(ApiMethodDescriptor.MethodType.UNARY) 481 .setRequestFormatter( 482 ProtoMessageRequestFormatter.<ResizeRegionDiskRequest>newBuilder() 483 .setPath( 484 "/compute/v1/projects/{project}/regions/{region}/disks/{disk}/resize", 485 request -> { 486 Map<String, String> fields = new HashMap<>(); 487 ProtoRestSerializer<ResizeRegionDiskRequest> serializer = 488 ProtoRestSerializer.create(); 489 serializer.putPathParam(fields, "disk", request.getDisk()); 490 serializer.putPathParam(fields, "project", request.getProject()); 491 serializer.putPathParam(fields, "region", request.getRegion()); 492 return fields; 493 }) 494 .setQueryParamsExtractor( 495 request -> { 496 Map<String, List<String>> fields = new HashMap<>(); 497 ProtoRestSerializer<ResizeRegionDiskRequest> serializer = 498 ProtoRestSerializer.create(); 499 if (request.hasRequestId()) { 500 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 501 } 502 return fields; 503 }) 504 .setRequestBodyExtractor( 505 request -> 506 ProtoRestSerializer.create() 507 .toBody( 508 "regionDisksResizeRequestResource", 509 request.getRegionDisksResizeRequestResource(), 510 false)) 511 .build()) 512 .setResponseParser( 513 ProtoMessageResponseParser.<Operation>newBuilder() 514 .setDefaultInstance(Operation.getDefaultInstance()) 515 .setDefaultTypeRegistry(typeRegistry) 516 .build()) 517 .setOperationSnapshotFactory( 518 (ResizeRegionDiskRequest request, Operation response) -> { 519 StringBuilder opName = new StringBuilder(response.getName()); 520 opName.append(":").append(request.getProject()); 521 opName.append(":").append(request.getRegion()); 522 return HttpJsonOperationSnapshot.newBuilder() 523 .setName(opName.toString()) 524 .setMetadata(response) 525 .setDone(Status.DONE.equals(response.getStatus())) 526 .setResponse(response) 527 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 528 .build(); 529 }) 530 .build(); 531 532 private static final ApiMethodDescriptor<SetIamPolicyRegionDiskRequest, Policy> 533 setIamPolicyMethodDescriptor = 534 ApiMethodDescriptor.<SetIamPolicyRegionDiskRequest, Policy>newBuilder() 535 .setFullMethodName("google.cloud.compute.v1.RegionDisks/SetIamPolicy") 536 .setHttpMethod("POST") 537 .setType(ApiMethodDescriptor.MethodType.UNARY) 538 .setRequestFormatter( 539 ProtoMessageRequestFormatter.<SetIamPolicyRegionDiskRequest>newBuilder() 540 .setPath( 541 "/compute/v1/projects/{project}/regions/{region}/disks/{resource}/setIamPolicy", 542 request -> { 543 Map<String, String> fields = new HashMap<>(); 544 ProtoRestSerializer<SetIamPolicyRegionDiskRequest> serializer = 545 ProtoRestSerializer.create(); 546 serializer.putPathParam(fields, "project", request.getProject()); 547 serializer.putPathParam(fields, "region", request.getRegion()); 548 serializer.putPathParam(fields, "resource", request.getResource()); 549 return fields; 550 }) 551 .setQueryParamsExtractor( 552 request -> { 553 Map<String, List<String>> fields = new HashMap<>(); 554 ProtoRestSerializer<SetIamPolicyRegionDiskRequest> serializer = 555 ProtoRestSerializer.create(); 556 return fields; 557 }) 558 .setRequestBodyExtractor( 559 request -> 560 ProtoRestSerializer.create() 561 .toBody( 562 "regionSetPolicyRequestResource", 563 request.getRegionSetPolicyRequestResource(), 564 false)) 565 .build()) 566 .setResponseParser( 567 ProtoMessageResponseParser.<Policy>newBuilder() 568 .setDefaultInstance(Policy.getDefaultInstance()) 569 .setDefaultTypeRegistry(typeRegistry) 570 .build()) 571 .build(); 572 573 private static final ApiMethodDescriptor<SetLabelsRegionDiskRequest, Operation> 574 setLabelsMethodDescriptor = 575 ApiMethodDescriptor.<SetLabelsRegionDiskRequest, Operation>newBuilder() 576 .setFullMethodName("google.cloud.compute.v1.RegionDisks/SetLabels") 577 .setHttpMethod("POST") 578 .setType(ApiMethodDescriptor.MethodType.UNARY) 579 .setRequestFormatter( 580 ProtoMessageRequestFormatter.<SetLabelsRegionDiskRequest>newBuilder() 581 .setPath( 582 "/compute/v1/projects/{project}/regions/{region}/disks/{resource}/setLabels", 583 request -> { 584 Map<String, String> fields = new HashMap<>(); 585 ProtoRestSerializer<SetLabelsRegionDiskRequest> serializer = 586 ProtoRestSerializer.create(); 587 serializer.putPathParam(fields, "project", request.getProject()); 588 serializer.putPathParam(fields, "region", request.getRegion()); 589 serializer.putPathParam(fields, "resource", request.getResource()); 590 return fields; 591 }) 592 .setQueryParamsExtractor( 593 request -> { 594 Map<String, List<String>> fields = new HashMap<>(); 595 ProtoRestSerializer<SetLabelsRegionDiskRequest> serializer = 596 ProtoRestSerializer.create(); 597 if (request.hasRequestId()) { 598 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 599 } 600 return fields; 601 }) 602 .setRequestBodyExtractor( 603 request -> 604 ProtoRestSerializer.create() 605 .toBody( 606 "regionSetLabelsRequestResource", 607 request.getRegionSetLabelsRequestResource(), 608 false)) 609 .build()) 610 .setResponseParser( 611 ProtoMessageResponseParser.<Operation>newBuilder() 612 .setDefaultInstance(Operation.getDefaultInstance()) 613 .setDefaultTypeRegistry(typeRegistry) 614 .build()) 615 .setOperationSnapshotFactory( 616 (SetLabelsRegionDiskRequest request, Operation response) -> { 617 StringBuilder opName = new StringBuilder(response.getName()); 618 opName.append(":").append(request.getProject()); 619 opName.append(":").append(request.getRegion()); 620 return HttpJsonOperationSnapshot.newBuilder() 621 .setName(opName.toString()) 622 .setMetadata(response) 623 .setDone(Status.DONE.equals(response.getStatus())) 624 .setResponse(response) 625 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 626 .build(); 627 }) 628 .build(); 629 630 private static final ApiMethodDescriptor< 631 TestIamPermissionsRegionDiskRequest, TestPermissionsResponse> 632 testIamPermissionsMethodDescriptor = 633 ApiMethodDescriptor 634 .<TestIamPermissionsRegionDiskRequest, TestPermissionsResponse>newBuilder() 635 .setFullMethodName("google.cloud.compute.v1.RegionDisks/TestIamPermissions") 636 .setHttpMethod("POST") 637 .setType(ApiMethodDescriptor.MethodType.UNARY) 638 .setRequestFormatter( 639 ProtoMessageRequestFormatter.<TestIamPermissionsRegionDiskRequest>newBuilder() 640 .setPath( 641 "/compute/v1/projects/{project}/regions/{region}/disks/{resource}/testIamPermissions", 642 request -> { 643 Map<String, String> fields = new HashMap<>(); 644 ProtoRestSerializer<TestIamPermissionsRegionDiskRequest> serializer = 645 ProtoRestSerializer.create(); 646 serializer.putPathParam(fields, "project", request.getProject()); 647 serializer.putPathParam(fields, "region", request.getRegion()); 648 serializer.putPathParam(fields, "resource", request.getResource()); 649 return fields; 650 }) 651 .setQueryParamsExtractor( 652 request -> { 653 Map<String, List<String>> fields = new HashMap<>(); 654 ProtoRestSerializer<TestIamPermissionsRegionDiskRequest> serializer = 655 ProtoRestSerializer.create(); 656 return fields; 657 }) 658 .setRequestBodyExtractor( 659 request -> 660 ProtoRestSerializer.create() 661 .toBody( 662 "testPermissionsRequestResource", 663 request.getTestPermissionsRequestResource(), 664 false)) 665 .build()) 666 .setResponseParser( 667 ProtoMessageResponseParser.<TestPermissionsResponse>newBuilder() 668 .setDefaultInstance(TestPermissionsResponse.getDefaultInstance()) 669 .setDefaultTypeRegistry(typeRegistry) 670 .build()) 671 .build(); 672 673 private static final ApiMethodDescriptor<UpdateRegionDiskRequest, Operation> 674 updateMethodDescriptor = 675 ApiMethodDescriptor.<UpdateRegionDiskRequest, Operation>newBuilder() 676 .setFullMethodName("google.cloud.compute.v1.RegionDisks/Update") 677 .setHttpMethod("PATCH") 678 .setType(ApiMethodDescriptor.MethodType.UNARY) 679 .setRequestFormatter( 680 ProtoMessageRequestFormatter.<UpdateRegionDiskRequest>newBuilder() 681 .setPath( 682 "/compute/v1/projects/{project}/regions/{region}/disks/{disk}", 683 request -> { 684 Map<String, String> fields = new HashMap<>(); 685 ProtoRestSerializer<UpdateRegionDiskRequest> serializer = 686 ProtoRestSerializer.create(); 687 serializer.putPathParam(fields, "disk", request.getDisk()); 688 serializer.putPathParam(fields, "project", request.getProject()); 689 serializer.putPathParam(fields, "region", request.getRegion()); 690 return fields; 691 }) 692 .setQueryParamsExtractor( 693 request -> { 694 Map<String, List<String>> fields = new HashMap<>(); 695 ProtoRestSerializer<UpdateRegionDiskRequest> serializer = 696 ProtoRestSerializer.create(); 697 if (request.hasPaths()) { 698 serializer.putQueryParam(fields, "paths", request.getPaths()); 699 } 700 if (request.hasRequestId()) { 701 serializer.putQueryParam(fields, "requestId", request.getRequestId()); 702 } 703 if (request.hasUpdateMask()) { 704 serializer.putQueryParam( 705 fields, "updateMask", request.getUpdateMask()); 706 } 707 return fields; 708 }) 709 .setRequestBodyExtractor( 710 request -> 711 ProtoRestSerializer.create() 712 .toBody("diskResource", request.getDiskResource(), false)) 713 .build()) 714 .setResponseParser( 715 ProtoMessageResponseParser.<Operation>newBuilder() 716 .setDefaultInstance(Operation.getDefaultInstance()) 717 .setDefaultTypeRegistry(typeRegistry) 718 .build()) 719 .setOperationSnapshotFactory( 720 (UpdateRegionDiskRequest request, Operation response) -> { 721 StringBuilder opName = new StringBuilder(response.getName()); 722 opName.append(":").append(request.getProject()); 723 opName.append(":").append(request.getRegion()); 724 return HttpJsonOperationSnapshot.newBuilder() 725 .setName(opName.toString()) 726 .setMetadata(response) 727 .setDone(Status.DONE.equals(response.getStatus())) 728 .setResponse(response) 729 .setError(response.getHttpErrorStatusCode(), response.getHttpErrorMessage()) 730 .build(); 731 }) 732 .build(); 733 734 private final UnaryCallable<AddResourcePoliciesRegionDiskRequest, Operation> 735 addResourcePoliciesCallable; 736 private final OperationCallable<AddResourcePoliciesRegionDiskRequest, Operation, Operation> 737 addResourcePoliciesOperationCallable; 738 private final UnaryCallable<CreateSnapshotRegionDiskRequest, Operation> createSnapshotCallable; 739 private final OperationCallable<CreateSnapshotRegionDiskRequest, Operation, Operation> 740 createSnapshotOperationCallable; 741 private final UnaryCallable<DeleteRegionDiskRequest, Operation> deleteCallable; 742 private final OperationCallable<DeleteRegionDiskRequest, Operation, Operation> 743 deleteOperationCallable; 744 private final UnaryCallable<GetRegionDiskRequest, Disk> getCallable; 745 private final UnaryCallable<GetIamPolicyRegionDiskRequest, Policy> getIamPolicyCallable; 746 private final UnaryCallable<InsertRegionDiskRequest, Operation> insertCallable; 747 private final OperationCallable<InsertRegionDiskRequest, Operation, Operation> 748 insertOperationCallable; 749 private final UnaryCallable<ListRegionDisksRequest, DiskList> listCallable; 750 private final UnaryCallable<ListRegionDisksRequest, ListPagedResponse> listPagedCallable; 751 private final UnaryCallable<RemoveResourcePoliciesRegionDiskRequest, Operation> 752 removeResourcePoliciesCallable; 753 private final OperationCallable<RemoveResourcePoliciesRegionDiskRequest, Operation, Operation> 754 removeResourcePoliciesOperationCallable; 755 private final UnaryCallable<ResizeRegionDiskRequest, Operation> resizeCallable; 756 private final OperationCallable<ResizeRegionDiskRequest, Operation, Operation> 757 resizeOperationCallable; 758 private final UnaryCallable<SetIamPolicyRegionDiskRequest, Policy> setIamPolicyCallable; 759 private final UnaryCallable<SetLabelsRegionDiskRequest, Operation> setLabelsCallable; 760 private final OperationCallable<SetLabelsRegionDiskRequest, Operation, Operation> 761 setLabelsOperationCallable; 762 private final UnaryCallable<TestIamPermissionsRegionDiskRequest, TestPermissionsResponse> 763 testIamPermissionsCallable; 764 private final UnaryCallable<UpdateRegionDiskRequest, Operation> updateCallable; 765 private final OperationCallable<UpdateRegionDiskRequest, Operation, Operation> 766 updateOperationCallable; 767 768 private final BackgroundResource backgroundResources; 769 private final HttpJsonRegionOperationsStub httpJsonOperationsStub; 770 private final HttpJsonStubCallableFactory callableFactory; 771 create(RegionDisksStubSettings settings)772 public static final HttpJsonRegionDisksStub create(RegionDisksStubSettings settings) 773 throws IOException { 774 return new HttpJsonRegionDisksStub(settings, ClientContext.create(settings)); 775 } 776 create(ClientContext clientContext)777 public static final HttpJsonRegionDisksStub create(ClientContext clientContext) 778 throws IOException { 779 return new HttpJsonRegionDisksStub(RegionDisksStubSettings.newBuilder().build(), clientContext); 780 } 781 create( ClientContext clientContext, HttpJsonStubCallableFactory callableFactory)782 public static final HttpJsonRegionDisksStub create( 783 ClientContext clientContext, HttpJsonStubCallableFactory callableFactory) throws IOException { 784 return new HttpJsonRegionDisksStub( 785 RegionDisksStubSettings.newBuilder().build(), clientContext, callableFactory); 786 } 787 788 /** 789 * Constructs an instance of HttpJsonRegionDisksStub, using the given settings. This is protected 790 * so that it is easy to make a subclass, but otherwise, the static factory methods should be 791 * preferred. 792 */ HttpJsonRegionDisksStub(RegionDisksStubSettings settings, ClientContext clientContext)793 protected HttpJsonRegionDisksStub(RegionDisksStubSettings settings, ClientContext clientContext) 794 throws IOException { 795 this(settings, clientContext, new HttpJsonRegionDisksCallableFactory()); 796 } 797 798 /** 799 * Constructs an instance of HttpJsonRegionDisksStub, using the given settings. This is protected 800 * so that it is easy to make a subclass, but otherwise, the static factory methods should be 801 * preferred. 802 */ HttpJsonRegionDisksStub( RegionDisksStubSettings settings, ClientContext clientContext, HttpJsonStubCallableFactory callableFactory)803 protected HttpJsonRegionDisksStub( 804 RegionDisksStubSettings settings, 805 ClientContext clientContext, 806 HttpJsonStubCallableFactory callableFactory) 807 throws IOException { 808 this.callableFactory = callableFactory; 809 this.httpJsonOperationsStub = 810 HttpJsonRegionOperationsStub.create(clientContext, callableFactory); 811 812 HttpJsonCallSettings<AddResourcePoliciesRegionDiskRequest, Operation> 813 addResourcePoliciesTransportSettings = 814 HttpJsonCallSettings.<AddResourcePoliciesRegionDiskRequest, Operation>newBuilder() 815 .setMethodDescriptor(addResourcePoliciesMethodDescriptor) 816 .setTypeRegistry(typeRegistry) 817 .build(); 818 HttpJsonCallSettings<CreateSnapshotRegionDiskRequest, Operation> 819 createSnapshotTransportSettings = 820 HttpJsonCallSettings.<CreateSnapshotRegionDiskRequest, Operation>newBuilder() 821 .setMethodDescriptor(createSnapshotMethodDescriptor) 822 .setTypeRegistry(typeRegistry) 823 .build(); 824 HttpJsonCallSettings<DeleteRegionDiskRequest, Operation> deleteTransportSettings = 825 HttpJsonCallSettings.<DeleteRegionDiskRequest, Operation>newBuilder() 826 .setMethodDescriptor(deleteMethodDescriptor) 827 .setTypeRegistry(typeRegistry) 828 .build(); 829 HttpJsonCallSettings<GetRegionDiskRequest, Disk> getTransportSettings = 830 HttpJsonCallSettings.<GetRegionDiskRequest, Disk>newBuilder() 831 .setMethodDescriptor(getMethodDescriptor) 832 .setTypeRegistry(typeRegistry) 833 .build(); 834 HttpJsonCallSettings<GetIamPolicyRegionDiskRequest, Policy> getIamPolicyTransportSettings = 835 HttpJsonCallSettings.<GetIamPolicyRegionDiskRequest, Policy>newBuilder() 836 .setMethodDescriptor(getIamPolicyMethodDescriptor) 837 .setTypeRegistry(typeRegistry) 838 .build(); 839 HttpJsonCallSettings<InsertRegionDiskRequest, Operation> insertTransportSettings = 840 HttpJsonCallSettings.<InsertRegionDiskRequest, Operation>newBuilder() 841 .setMethodDescriptor(insertMethodDescriptor) 842 .setTypeRegistry(typeRegistry) 843 .build(); 844 HttpJsonCallSettings<ListRegionDisksRequest, DiskList> listTransportSettings = 845 HttpJsonCallSettings.<ListRegionDisksRequest, DiskList>newBuilder() 846 .setMethodDescriptor(listMethodDescriptor) 847 .setTypeRegistry(typeRegistry) 848 .build(); 849 HttpJsonCallSettings<RemoveResourcePoliciesRegionDiskRequest, Operation> 850 removeResourcePoliciesTransportSettings = 851 HttpJsonCallSettings.<RemoveResourcePoliciesRegionDiskRequest, Operation>newBuilder() 852 .setMethodDescriptor(removeResourcePoliciesMethodDescriptor) 853 .setTypeRegistry(typeRegistry) 854 .build(); 855 HttpJsonCallSettings<ResizeRegionDiskRequest, Operation> resizeTransportSettings = 856 HttpJsonCallSettings.<ResizeRegionDiskRequest, Operation>newBuilder() 857 .setMethodDescriptor(resizeMethodDescriptor) 858 .setTypeRegistry(typeRegistry) 859 .build(); 860 HttpJsonCallSettings<SetIamPolicyRegionDiskRequest, Policy> setIamPolicyTransportSettings = 861 HttpJsonCallSettings.<SetIamPolicyRegionDiskRequest, Policy>newBuilder() 862 .setMethodDescriptor(setIamPolicyMethodDescriptor) 863 .setTypeRegistry(typeRegistry) 864 .build(); 865 HttpJsonCallSettings<SetLabelsRegionDiskRequest, Operation> setLabelsTransportSettings = 866 HttpJsonCallSettings.<SetLabelsRegionDiskRequest, Operation>newBuilder() 867 .setMethodDescriptor(setLabelsMethodDescriptor) 868 .setTypeRegistry(typeRegistry) 869 .build(); 870 HttpJsonCallSettings<TestIamPermissionsRegionDiskRequest, TestPermissionsResponse> 871 testIamPermissionsTransportSettings = 872 HttpJsonCallSettings 873 .<TestIamPermissionsRegionDiskRequest, TestPermissionsResponse>newBuilder() 874 .setMethodDescriptor(testIamPermissionsMethodDescriptor) 875 .setTypeRegistry(typeRegistry) 876 .build(); 877 HttpJsonCallSettings<UpdateRegionDiskRequest, Operation> updateTransportSettings = 878 HttpJsonCallSettings.<UpdateRegionDiskRequest, Operation>newBuilder() 879 .setMethodDescriptor(updateMethodDescriptor) 880 .setTypeRegistry(typeRegistry) 881 .build(); 882 883 this.addResourcePoliciesCallable = 884 callableFactory.createUnaryCallable( 885 addResourcePoliciesTransportSettings, 886 settings.addResourcePoliciesSettings(), 887 clientContext); 888 this.addResourcePoliciesOperationCallable = 889 callableFactory.createOperationCallable( 890 addResourcePoliciesTransportSettings, 891 settings.addResourcePoliciesOperationSettings(), 892 clientContext, 893 httpJsonOperationsStub); 894 this.createSnapshotCallable = 895 callableFactory.createUnaryCallable( 896 createSnapshotTransportSettings, settings.createSnapshotSettings(), clientContext); 897 this.createSnapshotOperationCallable = 898 callableFactory.createOperationCallable( 899 createSnapshotTransportSettings, 900 settings.createSnapshotOperationSettings(), 901 clientContext, 902 httpJsonOperationsStub); 903 this.deleteCallable = 904 callableFactory.createUnaryCallable( 905 deleteTransportSettings, settings.deleteSettings(), clientContext); 906 this.deleteOperationCallable = 907 callableFactory.createOperationCallable( 908 deleteTransportSettings, 909 settings.deleteOperationSettings(), 910 clientContext, 911 httpJsonOperationsStub); 912 this.getCallable = 913 callableFactory.createUnaryCallable( 914 getTransportSettings, settings.getSettings(), clientContext); 915 this.getIamPolicyCallable = 916 callableFactory.createUnaryCallable( 917 getIamPolicyTransportSettings, settings.getIamPolicySettings(), clientContext); 918 this.insertCallable = 919 callableFactory.createUnaryCallable( 920 insertTransportSettings, settings.insertSettings(), clientContext); 921 this.insertOperationCallable = 922 callableFactory.createOperationCallable( 923 insertTransportSettings, 924 settings.insertOperationSettings(), 925 clientContext, 926 httpJsonOperationsStub); 927 this.listCallable = 928 callableFactory.createUnaryCallable( 929 listTransportSettings, settings.listSettings(), clientContext); 930 this.listPagedCallable = 931 callableFactory.createPagedCallable( 932 listTransportSettings, settings.listSettings(), clientContext); 933 this.removeResourcePoliciesCallable = 934 callableFactory.createUnaryCallable( 935 removeResourcePoliciesTransportSettings, 936 settings.removeResourcePoliciesSettings(), 937 clientContext); 938 this.removeResourcePoliciesOperationCallable = 939 callableFactory.createOperationCallable( 940 removeResourcePoliciesTransportSettings, 941 settings.removeResourcePoliciesOperationSettings(), 942 clientContext, 943 httpJsonOperationsStub); 944 this.resizeCallable = 945 callableFactory.createUnaryCallable( 946 resizeTransportSettings, settings.resizeSettings(), clientContext); 947 this.resizeOperationCallable = 948 callableFactory.createOperationCallable( 949 resizeTransportSettings, 950 settings.resizeOperationSettings(), 951 clientContext, 952 httpJsonOperationsStub); 953 this.setIamPolicyCallable = 954 callableFactory.createUnaryCallable( 955 setIamPolicyTransportSettings, settings.setIamPolicySettings(), clientContext); 956 this.setLabelsCallable = 957 callableFactory.createUnaryCallable( 958 setLabelsTransportSettings, settings.setLabelsSettings(), clientContext); 959 this.setLabelsOperationCallable = 960 callableFactory.createOperationCallable( 961 setLabelsTransportSettings, 962 settings.setLabelsOperationSettings(), 963 clientContext, 964 httpJsonOperationsStub); 965 this.testIamPermissionsCallable = 966 callableFactory.createUnaryCallable( 967 testIamPermissionsTransportSettings, 968 settings.testIamPermissionsSettings(), 969 clientContext); 970 this.updateCallable = 971 callableFactory.createUnaryCallable( 972 updateTransportSettings, settings.updateSettings(), clientContext); 973 this.updateOperationCallable = 974 callableFactory.createOperationCallable( 975 updateTransportSettings, 976 settings.updateOperationSettings(), 977 clientContext, 978 httpJsonOperationsStub); 979 980 this.backgroundResources = 981 new BackgroundResourceAggregation(clientContext.getBackgroundResources()); 982 } 983 984 @InternalApi getMethodDescriptors()985 public static List<ApiMethodDescriptor> getMethodDescriptors() { 986 List<ApiMethodDescriptor> methodDescriptors = new ArrayList<>(); 987 methodDescriptors.add(addResourcePoliciesMethodDescriptor); 988 methodDescriptors.add(createSnapshotMethodDescriptor); 989 methodDescriptors.add(deleteMethodDescriptor); 990 methodDescriptors.add(getMethodDescriptor); 991 methodDescriptors.add(getIamPolicyMethodDescriptor); 992 methodDescriptors.add(insertMethodDescriptor); 993 methodDescriptors.add(listMethodDescriptor); 994 methodDescriptors.add(removeResourcePoliciesMethodDescriptor); 995 methodDescriptors.add(resizeMethodDescriptor); 996 methodDescriptors.add(setIamPolicyMethodDescriptor); 997 methodDescriptors.add(setLabelsMethodDescriptor); 998 methodDescriptors.add(testIamPermissionsMethodDescriptor); 999 methodDescriptors.add(updateMethodDescriptor); 1000 return methodDescriptors; 1001 } 1002 1003 @Override 1004 public UnaryCallable<AddResourcePoliciesRegionDiskRequest, Operation> addResourcePoliciesCallable()1005 addResourcePoliciesCallable() { 1006 return addResourcePoliciesCallable; 1007 } 1008 1009 @Override 1010 public OperationCallable<AddResourcePoliciesRegionDiskRequest, Operation, Operation> addResourcePoliciesOperationCallable()1011 addResourcePoliciesOperationCallable() { 1012 return addResourcePoliciesOperationCallable; 1013 } 1014 1015 @Override createSnapshotCallable()1016 public UnaryCallable<CreateSnapshotRegionDiskRequest, Operation> createSnapshotCallable() { 1017 return createSnapshotCallable; 1018 } 1019 1020 @Override 1021 public OperationCallable<CreateSnapshotRegionDiskRequest, Operation, Operation> createSnapshotOperationCallable()1022 createSnapshotOperationCallable() { 1023 return createSnapshotOperationCallable; 1024 } 1025 1026 @Override deleteCallable()1027 public UnaryCallable<DeleteRegionDiskRequest, Operation> deleteCallable() { 1028 return deleteCallable; 1029 } 1030 1031 @Override 1032 public OperationCallable<DeleteRegionDiskRequest, Operation, Operation> deleteOperationCallable()1033 deleteOperationCallable() { 1034 return deleteOperationCallable; 1035 } 1036 1037 @Override getCallable()1038 public UnaryCallable<GetRegionDiskRequest, Disk> getCallable() { 1039 return getCallable; 1040 } 1041 1042 @Override getIamPolicyCallable()1043 public UnaryCallable<GetIamPolicyRegionDiskRequest, Policy> getIamPolicyCallable() { 1044 return getIamPolicyCallable; 1045 } 1046 1047 @Override insertCallable()1048 public UnaryCallable<InsertRegionDiskRequest, Operation> insertCallable() { 1049 return insertCallable; 1050 } 1051 1052 @Override 1053 public OperationCallable<InsertRegionDiskRequest, Operation, Operation> insertOperationCallable()1054 insertOperationCallable() { 1055 return insertOperationCallable; 1056 } 1057 1058 @Override listCallable()1059 public UnaryCallable<ListRegionDisksRequest, DiskList> listCallable() { 1060 return listCallable; 1061 } 1062 1063 @Override listPagedCallable()1064 public UnaryCallable<ListRegionDisksRequest, ListPagedResponse> listPagedCallable() { 1065 return listPagedCallable; 1066 } 1067 1068 @Override 1069 public UnaryCallable<RemoveResourcePoliciesRegionDiskRequest, Operation> removeResourcePoliciesCallable()1070 removeResourcePoliciesCallable() { 1071 return removeResourcePoliciesCallable; 1072 } 1073 1074 @Override 1075 public OperationCallable<RemoveResourcePoliciesRegionDiskRequest, Operation, Operation> removeResourcePoliciesOperationCallable()1076 removeResourcePoliciesOperationCallable() { 1077 return removeResourcePoliciesOperationCallable; 1078 } 1079 1080 @Override resizeCallable()1081 public UnaryCallable<ResizeRegionDiskRequest, Operation> resizeCallable() { 1082 return resizeCallable; 1083 } 1084 1085 @Override 1086 public OperationCallable<ResizeRegionDiskRequest, Operation, Operation> resizeOperationCallable()1087 resizeOperationCallable() { 1088 return resizeOperationCallable; 1089 } 1090 1091 @Override setIamPolicyCallable()1092 public UnaryCallable<SetIamPolicyRegionDiskRequest, Policy> setIamPolicyCallable() { 1093 return setIamPolicyCallable; 1094 } 1095 1096 @Override setLabelsCallable()1097 public UnaryCallable<SetLabelsRegionDiskRequest, Operation> setLabelsCallable() { 1098 return setLabelsCallable; 1099 } 1100 1101 @Override 1102 public OperationCallable<SetLabelsRegionDiskRequest, Operation, Operation> setLabelsOperationCallable()1103 setLabelsOperationCallable() { 1104 return setLabelsOperationCallable; 1105 } 1106 1107 @Override 1108 public UnaryCallable<TestIamPermissionsRegionDiskRequest, TestPermissionsResponse> testIamPermissionsCallable()1109 testIamPermissionsCallable() { 1110 return testIamPermissionsCallable; 1111 } 1112 1113 @Override updateCallable()1114 public UnaryCallable<UpdateRegionDiskRequest, Operation> updateCallable() { 1115 return updateCallable; 1116 } 1117 1118 @Override 1119 public OperationCallable<UpdateRegionDiskRequest, Operation, Operation> updateOperationCallable()1120 updateOperationCallable() { 1121 return updateOperationCallable; 1122 } 1123 1124 @Override close()1125 public final void close() { 1126 try { 1127 backgroundResources.close(); 1128 } catch (RuntimeException e) { 1129 throw e; 1130 } catch (Exception e) { 1131 throw new IllegalStateException("Failed to close resource", e); 1132 } 1133 } 1134 1135 @Override shutdown()1136 public void shutdown() { 1137 backgroundResources.shutdown(); 1138 } 1139 1140 @Override isShutdown()1141 public boolean isShutdown() { 1142 return backgroundResources.isShutdown(); 1143 } 1144 1145 @Override isTerminated()1146 public boolean isTerminated() { 1147 return backgroundResources.isTerminated(); 1148 } 1149 1150 @Override shutdownNow()1151 public void shutdownNow() { 1152 backgroundResources.shutdownNow(); 1153 } 1154 1155 @Override awaitTermination(long duration, TimeUnit unit)1156 public boolean awaitTermination(long duration, TimeUnit unit) throws InterruptedException { 1157 return backgroundResources.awaitTermination(duration, unit); 1158 } 1159 } 1160