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