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