• 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.talent.v4.stub;
18 
19 import static com.google.cloud.talent.v4.TenantServiceClient.ListTenantsPagedResponse;
20 
21 import com.google.api.gax.core.BackgroundResource;
22 import com.google.api.gax.core.BackgroundResourceAggregation;
23 import com.google.api.gax.grpc.GrpcCallSettings;
24 import com.google.api.gax.grpc.GrpcStubCallableFactory;
25 import com.google.api.gax.rpc.ClientContext;
26 import com.google.api.gax.rpc.UnaryCallable;
27 import com.google.cloud.talent.v4.CreateTenantRequest;
28 import com.google.cloud.talent.v4.DeleteTenantRequest;
29 import com.google.cloud.talent.v4.GetTenantRequest;
30 import com.google.cloud.talent.v4.ListTenantsRequest;
31 import com.google.cloud.talent.v4.ListTenantsResponse;
32 import com.google.cloud.talent.v4.Tenant;
33 import com.google.cloud.talent.v4.UpdateTenantRequest;
34 import com.google.common.collect.ImmutableMap;
35 import com.google.longrunning.stub.GrpcOperationsStub;
36 import com.google.protobuf.Empty;
37 import io.grpc.MethodDescriptor;
38 import io.grpc.protobuf.ProtoUtils;
39 import java.io.IOException;
40 import java.util.concurrent.TimeUnit;
41 import javax.annotation.Generated;
42 
43 // AUTO-GENERATED DOCUMENTATION AND CLASS.
44 /**
45  * gRPC stub implementation for the TenantService service API.
46  *
47  * <p>This class is for advanced usage and reflects the underlying API directly.
48  */
49 @Generated("by gapic-generator-java")
50 public class GrpcTenantServiceStub extends TenantServiceStub {
51   private static final MethodDescriptor<CreateTenantRequest, Tenant> createTenantMethodDescriptor =
52       MethodDescriptor.<CreateTenantRequest, Tenant>newBuilder()
53           .setType(MethodDescriptor.MethodType.UNARY)
54           .setFullMethodName("google.cloud.talent.v4.TenantService/CreateTenant")
55           .setRequestMarshaller(ProtoUtils.marshaller(CreateTenantRequest.getDefaultInstance()))
56           .setResponseMarshaller(ProtoUtils.marshaller(Tenant.getDefaultInstance()))
57           .build();
58 
59   private static final MethodDescriptor<GetTenantRequest, Tenant> getTenantMethodDescriptor =
60       MethodDescriptor.<GetTenantRequest, Tenant>newBuilder()
61           .setType(MethodDescriptor.MethodType.UNARY)
62           .setFullMethodName("google.cloud.talent.v4.TenantService/GetTenant")
63           .setRequestMarshaller(ProtoUtils.marshaller(GetTenantRequest.getDefaultInstance()))
64           .setResponseMarshaller(ProtoUtils.marshaller(Tenant.getDefaultInstance()))
65           .build();
66 
67   private static final MethodDescriptor<UpdateTenantRequest, Tenant> updateTenantMethodDescriptor =
68       MethodDescriptor.<UpdateTenantRequest, Tenant>newBuilder()
69           .setType(MethodDescriptor.MethodType.UNARY)
70           .setFullMethodName("google.cloud.talent.v4.TenantService/UpdateTenant")
71           .setRequestMarshaller(ProtoUtils.marshaller(UpdateTenantRequest.getDefaultInstance()))
72           .setResponseMarshaller(ProtoUtils.marshaller(Tenant.getDefaultInstance()))
73           .build();
74 
75   private static final MethodDescriptor<DeleteTenantRequest, Empty> deleteTenantMethodDescriptor =
76       MethodDescriptor.<DeleteTenantRequest, Empty>newBuilder()
77           .setType(MethodDescriptor.MethodType.UNARY)
78           .setFullMethodName("google.cloud.talent.v4.TenantService/DeleteTenant")
79           .setRequestMarshaller(ProtoUtils.marshaller(DeleteTenantRequest.getDefaultInstance()))
80           .setResponseMarshaller(ProtoUtils.marshaller(Empty.getDefaultInstance()))
81           .build();
82 
83   private static final MethodDescriptor<ListTenantsRequest, ListTenantsResponse>
84       listTenantsMethodDescriptor =
85           MethodDescriptor.<ListTenantsRequest, ListTenantsResponse>newBuilder()
86               .setType(MethodDescriptor.MethodType.UNARY)
87               .setFullMethodName("google.cloud.talent.v4.TenantService/ListTenants")
88               .setRequestMarshaller(ProtoUtils.marshaller(ListTenantsRequest.getDefaultInstance()))
89               .setResponseMarshaller(
90                   ProtoUtils.marshaller(ListTenantsResponse.getDefaultInstance()))
91               .build();
92 
93   private final UnaryCallable<CreateTenantRequest, Tenant> createTenantCallable;
94   private final UnaryCallable<GetTenantRequest, Tenant> getTenantCallable;
95   private final UnaryCallable<UpdateTenantRequest, Tenant> updateTenantCallable;
96   private final UnaryCallable<DeleteTenantRequest, Empty> deleteTenantCallable;
97   private final UnaryCallable<ListTenantsRequest, ListTenantsResponse> listTenantsCallable;
98   private final UnaryCallable<ListTenantsRequest, ListTenantsPagedResponse>
99       listTenantsPagedCallable;
100 
101   private final BackgroundResource backgroundResources;
102   private final GrpcOperationsStub operationsStub;
103   private final GrpcStubCallableFactory callableFactory;
104 
create(TenantServiceStubSettings settings)105   public static final GrpcTenantServiceStub create(TenantServiceStubSettings settings)
106       throws IOException {
107     return new GrpcTenantServiceStub(settings, ClientContext.create(settings));
108   }
109 
create(ClientContext clientContext)110   public static final GrpcTenantServiceStub create(ClientContext clientContext) throws IOException {
111     return new GrpcTenantServiceStub(TenantServiceStubSettings.newBuilder().build(), clientContext);
112   }
113 
create( ClientContext clientContext, GrpcStubCallableFactory callableFactory)114   public static final GrpcTenantServiceStub create(
115       ClientContext clientContext, GrpcStubCallableFactory callableFactory) throws IOException {
116     return new GrpcTenantServiceStub(
117         TenantServiceStubSettings.newBuilder().build(), clientContext, callableFactory);
118   }
119 
120   /**
121    * Constructs an instance of GrpcTenantServiceStub, using the given settings. This is protected so
122    * that it is easy to make a subclass, but otherwise, the static factory methods should be
123    * preferred.
124    */
GrpcTenantServiceStub(TenantServiceStubSettings settings, ClientContext clientContext)125   protected GrpcTenantServiceStub(TenantServiceStubSettings settings, ClientContext clientContext)
126       throws IOException {
127     this(settings, clientContext, new GrpcTenantServiceCallableFactory());
128   }
129 
130   /**
131    * Constructs an instance of GrpcTenantServiceStub, using the given settings. This is protected so
132    * that it is easy to make a subclass, but otherwise, the static factory methods should be
133    * preferred.
134    */
GrpcTenantServiceStub( TenantServiceStubSettings settings, ClientContext clientContext, GrpcStubCallableFactory callableFactory)135   protected GrpcTenantServiceStub(
136       TenantServiceStubSettings settings,
137       ClientContext clientContext,
138       GrpcStubCallableFactory callableFactory)
139       throws IOException {
140     this.callableFactory = callableFactory;
141     this.operationsStub = GrpcOperationsStub.create(clientContext, callableFactory);
142 
143     GrpcCallSettings<CreateTenantRequest, Tenant> createTenantTransportSettings =
144         GrpcCallSettings.<CreateTenantRequest, Tenant>newBuilder()
145             .setMethodDescriptor(createTenantMethodDescriptor)
146             .setParamsExtractor(
147                 request -> {
148                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
149                   params.put("parent", String.valueOf(request.getParent()));
150                   return params.build();
151                 })
152             .build();
153     GrpcCallSettings<GetTenantRequest, Tenant> getTenantTransportSettings =
154         GrpcCallSettings.<GetTenantRequest, Tenant>newBuilder()
155             .setMethodDescriptor(getTenantMethodDescriptor)
156             .setParamsExtractor(
157                 request -> {
158                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
159                   params.put("name", String.valueOf(request.getName()));
160                   return params.build();
161                 })
162             .build();
163     GrpcCallSettings<UpdateTenantRequest, Tenant> updateTenantTransportSettings =
164         GrpcCallSettings.<UpdateTenantRequest, Tenant>newBuilder()
165             .setMethodDescriptor(updateTenantMethodDescriptor)
166             .setParamsExtractor(
167                 request -> {
168                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
169                   params.put("tenant.name", String.valueOf(request.getTenant().getName()));
170                   return params.build();
171                 })
172             .build();
173     GrpcCallSettings<DeleteTenantRequest, Empty> deleteTenantTransportSettings =
174         GrpcCallSettings.<DeleteTenantRequest, Empty>newBuilder()
175             .setMethodDescriptor(deleteTenantMethodDescriptor)
176             .setParamsExtractor(
177                 request -> {
178                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
179                   params.put("name", String.valueOf(request.getName()));
180                   return params.build();
181                 })
182             .build();
183     GrpcCallSettings<ListTenantsRequest, ListTenantsResponse> listTenantsTransportSettings =
184         GrpcCallSettings.<ListTenantsRequest, ListTenantsResponse>newBuilder()
185             .setMethodDescriptor(listTenantsMethodDescriptor)
186             .setParamsExtractor(
187                 request -> {
188                   ImmutableMap.Builder<String, String> params = ImmutableMap.builder();
189                   params.put("parent", String.valueOf(request.getParent()));
190                   return params.build();
191                 })
192             .build();
193 
194     this.createTenantCallable =
195         callableFactory.createUnaryCallable(
196             createTenantTransportSettings, settings.createTenantSettings(), clientContext);
197     this.getTenantCallable =
198         callableFactory.createUnaryCallable(
199             getTenantTransportSettings, settings.getTenantSettings(), clientContext);
200     this.updateTenantCallable =
201         callableFactory.createUnaryCallable(
202             updateTenantTransportSettings, settings.updateTenantSettings(), clientContext);
203     this.deleteTenantCallable =
204         callableFactory.createUnaryCallable(
205             deleteTenantTransportSettings, settings.deleteTenantSettings(), clientContext);
206     this.listTenantsCallable =
207         callableFactory.createUnaryCallable(
208             listTenantsTransportSettings, settings.listTenantsSettings(), clientContext);
209     this.listTenantsPagedCallable =
210         callableFactory.createPagedCallable(
211             listTenantsTransportSettings, settings.listTenantsSettings(), clientContext);
212 
213     this.backgroundResources =
214         new BackgroundResourceAggregation(clientContext.getBackgroundResources());
215   }
216 
getOperationsStub()217   public GrpcOperationsStub getOperationsStub() {
218     return operationsStub;
219   }
220 
221   @Override
createTenantCallable()222   public UnaryCallable<CreateTenantRequest, Tenant> createTenantCallable() {
223     return createTenantCallable;
224   }
225 
226   @Override
getTenantCallable()227   public UnaryCallable<GetTenantRequest, Tenant> getTenantCallable() {
228     return getTenantCallable;
229   }
230 
231   @Override
updateTenantCallable()232   public UnaryCallable<UpdateTenantRequest, Tenant> updateTenantCallable() {
233     return updateTenantCallable;
234   }
235 
236   @Override
deleteTenantCallable()237   public UnaryCallable<DeleteTenantRequest, Empty> deleteTenantCallable() {
238     return deleteTenantCallable;
239   }
240 
241   @Override
listTenantsCallable()242   public UnaryCallable<ListTenantsRequest, ListTenantsResponse> listTenantsCallable() {
243     return listTenantsCallable;
244   }
245 
246   @Override
listTenantsPagedCallable()247   public UnaryCallable<ListTenantsRequest, ListTenantsPagedResponse> listTenantsPagedCallable() {
248     return listTenantsPagedCallable;
249   }
250 
251   @Override
close()252   public final void close() {
253     try {
254       backgroundResources.close();
255     } catch (RuntimeException e) {
256       throw e;
257     } catch (Exception e) {
258       throw new IllegalStateException("Failed to close resource", e);
259     }
260   }
261 
262   @Override
shutdown()263   public void shutdown() {
264     backgroundResources.shutdown();
265   }
266 
267   @Override
isShutdown()268   public boolean isShutdown() {
269     return backgroundResources.isShutdown();
270   }
271 
272   @Override
isTerminated()273   public boolean isTerminated() {
274     return backgroundResources.isTerminated();
275   }
276 
277   @Override
shutdownNow()278   public void shutdownNow() {
279     backgroundResources.shutdownNow();
280   }
281 
282   @Override
awaitTermination(long duration, TimeUnit unit)283   public boolean awaitTermination(long duration, TimeUnit unit) throws InterruptedException {
284     return backgroundResources.awaitTermination(duration, unit);
285   }
286 }
287