1// SPDX-License-Identifier: MIT
2
3// Code generated by protoc-gen-go. DO NOT EDIT.
4// versions:
5// protoc-gen-go v1.36.12
6// protoc (unknown)
7// source: ermite/runner.proto
8
9package ermite
10
11import (
12 protoreflect "google.golang.org/protobuf/reflect/protoreflect"
13 protoimpl "google.golang.org/protobuf/runtime/protoimpl"
14 durationpb "google.golang.org/protobuf/types/known/durationpb"
15 timestamppb "google.golang.org/protobuf/types/known/timestamppb"
16 reflect "reflect"
17 sync "sync"
18 unsafe "unsafe"
19)
20
21const (
22 // Verify that this generated code is sufficiently up-to-date.
23 _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
24 // Verify that runtime/protoimpl is sufficiently up-to-date.
25 _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
26)
27
28// CiStatus is where a run, a job or a check is in its life. It is the same
29// as GitHub's status, without the rarely used values.
30type CiStatus int32
31
32const (
33 // Not set. In a filter it means every status. Never returned by the server.
34 CiStatus_CI_STATUS_UNSPECIFIED CiStatus = 0
35 // Waiting: for a runner, for the jobs it needs, or for its turn
36 // (max-parallel).
37 CiStatus_CI_STATUS_QUEUED CiStatus = 1
38 // At least one job has been given to a runner and has not ended.
39 CiStatus_CI_STATUS_IN_PROGRESS CiStatus = 2
40 // Over. The conclusion says how it ended.
41 CiStatus_CI_STATUS_COMPLETED CiStatus = 3
42)
43
44// Enum value maps for CiStatus.
45var (
46 CiStatus_name = map[int32]string{
47 0: "CI_STATUS_UNSPECIFIED",
48 1: "CI_STATUS_QUEUED",
49 2: "CI_STATUS_IN_PROGRESS",
50 3: "CI_STATUS_COMPLETED",
51 }
52 CiStatus_value = map[string]int32{
53 "CI_STATUS_UNSPECIFIED": 0,
54 "CI_STATUS_QUEUED": 1,
55 "CI_STATUS_IN_PROGRESS": 2,
56 "CI_STATUS_COMPLETED": 3,
57 }
58)
59
60func (x CiStatus) Enum() *CiStatus {
61 p := new(CiStatus)
62 *p = x
63 return p
64}
65
66func (x CiStatus) String() string {
67 return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
68}
69
70func (CiStatus) Descriptor() protoreflect.EnumDescriptor {
71 return file_ermite_runner_proto_enumTypes[0].Descriptor()
72}
73
74func (CiStatus) Type() protoreflect.EnumType {
75 return &file_ermite_runner_proto_enumTypes[0]
76}
77
78func (x CiStatus) Number() protoreflect.EnumNumber {
79 return protoreflect.EnumNumber(x)
80}
81
82// Deprecated: Use CiStatus.Descriptor instead.
83func (CiStatus) EnumDescriptor() ([]byte, []int) {
84 return file_ermite_runner_proto_rawDescGZIP(), []int{0}
85}
86
87// CiConclusion is how a run, a job, a step or a check ended, with GitHub's
88// values and meaning. It is unset (CI_CONCLUSION_UNSPECIFIED) until the status is
89// COMPLETED.
90type CiConclusion int32
91
92const (
93 // Not completed yet. Never returned by the server for a completed item.
94 CiConclusion_CI_CONCLUSION_UNSPECIFIED CiConclusion = 0
95 // Everything it ran succeeded.
96 CiConclusion_CI_CONCLUSION_SUCCESS CiConclusion = 1
97 // A step failed, or the job failed for another reason described in
98 // RunJob.error (runner lost, queue timeout, log limit, feature not
99 // supported yet, invalid workflow file).
100 CiConclusion_CI_CONCLUSION_FAILURE CiConclusion = 2
101 // Cancelled by the owner, or by fail-fast, or because the runner shut down.
102 CiConclusion_CI_CONCLUSION_CANCELLED CiConclusion = 3
103 // Never ran: its "if" was false, or a job it needs did not succeed, or it was
104 // not selected. Never reported by a runner.
105 CiConclusion_CI_CONCLUSION_SKIPPED CiConclusion = 4
106 // Exceeded its timeout.
107 CiConclusion_CI_CONCLUSION_TIMED_OUT CiConclusion = 5
108 // Neither a success nor a failure. Defined for parity with GitHub; no
109 // workflow job ends this way yet. For merging it counts as a success.
110 CiConclusion_CI_CONCLUSION_NEUTRAL CiConclusion = 6
111 // Waits for a human action (for example the approval of an environment).
112 // Defined for parity with GitHub; the server does not produce it before
113 // environments exist. For merging it counts as a failure.
114 CiConclusion_CI_CONCLUSION_ACTION_REQUIRED CiConclusion = 7
115)
116
117// Enum value maps for CiConclusion.
118var (
119 CiConclusion_name = map[int32]string{
120 0: "CI_CONCLUSION_UNSPECIFIED",
121 1: "CI_CONCLUSION_SUCCESS",
122 2: "CI_CONCLUSION_FAILURE",
123 3: "CI_CONCLUSION_CANCELLED",
124 4: "CI_CONCLUSION_SKIPPED",
125 5: "CI_CONCLUSION_TIMED_OUT",
126 6: "CI_CONCLUSION_NEUTRAL",
127 7: "CI_CONCLUSION_ACTION_REQUIRED",
128 }
129 CiConclusion_value = map[string]int32{
130 "CI_CONCLUSION_UNSPECIFIED": 0,
131 "CI_CONCLUSION_SUCCESS": 1,
132 "CI_CONCLUSION_FAILURE": 2,
133 "CI_CONCLUSION_CANCELLED": 3,
134 "CI_CONCLUSION_SKIPPED": 4,
135 "CI_CONCLUSION_TIMED_OUT": 5,
136 "CI_CONCLUSION_NEUTRAL": 6,
137 "CI_CONCLUSION_ACTION_REQUIRED": 7,
138 }
139)
140
141func (x CiConclusion) Enum() *CiConclusion {
142 p := new(CiConclusion)
143 *p = x
144 return p
145}
146
147func (x CiConclusion) String() string {
148 return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
149}
150
151func (CiConclusion) Descriptor() protoreflect.EnumDescriptor {
152 return file_ermite_runner_proto_enumTypes[1].Descriptor()
153}
154
155func (CiConclusion) Type() protoreflect.EnumType {
156 return &file_ermite_runner_proto_enumTypes[1]
157}
158
159func (x CiConclusion) Number() protoreflect.EnumNumber {
160 return protoreflect.EnumNumber(x)
161}
162
163// Deprecated: Use CiConclusion.Descriptor instead.
164func (CiConclusion) EnumDescriptor() ([]byte, []int) {
165 return file_ermite_runner_proto_rawDescGZIP(), []int{1}
166}
167
168// StepState is where a step is in its life.
169type StepState int32
170
171const (
172 // Not set. Rejected in requests, never returned by the server.
173 StepState_STEP_STATE_UNSPECIFIED StepState = 0
174 // Known but not started.
175 StepState_STEP_STATE_PENDING StepState = 1
176 // Running.
177 StepState_STEP_STATE_IN_PROGRESS StepState = 2
178 // Over. The conclusion says how it ended. A step that did not run because
179 // of its "if" or an earlier failure is COMPLETED with CI_CONCLUSION_SKIPPED.
180 StepState_STEP_STATE_COMPLETED StepState = 3
181)
182
183// Enum value maps for StepState.
184var (
185 StepState_name = map[int32]string{
186 0: "STEP_STATE_UNSPECIFIED",
187 1: "STEP_STATE_PENDING",
188 2: "STEP_STATE_IN_PROGRESS",
189 3: "STEP_STATE_COMPLETED",
190 }
191 StepState_value = map[string]int32{
192 "STEP_STATE_UNSPECIFIED": 0,
193 "STEP_STATE_PENDING": 1,
194 "STEP_STATE_IN_PROGRESS": 2,
195 "STEP_STATE_COMPLETED": 3,
196 }
197)
198
199func (x StepState) Enum() *StepState {
200 p := new(StepState)
201 *p = x
202 return p
203}
204
205func (x StepState) String() string {
206 return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
207}
208
209func (StepState) Descriptor() protoreflect.EnumDescriptor {
210 return file_ermite_runner_proto_enumTypes[2].Descriptor()
211}
212
213func (StepState) Type() protoreflect.EnumType {
214 return &file_ermite_runner_proto_enumTypes[2]
215}
216
217func (x StepState) Number() protoreflect.EnumNumber {
218 return protoreflect.EnumNumber(x)
219}
220
221// Deprecated: Use StepState.Descriptor instead.
222func (StepState) EnumDescriptor() ([]byte, []int) {
223 return file_ermite_runner_proto_rawDescGZIP(), []int{2}
224}
225
226// RunnerIsolation is how a runner isolates each job from the host and from
227// other jobs. The runner chooses it (auto-detection included) and reports it
228// at registration; the job page shows it.
229type RunnerIsolation int32
230
231const (
232 // Not set. Rejected at registration, never returned by the server.
233 RunnerIsolation_RUNNER_ISOLATION_UNSPECIFIED RunnerIsolation = 0
234 // One micro-VM per job, destroyed at the end.
235 RunnerIsolation_RUNNER_ISOLATION_VM RunnerIsolation = 1
236 // One container per job with its own Docker daemon, run by the sysbox
237 // runtime. Shares the host kernel.
238 RunnerIsolation_RUNNER_ISOLATION_CONTAINER_SYSBOX RunnerIsolation = 2
239 // One privileged container per job with its own Docker daemon. Shares the
240 // host kernel and is equivalent to root on the host: the weakest mode.
241 RunnerIsolation_RUNNER_ISOLATION_CONTAINER_PRIVILEGED RunnerIsolation = 3
242)
243
244// Enum value maps for RunnerIsolation.
245var (
246 RunnerIsolation_name = map[int32]string{
247 0: "RUNNER_ISOLATION_UNSPECIFIED",
248 1: "RUNNER_ISOLATION_VM",
249 2: "RUNNER_ISOLATION_CONTAINER_SYSBOX",
250 3: "RUNNER_ISOLATION_CONTAINER_PRIVILEGED",
251 }
252 RunnerIsolation_value = map[string]int32{
253 "RUNNER_ISOLATION_UNSPECIFIED": 0,
254 "RUNNER_ISOLATION_VM": 1,
255 "RUNNER_ISOLATION_CONTAINER_SYSBOX": 2,
256 "RUNNER_ISOLATION_CONTAINER_PRIVILEGED": 3,
257 }
258)
259
260func (x RunnerIsolation) Enum() *RunnerIsolation {
261 p := new(RunnerIsolation)
262 *p = x
263 return p
264}
265
266func (x RunnerIsolation) String() string {
267 return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
268}
269
270func (RunnerIsolation) Descriptor() protoreflect.EnumDescriptor {
271 return file_ermite_runner_proto_enumTypes[3].Descriptor()
272}
273
274func (RunnerIsolation) Type() protoreflect.EnumType {
275 return &file_ermite_runner_proto_enumTypes[3]
276}
277
278func (x RunnerIsolation) Number() protoreflect.EnumNumber {
279 return protoreflect.EnumNumber(x)
280}
281
282// Deprecated: Use RunnerIsolation.Descriptor instead.
283func (RunnerIsolation) EnumDescriptor() ([]byte, []int) {
284 return file_ermite_runner_proto_rawDescGZIP(), []int{3}
285}
286
287// CancelReason says why the server asks a runner to stop a job.
288type CancelReason int32
289
290const (
291 // Not set. Never sent in a CancelRequest.
292 CancelReason_CANCEL_REASON_UNSPECIFIED CancelReason = 0
293 // The owner cancelled the run (RunService.CancelRun, web or CLI). The job
294 // ends CI_CONCLUSION_CANCELLED.
295 CancelReason_CANCEL_REASON_USER CancelReason = 1
296 // Another job of the same matrix failed and the strategy has fail-fast. The
297 // job ends CI_CONCLUSION_CANCELLED.
298 CancelReason_CANCEL_REASON_FAIL_FAST CancelReason = 2
299 // The job exceeded its time budget (see Job.timeout_minutes). The job ends
300 // CI_CONCLUSION_TIMED_OUT.
301 CancelReason_CANCEL_REASON_TIMEOUT CancelReason = 3
302)
303
304// Enum value maps for CancelReason.
305var (
306 CancelReason_name = map[int32]string{
307 0: "CANCEL_REASON_UNSPECIFIED",
308 1: "CANCEL_REASON_USER",
309 2: "CANCEL_REASON_FAIL_FAST",
310 3: "CANCEL_REASON_TIMEOUT",
311 }
312 CancelReason_value = map[string]int32{
313 "CANCEL_REASON_UNSPECIFIED": 0,
314 "CANCEL_REASON_USER": 1,
315 "CANCEL_REASON_FAIL_FAST": 2,
316 "CANCEL_REASON_TIMEOUT": 3,
317 }
318)
319
320func (x CancelReason) Enum() *CancelReason {
321 p := new(CancelReason)
322 *p = x
323 return p
324}
325
326func (x CancelReason) String() string {
327 return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
328}
329
330func (CancelReason) Descriptor() protoreflect.EnumDescriptor {
331 return file_ermite_runner_proto_enumTypes[4].Descriptor()
332}
333
334func (CancelReason) Type() protoreflect.EnumType {
335 return &file_ermite_runner_proto_enumTypes[4]
336}
337
338func (x CancelReason) Number() protoreflect.EnumNumber {
339 return protoreflect.EnumNumber(x)
340}
341
342// Deprecated: Use CancelReason.Descriptor instead.
343func (CancelReason) EnumDescriptor() ([]byte, []int) {
344 return file_ermite_runner_proto_rawDescGZIP(), []int{4}
345}
346
347// RegisterRunnerRequest describes the runner to register.
348type RegisterRunnerRequest struct {
349 state protoimpl.MessageState `protogen:"open.v1"`
350 // Name identifies the runner for people (job page, logs, ListRunners) and is
351 // unique: 1 to 64 characters among letters, digits, ".", "_" and "-". It is
352 // not a label and never matches runs-on.
353 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
354 // Labels are the labels the runner adds to its implicit ones: at most 64,
355 // each 1 to 64 characters among letters, digits, ".", "_" and "-", for
356 // example "ubuntu-latest". Comparison is case-insensitive and duplicates
357 // are removed. The server adds the implicit labels "self-hosted", the os
358 // and the arch ("linux", "x64" or "arm64"); the runner name is not a label.
359 Labels []string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty"`
360 // Version is the release of the runner, for example "v0.1.0", or "devel".
361 // Informational, at most 64 characters.
362 Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
363 // Isolation is how the runner isolates jobs. Required.
364 Isolation RunnerIsolation `protobuf:"varint,4,opt,name=isolation,proto3,enum=ermite.RunnerIsolation" json:"isolation,omitempty"`
365 // Arch is the CPU architecture, in GitHub's names: "x64" or "arm64". Other
366 // values are invalid_argument (the set may grow with compatible additions).
367 Arch string `protobuf:"bytes,5,opt,name=arch,proto3" json:"arch,omitempty"`
368 // Os is the operating system: "linux". Other values are invalid_argument
369 // (the set may grow with compatible additions).
370 Os string `protobuf:"bytes,6,opt,name=os,proto3" json:"os,omitempty"`
371 // Replace removes the runner that already has this name, if any, before
372 // registering this one: its runner token is revoked at once, as in
373 // RunService.RemoveRunner, and a job it is running is not affected. The new
374 // runner gets a new runner_id. Needs the same scope as registering. Without
375 // replace, a name in use is already_exists. It is how a runner re-registers
376 // after losing its state.
377 Replace bool `protobuf:"varint,7,opt,name=replace,proto3" json:"replace,omitempty"`
378 unknownFields protoimpl.UnknownFields
379 sizeCache protoimpl.SizeCache
380}
381
382func (x *RegisterRunnerRequest) Reset() {
383 *x = RegisterRunnerRequest{}
384 mi := &file_ermite_runner_proto_msgTypes[0]
385 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
386 ms.StoreMessageInfo(mi)
387}
388
389func (x *RegisterRunnerRequest) String() string {
390 return protoimpl.X.MessageStringOf(x)
391}
392
393func (*RegisterRunnerRequest) ProtoMessage() {}
394
395func (x *RegisterRunnerRequest) ProtoReflect() protoreflect.Message {
396 mi := &file_ermite_runner_proto_msgTypes[0]
397 if x != nil {
398 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
399 if ms.LoadMessageInfo() == nil {
400 ms.StoreMessageInfo(mi)
401 }
402 return ms
403 }
404 return mi.MessageOf(x)
405}
406
407// Deprecated: Use RegisterRunnerRequest.ProtoReflect.Descriptor instead.
408func (*RegisterRunnerRequest) Descriptor() ([]byte, []int) {
409 return file_ermite_runner_proto_rawDescGZIP(), []int{0}
410}
411
412func (x *RegisterRunnerRequest) GetName() string {
413 if x != nil {
414 return x.Name
415 }
416 return ""
417}
418
419func (x *RegisterRunnerRequest) GetLabels() []string {
420 if x != nil {
421 return x.Labels
422 }
423 return nil
424}
425
426func (x *RegisterRunnerRequest) GetVersion() string {
427 if x != nil {
428 return x.Version
429 }
430 return ""
431}
432
433func (x *RegisterRunnerRequest) GetIsolation() RunnerIsolation {
434 if x != nil {
435 return x.Isolation
436 }
437 return RunnerIsolation_RUNNER_ISOLATION_UNSPECIFIED
438}
439
440func (x *RegisterRunnerRequest) GetArch() string {
441 if x != nil {
442 return x.Arch
443 }
444 return ""
445}
446
447func (x *RegisterRunnerRequest) GetOs() string {
448 if x != nil {
449 return x.Os
450 }
451 return ""
452}
453
454func (x *RegisterRunnerRequest) GetReplace() bool {
455 if x != nil {
456 return x.Replace
457 }
458 return false
459}
460
461// RegisterRunnerResponse holds the new runner and its secret.
462type RegisterRunnerResponse struct {
463 state protoimpl.MessageState `protogen:"open.v1"`
464 // RunnerId identifies the runner in ListRunners and RemoveRunner. It is not
465 // a secret.
466 RunnerId string `protobuf:"bytes,1,opt,name=runner_id,json=runnerId,proto3" json:"runner_id,omitempty"`
467 // RunnerToken is the secret of the runner, to present as "Authorization:
468 // Bearer <runner_token>" to FetchJob: "ermiterun_" and 43 base64url
469 // characters (32 random bytes, no padding). It is returned once: the server
470 // keeps only its SHA-256, the runner must store it (mode 0600). It stops
471 // working when the runner is removed or replaced.
472 RunnerToken string `protobuf:"bytes,2,opt,name=runner_token,json=runnerToken,proto3" json:"runner_token,omitempty"`
473 unknownFields protoimpl.UnknownFields
474 sizeCache protoimpl.SizeCache
475}
476
477func (x *RegisterRunnerResponse) Reset() {
478 *x = RegisterRunnerResponse{}
479 mi := &file_ermite_runner_proto_msgTypes[1]
480 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
481 ms.StoreMessageInfo(mi)
482}
483
484func (x *RegisterRunnerResponse) String() string {
485 return protoimpl.X.MessageStringOf(x)
486}
487
488func (*RegisterRunnerResponse) ProtoMessage() {}
489
490func (x *RegisterRunnerResponse) ProtoReflect() protoreflect.Message {
491 mi := &file_ermite_runner_proto_msgTypes[1]
492 if x != nil {
493 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
494 if ms.LoadMessageInfo() == nil {
495 ms.StoreMessageInfo(mi)
496 }
497 return ms
498 }
499 return mi.MessageOf(x)
500}
501
502// Deprecated: Use RegisterRunnerResponse.ProtoReflect.Descriptor instead.
503func (*RegisterRunnerResponse) Descriptor() ([]byte, []int) {
504 return file_ermite_runner_proto_rawDescGZIP(), []int{1}
505}
506
507func (x *RegisterRunnerResponse) GetRunnerId() string {
508 if x != nil {
509 return x.RunnerId
510 }
511 return ""
512}
513
514func (x *RegisterRunnerResponse) GetRunnerToken() string {
515 if x != nil {
516 return x.RunnerToken
517 }
518 return ""
519}
520
521// FetchJobRequest asks for a job.
522type FetchJobRequest struct {
523 state protoimpl.MessageState `protogen:"open.v1"`
524 // Labels narrows the labels offered for this call. Empty means all the
525 // labels of the runner, which is the normal case. Otherwise each one must be
526 // a label of the runner (invalid_argument if not) and only jobs whose runs-on
527 // labels are all among them are offered.
528 Labels []string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty"`
529 // PollId identifies this poll, chosen by the client (for example 16 random
530 // bytes in base64url), 1 to 64 characters among letters, digits, "_" and
531 // "-". A client that retries a call whose response it did not get sends the
532 // same poll_id, and gets the assignment the first call made, if it made one
533 // (see FetchJob). A new poll uses a new id. Empty means no retry protection:
534 // a lost assignment is then recovered by the acknowledgement timeout alone.
535 PollId string `protobuf:"bytes,2,opt,name=poll_id,json=pollId,proto3" json:"poll_id,omitempty"`
536 unknownFields protoimpl.UnknownFields
537 sizeCache protoimpl.SizeCache
538}
539
540func (x *FetchJobRequest) Reset() {
541 *x = FetchJobRequest{}
542 mi := &file_ermite_runner_proto_msgTypes[2]
543 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
544 ms.StoreMessageInfo(mi)
545}
546
547func (x *FetchJobRequest) String() string {
548 return protoimpl.X.MessageStringOf(x)
549}
550
551func (*FetchJobRequest) ProtoMessage() {}
552
553func (x *FetchJobRequest) ProtoReflect() protoreflect.Message {
554 mi := &file_ermite_runner_proto_msgTypes[2]
555 if x != nil {
556 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
557 if ms.LoadMessageInfo() == nil {
558 ms.StoreMessageInfo(mi)
559 }
560 return ms
561 }
562 return mi.MessageOf(x)
563}
564
565// Deprecated: Use FetchJobRequest.ProtoReflect.Descriptor instead.
566func (*FetchJobRequest) Descriptor() ([]byte, []int) {
567 return file_ermite_runner_proto_rawDescGZIP(), []int{2}
568}
569
570func (x *FetchJobRequest) GetLabels() []string {
571 if x != nil {
572 return x.Labels
573 }
574 return nil
575}
576
577func (x *FetchJobRequest) GetPollId() string {
578 if x != nil {
579 return x.PollId
580 }
581 return ""
582}
583
584// FetchJobResponse holds the job given to the runner, if any.
585type FetchJobResponse struct {
586 state protoimpl.MessageState `protogen:"open.v1"`
587 // Job is the job to run. Unset when no job was available before the end of
588 // the poll.
589 Job *Job `protobuf:"bytes,1,opt,name=job,proto3" json:"job,omitempty"`
590 // RetryAfter is how long the client waits before its next FetchJob. Unset or
591 // zero means call again at once. The server sets it when it has no job for
592 // the runner and wants to slow polling down (load, shutdown in progress);
593 // clients obey it and may wait longer, never less. Unset when job is set.
594 RetryAfter *durationpb.Duration `protobuf:"bytes,2,opt,name=retry_after,json=retryAfter,proto3" json:"retry_after,omitempty"`
595 unknownFields protoimpl.UnknownFields
596 sizeCache protoimpl.SizeCache
597}
598
599func (x *FetchJobResponse) Reset() {
600 *x = FetchJobResponse{}
601 mi := &file_ermite_runner_proto_msgTypes[3]
602 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
603 ms.StoreMessageInfo(mi)
604}
605
606func (x *FetchJobResponse) String() string {
607 return protoimpl.X.MessageStringOf(x)
608}
609
610func (*FetchJobResponse) ProtoMessage() {}
611
612func (x *FetchJobResponse) ProtoReflect() protoreflect.Message {
613 mi := &file_ermite_runner_proto_msgTypes[3]
614 if x != nil {
615 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
616 if ms.LoadMessageInfo() == nil {
617 ms.StoreMessageInfo(mi)
618 }
619 return ms
620 }
621 return mi.MessageOf(x)
622}
623
624// Deprecated: Use FetchJobResponse.ProtoReflect.Descriptor instead.
625func (*FetchJobResponse) Descriptor() ([]byte, []int) {
626 return file_ermite_runner_proto_rawDescGZIP(), []int{3}
627}
628
629func (x *FetchJobResponse) GetJob() *Job {
630 if x != nil {
631 return x.Job
632 }
633 return nil
634}
635
636func (x *FetchJobResponse) GetRetryAfter() *durationpb.Duration {
637 if x != nil {
638 return x.RetryAfter
639 }
640 return nil
641}
642
643// Job is a job given to a runner: everything needed to run it, nothing more.
644// The runner parses workflow_yaml itself; the protocol does not carry the
645// workflow model, so it does not change when the model grows.
646type Job struct {
647 state protoimpl.MessageState `protogen:"open.v1"`
648 // JobId identifies the job on the server. It is opaque, unique across
649 // repositories and runs, and the same for every attempt of the job. With
650 // attempt it names one execution.
651 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
652 // RunId is the run the job belongs to, the "github.run_id". It is global to
653 // the server.
654 RunId int64 `protobuf:"varint,2,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
655 // Attempt is the attempt of the run this job executes: 1 for the first, and
656 // one more after each RunService.RerunRun. It is the "github.run_attempt".
657 Attempt int32 `protobuf:"varint,3,opt,name=attempt,proto3" json:"attempt,omitempty"`
658 // JobToken is the secret that authenticates this job's UpdateJob,
659 // AppendLog, Heartbeat, WatchJob and CompleteJob calls ("Authorization:
660 // Bearer <job_token>"): "ermitejob_" and 43 base64url characters (32 random
661 // bytes, no padding). It is random, valid from the assignment until the job
662 // ends (and for CompleteJob 24 hours more), survives a server restart and
663 // is shown only in this response, or in a repeat of the same poll_id. It
664 // must stay in the runner host process and never reach the job's code. A new
665 // assignment of the same job has a new token.
666 JobToken string `protobuf:"bytes,4,opt,name=job_token,json=jobToken,proto3" json:"job_token,omitempty"`
667 // WorkflowPath is the path of the workflow file in the repository, for
668 // example ".github/workflows/ci.yml".
669 WorkflowPath string `protobuf:"bytes,5,opt,name=workflow_path,json=workflowPath,proto3" json:"workflow_path,omitempty"`
670 // WorkflowYaml is the content of that file at sha, as is, at most 1 MiB
671 // (larger files fail at planning).
672 WorkflowYaml string `protobuf:"bytes,6,opt,name=workflow_yaml,json=workflowYaml,proto3" json:"workflow_yaml,omitempty"`
673 // JobKey is the key of the job under "jobs:" in the workflow, the
674 // "github.job".
675 JobKey string `protobuf:"bytes,7,opt,name=job_key,json=jobKey,proto3" json:"job_key,omitempty"`
676 // Matrix is the JSON object of the matrix values of this instance of the
677 // job, for example {"os":"linux","go":"1.27"}. "{}" when the job has no
678 // matrix. It is the "matrix" context.
679 Matrix string `protobuf:"bytes,8,opt,name=matrix,proto3" json:"matrix,omitempty"`
680 // Contexts is a JSON object with the contexts that the server computed for
681 // this job: "github", "needs", "strategy", "matrix", "inputs" and "vars", in
682 // the shape GitHub gives them. The contexts "job", "runner", "steps" and
683 // "env" belong to the runner and are not in it. Other keys may be added
684 // later; clients ignore those they do not know.
685 Contexts string `protobuf:"bytes,9,opt,name=contexts,proto3" json:"contexts,omitempty"`
686 // Labels are the runs-on labels of the job, evaluated.
687 Labels []string `protobuf:"bytes,10,rep,name=labels,proto3" json:"labels,omitempty"`
688 // TimeoutMinutes is the timeout of the job in minutes: the value of the
689 // workflow's timeout-minutes, or 360 when it has none. At least 1. The
690 // runner enforces it from the moment it receives the job. The server counts
691 // from the moment of the assignment and adds 60 seconds of slack, so the
692 // runner's own timeout always comes first: when the server's deadline
693 // passes it announces CANCEL_REASON_TIMEOUT, and ends the job itself after
694 // 60 more seconds without a conclusion (see WatchJob).
695 TimeoutMinutes int32 `protobuf:"varint,11,opt,name=timeout_minutes,json=timeoutMinutes,proto3" json:"timeout_minutes,omitempty"`
696 // Repo is the name of the repository.
697 Repo string `protobuf:"bytes,12,opt,name=repo,proto3" json:"repo,omitempty"`
698 // Sha is the full id of the commit the run is for, 40 lowercase
699 // hexadecimal characters for SHA-1. The runner reads the code at it.
700 Sha string `protobuf:"bytes,13,opt,name=sha,proto3" json:"sha,omitempty"`
701 // Ref is the full ref name that triggered the run, for example
702 // "refs/heads/main" or "refs/tags/v1.0.0".
703 Ref string `protobuf:"bytes,14,opt,name=ref,proto3" json:"ref,omitempty"`
704 unknownFields protoimpl.UnknownFields
705 sizeCache protoimpl.SizeCache
706}
707
708func (x *Job) Reset() {
709 *x = Job{}
710 mi := &file_ermite_runner_proto_msgTypes[4]
711 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
712 ms.StoreMessageInfo(mi)
713}
714
715func (x *Job) String() string {
716 return protoimpl.X.MessageStringOf(x)
717}
718
719func (*Job) ProtoMessage() {}
720
721func (x *Job) ProtoReflect() protoreflect.Message {
722 mi := &file_ermite_runner_proto_msgTypes[4]
723 if x != nil {
724 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
725 if ms.LoadMessageInfo() == nil {
726 ms.StoreMessageInfo(mi)
727 }
728 return ms
729 }
730 return mi.MessageOf(x)
731}
732
733// Deprecated: Use Job.ProtoReflect.Descriptor instead.
734func (*Job) Descriptor() ([]byte, []int) {
735 return file_ermite_runner_proto_rawDescGZIP(), []int{4}
736}
737
738func (x *Job) GetJobId() string {
739 if x != nil {
740 return x.JobId
741 }
742 return ""
743}
744
745func (x *Job) GetRunId() int64 {
746 if x != nil {
747 return x.RunId
748 }
749 return 0
750}
751
752func (x *Job) GetAttempt() int32 {
753 if x != nil {
754 return x.Attempt
755 }
756 return 0
757}
758
759func (x *Job) GetJobToken() string {
760 if x != nil {
761 return x.JobToken
762 }
763 return ""
764}
765
766func (x *Job) GetWorkflowPath() string {
767 if x != nil {
768 return x.WorkflowPath
769 }
770 return ""
771}
772
773func (x *Job) GetWorkflowYaml() string {
774 if x != nil {
775 return x.WorkflowYaml
776 }
777 return ""
778}
779
780func (x *Job) GetJobKey() string {
781 if x != nil {
782 return x.JobKey
783 }
784 return ""
785}
786
787func (x *Job) GetMatrix() string {
788 if x != nil {
789 return x.Matrix
790 }
791 return ""
792}
793
794func (x *Job) GetContexts() string {
795 if x != nil {
796 return x.Contexts
797 }
798 return ""
799}
800
801func (x *Job) GetLabels() []string {
802 if x != nil {
803 return x.Labels
804 }
805 return nil
806}
807
808func (x *Job) GetTimeoutMinutes() int32 {
809 if x != nil {
810 return x.TimeoutMinutes
811 }
812 return 0
813}
814
815func (x *Job) GetRepo() string {
816 if x != nil {
817 return x.Repo
818 }
819 return ""
820}
821
822func (x *Job) GetSha() string {
823 if x != nil {
824 return x.Sha
825 }
826 return ""
827}
828
829func (x *Job) GetRef() string {
830 if x != nil {
831 return x.Ref
832 }
833 return ""
834}
835
836// UpdateJobRequest reports the steps of a running job.
837type UpdateJobRequest struct {
838 state protoimpl.MessageState `protogen:"open.v1"`
839 // JobId is the Job.job_id. It must be the job of the token.
840 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
841 // Steps are the steps whose state changed or that are new. Each one is a
842 // full snapshot of its step, applied by number. At most 1,000 steps per job
843 // (invalid_argument beyond). Steps are numbered like GitHub's log: the
844 // implicit "Set up job" is 1, the steps of the workflow follow in order, and
845 // the implicit "Complete job" is last.
846 Steps []*StepUpdate `protobuf:"bytes,2,rep,name=steps,proto3" json:"steps,omitempty"`
847 unknownFields protoimpl.UnknownFields
848 sizeCache protoimpl.SizeCache
849}
850
851func (x *UpdateJobRequest) Reset() {
852 *x = UpdateJobRequest{}
853 mi := &file_ermite_runner_proto_msgTypes[5]
854 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
855 ms.StoreMessageInfo(mi)
856}
857
858func (x *UpdateJobRequest) String() string {
859 return protoimpl.X.MessageStringOf(x)
860}
861
862func (*UpdateJobRequest) ProtoMessage() {}
863
864func (x *UpdateJobRequest) ProtoReflect() protoreflect.Message {
865 mi := &file_ermite_runner_proto_msgTypes[5]
866 if x != nil {
867 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
868 if ms.LoadMessageInfo() == nil {
869 ms.StoreMessageInfo(mi)
870 }
871 return ms
872 }
873 return mi.MessageOf(x)
874}
875
876// Deprecated: Use UpdateJobRequest.ProtoReflect.Descriptor instead.
877func (*UpdateJobRequest) Descriptor() ([]byte, []int) {
878 return file_ermite_runner_proto_rawDescGZIP(), []int{5}
879}
880
881func (x *UpdateJobRequest) GetJobId() string {
882 if x != nil {
883 return x.JobId
884 }
885 return ""
886}
887
888func (x *UpdateJobRequest) GetSteps() []*StepUpdate {
889 if x != nil {
890 return x.Steps
891 }
892 return nil
893}
894
895// StepUpdate is the state of one step as the runner knows it.
896type StepUpdate struct {
897 state protoimpl.MessageState `protogen:"open.v1"`
898 // Number is the 1-based number of the step in the job. It is the number
899 // used by AppendLog.
900 Number int32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
901 // Name is the display name of the step, evaluated: the "name" of the
902 // workflow step, or "Run <first line of the script>", as GitHub shows it.
903 // At most 1,024 characters; the server cuts longer names.
904 Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
905 // State is where the step is.
906 State StepState `protobuf:"varint,3,opt,name=state,proto3,enum=ermite.StepState" json:"state,omitempty"`
907 // Conclusion is how the step ended. Required (not UNSPECIFIED) when state is
908 // COMPLETED, must be UNSPECIFIED otherwise. Allowed values: success,
909 // failure, cancelled, skipped.
910 Conclusion CiConclusion `protobuf:"varint,4,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
911 // StartedAt is when the step started, by the clock of the runner. Required
912 // from IN_PROGRESS on.
913 StartedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
914 // CompletedAt is when the step ended, by the clock of the runner. Required
915 // when state is COMPLETED.
916 CompletedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"`
917 unknownFields protoimpl.UnknownFields
918 sizeCache protoimpl.SizeCache
919}
920
921func (x *StepUpdate) Reset() {
922 *x = StepUpdate{}
923 mi := &file_ermite_runner_proto_msgTypes[6]
924 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
925 ms.StoreMessageInfo(mi)
926}
927
928func (x *StepUpdate) String() string {
929 return protoimpl.X.MessageStringOf(x)
930}
931
932func (*StepUpdate) ProtoMessage() {}
933
934func (x *StepUpdate) ProtoReflect() protoreflect.Message {
935 mi := &file_ermite_runner_proto_msgTypes[6]
936 if x != nil {
937 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
938 if ms.LoadMessageInfo() == nil {
939 ms.StoreMessageInfo(mi)
940 }
941 return ms
942 }
943 return mi.MessageOf(x)
944}
945
946// Deprecated: Use StepUpdate.ProtoReflect.Descriptor instead.
947func (*StepUpdate) Descriptor() ([]byte, []int) {
948 return file_ermite_runner_proto_rawDescGZIP(), []int{6}
949}
950
951func (x *StepUpdate) GetNumber() int32 {
952 if x != nil {
953 return x.Number
954 }
955 return 0
956}
957
958func (x *StepUpdate) GetName() string {
959 if x != nil {
960 return x.Name
961 }
962 return ""
963}
964
965func (x *StepUpdate) GetState() StepState {
966 if x != nil {
967 return x.State
968 }
969 return StepState_STEP_STATE_UNSPECIFIED
970}
971
972func (x *StepUpdate) GetConclusion() CiConclusion {
973 if x != nil {
974 return x.Conclusion
975 }
976 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
977}
978
979func (x *StepUpdate) GetStartedAt() *timestamppb.Timestamp {
980 if x != nil {
981 return x.StartedAt
982 }
983 return nil
984}
985
986func (x *StepUpdate) GetCompletedAt() *timestamppb.Timestamp {
987 if x != nil {
988 return x.CompletedAt
989 }
990 return nil
991}
992
993// UpdateJobResponse is empty.
994type UpdateJobResponse struct {
995 state protoimpl.MessageState `protogen:"open.v1"`
996 unknownFields protoimpl.UnknownFields
997 sizeCache protoimpl.SizeCache
998}
999
1000func (x *UpdateJobResponse) Reset() {
1001 *x = UpdateJobResponse{}
1002 mi := &file_ermite_runner_proto_msgTypes[7]
1003 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1004 ms.StoreMessageInfo(mi)
1005}
1006
1007func (x *UpdateJobResponse) String() string {
1008 return protoimpl.X.MessageStringOf(x)
1009}
1010
1011func (*UpdateJobResponse) ProtoMessage() {}
1012
1013func (x *UpdateJobResponse) ProtoReflect() protoreflect.Message {
1014 mi := &file_ermite_runner_proto_msgTypes[7]
1015 if x != nil {
1016 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1017 if ms.LoadMessageInfo() == nil {
1018 ms.StoreMessageInfo(mi)
1019 }
1020 return ms
1021 }
1022 return mi.MessageOf(x)
1023}
1024
1025// Deprecated: Use UpdateJobResponse.ProtoReflect.Descriptor instead.
1026func (*UpdateJobResponse) Descriptor() ([]byte, []int) {
1027 return file_ermite_runner_proto_rawDescGZIP(), []int{7}
1028}
1029
1030// CompleteJobRequest ends a job.
1031type CompleteJobRequest struct {
1032 state protoimpl.MessageState `protogen:"open.v1"`
1033 // JobId is the Job.job_id. It must be the job of the token.
1034 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1035 // Conclusion is how the job ended. Required: a runner reports
1036 // CI_CONCLUSION_SUCCESS, CI_CONCLUSION_FAILURE, CI_CONCLUSION_CANCELLED or
1037 // CI_CONCLUSION_TIMED_OUT; any other value is invalid_argument. Skipped is
1038 // decided by the server and never reported by a runner.
1039 Conclusion CiConclusion `protobuf:"varint,2,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
1040 // Outputs are the outputs of the job, evaluated by the runner. Names are 1
1041 // to 255 characters among letters, digits, "_" and "-" and begin with a
1042 // letter or "_" and are case-insensitive: two names that differ only by case
1043 // are invalid_argument. Each value is at most 1 MiB, and all names and
1044 // values together at most 1 MiB (1,048,576 bytes); beyond that the whole call
1045 // is rejected with invalid_argument and the runner reports the failure of
1046 // the job without outputs, with a line in the log.
1047 Outputs map[string]string `protobuf:"bytes,3,rep,name=outputs,proto3" json:"outputs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
1048 // RunnerShutdown is true when the runner ends the job because it was told to
1049 // stop (service stopped, signal). Only allowed with CI_CONCLUSION_CANCELLED.
1050 // The server then annotates the job with GitHub's message "The runner has
1051 // received a shutdown signal. This can happen when the runner service is
1052 // stopped, or a manually started runner is canceled." The conclusion
1053 // CANCELLED for this case is to be verified against a recording of GitHub.
1054 RunnerShutdown bool `protobuf:"varint,4,opt,name=runner_shutdown,json=runnerShutdown,proto3" json:"runner_shutdown,omitempty"`
1055 // Steps are the final steps, with the same meaning as UpdateJobRequest.steps,
1056 // applied in the same atomic step as the conclusion.
1057 Steps []*StepUpdate `protobuf:"bytes,5,rep,name=steps,proto3" json:"steps,omitempty"`
1058 unknownFields protoimpl.UnknownFields
1059 sizeCache protoimpl.SizeCache
1060}
1061
1062func (x *CompleteJobRequest) Reset() {
1063 *x = CompleteJobRequest{}
1064 mi := &file_ermite_runner_proto_msgTypes[8]
1065 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1066 ms.StoreMessageInfo(mi)
1067}
1068
1069func (x *CompleteJobRequest) String() string {
1070 return protoimpl.X.MessageStringOf(x)
1071}
1072
1073func (*CompleteJobRequest) ProtoMessage() {}
1074
1075func (x *CompleteJobRequest) ProtoReflect() protoreflect.Message {
1076 mi := &file_ermite_runner_proto_msgTypes[8]
1077 if x != nil {
1078 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1079 if ms.LoadMessageInfo() == nil {
1080 ms.StoreMessageInfo(mi)
1081 }
1082 return ms
1083 }
1084 return mi.MessageOf(x)
1085}
1086
1087// Deprecated: Use CompleteJobRequest.ProtoReflect.Descriptor instead.
1088func (*CompleteJobRequest) Descriptor() ([]byte, []int) {
1089 return file_ermite_runner_proto_rawDescGZIP(), []int{8}
1090}
1091
1092func (x *CompleteJobRequest) GetJobId() string {
1093 if x != nil {
1094 return x.JobId
1095 }
1096 return ""
1097}
1098
1099func (x *CompleteJobRequest) GetConclusion() CiConclusion {
1100 if x != nil {
1101 return x.Conclusion
1102 }
1103 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1104}
1105
1106func (x *CompleteJobRequest) GetOutputs() map[string]string {
1107 if x != nil {
1108 return x.Outputs
1109 }
1110 return nil
1111}
1112
1113func (x *CompleteJobRequest) GetRunnerShutdown() bool {
1114 if x != nil {
1115 return x.RunnerShutdown
1116 }
1117 return false
1118}
1119
1120func (x *CompleteJobRequest) GetSteps() []*StepUpdate {
1121 if x != nil {
1122 return x.Steps
1123 }
1124 return nil
1125}
1126
1127// CompleteJobResponse is the stored result of a job.
1128type CompleteJobResponse struct {
1129 state protoimpl.MessageState `protogen:"open.v1"`
1130 // Conclusion is the conclusion of the job as the server stored it. It is the
1131 // one of the request when applied is true.
1132 Conclusion CiConclusion `protobuf:"varint,1,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
1133 // Error is the error text stored with the job, as RunJob.error. Empty when
1134 // there is none.
1135 Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
1136 // Applied is true when this call ended the job, false when the job had
1137 // already ended (a retry, or the server ended it first) and nothing changed.
1138 Applied bool `protobuf:"varint,3,opt,name=applied,proto3" json:"applied,omitempty"`
1139 unknownFields protoimpl.UnknownFields
1140 sizeCache protoimpl.SizeCache
1141}
1142
1143func (x *CompleteJobResponse) Reset() {
1144 *x = CompleteJobResponse{}
1145 mi := &file_ermite_runner_proto_msgTypes[9]
1146 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1147 ms.StoreMessageInfo(mi)
1148}
1149
1150func (x *CompleteJobResponse) String() string {
1151 return protoimpl.X.MessageStringOf(x)
1152}
1153
1154func (*CompleteJobResponse) ProtoMessage() {}
1155
1156func (x *CompleteJobResponse) ProtoReflect() protoreflect.Message {
1157 mi := &file_ermite_runner_proto_msgTypes[9]
1158 if x != nil {
1159 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1160 if ms.LoadMessageInfo() == nil {
1161 ms.StoreMessageInfo(mi)
1162 }
1163 return ms
1164 }
1165 return mi.MessageOf(x)
1166}
1167
1168// Deprecated: Use CompleteJobResponse.ProtoReflect.Descriptor instead.
1169func (*CompleteJobResponse) Descriptor() ([]byte, []int) {
1170 return file_ermite_runner_proto_rawDescGZIP(), []int{9}
1171}
1172
1173func (x *CompleteJobResponse) GetConclusion() CiConclusion {
1174 if x != nil {
1175 return x.Conclusion
1176 }
1177 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1178}
1179
1180func (x *CompleteJobResponse) GetError() string {
1181 if x != nil {
1182 return x.Error
1183 }
1184 return ""
1185}
1186
1187func (x *CompleteJobResponse) GetApplied() bool {
1188 if x != nil {
1189 return x.Applied
1190 }
1191 return false
1192}
1193
1194// JobEnded says that a job has ended. It is sent in WatchJob and attached, as
1195// an error detail, to the failed_precondition errors that RunnerService returns
1196// for a job that has ended.
1197type JobEnded struct {
1198 state protoimpl.MessageState `protogen:"open.v1"`
1199 // Conclusion is how the job ended.
1200 Conclusion CiConclusion `protobuf:"varint,1,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
1201 // Error is the error text stored with the job, as RunJob.error. Empty when
1202 // there is none.
1203 Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
1204 unknownFields protoimpl.UnknownFields
1205 sizeCache protoimpl.SizeCache
1206}
1207
1208func (x *JobEnded) Reset() {
1209 *x = JobEnded{}
1210 mi := &file_ermite_runner_proto_msgTypes[10]
1211 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1212 ms.StoreMessageInfo(mi)
1213}
1214
1215func (x *JobEnded) String() string {
1216 return protoimpl.X.MessageStringOf(x)
1217}
1218
1219func (*JobEnded) ProtoMessage() {}
1220
1221func (x *JobEnded) ProtoReflect() protoreflect.Message {
1222 mi := &file_ermite_runner_proto_msgTypes[10]
1223 if x != nil {
1224 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1225 if ms.LoadMessageInfo() == nil {
1226 ms.StoreMessageInfo(mi)
1227 }
1228 return ms
1229 }
1230 return mi.MessageOf(x)
1231}
1232
1233// Deprecated: Use JobEnded.ProtoReflect.Descriptor instead.
1234func (*JobEnded) Descriptor() ([]byte, []int) {
1235 return file_ermite_runner_proto_rawDescGZIP(), []int{10}
1236}
1237
1238func (x *JobEnded) GetConclusion() CiConclusion {
1239 if x != nil {
1240 return x.Conclusion
1241 }
1242 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1243}
1244
1245func (x *JobEnded) GetError() string {
1246 if x != nil {
1247 return x.Error
1248 }
1249 return ""
1250}
1251
1252// AppendLogRequest carries log lines of one step.
1253type AppendLogRequest struct {
1254 state protoimpl.MessageState `protogen:"open.v1"`
1255 // JobId is the Job.job_id. It must be the job of the token.
1256 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1257 // Step is the number of the step the lines belong to (see
1258 // UpdateJobRequest.steps), at least 1, and at least the step of the last
1259 // stored line. A step that UpdateJob has not announced yet is created by the
1260 // first lines. See the rules on AppendLog.
1261 Step int32 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
1262 // Offset is the number of the first line of the request in the log of the
1263 // job, counted from 0 across all steps. See the rules on AppendLog.
1264 Offset int64 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
1265 // Lines are the lines to append, in order: at most 1,000, at most 64 KiB of
1266 // text in total.
1267 Lines []*LogLine `protobuf:"bytes,4,rep,name=lines,proto3" json:"lines,omitempty"`
1268 unknownFields protoimpl.UnknownFields
1269 sizeCache protoimpl.SizeCache
1270}
1271
1272func (x *AppendLogRequest) Reset() {
1273 *x = AppendLogRequest{}
1274 mi := &file_ermite_runner_proto_msgTypes[11]
1275 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1276 ms.StoreMessageInfo(mi)
1277}
1278
1279func (x *AppendLogRequest) String() string {
1280 return protoimpl.X.MessageStringOf(x)
1281}
1282
1283func (*AppendLogRequest) ProtoMessage() {}
1284
1285func (x *AppendLogRequest) ProtoReflect() protoreflect.Message {
1286 mi := &file_ermite_runner_proto_msgTypes[11]
1287 if x != nil {
1288 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1289 if ms.LoadMessageInfo() == nil {
1290 ms.StoreMessageInfo(mi)
1291 }
1292 return ms
1293 }
1294 return mi.MessageOf(x)
1295}
1296
1297// Deprecated: Use AppendLogRequest.ProtoReflect.Descriptor instead.
1298func (*AppendLogRequest) Descriptor() ([]byte, []int) {
1299 return file_ermite_runner_proto_rawDescGZIP(), []int{11}
1300}
1301
1302func (x *AppendLogRequest) GetJobId() string {
1303 if x != nil {
1304 return x.JobId
1305 }
1306 return ""
1307}
1308
1309func (x *AppendLogRequest) GetStep() int32 {
1310 if x != nil {
1311 return x.Step
1312 }
1313 return 0
1314}
1315
1316func (x *AppendLogRequest) GetOffset() int64 {
1317 if x != nil {
1318 return x.Offset
1319 }
1320 return 0
1321}
1322
1323func (x *AppendLogRequest) GetLines() []*LogLine {
1324 if x != nil {
1325 return x.Lines
1326 }
1327 return nil
1328}
1329
1330// LogLine is one line of a job log.
1331type LogLine struct {
1332 state protoimpl.MessageState `protogen:"open.v1"`
1333 // Time is when the line was produced, by the clock of the runner. The server
1334 // keeps it with nanosecond precision (RFC 3339) and does not reorder lines.
1335 Time *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
1336 // Text is the line without its line terminator, valid UTF-8 (the client
1337 // replaces invalid bytes with U+FFFD). It must not contain a line feed; a
1338 // carriage return is kept. It is the line as GitHub's raw log has it,
1339 // including "##[group]" and "##[endgroup]" markers and "##[error]" lines.
1340 Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
1341 // Continued is true when this line is the continuation of the line before
1342 // it, which was too long to send whole. A runner cuts a line of more than
1343 // 64 KiB into pieces at UTF-8 character boundaries, each piece of at most
1344 // 64 KiB, and sets continued on every piece but the first. Each piece is one
1345 // line for numbering and offsets; the server and the raw log join the
1346 // pieces back, so the original line is rebuilt exactly. The first line of a
1347 // job cannot be continued (invalid_argument) and a continued line is in
1348 // the same step as the line before it (failed_precondition otherwise).
1349 Continued bool `protobuf:"varint,3,opt,name=continued,proto3" json:"continued,omitempty"`
1350 unknownFields protoimpl.UnknownFields
1351 sizeCache protoimpl.SizeCache
1352}
1353
1354func (x *LogLine) Reset() {
1355 *x = LogLine{}
1356 mi := &file_ermite_runner_proto_msgTypes[12]
1357 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1358 ms.StoreMessageInfo(mi)
1359}
1360
1361func (x *LogLine) String() string {
1362 return protoimpl.X.MessageStringOf(x)
1363}
1364
1365func (*LogLine) ProtoMessage() {}
1366
1367func (x *LogLine) ProtoReflect() protoreflect.Message {
1368 mi := &file_ermite_runner_proto_msgTypes[12]
1369 if x != nil {
1370 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1371 if ms.LoadMessageInfo() == nil {
1372 ms.StoreMessageInfo(mi)
1373 }
1374 return ms
1375 }
1376 return mi.MessageOf(x)
1377}
1378
1379// Deprecated: Use LogLine.ProtoReflect.Descriptor instead.
1380func (*LogLine) Descriptor() ([]byte, []int) {
1381 return file_ermite_runner_proto_rawDescGZIP(), []int{12}
1382}
1383
1384func (x *LogLine) GetTime() *timestamppb.Timestamp {
1385 if x != nil {
1386 return x.Time
1387 }
1388 return nil
1389}
1390
1391func (x *LogLine) GetText() string {
1392 if x != nil {
1393 return x.Text
1394 }
1395 return ""
1396}
1397
1398func (x *LogLine) GetContinued() bool {
1399 if x != nil {
1400 return x.Continued
1401 }
1402 return false
1403}
1404
1405// AppendLogResponse tells how much of the log the server holds.
1406type AppendLogResponse struct {
1407 state protoimpl.MessageState `protogen:"open.v1"`
1408 // NextOffset is the number of lines of the job log after the call, which is
1409 // the offset of the next request.
1410 NextOffset int64 `protobuf:"varint,1,opt,name=next_offset,json=nextOffset,proto3" json:"next_offset,omitempty"`
1411 unknownFields protoimpl.UnknownFields
1412 sizeCache protoimpl.SizeCache
1413}
1414
1415func (x *AppendLogResponse) Reset() {
1416 *x = AppendLogResponse{}
1417 mi := &file_ermite_runner_proto_msgTypes[13]
1418 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1419 ms.StoreMessageInfo(mi)
1420}
1421
1422func (x *AppendLogResponse) String() string {
1423 return protoimpl.X.MessageStringOf(x)
1424}
1425
1426func (*AppendLogResponse) ProtoMessage() {}
1427
1428func (x *AppendLogResponse) ProtoReflect() protoreflect.Message {
1429 mi := &file_ermite_runner_proto_msgTypes[13]
1430 if x != nil {
1431 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1432 if ms.LoadMessageInfo() == nil {
1433 ms.StoreMessageInfo(mi)
1434 }
1435 return ms
1436 }
1437 return mi.MessageOf(x)
1438}
1439
1440// Deprecated: Use AppendLogResponse.ProtoReflect.Descriptor instead.
1441func (*AppendLogResponse) Descriptor() ([]byte, []int) {
1442 return file_ermite_runner_proto_rawDescGZIP(), []int{13}
1443}
1444
1445func (x *AppendLogResponse) GetNextOffset() int64 {
1446 if x != nil {
1447 return x.NextOffset
1448 }
1449 return 0
1450}
1451
1452// HeartbeatRequest names the job that is alive.
1453type HeartbeatRequest struct {
1454 state protoimpl.MessageState `protogen:"open.v1"`
1455 // JobId is the Job.job_id. It must be the job of the token.
1456 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1457 unknownFields protoimpl.UnknownFields
1458 sizeCache protoimpl.SizeCache
1459}
1460
1461func (x *HeartbeatRequest) Reset() {
1462 *x = HeartbeatRequest{}
1463 mi := &file_ermite_runner_proto_msgTypes[14]
1464 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1465 ms.StoreMessageInfo(mi)
1466}
1467
1468func (x *HeartbeatRequest) String() string {
1469 return protoimpl.X.MessageStringOf(x)
1470}
1471
1472func (*HeartbeatRequest) ProtoMessage() {}
1473
1474func (x *HeartbeatRequest) ProtoReflect() protoreflect.Message {
1475 mi := &file_ermite_runner_proto_msgTypes[14]
1476 if x != nil {
1477 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1478 if ms.LoadMessageInfo() == nil {
1479 ms.StoreMessageInfo(mi)
1480 }
1481 return ms
1482 }
1483 return mi.MessageOf(x)
1484}
1485
1486// Deprecated: Use HeartbeatRequest.ProtoReflect.Descriptor instead.
1487func (*HeartbeatRequest) Descriptor() ([]byte, []int) {
1488 return file_ermite_runner_proto_rawDescGZIP(), []int{14}
1489}
1490
1491func (x *HeartbeatRequest) GetJobId() string {
1492 if x != nil {
1493 return x.JobId
1494 }
1495 return ""
1496}
1497
1498// HeartbeatResponse is empty.
1499type HeartbeatResponse struct {
1500 state protoimpl.MessageState `protogen:"open.v1"`
1501 unknownFields protoimpl.UnknownFields
1502 sizeCache protoimpl.SizeCache
1503}
1504
1505func (x *HeartbeatResponse) Reset() {
1506 *x = HeartbeatResponse{}
1507 mi := &file_ermite_runner_proto_msgTypes[15]
1508 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1509 ms.StoreMessageInfo(mi)
1510}
1511
1512func (x *HeartbeatResponse) String() string {
1513 return protoimpl.X.MessageStringOf(x)
1514}
1515
1516func (*HeartbeatResponse) ProtoMessage() {}
1517
1518func (x *HeartbeatResponse) ProtoReflect() protoreflect.Message {
1519 mi := &file_ermite_runner_proto_msgTypes[15]
1520 if x != nil {
1521 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1522 if ms.LoadMessageInfo() == nil {
1523 ms.StoreMessageInfo(mi)
1524 }
1525 return ms
1526 }
1527 return mi.MessageOf(x)
1528}
1529
1530// Deprecated: Use HeartbeatResponse.ProtoReflect.Descriptor instead.
1531func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
1532 return file_ermite_runner_proto_rawDescGZIP(), []int{15}
1533}
1534
1535// WatchJobRequest names the job to watch.
1536type WatchJobRequest struct {
1537 state protoimpl.MessageState `protogen:"open.v1"`
1538 // JobId is the Job.job_id. It must be the job of the token.
1539 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1540 unknownFields protoimpl.UnknownFields
1541 sizeCache protoimpl.SizeCache
1542}
1543
1544func (x *WatchJobRequest) Reset() {
1545 *x = WatchJobRequest{}
1546 mi := &file_ermite_runner_proto_msgTypes[16]
1547 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1548 ms.StoreMessageInfo(mi)
1549}
1550
1551func (x *WatchJobRequest) String() string {
1552 return protoimpl.X.MessageStringOf(x)
1553}
1554
1555func (*WatchJobRequest) ProtoMessage() {}
1556
1557func (x *WatchJobRequest) ProtoReflect() protoreflect.Message {
1558 mi := &file_ermite_runner_proto_msgTypes[16]
1559 if x != nil {
1560 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1561 if ms.LoadMessageInfo() == nil {
1562 ms.StoreMessageInfo(mi)
1563 }
1564 return ms
1565 }
1566 return mi.MessageOf(x)
1567}
1568
1569// Deprecated: Use WatchJobRequest.ProtoReflect.Descriptor instead.
1570func (*WatchJobRequest) Descriptor() ([]byte, []int) {
1571 return file_ermite_runner_proto_rawDescGZIP(), []int{16}
1572}
1573
1574func (x *WatchJobRequest) GetJobId() string {
1575 if x != nil {
1576 return x.JobId
1577 }
1578 return ""
1579}
1580
1581// WatchJobResponse is one message of the stream.
1582type WatchJobResponse struct {
1583 state protoimpl.MessageState `protogen:"open.v1"`
1584 // Msg is what the message carries. New kinds may be added: a client ignores
1585 // the ones it does not know.
1586 //
1587 // Types that are valid to be assigned to Msg:
1588 //
1589 // *WatchJobResponse_Keepalive
1590 // *WatchJobResponse_Cancel
1591 // *WatchJobResponse_Ended
1592 Msg isWatchJobResponse_Msg `protobuf_oneof:"msg"`
1593 unknownFields protoimpl.UnknownFields
1594 sizeCache protoimpl.SizeCache
1595}
1596
1597func (x *WatchJobResponse) Reset() {
1598 *x = WatchJobResponse{}
1599 mi := &file_ermite_runner_proto_msgTypes[17]
1600 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1601 ms.StoreMessageInfo(mi)
1602}
1603
1604func (x *WatchJobResponse) String() string {
1605 return protoimpl.X.MessageStringOf(x)
1606}
1607
1608func (*WatchJobResponse) ProtoMessage() {}
1609
1610func (x *WatchJobResponse) ProtoReflect() protoreflect.Message {
1611 mi := &file_ermite_runner_proto_msgTypes[17]
1612 if x != nil {
1613 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1614 if ms.LoadMessageInfo() == nil {
1615 ms.StoreMessageInfo(mi)
1616 }
1617 return ms
1618 }
1619 return mi.MessageOf(x)
1620}
1621
1622// Deprecated: Use WatchJobResponse.ProtoReflect.Descriptor instead.
1623func (*WatchJobResponse) Descriptor() ([]byte, []int) {
1624 return file_ermite_runner_proto_rawDescGZIP(), []int{17}
1625}
1626
1627func (x *WatchJobResponse) GetMsg() isWatchJobResponse_Msg {
1628 if x != nil {
1629 return x.Msg
1630 }
1631 return nil
1632}
1633
1634func (x *WatchJobResponse) GetKeepalive() *Keepalive {
1635 if x != nil {
1636 if x, ok := x.Msg.(*WatchJobResponse_Keepalive); ok {
1637 return x.Keepalive
1638 }
1639 }
1640 return nil
1641}
1642
1643func (x *WatchJobResponse) GetCancel() *CancelRequest {
1644 if x != nil {
1645 if x, ok := x.Msg.(*WatchJobResponse_Cancel); ok {
1646 return x.Cancel
1647 }
1648 }
1649 return nil
1650}
1651
1652func (x *WatchJobResponse) GetEnded() *JobEnded {
1653 if x != nil {
1654 if x, ok := x.Msg.(*WatchJobResponse_Ended); ok {
1655 return x.Ended
1656 }
1657 }
1658 return nil
1659}
1660
1661type isWatchJobResponse_Msg interface {
1662 isWatchJobResponse_Msg()
1663}
1664
1665type WatchJobResponse_Keepalive struct {
1666 // Keepalive: nothing to do, the stream is alive.
1667 Keepalive *Keepalive `protobuf:"bytes,1,opt,name=keepalive,proto3,oneof"`
1668}
1669
1670type WatchJobResponse_Cancel struct {
1671 // Cancel: the job must stop.
1672 Cancel *CancelRequest `protobuf:"bytes,2,opt,name=cancel,proto3,oneof"`
1673}
1674
1675type WatchJobResponse_Ended struct {
1676 // Ended: the job has ended. The last message of a stream: a close without
1677 // it means the client reconnects.
1678 Ended *JobEnded `protobuf:"bytes,3,opt,name=ended,proto3,oneof"`
1679}
1680
1681func (*WatchJobResponse_Keepalive) isWatchJobResponse_Msg() {}
1682
1683func (*WatchJobResponse_Cancel) isWatchJobResponse_Msg() {}
1684
1685func (*WatchJobResponse_Ended) isWatchJobResponse_Msg() {}
1686
1687// Keepalive has no fields.
1688type Keepalive struct {
1689 state protoimpl.MessageState `protogen:"open.v1"`
1690 unknownFields protoimpl.UnknownFields
1691 sizeCache protoimpl.SizeCache
1692}
1693
1694func (x *Keepalive) Reset() {
1695 *x = Keepalive{}
1696 mi := &file_ermite_runner_proto_msgTypes[18]
1697 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1698 ms.StoreMessageInfo(mi)
1699}
1700
1701func (x *Keepalive) String() string {
1702 return protoimpl.X.MessageStringOf(x)
1703}
1704
1705func (*Keepalive) ProtoMessage() {}
1706
1707func (x *Keepalive) ProtoReflect() protoreflect.Message {
1708 mi := &file_ermite_runner_proto_msgTypes[18]
1709 if x != nil {
1710 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1711 if ms.LoadMessageInfo() == nil {
1712 ms.StoreMessageInfo(mi)
1713 }
1714 return ms
1715 }
1716 return mi.MessageOf(x)
1717}
1718
1719// Deprecated: Use Keepalive.ProtoReflect.Descriptor instead.
1720func (*Keepalive) Descriptor() ([]byte, []int) {
1721 return file_ermite_runner_proto_rawDescGZIP(), []int{18}
1722}
1723
1724// CancelRequest asks the runner to stop a job.
1725type CancelRequest struct {
1726 state protoimpl.MessageState `protogen:"open.v1"`
1727 // Reason is why the job must stop. New reasons may be added; a runner that
1728 // does not know one cancels the job and reports CI_CONCLUSION_CANCELLED.
1729 Reason CancelReason `protobuf:"varint,1,opt,name=reason,proto3,enum=ermite.CancelReason" json:"reason,omitempty"`
1730 // Message is a short human-readable explanation, for the job log, for
1731 // example "Canceled by the owner". At most 1,024 characters.
1732 Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
1733 // RequestedAt is when the cancellation was requested, by the clock of the
1734 // server.
1735 RequestedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=requested_at,json=requestedAt,proto3" json:"requested_at,omitempty"`
1736 unknownFields protoimpl.UnknownFields
1737 sizeCache protoimpl.SizeCache
1738}
1739
1740func (x *CancelRequest) Reset() {
1741 *x = CancelRequest{}
1742 mi := &file_ermite_runner_proto_msgTypes[19]
1743 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1744 ms.StoreMessageInfo(mi)
1745}
1746
1747func (x *CancelRequest) String() string {
1748 return protoimpl.X.MessageStringOf(x)
1749}
1750
1751func (*CancelRequest) ProtoMessage() {}
1752
1753func (x *CancelRequest) ProtoReflect() protoreflect.Message {
1754 mi := &file_ermite_runner_proto_msgTypes[19]
1755 if x != nil {
1756 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1757 if ms.LoadMessageInfo() == nil {
1758 ms.StoreMessageInfo(mi)
1759 }
1760 return ms
1761 }
1762 return mi.MessageOf(x)
1763}
1764
1765// Deprecated: Use CancelRequest.ProtoReflect.Descriptor instead.
1766func (*CancelRequest) Descriptor() ([]byte, []int) {
1767 return file_ermite_runner_proto_rawDescGZIP(), []int{19}
1768}
1769
1770func (x *CancelRequest) GetReason() CancelReason {
1771 if x != nil {
1772 return x.Reason
1773 }
1774 return CancelReason_CANCEL_REASON_UNSPECIFIED
1775}
1776
1777func (x *CancelRequest) GetMessage() string {
1778 if x != nil {
1779 return x.Message
1780 }
1781 return ""
1782}
1783
1784func (x *CancelRequest) GetRequestedAt() *timestamppb.Timestamp {
1785 if x != nil {
1786 return x.RequestedAt
1787 }
1788 return nil
1789}
1790
1791var File_ermite_runner_proto protoreflect.FileDescriptor
1792
1793const file_ermite_runner_proto_rawDesc = "" +
1794 "\n" +
1795 "\x13ermite/runner.proto\x12\x06ermite\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xd2\x01\n" +
1796 "\x15RegisterRunnerRequest\x12\x12\n" +
1797 "\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
1798 "\x06labels\x18\x02 \x03(\tR\x06labels\x12\x18\n" +
1799 "\aversion\x18\x03 \x01(\tR\aversion\x125\n" +
1800 "\tisolation\x18\x04 \x01(\x0e2\x17.ermite.RunnerIsolationR\tisolation\x12\x12\n" +
1801 "\x04arch\x18\x05 \x01(\tR\x04arch\x12\x0e\n" +
1802 "\x02os\x18\x06 \x01(\tR\x02os\x12\x18\n" +
1803 "\areplace\x18\a \x01(\bR\areplace\"X\n" +
1804 "\x16RegisterRunnerResponse\x12\x1b\n" +
1805 "\trunner_id\x18\x01 \x01(\tR\brunnerId\x12!\n" +
1806 "\frunner_token\x18\x02 \x01(\tR\vrunnerToken\"B\n" +
1807 "\x0fFetchJobRequest\x12\x16\n" +
1808 "\x06labels\x18\x01 \x03(\tR\x06labels\x12\x17\n" +
1809 "\apoll_id\x18\x02 \x01(\tR\x06pollId\"m\n" +
1810 "\x10FetchJobResponse\x12\x1d\n" +
1811 "\x03job\x18\x01 \x01(\v2\v.ermite.JobR\x03job\x12:\n" +
1812 "\vretry_after\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\n" +
1813 "retryAfter\"\xfa\x02\n" +
1814 "\x03Job\x12\x15\n" +
1815 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x15\n" +
1816 "\x06run_id\x18\x02 \x01(\x03R\x05runId\x12\x18\n" +
1817 "\aattempt\x18\x03 \x01(\x05R\aattempt\x12\x1b\n" +
1818 "\tjob_token\x18\x04 \x01(\tR\bjobToken\x12#\n" +
1819 "\rworkflow_path\x18\x05 \x01(\tR\fworkflowPath\x12#\n" +
1820 "\rworkflow_yaml\x18\x06 \x01(\tR\fworkflowYaml\x12\x17\n" +
1821 "\ajob_key\x18\a \x01(\tR\x06jobKey\x12\x16\n" +
1822 "\x06matrix\x18\b \x01(\tR\x06matrix\x12\x1a\n" +
1823 "\bcontexts\x18\t \x01(\tR\bcontexts\x12\x16\n" +
1824 "\x06labels\x18\n" +
1825 " \x03(\tR\x06labels\x12'\n" +
1826 "\x0ftimeout_minutes\x18\v \x01(\x05R\x0etimeoutMinutes\x12\x12\n" +
1827 "\x04repo\x18\f \x01(\tR\x04repo\x12\x10\n" +
1828 "\x03sha\x18\r \x01(\tR\x03sha\x12\x10\n" +
1829 "\x03ref\x18\x0e \x01(\tR\x03ref\"S\n" +
1830 "\x10UpdateJobRequest\x12\x15\n" +
1831 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12(\n" +
1832 "\x05steps\x18\x02 \x03(\v2\x12.ermite.StepUpdateR\x05steps\"\x91\x02\n" +
1833 "\n" +
1834 "StepUpdate\x12\x16\n" +
1835 "\x06number\x18\x01 \x01(\x05R\x06number\x12\x12\n" +
1836 "\x04name\x18\x02 \x01(\tR\x04name\x12'\n" +
1837 "\x05state\x18\x03 \x01(\x0e2\x11.ermite.StepStateR\x05state\x124\n" +
1838 "\n" +
1839 "conclusion\x18\x04 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
1840 "conclusion\x129\n" +
1841 "\n" +
1842 "started_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tstartedAt\x12=\n" +
1843 "\fcompleted_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\vcompletedAt\"\x13\n" +
1844 "\x11UpdateJobResponse\"\xb3\x02\n" +
1845 "\x12CompleteJobRequest\x12\x15\n" +
1846 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x124\n" +
1847 "\n" +
1848 "conclusion\x18\x02 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
1849 "conclusion\x12A\n" +
1850 "\aoutputs\x18\x03 \x03(\v2'.ermite.CompleteJobRequest.OutputsEntryR\aoutputs\x12'\n" +
1851 "\x0frunner_shutdown\x18\x04 \x01(\bR\x0erunnerShutdown\x12(\n" +
1852 "\x05steps\x18\x05 \x03(\v2\x12.ermite.StepUpdateR\x05steps\x1a:\n" +
1853 "\fOutputsEntry\x12\x10\n" +
1854 "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
1855 "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"{\n" +
1856 "\x13CompleteJobResponse\x124\n" +
1857 "\n" +
1858 "conclusion\x18\x01 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
1859 "conclusion\x12\x14\n" +
1860 "\x05error\x18\x02 \x01(\tR\x05error\x12\x18\n" +
1861 "\aapplied\x18\x03 \x01(\bR\aapplied\"V\n" +
1862 "\bJobEnded\x124\n" +
1863 "\n" +
1864 "conclusion\x18\x01 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
1865 "conclusion\x12\x14\n" +
1866 "\x05error\x18\x02 \x01(\tR\x05error\"|\n" +
1867 "\x10AppendLogRequest\x12\x15\n" +
1868 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x12\n" +
1869 "\x04step\x18\x02 \x01(\x05R\x04step\x12\x16\n" +
1870 "\x06offset\x18\x03 \x01(\x03R\x06offset\x12%\n" +
1871 "\x05lines\x18\x04 \x03(\v2\x0f.ermite.LogLineR\x05lines\"k\n" +
1872 "\aLogLine\x12.\n" +
1873 "\x04time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x04time\x12\x12\n" +
1874 "\x04text\x18\x02 \x01(\tR\x04text\x12\x1c\n" +
1875 "\tcontinued\x18\x03 \x01(\bR\tcontinued\"4\n" +
1876 "\x11AppendLogResponse\x12\x1f\n" +
1877 "\vnext_offset\x18\x01 \x01(\x03R\n" +
1878 "nextOffset\")\n" +
1879 "\x10HeartbeatRequest\x12\x15\n" +
1880 "\x06job_id\x18\x01 \x01(\tR\x05jobId\"\x13\n" +
1881 "\x11HeartbeatResponse\"(\n" +
1882 "\x0fWatchJobRequest\x12\x15\n" +
1883 "\x06job_id\x18\x01 \x01(\tR\x05jobId\"\xa7\x01\n" +
1884 "\x10WatchJobResponse\x121\n" +
1885 "\tkeepalive\x18\x01 \x01(\v2\x11.ermite.KeepaliveH\x00R\tkeepalive\x12/\n" +
1886 "\x06cancel\x18\x02 \x01(\v2\x15.ermite.CancelRequestH\x00R\x06cancel\x12(\n" +
1887 "\x05ended\x18\x03 \x01(\v2\x10.ermite.JobEndedH\x00R\x05endedB\x05\n" +
1888 "\x03msg\"\v\n" +
1889 "\tKeepalive\"\x96\x01\n" +
1890 "\rCancelRequest\x12,\n" +
1891 "\x06reason\x18\x01 \x01(\x0e2\x14.ermite.CancelReasonR\x06reason\x12\x18\n" +
1892 "\amessage\x18\x02 \x01(\tR\amessage\x12=\n" +
1893 "\frequested_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\vrequestedAt*o\n" +
1894 "\bCiStatus\x12\x19\n" +
1895 "\x15CI_STATUS_UNSPECIFIED\x10\x00\x12\x14\n" +
1896 "\x10CI_STATUS_QUEUED\x10\x01\x12\x19\n" +
1897 "\x15CI_STATUS_IN_PROGRESS\x10\x02\x12\x17\n" +
1898 "\x13CI_STATUS_COMPLETED\x10\x03*\xf6\x01\n" +
1899 "\fCiConclusion\x12\x1d\n" +
1900 "\x19CI_CONCLUSION_UNSPECIFIED\x10\x00\x12\x19\n" +
1901 "\x15CI_CONCLUSION_SUCCESS\x10\x01\x12\x19\n" +
1902 "\x15CI_CONCLUSION_FAILURE\x10\x02\x12\x1b\n" +
1903 "\x17CI_CONCLUSION_CANCELLED\x10\x03\x12\x19\n" +
1904 "\x15CI_CONCLUSION_SKIPPED\x10\x04\x12\x1b\n" +
1905 "\x17CI_CONCLUSION_TIMED_OUT\x10\x05\x12\x19\n" +
1906 "\x15CI_CONCLUSION_NEUTRAL\x10\x06\x12!\n" +
1907 "\x1dCI_CONCLUSION_ACTION_REQUIRED\x10\a*u\n" +
1908 "\tStepState\x12\x1a\n" +
1909 "\x16STEP_STATE_UNSPECIFIED\x10\x00\x12\x16\n" +
1910 "\x12STEP_STATE_PENDING\x10\x01\x12\x1a\n" +
1911 "\x16STEP_STATE_IN_PROGRESS\x10\x02\x12\x18\n" +
1912 "\x14STEP_STATE_COMPLETED\x10\x03*\x9e\x01\n" +
1913 "\x0fRunnerIsolation\x12 \n" +
1914 "\x1cRUNNER_ISOLATION_UNSPECIFIED\x10\x00\x12\x17\n" +
1915 "\x13RUNNER_ISOLATION_VM\x10\x01\x12%\n" +
1916 "!RUNNER_ISOLATION_CONTAINER_SYSBOX\x10\x02\x12)\n" +
1917 "%RUNNER_ISOLATION_CONTAINER_PRIVILEGED\x10\x03*}\n" +
1918 "\fCancelReason\x12\x1d\n" +
1919 "\x19CANCEL_REASON_UNSPECIFIED\x10\x00\x12\x16\n" +
1920 "\x12CANCEL_REASON_USER\x10\x01\x12\x1b\n" +
1921 "\x17CANCEL_REASON_FAIL_FAST\x10\x02\x12\x19\n" +
1922 "\x15CANCEL_REASON_TIMEOUT\x10\x032\xee\x03\n" +
1923 "\rRunnerService\x12O\n" +
1924 "\x0eRegisterRunner\x12\x1d.ermite.RegisterRunnerRequest\x1a\x1e.ermite.RegisterRunnerResponse\x12=\n" +
1925 "\bFetchJob\x12\x17.ermite.FetchJobRequest\x1a\x18.ermite.FetchJobResponse\x12@\n" +
1926 "\tUpdateJob\x12\x18.ermite.UpdateJobRequest\x1a\x19.ermite.UpdateJobResponse\x12@\n" +
1927 "\tAppendLog\x12\x18.ermite.AppendLogRequest\x1a\x19.ermite.AppendLogResponse\x12@\n" +
1928 "\tHeartbeat\x12\x18.ermite.HeartbeatRequest\x1a\x19.ermite.HeartbeatResponse\x12?\n" +
1929 "\bWatchJob\x12\x17.ermite.WatchJobRequest\x1a\x18.ermite.WatchJobResponse0\x01\x12F\n" +
1930 "\vCompleteJob\x12\x1a.ermite.CompleteJobRequest\x1a\x1b.ermite.CompleteJobResponseBr\n" +
1931 "\n" +
1932 "com.ermiteB\vRunnerProtoP\x01Z\x1fbnema.dev/ermite-api/gen/ermite\xa2\x02\x03EXX\xaa\x02\x06Ermite\xca\x02\x06Ermite\xe2\x02\x12Ermite\\GPBMetadata\xea\x02\x06Ermiteb\x06proto3"
1933
1934var (
1935 file_ermite_runner_proto_rawDescOnce sync.Once
1936 file_ermite_runner_proto_rawDescData []byte
1937)
1938
1939func file_ermite_runner_proto_rawDescGZIP() []byte {
1940 file_ermite_runner_proto_rawDescOnce.Do(func() {
1941 file_ermite_runner_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ermite_runner_proto_rawDesc), len(file_ermite_runner_proto_rawDesc)))
1942 })
1943 return file_ermite_runner_proto_rawDescData
1944}
1945
1946var file_ermite_runner_proto_enumTypes = make([]protoimpl.EnumInfo, 5)
1947var file_ermite_runner_proto_msgTypes = make([]protoimpl.MessageInfo, 21)
1948var file_ermite_runner_proto_goTypes = []any{
1949 (CiStatus)(0), // 0: ermite.CiStatus
1950 (CiConclusion)(0), // 1: ermite.CiConclusion
1951 (StepState)(0), // 2: ermite.StepState
1952 (RunnerIsolation)(0), // 3: ermite.RunnerIsolation
1953 (CancelReason)(0), // 4: ermite.CancelReason
1954 (*RegisterRunnerRequest)(nil), // 5: ermite.RegisterRunnerRequest
1955 (*RegisterRunnerResponse)(nil), // 6: ermite.RegisterRunnerResponse
1956 (*FetchJobRequest)(nil), // 7: ermite.FetchJobRequest
1957 (*FetchJobResponse)(nil), // 8: ermite.FetchJobResponse
1958 (*Job)(nil), // 9: ermite.Job
1959 (*UpdateJobRequest)(nil), // 10: ermite.UpdateJobRequest
1960 (*StepUpdate)(nil), // 11: ermite.StepUpdate
1961 (*UpdateJobResponse)(nil), // 12: ermite.UpdateJobResponse
1962 (*CompleteJobRequest)(nil), // 13: ermite.CompleteJobRequest
1963 (*CompleteJobResponse)(nil), // 14: ermite.CompleteJobResponse
1964 (*JobEnded)(nil), // 15: ermite.JobEnded
1965 (*AppendLogRequest)(nil), // 16: ermite.AppendLogRequest
1966 (*LogLine)(nil), // 17: ermite.LogLine
1967 (*AppendLogResponse)(nil), // 18: ermite.AppendLogResponse
1968 (*HeartbeatRequest)(nil), // 19: ermite.HeartbeatRequest
1969 (*HeartbeatResponse)(nil), // 20: ermite.HeartbeatResponse
1970 (*WatchJobRequest)(nil), // 21: ermite.WatchJobRequest
1971 (*WatchJobResponse)(nil), // 22: ermite.WatchJobResponse
1972 (*Keepalive)(nil), // 23: ermite.Keepalive
1973 (*CancelRequest)(nil), // 24: ermite.CancelRequest
1974 nil, // 25: ermite.CompleteJobRequest.OutputsEntry
1975 (*durationpb.Duration)(nil), // 26: google.protobuf.Duration
1976 (*timestamppb.Timestamp)(nil), // 27: google.protobuf.Timestamp
1977}
1978var file_ermite_runner_proto_depIdxs = []int32{
1979 3, // 0: ermite.RegisterRunnerRequest.isolation:type_name -> ermite.RunnerIsolation
1980 9, // 1: ermite.FetchJobResponse.job:type_name -> ermite.Job
1981 26, // 2: ermite.FetchJobResponse.retry_after:type_name -> google.protobuf.Duration
1982 11, // 3: ermite.UpdateJobRequest.steps:type_name -> ermite.StepUpdate
1983 2, // 4: ermite.StepUpdate.state:type_name -> ermite.StepState
1984 1, // 5: ermite.StepUpdate.conclusion:type_name -> ermite.CiConclusion
1985 27, // 6: ermite.StepUpdate.started_at:type_name -> google.protobuf.Timestamp
1986 27, // 7: ermite.StepUpdate.completed_at:type_name -> google.protobuf.Timestamp
1987 1, // 8: ermite.CompleteJobRequest.conclusion:type_name -> ermite.CiConclusion
1988 25, // 9: ermite.CompleteJobRequest.outputs:type_name -> ermite.CompleteJobRequest.OutputsEntry
1989 11, // 10: ermite.CompleteJobRequest.steps:type_name -> ermite.StepUpdate
1990 1, // 11: ermite.CompleteJobResponse.conclusion:type_name -> ermite.CiConclusion
1991 1, // 12: ermite.JobEnded.conclusion:type_name -> ermite.CiConclusion
1992 17, // 13: ermite.AppendLogRequest.lines:type_name -> ermite.LogLine
1993 27, // 14: ermite.LogLine.time:type_name -> google.protobuf.Timestamp
1994 23, // 15: ermite.WatchJobResponse.keepalive:type_name -> ermite.Keepalive
1995 24, // 16: ermite.WatchJobResponse.cancel:type_name -> ermite.CancelRequest
1996 15, // 17: ermite.WatchJobResponse.ended:type_name -> ermite.JobEnded
1997 4, // 18: ermite.CancelRequest.reason:type_name -> ermite.CancelReason
1998 27, // 19: ermite.CancelRequest.requested_at:type_name -> google.protobuf.Timestamp
1999 5, // 20: ermite.RunnerService.RegisterRunner:input_type -> ermite.RegisterRunnerRequest
2000 7, // 21: ermite.RunnerService.FetchJob:input_type -> ermite.FetchJobRequest
2001 10, // 22: ermite.RunnerService.UpdateJob:input_type -> ermite.UpdateJobRequest
2002 16, // 23: ermite.RunnerService.AppendLog:input_type -> ermite.AppendLogRequest
2003 19, // 24: ermite.RunnerService.Heartbeat:input_type -> ermite.HeartbeatRequest
2004 21, // 25: ermite.RunnerService.WatchJob:input_type -> ermite.WatchJobRequest
2005 13, // 26: ermite.RunnerService.CompleteJob:input_type -> ermite.CompleteJobRequest
2006 6, // 27: ermite.RunnerService.RegisterRunner:output_type -> ermite.RegisterRunnerResponse
2007 8, // 28: ermite.RunnerService.FetchJob:output_type -> ermite.FetchJobResponse
2008 12, // 29: ermite.RunnerService.UpdateJob:output_type -> ermite.UpdateJobResponse
2009 18, // 30: ermite.RunnerService.AppendLog:output_type -> ermite.AppendLogResponse
2010 20, // 31: ermite.RunnerService.Heartbeat:output_type -> ermite.HeartbeatResponse
2011 22, // 32: ermite.RunnerService.WatchJob:output_type -> ermite.WatchJobResponse
2012 14, // 33: ermite.RunnerService.CompleteJob:output_type -> ermite.CompleteJobResponse
2013 27, // [27:34] is the sub-list for method output_type
2014 20, // [20:27] is the sub-list for method input_type
2015 20, // [20:20] is the sub-list for extension type_name
2016 20, // [20:20] is the sub-list for extension extendee
2017 0, // [0:20] is the sub-list for field type_name
2018}
2019
2020func init() { file_ermite_runner_proto_init() }
2021func file_ermite_runner_proto_init() {
2022 if File_ermite_runner_proto != nil {
2023 return
2024 }
2025 file_ermite_runner_proto_msgTypes[17].OneofWrappers = []any{
2026 (*WatchJobResponse_Keepalive)(nil),
2027 (*WatchJobResponse_Cancel)(nil),
2028 (*WatchJobResponse_Ended)(nil),
2029 }
2030 type x struct{}
2031 out := protoimpl.TypeBuilder{
2032 File: protoimpl.DescBuilder{
2033 GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
2034 RawDescriptor: unsafe.Slice(unsafe.StringData(file_ermite_runner_proto_rawDesc), len(file_ermite_runner_proto_rawDesc)),
2035 NumEnums: 5,
2036 NumMessages: 21,
2037 NumExtensions: 0,
2038 NumServices: 1,
2039 },
2040 GoTypes: file_ermite_runner_proto_goTypes,
2041 DependencyIndexes: file_ermite_runner_proto_depIdxs,
2042 EnumInfos: file_ermite_runner_proto_enumTypes,
2043 MessageInfos: file_ermite_runner_proto_msgTypes,
2044 }.Build()
2045 File_ermite_runner_proto = out.File
2046 file_ermite_runner_proto_goTypes = nil
2047 file_ermite_runner_proto_depIdxs = nil
2048}