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