• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright 2020 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 package com.google.cloud.scheduler.v1;
17 
18 import static io.grpc.MethodDescriptor.generateFullMethodName;
19 
20 /**
21  *
22  *
23  * <pre>
24  * The Cloud Scheduler API allows external entities to reliably
25  * schedule asynchronous jobs.
26  * </pre>
27  */
28 @javax.annotation.Generated(
29     value = "by gRPC proto compiler",
30     comments = "Source: google/cloud/scheduler/v1/cloudscheduler.proto")
31 @io.grpc.stub.annotations.GrpcGenerated
32 public final class CloudSchedulerGrpc {
33 
CloudSchedulerGrpc()34   private CloudSchedulerGrpc() {}
35 
36   public static final String SERVICE_NAME = "google.cloud.scheduler.v1.CloudScheduler";
37 
38   // Static method descriptors that strictly reflect the proto.
39   private static volatile io.grpc.MethodDescriptor<
40           com.google.cloud.scheduler.v1.ListJobsRequest,
41           com.google.cloud.scheduler.v1.ListJobsResponse>
42       getListJobsMethod;
43 
44   @io.grpc.stub.annotations.RpcMethod(
45       fullMethodName = SERVICE_NAME + '/' + "ListJobs",
46       requestType = com.google.cloud.scheduler.v1.ListJobsRequest.class,
47       responseType = com.google.cloud.scheduler.v1.ListJobsResponse.class,
48       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
49   public static io.grpc.MethodDescriptor<
50           com.google.cloud.scheduler.v1.ListJobsRequest,
51           com.google.cloud.scheduler.v1.ListJobsResponse>
getListJobsMethod()52       getListJobsMethod() {
53     io.grpc.MethodDescriptor<
54             com.google.cloud.scheduler.v1.ListJobsRequest,
55             com.google.cloud.scheduler.v1.ListJobsResponse>
56         getListJobsMethod;
57     if ((getListJobsMethod = CloudSchedulerGrpc.getListJobsMethod) == null) {
58       synchronized (CloudSchedulerGrpc.class) {
59         if ((getListJobsMethod = CloudSchedulerGrpc.getListJobsMethod) == null) {
60           CloudSchedulerGrpc.getListJobsMethod =
61               getListJobsMethod =
62                   io.grpc.MethodDescriptor
63                       .<com.google.cloud.scheduler.v1.ListJobsRequest,
64                           com.google.cloud.scheduler.v1.ListJobsResponse>
65                           newBuilder()
66                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
67                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ListJobs"))
68                       .setSampledToLocalTracing(true)
69                       .setRequestMarshaller(
70                           io.grpc.protobuf.ProtoUtils.marshaller(
71                               com.google.cloud.scheduler.v1.ListJobsRequest.getDefaultInstance()))
72                       .setResponseMarshaller(
73                           io.grpc.protobuf.ProtoUtils.marshaller(
74                               com.google.cloud.scheduler.v1.ListJobsResponse.getDefaultInstance()))
75                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("ListJobs"))
76                       .build();
77         }
78       }
79     }
80     return getListJobsMethod;
81   }
82 
83   private static volatile io.grpc.MethodDescriptor<
84           com.google.cloud.scheduler.v1.GetJobRequest, com.google.cloud.scheduler.v1.Job>
85       getGetJobMethod;
86 
87   @io.grpc.stub.annotations.RpcMethod(
88       fullMethodName = SERVICE_NAME + '/' + "GetJob",
89       requestType = com.google.cloud.scheduler.v1.GetJobRequest.class,
90       responseType = com.google.cloud.scheduler.v1.Job.class,
91       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
92   public static io.grpc.MethodDescriptor<
93           com.google.cloud.scheduler.v1.GetJobRequest, com.google.cloud.scheduler.v1.Job>
getGetJobMethod()94       getGetJobMethod() {
95     io.grpc.MethodDescriptor<
96             com.google.cloud.scheduler.v1.GetJobRequest, com.google.cloud.scheduler.v1.Job>
97         getGetJobMethod;
98     if ((getGetJobMethod = CloudSchedulerGrpc.getGetJobMethod) == null) {
99       synchronized (CloudSchedulerGrpc.class) {
100         if ((getGetJobMethod = CloudSchedulerGrpc.getGetJobMethod) == null) {
101           CloudSchedulerGrpc.getGetJobMethod =
102               getGetJobMethod =
103                   io.grpc.MethodDescriptor
104                       .<com.google.cloud.scheduler.v1.GetJobRequest,
105                           com.google.cloud.scheduler.v1.Job>
106                           newBuilder()
107                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
108                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "GetJob"))
109                       .setSampledToLocalTracing(true)
110                       .setRequestMarshaller(
111                           io.grpc.protobuf.ProtoUtils.marshaller(
112                               com.google.cloud.scheduler.v1.GetJobRequest.getDefaultInstance()))
113                       .setResponseMarshaller(
114                           io.grpc.protobuf.ProtoUtils.marshaller(
115                               com.google.cloud.scheduler.v1.Job.getDefaultInstance()))
116                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("GetJob"))
117                       .build();
118         }
119       }
120     }
121     return getGetJobMethod;
122   }
123 
124   private static volatile io.grpc.MethodDescriptor<
125           com.google.cloud.scheduler.v1.CreateJobRequest, com.google.cloud.scheduler.v1.Job>
126       getCreateJobMethod;
127 
128   @io.grpc.stub.annotations.RpcMethod(
129       fullMethodName = SERVICE_NAME + '/' + "CreateJob",
130       requestType = com.google.cloud.scheduler.v1.CreateJobRequest.class,
131       responseType = com.google.cloud.scheduler.v1.Job.class,
132       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
133   public static io.grpc.MethodDescriptor<
134           com.google.cloud.scheduler.v1.CreateJobRequest, com.google.cloud.scheduler.v1.Job>
getCreateJobMethod()135       getCreateJobMethod() {
136     io.grpc.MethodDescriptor<
137             com.google.cloud.scheduler.v1.CreateJobRequest, com.google.cloud.scheduler.v1.Job>
138         getCreateJobMethod;
139     if ((getCreateJobMethod = CloudSchedulerGrpc.getCreateJobMethod) == null) {
140       synchronized (CloudSchedulerGrpc.class) {
141         if ((getCreateJobMethod = CloudSchedulerGrpc.getCreateJobMethod) == null) {
142           CloudSchedulerGrpc.getCreateJobMethod =
143               getCreateJobMethod =
144                   io.grpc.MethodDescriptor
145                       .<com.google.cloud.scheduler.v1.CreateJobRequest,
146                           com.google.cloud.scheduler.v1.Job>
147                           newBuilder()
148                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
149                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "CreateJob"))
150                       .setSampledToLocalTracing(true)
151                       .setRequestMarshaller(
152                           io.grpc.protobuf.ProtoUtils.marshaller(
153                               com.google.cloud.scheduler.v1.CreateJobRequest.getDefaultInstance()))
154                       .setResponseMarshaller(
155                           io.grpc.protobuf.ProtoUtils.marshaller(
156                               com.google.cloud.scheduler.v1.Job.getDefaultInstance()))
157                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("CreateJob"))
158                       .build();
159         }
160       }
161     }
162     return getCreateJobMethod;
163   }
164 
165   private static volatile io.grpc.MethodDescriptor<
166           com.google.cloud.scheduler.v1.UpdateJobRequest, com.google.cloud.scheduler.v1.Job>
167       getUpdateJobMethod;
168 
169   @io.grpc.stub.annotations.RpcMethod(
170       fullMethodName = SERVICE_NAME + '/' + "UpdateJob",
171       requestType = com.google.cloud.scheduler.v1.UpdateJobRequest.class,
172       responseType = com.google.cloud.scheduler.v1.Job.class,
173       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
174   public static io.grpc.MethodDescriptor<
175           com.google.cloud.scheduler.v1.UpdateJobRequest, com.google.cloud.scheduler.v1.Job>
getUpdateJobMethod()176       getUpdateJobMethod() {
177     io.grpc.MethodDescriptor<
178             com.google.cloud.scheduler.v1.UpdateJobRequest, com.google.cloud.scheduler.v1.Job>
179         getUpdateJobMethod;
180     if ((getUpdateJobMethod = CloudSchedulerGrpc.getUpdateJobMethod) == null) {
181       synchronized (CloudSchedulerGrpc.class) {
182         if ((getUpdateJobMethod = CloudSchedulerGrpc.getUpdateJobMethod) == null) {
183           CloudSchedulerGrpc.getUpdateJobMethod =
184               getUpdateJobMethod =
185                   io.grpc.MethodDescriptor
186                       .<com.google.cloud.scheduler.v1.UpdateJobRequest,
187                           com.google.cloud.scheduler.v1.Job>
188                           newBuilder()
189                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
190                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "UpdateJob"))
191                       .setSampledToLocalTracing(true)
192                       .setRequestMarshaller(
193                           io.grpc.protobuf.ProtoUtils.marshaller(
194                               com.google.cloud.scheduler.v1.UpdateJobRequest.getDefaultInstance()))
195                       .setResponseMarshaller(
196                           io.grpc.protobuf.ProtoUtils.marshaller(
197                               com.google.cloud.scheduler.v1.Job.getDefaultInstance()))
198                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("UpdateJob"))
199                       .build();
200         }
201       }
202     }
203     return getUpdateJobMethod;
204   }
205 
206   private static volatile io.grpc.MethodDescriptor<
207           com.google.cloud.scheduler.v1.DeleteJobRequest, com.google.protobuf.Empty>
208       getDeleteJobMethod;
209 
210   @io.grpc.stub.annotations.RpcMethod(
211       fullMethodName = SERVICE_NAME + '/' + "DeleteJob",
212       requestType = com.google.cloud.scheduler.v1.DeleteJobRequest.class,
213       responseType = com.google.protobuf.Empty.class,
214       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
215   public static io.grpc.MethodDescriptor<
216           com.google.cloud.scheduler.v1.DeleteJobRequest, com.google.protobuf.Empty>
getDeleteJobMethod()217       getDeleteJobMethod() {
218     io.grpc.MethodDescriptor<
219             com.google.cloud.scheduler.v1.DeleteJobRequest, com.google.protobuf.Empty>
220         getDeleteJobMethod;
221     if ((getDeleteJobMethod = CloudSchedulerGrpc.getDeleteJobMethod) == null) {
222       synchronized (CloudSchedulerGrpc.class) {
223         if ((getDeleteJobMethod = CloudSchedulerGrpc.getDeleteJobMethod) == null) {
224           CloudSchedulerGrpc.getDeleteJobMethod =
225               getDeleteJobMethod =
226                   io.grpc.MethodDescriptor
227                       .<com.google.cloud.scheduler.v1.DeleteJobRequest, com.google.protobuf.Empty>
228                           newBuilder()
229                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
230                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "DeleteJob"))
231                       .setSampledToLocalTracing(true)
232                       .setRequestMarshaller(
233                           io.grpc.protobuf.ProtoUtils.marshaller(
234                               com.google.cloud.scheduler.v1.DeleteJobRequest.getDefaultInstance()))
235                       .setResponseMarshaller(
236                           io.grpc.protobuf.ProtoUtils.marshaller(
237                               com.google.protobuf.Empty.getDefaultInstance()))
238                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("DeleteJob"))
239                       .build();
240         }
241       }
242     }
243     return getDeleteJobMethod;
244   }
245 
246   private static volatile io.grpc.MethodDescriptor<
247           com.google.cloud.scheduler.v1.PauseJobRequest, com.google.cloud.scheduler.v1.Job>
248       getPauseJobMethod;
249 
250   @io.grpc.stub.annotations.RpcMethod(
251       fullMethodName = SERVICE_NAME + '/' + "PauseJob",
252       requestType = com.google.cloud.scheduler.v1.PauseJobRequest.class,
253       responseType = com.google.cloud.scheduler.v1.Job.class,
254       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
255   public static io.grpc.MethodDescriptor<
256           com.google.cloud.scheduler.v1.PauseJobRequest, com.google.cloud.scheduler.v1.Job>
getPauseJobMethod()257       getPauseJobMethod() {
258     io.grpc.MethodDescriptor<
259             com.google.cloud.scheduler.v1.PauseJobRequest, com.google.cloud.scheduler.v1.Job>
260         getPauseJobMethod;
261     if ((getPauseJobMethod = CloudSchedulerGrpc.getPauseJobMethod) == null) {
262       synchronized (CloudSchedulerGrpc.class) {
263         if ((getPauseJobMethod = CloudSchedulerGrpc.getPauseJobMethod) == null) {
264           CloudSchedulerGrpc.getPauseJobMethod =
265               getPauseJobMethod =
266                   io.grpc.MethodDescriptor
267                       .<com.google.cloud.scheduler.v1.PauseJobRequest,
268                           com.google.cloud.scheduler.v1.Job>
269                           newBuilder()
270                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
271                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "PauseJob"))
272                       .setSampledToLocalTracing(true)
273                       .setRequestMarshaller(
274                           io.grpc.protobuf.ProtoUtils.marshaller(
275                               com.google.cloud.scheduler.v1.PauseJobRequest.getDefaultInstance()))
276                       .setResponseMarshaller(
277                           io.grpc.protobuf.ProtoUtils.marshaller(
278                               com.google.cloud.scheduler.v1.Job.getDefaultInstance()))
279                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("PauseJob"))
280                       .build();
281         }
282       }
283     }
284     return getPauseJobMethod;
285   }
286 
287   private static volatile io.grpc.MethodDescriptor<
288           com.google.cloud.scheduler.v1.ResumeJobRequest, com.google.cloud.scheduler.v1.Job>
289       getResumeJobMethod;
290 
291   @io.grpc.stub.annotations.RpcMethod(
292       fullMethodName = SERVICE_NAME + '/' + "ResumeJob",
293       requestType = com.google.cloud.scheduler.v1.ResumeJobRequest.class,
294       responseType = com.google.cloud.scheduler.v1.Job.class,
295       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
296   public static io.grpc.MethodDescriptor<
297           com.google.cloud.scheduler.v1.ResumeJobRequest, com.google.cloud.scheduler.v1.Job>
getResumeJobMethod()298       getResumeJobMethod() {
299     io.grpc.MethodDescriptor<
300             com.google.cloud.scheduler.v1.ResumeJobRequest, com.google.cloud.scheduler.v1.Job>
301         getResumeJobMethod;
302     if ((getResumeJobMethod = CloudSchedulerGrpc.getResumeJobMethod) == null) {
303       synchronized (CloudSchedulerGrpc.class) {
304         if ((getResumeJobMethod = CloudSchedulerGrpc.getResumeJobMethod) == null) {
305           CloudSchedulerGrpc.getResumeJobMethod =
306               getResumeJobMethod =
307                   io.grpc.MethodDescriptor
308                       .<com.google.cloud.scheduler.v1.ResumeJobRequest,
309                           com.google.cloud.scheduler.v1.Job>
310                           newBuilder()
311                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
312                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "ResumeJob"))
313                       .setSampledToLocalTracing(true)
314                       .setRequestMarshaller(
315                           io.grpc.protobuf.ProtoUtils.marshaller(
316                               com.google.cloud.scheduler.v1.ResumeJobRequest.getDefaultInstance()))
317                       .setResponseMarshaller(
318                           io.grpc.protobuf.ProtoUtils.marshaller(
319                               com.google.cloud.scheduler.v1.Job.getDefaultInstance()))
320                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("ResumeJob"))
321                       .build();
322         }
323       }
324     }
325     return getResumeJobMethod;
326   }
327 
328   private static volatile io.grpc.MethodDescriptor<
329           com.google.cloud.scheduler.v1.RunJobRequest, com.google.cloud.scheduler.v1.Job>
330       getRunJobMethod;
331 
332   @io.grpc.stub.annotations.RpcMethod(
333       fullMethodName = SERVICE_NAME + '/' + "RunJob",
334       requestType = com.google.cloud.scheduler.v1.RunJobRequest.class,
335       responseType = com.google.cloud.scheduler.v1.Job.class,
336       methodType = io.grpc.MethodDescriptor.MethodType.UNARY)
337   public static io.grpc.MethodDescriptor<
338           com.google.cloud.scheduler.v1.RunJobRequest, com.google.cloud.scheduler.v1.Job>
getRunJobMethod()339       getRunJobMethod() {
340     io.grpc.MethodDescriptor<
341             com.google.cloud.scheduler.v1.RunJobRequest, com.google.cloud.scheduler.v1.Job>
342         getRunJobMethod;
343     if ((getRunJobMethod = CloudSchedulerGrpc.getRunJobMethod) == null) {
344       synchronized (CloudSchedulerGrpc.class) {
345         if ((getRunJobMethod = CloudSchedulerGrpc.getRunJobMethod) == null) {
346           CloudSchedulerGrpc.getRunJobMethod =
347               getRunJobMethod =
348                   io.grpc.MethodDescriptor
349                       .<com.google.cloud.scheduler.v1.RunJobRequest,
350                           com.google.cloud.scheduler.v1.Job>
351                           newBuilder()
352                       .setType(io.grpc.MethodDescriptor.MethodType.UNARY)
353                       .setFullMethodName(generateFullMethodName(SERVICE_NAME, "RunJob"))
354                       .setSampledToLocalTracing(true)
355                       .setRequestMarshaller(
356                           io.grpc.protobuf.ProtoUtils.marshaller(
357                               com.google.cloud.scheduler.v1.RunJobRequest.getDefaultInstance()))
358                       .setResponseMarshaller(
359                           io.grpc.protobuf.ProtoUtils.marshaller(
360                               com.google.cloud.scheduler.v1.Job.getDefaultInstance()))
361                       .setSchemaDescriptor(new CloudSchedulerMethodDescriptorSupplier("RunJob"))
362                       .build();
363         }
364       }
365     }
366     return getRunJobMethod;
367   }
368 
369   /** Creates a new async stub that supports all call types for the service */
newStub(io.grpc.Channel channel)370   public static CloudSchedulerStub newStub(io.grpc.Channel channel) {
371     io.grpc.stub.AbstractStub.StubFactory<CloudSchedulerStub> factory =
372         new io.grpc.stub.AbstractStub.StubFactory<CloudSchedulerStub>() {
373           @java.lang.Override
374           public CloudSchedulerStub newStub(
375               io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
376             return new CloudSchedulerStub(channel, callOptions);
377           }
378         };
379     return CloudSchedulerStub.newStub(factory, channel);
380   }
381 
382   /**
383    * Creates a new blocking-style stub that supports unary and streaming output calls on the service
384    */
newBlockingStub(io.grpc.Channel channel)385   public static CloudSchedulerBlockingStub newBlockingStub(io.grpc.Channel channel) {
386     io.grpc.stub.AbstractStub.StubFactory<CloudSchedulerBlockingStub> factory =
387         new io.grpc.stub.AbstractStub.StubFactory<CloudSchedulerBlockingStub>() {
388           @java.lang.Override
389           public CloudSchedulerBlockingStub newStub(
390               io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
391             return new CloudSchedulerBlockingStub(channel, callOptions);
392           }
393         };
394     return CloudSchedulerBlockingStub.newStub(factory, channel);
395   }
396 
397   /** Creates a new ListenableFuture-style stub that supports unary calls on the service */
newFutureStub(io.grpc.Channel channel)398   public static CloudSchedulerFutureStub newFutureStub(io.grpc.Channel channel) {
399     io.grpc.stub.AbstractStub.StubFactory<CloudSchedulerFutureStub> factory =
400         new io.grpc.stub.AbstractStub.StubFactory<CloudSchedulerFutureStub>() {
401           @java.lang.Override
402           public CloudSchedulerFutureStub newStub(
403               io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
404             return new CloudSchedulerFutureStub(channel, callOptions);
405           }
406         };
407     return CloudSchedulerFutureStub.newStub(factory, channel);
408   }
409 
410   /**
411    *
412    *
413    * <pre>
414    * The Cloud Scheduler API allows external entities to reliably
415    * schedule asynchronous jobs.
416    * </pre>
417    */
418   public interface AsyncService {
419 
420     /**
421      *
422      *
423      * <pre>
424      * Lists jobs.
425      * </pre>
426      */
listJobs( com.google.cloud.scheduler.v1.ListJobsRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.ListJobsResponse> responseObserver)427     default void listJobs(
428         com.google.cloud.scheduler.v1.ListJobsRequest request,
429         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.ListJobsResponse>
430             responseObserver) {
431       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getListJobsMethod(), responseObserver);
432     }
433 
434     /**
435      *
436      *
437      * <pre>
438      * Gets a job.
439      * </pre>
440      */
getJob( com.google.cloud.scheduler.v1.GetJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)441     default void getJob(
442         com.google.cloud.scheduler.v1.GetJobRequest request,
443         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
444       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getGetJobMethod(), responseObserver);
445     }
446 
447     /**
448      *
449      *
450      * <pre>
451      * Creates a job.
452      * </pre>
453      */
createJob( com.google.cloud.scheduler.v1.CreateJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)454     default void createJob(
455         com.google.cloud.scheduler.v1.CreateJobRequest request,
456         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
457       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getCreateJobMethod(), responseObserver);
458     }
459 
460     /**
461      *
462      *
463      * <pre>
464      * Updates a job.
465      * If successful, the updated [Job][google.cloud.scheduler.v1.Job] is
466      * returned. If the job does not exist, `NOT_FOUND` is returned.
467      * If UpdateJob does not successfully return, it is possible for the
468      * job to be in an
469      * [Job.State.UPDATE_FAILED][google.cloud.scheduler.v1.Job.State.UPDATE_FAILED]
470      * state. A job in this state may not be executed. If this happens, retry the
471      * UpdateJob request until a successful response is received.
472      * </pre>
473      */
updateJob( com.google.cloud.scheduler.v1.UpdateJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)474     default void updateJob(
475         com.google.cloud.scheduler.v1.UpdateJobRequest request,
476         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
477       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getUpdateJobMethod(), responseObserver);
478     }
479 
480     /**
481      *
482      *
483      * <pre>
484      * Deletes a job.
485      * </pre>
486      */
deleteJob( com.google.cloud.scheduler.v1.DeleteJobRequest request, io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver)487     default void deleteJob(
488         com.google.cloud.scheduler.v1.DeleteJobRequest request,
489         io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver) {
490       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getDeleteJobMethod(), responseObserver);
491     }
492 
493     /**
494      *
495      *
496      * <pre>
497      * Pauses a job.
498      * If a job is paused then the system will stop executing the job
499      * until it is re-enabled via
500      * [ResumeJob][google.cloud.scheduler.v1.CloudScheduler.ResumeJob]. The state
501      * of the job is stored in [state][google.cloud.scheduler.v1.Job.state]; if
502      * paused it will be set to
503      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. A job must
504      * be in [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED] to
505      * be paused.
506      * </pre>
507      */
pauseJob( com.google.cloud.scheduler.v1.PauseJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)508     default void pauseJob(
509         com.google.cloud.scheduler.v1.PauseJobRequest request,
510         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
511       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getPauseJobMethod(), responseObserver);
512     }
513 
514     /**
515      *
516      *
517      * <pre>
518      * Resume a job.
519      * This method reenables a job after it has been
520      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. The state
521      * of a job is stored in [Job.state][google.cloud.scheduler.v1.Job.state];
522      * after calling this method it will be set to
523      * [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]. A job
524      * must be in [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]
525      * to be resumed.
526      * </pre>
527      */
resumeJob( com.google.cloud.scheduler.v1.ResumeJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)528     default void resumeJob(
529         com.google.cloud.scheduler.v1.ResumeJobRequest request,
530         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
531       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getResumeJobMethod(), responseObserver);
532     }
533 
534     /**
535      *
536      *
537      * <pre>
538      * Forces a job to run now.
539      * When this method is called, Cloud Scheduler will dispatch the job, even
540      * if the job is already running.
541      * </pre>
542      */
runJob( com.google.cloud.scheduler.v1.RunJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)543     default void runJob(
544         com.google.cloud.scheduler.v1.RunJobRequest request,
545         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
546       io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getRunJobMethod(), responseObserver);
547     }
548   }
549 
550   /**
551    * Base class for the server implementation of the service CloudScheduler.
552    *
553    * <pre>
554    * The Cloud Scheduler API allows external entities to reliably
555    * schedule asynchronous jobs.
556    * </pre>
557    */
558   public abstract static class CloudSchedulerImplBase
559       implements io.grpc.BindableService, AsyncService {
560 
561     @java.lang.Override
bindService()562     public final io.grpc.ServerServiceDefinition bindService() {
563       return CloudSchedulerGrpc.bindService(this);
564     }
565   }
566 
567   /**
568    * A stub to allow clients to do asynchronous rpc calls to service CloudScheduler.
569    *
570    * <pre>
571    * The Cloud Scheduler API allows external entities to reliably
572    * schedule asynchronous jobs.
573    * </pre>
574    */
575   public static final class CloudSchedulerStub
576       extends io.grpc.stub.AbstractAsyncStub<CloudSchedulerStub> {
CloudSchedulerStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions)577     private CloudSchedulerStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
578       super(channel, callOptions);
579     }
580 
581     @java.lang.Override
build(io.grpc.Channel channel, io.grpc.CallOptions callOptions)582     protected CloudSchedulerStub build(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
583       return new CloudSchedulerStub(channel, callOptions);
584     }
585 
586     /**
587      *
588      *
589      * <pre>
590      * Lists jobs.
591      * </pre>
592      */
listJobs( com.google.cloud.scheduler.v1.ListJobsRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.ListJobsResponse> responseObserver)593     public void listJobs(
594         com.google.cloud.scheduler.v1.ListJobsRequest request,
595         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.ListJobsResponse>
596             responseObserver) {
597       io.grpc.stub.ClientCalls.asyncUnaryCall(
598           getChannel().newCall(getListJobsMethod(), getCallOptions()), request, responseObserver);
599     }
600 
601     /**
602      *
603      *
604      * <pre>
605      * Gets a job.
606      * </pre>
607      */
getJob( com.google.cloud.scheduler.v1.GetJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)608     public void getJob(
609         com.google.cloud.scheduler.v1.GetJobRequest request,
610         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
611       io.grpc.stub.ClientCalls.asyncUnaryCall(
612           getChannel().newCall(getGetJobMethod(), getCallOptions()), request, responseObserver);
613     }
614 
615     /**
616      *
617      *
618      * <pre>
619      * Creates a job.
620      * </pre>
621      */
createJob( com.google.cloud.scheduler.v1.CreateJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)622     public void createJob(
623         com.google.cloud.scheduler.v1.CreateJobRequest request,
624         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
625       io.grpc.stub.ClientCalls.asyncUnaryCall(
626           getChannel().newCall(getCreateJobMethod(), getCallOptions()), request, responseObserver);
627     }
628 
629     /**
630      *
631      *
632      * <pre>
633      * Updates a job.
634      * If successful, the updated [Job][google.cloud.scheduler.v1.Job] is
635      * returned. If the job does not exist, `NOT_FOUND` is returned.
636      * If UpdateJob does not successfully return, it is possible for the
637      * job to be in an
638      * [Job.State.UPDATE_FAILED][google.cloud.scheduler.v1.Job.State.UPDATE_FAILED]
639      * state. A job in this state may not be executed. If this happens, retry the
640      * UpdateJob request until a successful response is received.
641      * </pre>
642      */
updateJob( com.google.cloud.scheduler.v1.UpdateJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)643     public void updateJob(
644         com.google.cloud.scheduler.v1.UpdateJobRequest request,
645         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
646       io.grpc.stub.ClientCalls.asyncUnaryCall(
647           getChannel().newCall(getUpdateJobMethod(), getCallOptions()), request, responseObserver);
648     }
649 
650     /**
651      *
652      *
653      * <pre>
654      * Deletes a job.
655      * </pre>
656      */
deleteJob( com.google.cloud.scheduler.v1.DeleteJobRequest request, io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver)657     public void deleteJob(
658         com.google.cloud.scheduler.v1.DeleteJobRequest request,
659         io.grpc.stub.StreamObserver<com.google.protobuf.Empty> responseObserver) {
660       io.grpc.stub.ClientCalls.asyncUnaryCall(
661           getChannel().newCall(getDeleteJobMethod(), getCallOptions()), request, responseObserver);
662     }
663 
664     /**
665      *
666      *
667      * <pre>
668      * Pauses a job.
669      * If a job is paused then the system will stop executing the job
670      * until it is re-enabled via
671      * [ResumeJob][google.cloud.scheduler.v1.CloudScheduler.ResumeJob]. The state
672      * of the job is stored in [state][google.cloud.scheduler.v1.Job.state]; if
673      * paused it will be set to
674      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. A job must
675      * be in [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED] to
676      * be paused.
677      * </pre>
678      */
pauseJob( com.google.cloud.scheduler.v1.PauseJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)679     public void pauseJob(
680         com.google.cloud.scheduler.v1.PauseJobRequest request,
681         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
682       io.grpc.stub.ClientCalls.asyncUnaryCall(
683           getChannel().newCall(getPauseJobMethod(), getCallOptions()), request, responseObserver);
684     }
685 
686     /**
687      *
688      *
689      * <pre>
690      * Resume a job.
691      * This method reenables a job after it has been
692      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. The state
693      * of a job is stored in [Job.state][google.cloud.scheduler.v1.Job.state];
694      * after calling this method it will be set to
695      * [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]. A job
696      * must be in [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]
697      * to be resumed.
698      * </pre>
699      */
resumeJob( com.google.cloud.scheduler.v1.ResumeJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)700     public void resumeJob(
701         com.google.cloud.scheduler.v1.ResumeJobRequest request,
702         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
703       io.grpc.stub.ClientCalls.asyncUnaryCall(
704           getChannel().newCall(getResumeJobMethod(), getCallOptions()), request, responseObserver);
705     }
706 
707     /**
708      *
709      *
710      * <pre>
711      * Forces a job to run now.
712      * When this method is called, Cloud Scheduler will dispatch the job, even
713      * if the job is already running.
714      * </pre>
715      */
runJob( com.google.cloud.scheduler.v1.RunJobRequest request, io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver)716     public void runJob(
717         com.google.cloud.scheduler.v1.RunJobRequest request,
718         io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job> responseObserver) {
719       io.grpc.stub.ClientCalls.asyncUnaryCall(
720           getChannel().newCall(getRunJobMethod(), getCallOptions()), request, responseObserver);
721     }
722   }
723 
724   /**
725    * A stub to allow clients to do synchronous rpc calls to service CloudScheduler.
726    *
727    * <pre>
728    * The Cloud Scheduler API allows external entities to reliably
729    * schedule asynchronous jobs.
730    * </pre>
731    */
732   public static final class CloudSchedulerBlockingStub
733       extends io.grpc.stub.AbstractBlockingStub<CloudSchedulerBlockingStub> {
CloudSchedulerBlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions)734     private CloudSchedulerBlockingStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
735       super(channel, callOptions);
736     }
737 
738     @java.lang.Override
build( io.grpc.Channel channel, io.grpc.CallOptions callOptions)739     protected CloudSchedulerBlockingStub build(
740         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
741       return new CloudSchedulerBlockingStub(channel, callOptions);
742     }
743 
744     /**
745      *
746      *
747      * <pre>
748      * Lists jobs.
749      * </pre>
750      */
listJobs( com.google.cloud.scheduler.v1.ListJobsRequest request)751     public com.google.cloud.scheduler.v1.ListJobsResponse listJobs(
752         com.google.cloud.scheduler.v1.ListJobsRequest request) {
753       return io.grpc.stub.ClientCalls.blockingUnaryCall(
754           getChannel(), getListJobsMethod(), getCallOptions(), request);
755     }
756 
757     /**
758      *
759      *
760      * <pre>
761      * Gets a job.
762      * </pre>
763      */
getJob( com.google.cloud.scheduler.v1.GetJobRequest request)764     public com.google.cloud.scheduler.v1.Job getJob(
765         com.google.cloud.scheduler.v1.GetJobRequest request) {
766       return io.grpc.stub.ClientCalls.blockingUnaryCall(
767           getChannel(), getGetJobMethod(), getCallOptions(), request);
768     }
769 
770     /**
771      *
772      *
773      * <pre>
774      * Creates a job.
775      * </pre>
776      */
createJob( com.google.cloud.scheduler.v1.CreateJobRequest request)777     public com.google.cloud.scheduler.v1.Job createJob(
778         com.google.cloud.scheduler.v1.CreateJobRequest request) {
779       return io.grpc.stub.ClientCalls.blockingUnaryCall(
780           getChannel(), getCreateJobMethod(), getCallOptions(), request);
781     }
782 
783     /**
784      *
785      *
786      * <pre>
787      * Updates a job.
788      * If successful, the updated [Job][google.cloud.scheduler.v1.Job] is
789      * returned. If the job does not exist, `NOT_FOUND` is returned.
790      * If UpdateJob does not successfully return, it is possible for the
791      * job to be in an
792      * [Job.State.UPDATE_FAILED][google.cloud.scheduler.v1.Job.State.UPDATE_FAILED]
793      * state. A job in this state may not be executed. If this happens, retry the
794      * UpdateJob request until a successful response is received.
795      * </pre>
796      */
updateJob( com.google.cloud.scheduler.v1.UpdateJobRequest request)797     public com.google.cloud.scheduler.v1.Job updateJob(
798         com.google.cloud.scheduler.v1.UpdateJobRequest request) {
799       return io.grpc.stub.ClientCalls.blockingUnaryCall(
800           getChannel(), getUpdateJobMethod(), getCallOptions(), request);
801     }
802 
803     /**
804      *
805      *
806      * <pre>
807      * Deletes a job.
808      * </pre>
809      */
deleteJob( com.google.cloud.scheduler.v1.DeleteJobRequest request)810     public com.google.protobuf.Empty deleteJob(
811         com.google.cloud.scheduler.v1.DeleteJobRequest request) {
812       return io.grpc.stub.ClientCalls.blockingUnaryCall(
813           getChannel(), getDeleteJobMethod(), getCallOptions(), request);
814     }
815 
816     /**
817      *
818      *
819      * <pre>
820      * Pauses a job.
821      * If a job is paused then the system will stop executing the job
822      * until it is re-enabled via
823      * [ResumeJob][google.cloud.scheduler.v1.CloudScheduler.ResumeJob]. The state
824      * of the job is stored in [state][google.cloud.scheduler.v1.Job.state]; if
825      * paused it will be set to
826      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. A job must
827      * be in [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED] to
828      * be paused.
829      * </pre>
830      */
pauseJob( com.google.cloud.scheduler.v1.PauseJobRequest request)831     public com.google.cloud.scheduler.v1.Job pauseJob(
832         com.google.cloud.scheduler.v1.PauseJobRequest request) {
833       return io.grpc.stub.ClientCalls.blockingUnaryCall(
834           getChannel(), getPauseJobMethod(), getCallOptions(), request);
835     }
836 
837     /**
838      *
839      *
840      * <pre>
841      * Resume a job.
842      * This method reenables a job after it has been
843      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. The state
844      * of a job is stored in [Job.state][google.cloud.scheduler.v1.Job.state];
845      * after calling this method it will be set to
846      * [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]. A job
847      * must be in [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]
848      * to be resumed.
849      * </pre>
850      */
resumeJob( com.google.cloud.scheduler.v1.ResumeJobRequest request)851     public com.google.cloud.scheduler.v1.Job resumeJob(
852         com.google.cloud.scheduler.v1.ResumeJobRequest request) {
853       return io.grpc.stub.ClientCalls.blockingUnaryCall(
854           getChannel(), getResumeJobMethod(), getCallOptions(), request);
855     }
856 
857     /**
858      *
859      *
860      * <pre>
861      * Forces a job to run now.
862      * When this method is called, Cloud Scheduler will dispatch the job, even
863      * if the job is already running.
864      * </pre>
865      */
runJob( com.google.cloud.scheduler.v1.RunJobRequest request)866     public com.google.cloud.scheduler.v1.Job runJob(
867         com.google.cloud.scheduler.v1.RunJobRequest request) {
868       return io.grpc.stub.ClientCalls.blockingUnaryCall(
869           getChannel(), getRunJobMethod(), getCallOptions(), request);
870     }
871   }
872 
873   /**
874    * A stub to allow clients to do ListenableFuture-style rpc calls to service CloudScheduler.
875    *
876    * <pre>
877    * The Cloud Scheduler API allows external entities to reliably
878    * schedule asynchronous jobs.
879    * </pre>
880    */
881   public static final class CloudSchedulerFutureStub
882       extends io.grpc.stub.AbstractFutureStub<CloudSchedulerFutureStub> {
CloudSchedulerFutureStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions)883     private CloudSchedulerFutureStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
884       super(channel, callOptions);
885     }
886 
887     @java.lang.Override
build( io.grpc.Channel channel, io.grpc.CallOptions callOptions)888     protected CloudSchedulerFutureStub build(
889         io.grpc.Channel channel, io.grpc.CallOptions callOptions) {
890       return new CloudSchedulerFutureStub(channel, callOptions);
891     }
892 
893     /**
894      *
895      *
896      * <pre>
897      * Lists jobs.
898      * </pre>
899      */
900     public com.google.common.util.concurrent.ListenableFuture<
901             com.google.cloud.scheduler.v1.ListJobsResponse>
listJobs(com.google.cloud.scheduler.v1.ListJobsRequest request)902         listJobs(com.google.cloud.scheduler.v1.ListJobsRequest request) {
903       return io.grpc.stub.ClientCalls.futureUnaryCall(
904           getChannel().newCall(getListJobsMethod(), getCallOptions()), request);
905     }
906 
907     /**
908      *
909      *
910      * <pre>
911      * Gets a job.
912      * </pre>
913      */
914     public com.google.common.util.concurrent.ListenableFuture<com.google.cloud.scheduler.v1.Job>
getJob(com.google.cloud.scheduler.v1.GetJobRequest request)915         getJob(com.google.cloud.scheduler.v1.GetJobRequest request) {
916       return io.grpc.stub.ClientCalls.futureUnaryCall(
917           getChannel().newCall(getGetJobMethod(), getCallOptions()), request);
918     }
919 
920     /**
921      *
922      *
923      * <pre>
924      * Creates a job.
925      * </pre>
926      */
927     public com.google.common.util.concurrent.ListenableFuture<com.google.cloud.scheduler.v1.Job>
createJob(com.google.cloud.scheduler.v1.CreateJobRequest request)928         createJob(com.google.cloud.scheduler.v1.CreateJobRequest request) {
929       return io.grpc.stub.ClientCalls.futureUnaryCall(
930           getChannel().newCall(getCreateJobMethod(), getCallOptions()), request);
931     }
932 
933     /**
934      *
935      *
936      * <pre>
937      * Updates a job.
938      * If successful, the updated [Job][google.cloud.scheduler.v1.Job] is
939      * returned. If the job does not exist, `NOT_FOUND` is returned.
940      * If UpdateJob does not successfully return, it is possible for the
941      * job to be in an
942      * [Job.State.UPDATE_FAILED][google.cloud.scheduler.v1.Job.State.UPDATE_FAILED]
943      * state. A job in this state may not be executed. If this happens, retry the
944      * UpdateJob request until a successful response is received.
945      * </pre>
946      */
947     public com.google.common.util.concurrent.ListenableFuture<com.google.cloud.scheduler.v1.Job>
updateJob(com.google.cloud.scheduler.v1.UpdateJobRequest request)948         updateJob(com.google.cloud.scheduler.v1.UpdateJobRequest request) {
949       return io.grpc.stub.ClientCalls.futureUnaryCall(
950           getChannel().newCall(getUpdateJobMethod(), getCallOptions()), request);
951     }
952 
953     /**
954      *
955      *
956      * <pre>
957      * Deletes a job.
958      * </pre>
959      */
deleteJob( com.google.cloud.scheduler.v1.DeleteJobRequest request)960     public com.google.common.util.concurrent.ListenableFuture<com.google.protobuf.Empty> deleteJob(
961         com.google.cloud.scheduler.v1.DeleteJobRequest request) {
962       return io.grpc.stub.ClientCalls.futureUnaryCall(
963           getChannel().newCall(getDeleteJobMethod(), getCallOptions()), request);
964     }
965 
966     /**
967      *
968      *
969      * <pre>
970      * Pauses a job.
971      * If a job is paused then the system will stop executing the job
972      * until it is re-enabled via
973      * [ResumeJob][google.cloud.scheduler.v1.CloudScheduler.ResumeJob]. The state
974      * of the job is stored in [state][google.cloud.scheduler.v1.Job.state]; if
975      * paused it will be set to
976      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. A job must
977      * be in [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED] to
978      * be paused.
979      * </pre>
980      */
981     public com.google.common.util.concurrent.ListenableFuture<com.google.cloud.scheduler.v1.Job>
pauseJob(com.google.cloud.scheduler.v1.PauseJobRequest request)982         pauseJob(com.google.cloud.scheduler.v1.PauseJobRequest request) {
983       return io.grpc.stub.ClientCalls.futureUnaryCall(
984           getChannel().newCall(getPauseJobMethod(), getCallOptions()), request);
985     }
986 
987     /**
988      *
989      *
990      * <pre>
991      * Resume a job.
992      * This method reenables a job after it has been
993      * [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]. The state
994      * of a job is stored in [Job.state][google.cloud.scheduler.v1.Job.state];
995      * after calling this method it will be set to
996      * [Job.State.ENABLED][google.cloud.scheduler.v1.Job.State.ENABLED]. A job
997      * must be in [Job.State.PAUSED][google.cloud.scheduler.v1.Job.State.PAUSED]
998      * to be resumed.
999      * </pre>
1000      */
1001     public com.google.common.util.concurrent.ListenableFuture<com.google.cloud.scheduler.v1.Job>
resumeJob(com.google.cloud.scheduler.v1.ResumeJobRequest request)1002         resumeJob(com.google.cloud.scheduler.v1.ResumeJobRequest request) {
1003       return io.grpc.stub.ClientCalls.futureUnaryCall(
1004           getChannel().newCall(getResumeJobMethod(), getCallOptions()), request);
1005     }
1006 
1007     /**
1008      *
1009      *
1010      * <pre>
1011      * Forces a job to run now.
1012      * When this method is called, Cloud Scheduler will dispatch the job, even
1013      * if the job is already running.
1014      * </pre>
1015      */
1016     public com.google.common.util.concurrent.ListenableFuture<com.google.cloud.scheduler.v1.Job>
runJob(com.google.cloud.scheduler.v1.RunJobRequest request)1017         runJob(com.google.cloud.scheduler.v1.RunJobRequest request) {
1018       return io.grpc.stub.ClientCalls.futureUnaryCall(
1019           getChannel().newCall(getRunJobMethod(), getCallOptions()), request);
1020     }
1021   }
1022 
1023   private static final int METHODID_LIST_JOBS = 0;
1024   private static final int METHODID_GET_JOB = 1;
1025   private static final int METHODID_CREATE_JOB = 2;
1026   private static final int METHODID_UPDATE_JOB = 3;
1027   private static final int METHODID_DELETE_JOB = 4;
1028   private static final int METHODID_PAUSE_JOB = 5;
1029   private static final int METHODID_RESUME_JOB = 6;
1030   private static final int METHODID_RUN_JOB = 7;
1031 
1032   private static final class MethodHandlers<Req, Resp>
1033       implements io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>,
1034           io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>,
1035           io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>,
1036           io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> {
1037     private final AsyncService serviceImpl;
1038     private final int methodId;
1039 
MethodHandlers(AsyncService serviceImpl, int methodId)1040     MethodHandlers(AsyncService serviceImpl, int methodId) {
1041       this.serviceImpl = serviceImpl;
1042       this.methodId = methodId;
1043     }
1044 
1045     @java.lang.Override
1046     @java.lang.SuppressWarnings("unchecked")
invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver)1047     public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) {
1048       switch (methodId) {
1049         case METHODID_LIST_JOBS:
1050           serviceImpl.listJobs(
1051               (com.google.cloud.scheduler.v1.ListJobsRequest) request,
1052               (io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.ListJobsResponse>)
1053                   responseObserver);
1054           break;
1055         case METHODID_GET_JOB:
1056           serviceImpl.getJob(
1057               (com.google.cloud.scheduler.v1.GetJobRequest) request,
1058               (io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job>) responseObserver);
1059           break;
1060         case METHODID_CREATE_JOB:
1061           serviceImpl.createJob(
1062               (com.google.cloud.scheduler.v1.CreateJobRequest) request,
1063               (io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job>) responseObserver);
1064           break;
1065         case METHODID_UPDATE_JOB:
1066           serviceImpl.updateJob(
1067               (com.google.cloud.scheduler.v1.UpdateJobRequest) request,
1068               (io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job>) responseObserver);
1069           break;
1070         case METHODID_DELETE_JOB:
1071           serviceImpl.deleteJob(
1072               (com.google.cloud.scheduler.v1.DeleteJobRequest) request,
1073               (io.grpc.stub.StreamObserver<com.google.protobuf.Empty>) responseObserver);
1074           break;
1075         case METHODID_PAUSE_JOB:
1076           serviceImpl.pauseJob(
1077               (com.google.cloud.scheduler.v1.PauseJobRequest) request,
1078               (io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job>) responseObserver);
1079           break;
1080         case METHODID_RESUME_JOB:
1081           serviceImpl.resumeJob(
1082               (com.google.cloud.scheduler.v1.ResumeJobRequest) request,
1083               (io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job>) responseObserver);
1084           break;
1085         case METHODID_RUN_JOB:
1086           serviceImpl.runJob(
1087               (com.google.cloud.scheduler.v1.RunJobRequest) request,
1088               (io.grpc.stub.StreamObserver<com.google.cloud.scheduler.v1.Job>) responseObserver);
1089           break;
1090         default:
1091           throw new AssertionError();
1092       }
1093     }
1094 
1095     @java.lang.Override
1096     @java.lang.SuppressWarnings("unchecked")
invoke( io.grpc.stub.StreamObserver<Resp> responseObserver)1097     public io.grpc.stub.StreamObserver<Req> invoke(
1098         io.grpc.stub.StreamObserver<Resp> responseObserver) {
1099       switch (methodId) {
1100         default:
1101           throw new AssertionError();
1102       }
1103     }
1104   }
1105 
bindService(AsyncService service)1106   public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) {
1107     return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor())
1108         .addMethod(
1109             getListJobsMethod(),
1110             io.grpc.stub.ServerCalls.asyncUnaryCall(
1111                 new MethodHandlers<
1112                     com.google.cloud.scheduler.v1.ListJobsRequest,
1113                     com.google.cloud.scheduler.v1.ListJobsResponse>(service, METHODID_LIST_JOBS)))
1114         .addMethod(
1115             getGetJobMethod(),
1116             io.grpc.stub.ServerCalls.asyncUnaryCall(
1117                 new MethodHandlers<
1118                     com.google.cloud.scheduler.v1.GetJobRequest, com.google.cloud.scheduler.v1.Job>(
1119                     service, METHODID_GET_JOB)))
1120         .addMethod(
1121             getCreateJobMethod(),
1122             io.grpc.stub.ServerCalls.asyncUnaryCall(
1123                 new MethodHandlers<
1124                     com.google.cloud.scheduler.v1.CreateJobRequest,
1125                     com.google.cloud.scheduler.v1.Job>(service, METHODID_CREATE_JOB)))
1126         .addMethod(
1127             getUpdateJobMethod(),
1128             io.grpc.stub.ServerCalls.asyncUnaryCall(
1129                 new MethodHandlers<
1130                     com.google.cloud.scheduler.v1.UpdateJobRequest,
1131                     com.google.cloud.scheduler.v1.Job>(service, METHODID_UPDATE_JOB)))
1132         .addMethod(
1133             getDeleteJobMethod(),
1134             io.grpc.stub.ServerCalls.asyncUnaryCall(
1135                 new MethodHandlers<
1136                     com.google.cloud.scheduler.v1.DeleteJobRequest, com.google.protobuf.Empty>(
1137                     service, METHODID_DELETE_JOB)))
1138         .addMethod(
1139             getPauseJobMethod(),
1140             io.grpc.stub.ServerCalls.asyncUnaryCall(
1141                 new MethodHandlers<
1142                     com.google.cloud.scheduler.v1.PauseJobRequest,
1143                     com.google.cloud.scheduler.v1.Job>(service, METHODID_PAUSE_JOB)))
1144         .addMethod(
1145             getResumeJobMethod(),
1146             io.grpc.stub.ServerCalls.asyncUnaryCall(
1147                 new MethodHandlers<
1148                     com.google.cloud.scheduler.v1.ResumeJobRequest,
1149                     com.google.cloud.scheduler.v1.Job>(service, METHODID_RESUME_JOB)))
1150         .addMethod(
1151             getRunJobMethod(),
1152             io.grpc.stub.ServerCalls.asyncUnaryCall(
1153                 new MethodHandlers<
1154                     com.google.cloud.scheduler.v1.RunJobRequest, com.google.cloud.scheduler.v1.Job>(
1155                     service, METHODID_RUN_JOB)))
1156         .build();
1157   }
1158 
1159   private abstract static class CloudSchedulerBaseDescriptorSupplier
1160       implements io.grpc.protobuf.ProtoFileDescriptorSupplier,
1161           io.grpc.protobuf.ProtoServiceDescriptorSupplier {
CloudSchedulerBaseDescriptorSupplier()1162     CloudSchedulerBaseDescriptorSupplier() {}
1163 
1164     @java.lang.Override
getFileDescriptor()1165     public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() {
1166       return com.google.cloud.scheduler.v1.SchedulerProto.getDescriptor();
1167     }
1168 
1169     @java.lang.Override
getServiceDescriptor()1170     public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() {
1171       return getFileDescriptor().findServiceByName("CloudScheduler");
1172     }
1173   }
1174 
1175   private static final class CloudSchedulerFileDescriptorSupplier
1176       extends CloudSchedulerBaseDescriptorSupplier {
CloudSchedulerFileDescriptorSupplier()1177     CloudSchedulerFileDescriptorSupplier() {}
1178   }
1179 
1180   private static final class CloudSchedulerMethodDescriptorSupplier
1181       extends CloudSchedulerBaseDescriptorSupplier
1182       implements io.grpc.protobuf.ProtoMethodDescriptorSupplier {
1183     private final String methodName;
1184 
CloudSchedulerMethodDescriptorSupplier(String methodName)1185     CloudSchedulerMethodDescriptorSupplier(String methodName) {
1186       this.methodName = methodName;
1187     }
1188 
1189     @java.lang.Override
getMethodDescriptor()1190     public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() {
1191       return getServiceDescriptor().findMethodByName(methodName);
1192     }
1193   }
1194 
1195   private static volatile io.grpc.ServiceDescriptor serviceDescriptor;
1196 
getServiceDescriptor()1197   public static io.grpc.ServiceDescriptor getServiceDescriptor() {
1198     io.grpc.ServiceDescriptor result = serviceDescriptor;
1199     if (result == null) {
1200       synchronized (CloudSchedulerGrpc.class) {
1201         result = serviceDescriptor;
1202         if (result == null) {
1203           serviceDescriptor =
1204               result =
1205                   io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME)
1206                       .setSchemaDescriptor(new CloudSchedulerFileDescriptorSupplier())
1207                       .addMethod(getListJobsMethod())
1208                       .addMethod(getGetJobMethod())
1209                       .addMethod(getCreateJobMethod())
1210                       .addMethod(getUpdateJobMethod())
1211                       .addMethod(getDeleteJobMethod())
1212                       .addMethod(getPauseJobMethod())
1213                       .addMethod(getResumeJobMethod())
1214                       .addMethod(getRunJobMethod())
1215                       .build();
1216         }
1217       }
1218     }
1219     return result;
1220   }
1221 }
1222