• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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.tasks.v2.stub;
18 
19 import static com.google.cloud.tasks.v2.CloudTasksClient.ListQueuesPagedResponse;
20 import static com.google.cloud.tasks.v2.CloudTasksClient.ListTasksPagedResponse;
21 
22 import com.google.api.gax.core.BackgroundResource;
23 import com.google.api.gax.core.BackgroundResourceAggregation;
24 import com.google.api.gax.grpc.GrpcCallSettings;
25 import com.google.api.gax.grpc.GrpcStubCallableFactory;
26 import com.google.api.gax.rpc.ClientContext;
27 import com.google.api.gax.rpc.UnaryCallable;
28 import com.google.cloud.tasks.v2.CreateQueueRequest;
29 import com.google.cloud.tasks.v2.CreateTaskRequest;
30 import com.google.cloud.tasks.v2.DeleteQueueRequest;
31 import com.google.cloud.tasks.v2.DeleteTaskRequest;
32 import com.google.cloud.tasks.v2.GetQueueRequest;
33 import com.google.cloud.tasks.v2.GetTaskRequest;
34 import com.google.cloud.tasks.v2.ListQueuesRequest;
35 import com.google.cloud.tasks.v2.ListQueuesResponse;
36 import com.google.cloud.tasks.v2.ListTasksRequest;
37 import com.google.cloud.tasks.v2.ListTasksResponse;
38 import com.google.cloud.tasks.v2.PauseQueueRequest;
39 import com.google.cloud.tasks.v2.PurgeQueueRequest;
40 import com.google.cloud.tasks.v2.Queue;
41 import com.google.cloud.tasks.v2.ResumeQueueRequest;
42 import com.google.cloud.tasks.v2.RunTaskRequest;
43 import com.google.cloud.tasks.v2.Task;
44 import com.google.cloud.tasks.v2.UpdateQueueRequest;
45 import com.google.common.collect.ImmutableMap;
46 import com.google.iam.v1.GetIamPolicyRequest;
47 import com.google.iam.v1.Policy;
48 import com.google.iam.v1.SetIamPolicyRequest;
49 import com.google.iam.v1.TestIamPermissionsRequest;
50 import com.google.iam.v1.TestIamPermissionsResponse;
51 import com.google.longrunning.stub.GrpcOperationsStub;
52 import com.google.protobuf.Empty;
53 import io.grpc.MethodDescriptor;
54 import io.grpc.protobuf.ProtoUtils;
55 import java.io.IOException;
56 import java.util.concurrent.TimeUnit;
57 import javax.annotation.Generated;
58 
59 // AUTO-GENERATED DOCUMENTATION AND CLASS.
60 /**
61  * gRPC stub implementation for the CloudTasks service API.
62  *
63  * <p>This class is for advanced usage and reflects the underlying API directly.
64  */
65 @Generated("by gapic-generator-java")
66 public class GrpcCloudTasksStub extends CloudTasksStub {
67   private static final MethodDescriptor<ListQueuesRequest, ListQueuesResponse>
68       listQueuesMethodDescriptor =
69           MethodDescriptor.<ListQueuesRequest, ListQueuesResponse>newBuilder()
70               .setType(MethodDescriptor.MethodType.UNARY)
71               .setFullMethodName("google.cloud.tasks.v2.CloudTasks/ListQueues")
72               .setRequestMarshaller(ProtoUtils.marshaller(ListQueuesRequest.getDefaultInstance()))
73               .setResponseMarshaller(ProtoUtils.marshaller(ListQueuesResponse.getDefaultInstance()))
74               .build();
75 
76   private static final MethodDescriptor<GetQueueRequest, Queue> getQueueMethodDescriptor =
77       MethodDescriptor.<GetQueueRequest, Queue>newBuilder()
78           .setType(MethodDescriptor.MethodType.UNARY)
79           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/GetQueue")
80           .setRequestMarshaller(ProtoUtils.marshaller(GetQueueRequest.getDefaultInstance()))
81           .setResponseMarshaller(ProtoUtils.marshaller(Queue.getDefaultInstance()))
82           .build();
83 
84   private static final MethodDescriptor<CreateQueueRequest, Queue> createQueueMethodDescriptor =
85       MethodDescriptor.<CreateQueueRequest, Queue>newBuilder()
86           .setType(MethodDescriptor.MethodType.UNARY)
87           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/CreateQueue")
88           .setRequestMarshaller(ProtoUtils.marshaller(CreateQueueRequest.getDefaultInstance()))
89           .setResponseMarshaller(ProtoUtils.marshaller(Queue.getDefaultInstance()))
90           .build();
91 
92   private static final MethodDescriptor<UpdateQueueRequest, Queue> updateQueueMethodDescriptor =
93       MethodDescriptor.<UpdateQueueRequest, Queue>newBuilder()
94           .setType(MethodDescriptor.MethodType.UNARY)
95           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/UpdateQueue")
96           .setRequestMarshaller(ProtoUtils.marshaller(UpdateQueueRequest.getDefaultInstance()))
97           .setResponseMarshaller(ProtoUtils.marshaller(Queue.getDefaultInstance()))
98           .build();
99 
100   private static final MethodDescriptor<DeleteQueueRequest, Empty> deleteQueueMethodDescriptor =
101       MethodDescriptor.<DeleteQueueRequest, Empty>newBuilder()
102           .setType(MethodDescriptor.MethodType.UNARY)
103           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/DeleteQueue")
104           .setRequestMarshaller(ProtoUtils.marshaller(DeleteQueueRequest.getDefaultInstance()))
105           .setResponseMarshaller(ProtoUtils.marshaller(Empty.getDefaultInstance()))
106           .build();
107 
108   private static final MethodDescriptor<PurgeQueueRequest, Queue> purgeQueueMethodDescriptor =
109       MethodDescriptor.<PurgeQueueRequest, Queue>newBuilder()
110           .setType(MethodDescriptor.MethodType.UNARY)
111           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/PurgeQueue")
112           .setRequestMarshaller(ProtoUtils.marshaller(PurgeQueueRequest.getDefaultInstance()))
113           .setResponseMarshaller(ProtoUtils.marshaller(Queue.getDefaultInstance()))
114           .build();
115 
116   private static final MethodDescriptor<PauseQueueRequest, Queue> pauseQueueMethodDescriptor =
117       MethodDescriptor.<PauseQueueRequest, Queue>newBuilder()
118           .setType(MethodDescriptor.MethodType.UNARY)
119           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/PauseQueue")
120           .setRequestMarshaller(ProtoUtils.marshaller(PauseQueueRequest.getDefaultInstance()))
121           .setResponseMarshaller(ProtoUtils.marshaller(Queue.getDefaultInstance()))
122           .build();
123 
124   private static final MethodDescriptor<ResumeQueueRequest, Queue> resumeQueueMethodDescriptor =
125       MethodDescriptor.<ResumeQueueRequest, Queue>newBuilder()
126           .setType(MethodDescriptor.MethodType.UNARY)
127           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/ResumeQueue")
128           .setRequestMarshaller(ProtoUtils.marshaller(ResumeQueueRequest.getDefaultInstance()))
129           .setResponseMarshaller(ProtoUtils.marshaller(Queue.getDefaultInstance()))
130           .build();
131 
132   private static final MethodDescriptor<GetIamPolicyRequest, Policy> getIamPolicyMethodDescriptor =
133       MethodDescriptor.<GetIamPolicyRequest, Policy>newBuilder()
134           .setType(MethodDescriptor.MethodType.UNARY)
135           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/GetIamPolicy")
136           .setRequestMarshaller(ProtoUtils.marshaller(GetIamPolicyRequest.getDefaultInstance()))
137           .setResponseMarshaller(ProtoUtils.marshaller(Policy.getDefaultInstance()))
138           .build();
139 
140   private static final MethodDescriptor<SetIamPolicyRequest, Policy> setIamPolicyMethodDescriptor =
141       MethodDescriptor.<SetIamPolicyRequest, Policy>newBuilder()
142           .setType(MethodDescriptor.MethodType.UNARY)
143           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/SetIamPolicy")
144           .setRequestMarshaller(ProtoUtils.marshaller(SetIamPolicyRequest.getDefaultInstance()))
145           .setResponseMarshaller(ProtoUtils.marshaller(Policy.getDefaultInstance()))
146           .build();
147 
148   private static final MethodDescriptor<TestIamPermissionsRequest, TestIamPermissionsResponse>
149       testIamPermissionsMethodDescriptor =
150           MethodDescriptor.<TestIamPermissionsRequest, TestIamPermissionsResponse>newBuilder()
151               .setType(MethodDescriptor.MethodType.UNARY)
152               .setFullMethodName("google.cloud.tasks.v2.CloudTasks/TestIamPermissions")
153               .setRequestMarshaller(
154                   ProtoUtils.marshaller(TestIamPermissionsRequest.getDefaultInstance()))
155               .setResponseMarshaller(
156                   ProtoUtils.marshaller(TestIamPermissionsResponse.getDefaultInstance()))
157               .build();
158 
159   private static final MethodDescriptor<ListTasksRequest, ListTasksResponse>
160       listTasksMethodDescriptor =
161           MethodDescriptor.<ListTasksRequest, ListTasksResponse>newBuilder()
162               .setType(MethodDescriptor.MethodType.UNARY)
163               .setFullMethodName("google.cloud.tasks.v2.CloudTasks/ListTasks")
164               .setRequestMarshaller(ProtoUtils.marshaller(ListTasksRequest.getDefaultInstance()))
165               .setResponseMarshaller(ProtoUtils.marshaller(ListTasksResponse.getDefaultInstance()))
166               .build();
167 
168   private static final MethodDescriptor<GetTaskRequest, Task> getTaskMethodDescriptor =
169       MethodDescriptor.<GetTaskRequest, Task>newBuilder()
170           .setType(MethodDescriptor.MethodType.UNARY)
171           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/GetTask")
172           .setRequestMarshaller(ProtoUtils.marshaller(GetTaskRequest.getDefaultInstance()))
173           .setResponseMarshaller(ProtoUtils.marshaller(Task.getDefaultInstance()))
174           .build();
175 
176   private static final MethodDescriptor<CreateTaskRequest, Task> createTaskMethodDescriptor =
177       MethodDescriptor.<CreateTaskRequest, Task>newBuilder()
178           .setType(MethodDescriptor.MethodType.UNARY)
179           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/CreateTask")
180           .setRequestMarshaller(ProtoUtils.marshaller(CreateTaskRequest.getDefaultInstance()))
181           .setResponseMarshaller(ProtoUtils.marshaller(Task.getDefaultInstance()))
182           .build();
183 
184   private static final MethodDescriptor<DeleteTaskRequest, Empty> deleteTaskMethodDescriptor =
185       MethodDescriptor.<DeleteTaskRequest, Empty>newBuilder()
186           .setType(MethodDescriptor.MethodType.UNARY)
187           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/DeleteTask")
188           .setRequestMarshaller(ProtoUtils.marshaller(DeleteTaskRequest.getDefaultInstance()))
189           .setResponseMarshaller(ProtoUtils.marshaller(Empty.getDefaultInstance()))
190           .build();
191 
192   private static final MethodDescriptor<RunTaskRequest, Task> runTaskMethodDescriptor =
193       MethodDescriptor.<RunTaskRequest, Task>newBuilder()
194           .setType(MethodDescriptor.MethodType.UNARY)
195           .setFullMethodName("google.cloud.tasks.v2.CloudTasks/RunTask")
196           .setRequestMarshaller(ProtoUtils.marshaller(RunTaskRequest.getDefaultInstance()))
197           .setResponseMarshaller(ProtoUtils.marshaller(Task.getDefaultInstance()))
198           .build();
199 
200   private final UnaryCallable<ListQueuesRequest, ListQueuesResponse> listQueuesCallable;
201   private final UnaryCallable<ListQueuesRequest, ListQueuesPagedResponse> listQueuesPagedCallable;
202   private final UnaryCallable<GetQueueRequest, Queue> getQueueCallable;
203   private final UnaryCallable<CreateQueueRequest, Queue> createQueueCallable;
204   private final UnaryCallable<UpdateQueueRequest, Queue> updateQueueCallable;
205   private final UnaryCallable<DeleteQueueRequest, Empty> deleteQueueCallable;
206   private final UnaryCallable<PurgeQueueRequest, Queue> purgeQueueCallable;
207   private final UnaryCallable<PauseQueueRequest, Queue> pauseQueueCallable;
208   private final UnaryCallable<ResumeQueueRequest, Queue> resumeQueueCallable;
209   private final UnaryCallable<GetIamPolicyRequest, Policy> getIamPolicyCallable;
210   private final UnaryCallable<SetIamPolicyRequest, Policy> setIamPolicyCallable;
211   private final UnaryCallable<TestIamPermissionsRequest, TestIamPermissionsResponse>
212       testIamPermissionsCallable;
213   private final UnaryCallable<ListTasksRequest, ListTasksResponse> listTasksCallable;
214   private final UnaryCallable<ListTasksRequest, ListTasksPagedResponse> listTasksPagedCallable;
215   private final UnaryCallable<GetTaskRequest, Task> getTaskCallable;
216   private final UnaryCallable<CreateTaskRequest, Task> createTaskCallable;
217   private final UnaryCallable<DeleteTaskRequest, Empty> deleteTaskCallable;
218   private final UnaryCallable<RunTaskRequest, Task> runTaskCallable;
219 
220   private final BackgroundResource backgroundResources;
221   private final GrpcOperationsStub operationsStub;
222   private final GrpcStubCallableFactory callableFactory;
223 
create(CloudTasksStubSettings settings)224   public static final GrpcCloudTasksStub create(CloudTasksStubSettings settings)
225       throws IOException {
226     return new GrpcCloudTasksStub(settings, ClientContext.create(settings));
227   }
228 
create(ClientContext clientContext)229   public static final GrpcCloudTasksStub create(ClientContext clientContext) throws IOException {
230     return new GrpcCloudTasksStub(CloudTasksStubSettings.newBuilder().build(), clientContext);
231   }
232 
create( ClientContext clientContext, GrpcStubCallableFactory callableFactory)233   public static final GrpcCloudTasksStub create(
234       ClientContext clientContext, GrpcStubCallableFactory callableFactory) throws IOException {
235     return new GrpcCloudTasksStub(
236         CloudTasksStubSettings.newBuilder().build(), clientContext, callableFactory);
237   }
238 
239   /**
240    * Constructs an instance of GrpcCloudTasksStub, using the given settings. This is protected so
241    * that it is easy to make a subclass, but otherwise, the static factory methods should be
242    * preferred.
243    */
GrpcCloudTasksStub(CloudTasksStubSettings settings, ClientContext clientContext)244   protected GrpcCloudTasksStub(CloudTasksStubSettings settings, ClientContext clientContext)
245       throws IOException {
246     this(settings, clientContext, new GrpcCloudTasksCallableFactory());
247   }
248 
249   /**
250    * Constructs an instance of GrpcCloudTasksStub, using the given settings. This is protected so
251    * that it is easy to make a subclass, but otherwise, the static factory methods should be
252    * preferred.
253    */
GrpcCloudTasksStub( CloudTasksStubSettings settings, ClientContext clientContext, GrpcStubCallableFactory callableFactory)254   protected GrpcCloudTasksStub(
255       CloudTasksStubSettings settings,
256       ClientContext clientContext,
257       GrpcStubCallableFactory callableFactory)
258       throws IOException {
259     this.callableFactory = callableFactory;
260     this.operationsStub = GrpcOperationsStub.create(clientContext, callableFactory);
261 
262     GrpcCallSettings<ListQueuesRequest, ListQueuesResponse> listQueuesTransportSettings =
263         GrpcCallSettings.<ListQueuesRequest, ListQueuesResponse>newBuilder()
264             .setMethodDescriptor(listQueuesMethodDescriptor)
265             .setParamsExtractor(
266                 request -> {
267                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
268                   params.put("parent", String.valueOf(request.getParent()));
269                   return params.build();
270                 })
271             .build();
272     GrpcCallSettings<GetQueueRequest, Queue> getQueueTransportSettings =
273         GrpcCallSettings.<GetQueueRequest, Queue>newBuilder()
274             .setMethodDescriptor(getQueueMethodDescriptor)
275             .setParamsExtractor(
276                 request -> {
277                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
278                   params.put("name", String.valueOf(request.getName()));
279                   return params.build();
280                 })
281             .build();
282     GrpcCallSettings<CreateQueueRequest, Queue> createQueueTransportSettings =
283         GrpcCallSettings.<CreateQueueRequest, Queue>newBuilder()
284             .setMethodDescriptor(createQueueMethodDescriptor)
285             .setParamsExtractor(
286                 request -> {
287                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
288                   params.put("parent", String.valueOf(request.getParent()));
289                   return params.build();
290                 })
291             .build();
292     GrpcCallSettings<UpdateQueueRequest, Queue> updateQueueTransportSettings =
293         GrpcCallSettings.<UpdateQueueRequest, Queue>newBuilder()
294             .setMethodDescriptor(updateQueueMethodDescriptor)
295             .setParamsExtractor(
296                 request -> {
297                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
298                   params.put("queue.name", String.valueOf(request.getQueue().getName()));
299                   return params.build();
300                 })
301             .build();
302     GrpcCallSettings<DeleteQueueRequest, Empty> deleteQueueTransportSettings =
303         GrpcCallSettings.<DeleteQueueRequest, Empty>newBuilder()
304             .setMethodDescriptor(deleteQueueMethodDescriptor)
305             .setParamsExtractor(
306                 request -> {
307                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
308                   params.put("name", String.valueOf(request.getName()));
309                   return params.build();
310                 })
311             .build();
312     GrpcCallSettings<PurgeQueueRequest, Queue> purgeQueueTransportSettings =
313         GrpcCallSettings.<PurgeQueueRequest, Queue>newBuilder()
314             .setMethodDescriptor(purgeQueueMethodDescriptor)
315             .setParamsExtractor(
316                 request -> {
317                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
318                   params.put("name", String.valueOf(request.getName()));
319                   return params.build();
320                 })
321             .build();
322     GrpcCallSettings<PauseQueueRequest, Queue> pauseQueueTransportSettings =
323         GrpcCallSettings.<PauseQueueRequest, Queue>newBuilder()
324             .setMethodDescriptor(pauseQueueMethodDescriptor)
325             .setParamsExtractor(
326                 request -> {
327                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
328                   params.put("name", String.valueOf(request.getName()));
329                   return params.build();
330                 })
331             .build();
332     GrpcCallSettings<ResumeQueueRequest, Queue> resumeQueueTransportSettings =
333         GrpcCallSettings.<ResumeQueueRequest, Queue>newBuilder()
334             .setMethodDescriptor(resumeQueueMethodDescriptor)
335             .setParamsExtractor(
336                 request -> {
337                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
338                   params.put("name", String.valueOf(request.getName()));
339                   return params.build();
340                 })
341             .build();
342     GrpcCallSettings<GetIamPolicyRequest, Policy> getIamPolicyTransportSettings =
343         GrpcCallSettings.<GetIamPolicyRequest, Policy>newBuilder()
344             .setMethodDescriptor(getIamPolicyMethodDescriptor)
345             .setParamsExtractor(
346                 request -> {
347                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
348                   params.put("resource", String.valueOf(request.getResource()));
349                   return params.build();
350                 })
351             .build();
352     GrpcCallSettings<SetIamPolicyRequest, Policy> setIamPolicyTransportSettings =
353         GrpcCallSettings.<SetIamPolicyRequest, Policy>newBuilder()
354             .setMethodDescriptor(setIamPolicyMethodDescriptor)
355             .setParamsExtractor(
356                 request -> {
357                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
358                   params.put("resource", String.valueOf(request.getResource()));
359                   return params.build();
360                 })
361             .build();
362     GrpcCallSettings<TestIamPermissionsRequest, TestIamPermissionsResponse>
363         testIamPermissionsTransportSettings =
364             GrpcCallSettings.<TestIamPermissionsRequest, TestIamPermissionsResponse>newBuilder()
365                 .setMethodDescriptor(testIamPermissionsMethodDescriptor)
366                 .setParamsExtractor(
367                     request -> {
368                       ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
369                       params.put("resource", String.valueOf(request.getResource()));
370                       return params.build();
371                     })
372                 .build();
373     GrpcCallSettings<ListTasksRequest, ListTasksResponse> listTasksTransportSettings =
374         GrpcCallSettings.<ListTasksRequest, ListTasksResponse>newBuilder()
375             .setMethodDescriptor(listTasksMethodDescriptor)
376             .setParamsExtractor(
377                 request -> {
378                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
379                   params.put("parent", String.valueOf(request.getParent()));
380                   return params.build();
381                 })
382             .build();
383     GrpcCallSettings<GetTaskRequest, Task> getTaskTransportSettings =
384         GrpcCallSettings.<GetTaskRequest, Task>newBuilder()
385             .setMethodDescriptor(getTaskMethodDescriptor)
386             .setParamsExtractor(
387                 request -> {
388                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
389                   params.put("name", String.valueOf(request.getName()));
390                   return params.build();
391                 })
392             .build();
393     GrpcCallSettings<CreateTaskRequest, Task> createTaskTransportSettings =
394         GrpcCallSettings.<CreateTaskRequest, Task>newBuilder()
395             .setMethodDescriptor(createTaskMethodDescriptor)
396             .setParamsExtractor(
397                 request -> {
398                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
399                   params.put("parent", String.valueOf(request.getParent()));
400                   return params.build();
401                 })
402             .build();
403     GrpcCallSettings<DeleteTaskRequest, Empty> deleteTaskTransportSettings =
404         GrpcCallSettings.<DeleteTaskRequest, Empty>newBuilder()
405             .setMethodDescriptor(deleteTaskMethodDescriptor)
406             .setParamsExtractor(
407                 request -> {
408                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
409                   params.put("name", String.valueOf(request.getName()));
410                   return params.build();
411                 })
412             .build();
413     GrpcCallSettings<RunTaskRequest, Task> runTaskTransportSettings =
414         GrpcCallSettings.<RunTaskRequest, Task>newBuilder()
415             .setMethodDescriptor(runTaskMethodDescriptor)
416             .setParamsExtractor(
417                 request -> {
418                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
419                   params.put("name", String.valueOf(request.getName()));
420                   return params.build();
421                 })
422             .build();
423 
424     this.listQueuesCallable =
425         callableFactory.createUnaryCallable(
426             listQueuesTransportSettings, settings.listQueuesSettings(), clientContext);
427     this.listQueuesPagedCallable =
428         callableFactory.createPagedCallable(
429             listQueuesTransportSettings, settings.listQueuesSettings(), clientContext);
430     this.getQueueCallable =
431         callableFactory.createUnaryCallable(
432             getQueueTransportSettings, settings.getQueueSettings(), clientContext);
433     this.createQueueCallable =
434         callableFactory.createUnaryCallable(
435             createQueueTransportSettings, settings.createQueueSettings(), clientContext);
436     this.updateQueueCallable =
437         callableFactory.createUnaryCallable(
438             updateQueueTransportSettings, settings.updateQueueSettings(), clientContext);
439     this.deleteQueueCallable =
440         callableFactory.createUnaryCallable(
441             deleteQueueTransportSettings, settings.deleteQueueSettings(), clientContext);
442     this.purgeQueueCallable =
443         callableFactory.createUnaryCallable(
444             purgeQueueTransportSettings, settings.purgeQueueSettings(), clientContext);
445     this.pauseQueueCallable =
446         callableFactory.createUnaryCallable(
447             pauseQueueTransportSettings, settings.pauseQueueSettings(), clientContext);
448     this.resumeQueueCallable =
449         callableFactory.createUnaryCallable(
450             resumeQueueTransportSettings, settings.resumeQueueSettings(), clientContext);
451     this.getIamPolicyCallable =
452         callableFactory.createUnaryCallable(
453             getIamPolicyTransportSettings, settings.getIamPolicySettings(), clientContext);
454     this.setIamPolicyCallable =
455         callableFactory.createUnaryCallable(
456             setIamPolicyTransportSettings, settings.setIamPolicySettings(), clientContext);
457     this.testIamPermissionsCallable =
458         callableFactory.createUnaryCallable(
459             testIamPermissionsTransportSettings,
460             settings.testIamPermissionsSettings(),
461             clientContext);
462     this.listTasksCallable =
463         callableFactory.createUnaryCallable(
464             listTasksTransportSettings, settings.listTasksSettings(), clientContext);
465     this.listTasksPagedCallable =
466         callableFactory.createPagedCallable(
467             listTasksTransportSettings, settings.listTasksSettings(), clientContext);
468     this.getTaskCallable =
469         callableFactory.createUnaryCallable(
470             getTaskTransportSettings, settings.getTaskSettings(), clientContext);
471     this.createTaskCallable =
472         callableFactory.createUnaryCallable(
473             createTaskTransportSettings, settings.createTaskSettings(), clientContext);
474     this.deleteTaskCallable =
475         callableFactory.createUnaryCallable(
476             deleteTaskTransportSettings, settings.deleteTaskSettings(), clientContext);
477     this.runTaskCallable =
478         callableFactory.createUnaryCallable(
479             runTaskTransportSettings, settings.runTaskSettings(), clientContext);
480 
481     this.backgroundResources =
482         new BackgroundResourceAggregation(clientContext.getBackgroundResources());
483   }
484 
getOperationsStub()485   public GrpcOperationsStub getOperationsStub() {
486     return operationsStub;
487   }
488 
489   @Override
listQueuesCallable()490   public UnaryCallable<ListQueuesRequest, ListQueuesResponse> listQueuesCallable() {
491     return listQueuesCallable;
492   }
493 
494   @Override
listQueuesPagedCallable()495   public UnaryCallable<ListQueuesRequest, ListQueuesPagedResponse> listQueuesPagedCallable() {
496     return listQueuesPagedCallable;
497   }
498 
499   @Override
getQueueCallable()500   public UnaryCallable<GetQueueRequest, Queue> getQueueCallable() {
501     return getQueueCallable;
502   }
503 
504   @Override
createQueueCallable()505   public UnaryCallable<CreateQueueRequest, Queue> createQueueCallable() {
506     return createQueueCallable;
507   }
508 
509   @Override
updateQueueCallable()510   public UnaryCallable<UpdateQueueRequest, Queue> updateQueueCallable() {
511     return updateQueueCallable;
512   }
513 
514   @Override
deleteQueueCallable()515   public UnaryCallable<DeleteQueueRequest, Empty> deleteQueueCallable() {
516     return deleteQueueCallable;
517   }
518 
519   @Override
purgeQueueCallable()520   public UnaryCallable<PurgeQueueRequest, Queue> purgeQueueCallable() {
521     return purgeQueueCallable;
522   }
523 
524   @Override
pauseQueueCallable()525   public UnaryCallable<PauseQueueRequest, Queue> pauseQueueCallable() {
526     return pauseQueueCallable;
527   }
528 
529   @Override
resumeQueueCallable()530   public UnaryCallable<ResumeQueueRequest, Queue> resumeQueueCallable() {
531     return resumeQueueCallable;
532   }
533 
534   @Override
getIamPolicyCallable()535   public UnaryCallable<GetIamPolicyRequest, Policy> getIamPolicyCallable() {
536     return getIamPolicyCallable;
537   }
538 
539   @Override
setIamPolicyCallable()540   public UnaryCallable<SetIamPolicyRequest, Policy> setIamPolicyCallable() {
541     return setIamPolicyCallable;
542   }
543 
544   @Override
545   public UnaryCallable<TestIamPermissionsRequest, TestIamPermissionsResponse>
testIamPermissionsCallable()546       testIamPermissionsCallable() {
547     return testIamPermissionsCallable;
548   }
549 
550   @Override
listTasksCallable()551   public UnaryCallable<ListTasksRequest, ListTasksResponse> listTasksCallable() {
552     return listTasksCallable;
553   }
554 
555   @Override
listTasksPagedCallable()556   public UnaryCallable<ListTasksRequest, ListTasksPagedResponse> listTasksPagedCallable() {
557     return listTasksPagedCallable;
558   }
559 
560   @Override
getTaskCallable()561   public UnaryCallable<GetTaskRequest, Task> getTaskCallable() {
562     return getTaskCallable;
563   }
564 
565   @Override
createTaskCallable()566   public UnaryCallable<CreateTaskRequest, Task> createTaskCallable() {
567     return createTaskCallable;
568   }
569 
570   @Override
deleteTaskCallable()571   public UnaryCallable<DeleteTaskRequest, Empty> deleteTaskCallable() {
572     return deleteTaskCallable;
573   }
574 
575   @Override
runTaskCallable()576   public UnaryCallable<RunTaskRequest, Task> runTaskCallable() {
577     return runTaskCallable;
578   }
579 
580   @Override
close()581   public final void close() {
582     try {
583       backgroundResources.close();
584     } catch (RuntimeException e) {
585       throw e;
586     } catch (Exception e) {
587       throw new IllegalStateException("Failed to close resource", e);
588     }
589   }
590 
591   @Override
shutdown()592   public void shutdown() {
593     backgroundResources.shutdown();
594   }
595 
596   @Override
isShutdown()597   public boolean isShutdown() {
598     return backgroundResources.isShutdown();
599   }
600 
601   @Override
isTerminated()602   public boolean isTerminated() {
603     return backgroundResources.isTerminated();
604   }
605 
606   @Override
shutdownNow()607   public void shutdownNow() {
608     backgroundResources.shutdownNow();
609   }
610 
611   @Override
awaitTermination(long duration, TimeUnit unit)612   public boolean awaitTermination(long duration, TimeUnit unit) throws InterruptedException {
613     return backgroundResources.awaitTermination(duration, unit);
614   }
615 }
616