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