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// AnnotationLevel is the severity of an annotation, with the values of
348// GitHub's check run annotation levels ("notice", "warning", "failure"). The
349// workflow commands ::notice, ::warning and ::error produce NOTICE, WARNING and
350// FAILURE.
351type AnnotationLevel int32
352
353const (
354 // Not set. Rejected in requests, never returned by the server.
355 AnnotationLevel_ANNOTATION_LEVEL_UNSPECIFIED AnnotationLevel = 0
356 // Information: ::notice.
357 AnnotationLevel_ANNOTATION_LEVEL_NOTICE AnnotationLevel = 1
358 // A problem that does not fail the job by itself: ::warning.
359 AnnotationLevel_ANNOTATION_LEVEL_WARNING AnnotationLevel = 2
360 // An error: ::error.
361 AnnotationLevel_ANNOTATION_LEVEL_FAILURE AnnotationLevel = 3
362)
363
364// Enum value maps for AnnotationLevel.
365var (
366 AnnotationLevel_name = map[int32]string{
367 0: "ANNOTATION_LEVEL_UNSPECIFIED",
368 1: "ANNOTATION_LEVEL_NOTICE",
369 2: "ANNOTATION_LEVEL_WARNING",
370 3: "ANNOTATION_LEVEL_FAILURE",
371 }
372 AnnotationLevel_value = map[string]int32{
373 "ANNOTATION_LEVEL_UNSPECIFIED": 0,
374 "ANNOTATION_LEVEL_NOTICE": 1,
375 "ANNOTATION_LEVEL_WARNING": 2,
376 "ANNOTATION_LEVEL_FAILURE": 3,
377 }
378)
379
380func (x AnnotationLevel) Enum() *AnnotationLevel {
381 p := new(AnnotationLevel)
382 *p = x
383 return p
384}
385
386func (x AnnotationLevel) String() string {
387 return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
388}
389
390func (AnnotationLevel) Descriptor() protoreflect.EnumDescriptor {
391 return file_ermite_runner_proto_enumTypes[5].Descriptor()
392}
393
394func (AnnotationLevel) Type() protoreflect.EnumType {
395 return &file_ermite_runner_proto_enumTypes[5]
396}
397
398func (x AnnotationLevel) Number() protoreflect.EnumNumber {
399 return protoreflect.EnumNumber(x)
400}
401
402// Deprecated: Use AnnotationLevel.Descriptor instead.
403func (AnnotationLevel) EnumDescriptor() ([]byte, []int) {
404 return file_ermite_runner_proto_rawDescGZIP(), []int{5}
405}
406
407// ActionSource says where the server found an action.
408type ActionSource int32
409
410const (
411 // Not set. Only in a ResolvedAction that carries an error.
412 ActionSource_ACTION_SOURCE_UNSPECIFIED ActionSource = 0
413 // github.com: the archive is downloaded from GitHub, without a token.
414 ActionSource_ACTION_SOURCE_GITHUB ActionSource = 1
415 // A repository of this server, which wins over a github.com repository of
416 // the same name (as GitHub Enterprise Server's own actions do).
417 ActionSource_ACTION_SOURCE_ERMITE ActionSource = 2
418)
419
420// Enum value maps for ActionSource.
421var (
422 ActionSource_name = map[int32]string{
423 0: "ACTION_SOURCE_UNSPECIFIED",
424 1: "ACTION_SOURCE_GITHUB",
425 2: "ACTION_SOURCE_ERMITE",
426 }
427 ActionSource_value = map[string]int32{
428 "ACTION_SOURCE_UNSPECIFIED": 0,
429 "ACTION_SOURCE_GITHUB": 1,
430 "ACTION_SOURCE_ERMITE": 2,
431 }
432)
433
434func (x ActionSource) Enum() *ActionSource {
435 p := new(ActionSource)
436 *p = x
437 return p
438}
439
440func (x ActionSource) String() string {
441 return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
442}
443
444func (ActionSource) Descriptor() protoreflect.EnumDescriptor {
445 return file_ermite_runner_proto_enumTypes[6].Descriptor()
446}
447
448func (ActionSource) Type() protoreflect.EnumType {
449 return &file_ermite_runner_proto_enumTypes[6]
450}
451
452func (x ActionSource) Number() protoreflect.EnumNumber {
453 return protoreflect.EnumNumber(x)
454}
455
456// Deprecated: Use ActionSource.Descriptor instead.
457func (ActionSource) EnumDescriptor() ([]byte, []int) {
458 return file_ermite_runner_proto_rawDescGZIP(), []int{6}
459}
460
461// RegisterRunnerRequest describes the runner to register.
462type RegisterRunnerRequest struct {
463 state protoimpl.MessageState `protogen:"open.v1"`
464 // Name identifies the runner for people (job page, logs, ListRunners) and is
465 // unique: 1 to 64 characters among letters, digits, ".", "_" and "-". It is
466 // not a label and never matches runs-on.
467 Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
468 // Labels are the labels the runner adds to its implicit ones: at most 64,
469 // each 1 to 64 characters among letters, digits, ".", "_" and "-", for
470 // example "ubuntu-latest". Comparison is case-insensitive and duplicates
471 // are removed. The server adds the implicit labels "self-hosted", the os
472 // and the arch ("linux", "x64" or "arm64"); the runner name is not a label.
473 Labels []string `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty"`
474 // Version is the release of the runner, for example "v0.1.0", or "devel".
475 // Informational, at most 64 characters.
476 Version string `protobuf:"bytes,3,opt,name=version,proto3" json:"version,omitempty"`
477 // Isolation is how the runner isolates jobs. Required.
478 Isolation RunnerIsolation `protobuf:"varint,4,opt,name=isolation,proto3,enum=ermite.RunnerIsolation" json:"isolation,omitempty"`
479 // Arch is the CPU architecture, in GitHub's names: "x64" or "arm64". Other
480 // values are invalid_argument (the set may grow with compatible additions).
481 Arch string `protobuf:"bytes,5,opt,name=arch,proto3" json:"arch,omitempty"`
482 // Os is the operating system: "linux". Other values are invalid_argument
483 // (the set may grow with compatible additions).
484 Os string `protobuf:"bytes,6,opt,name=os,proto3" json:"os,omitempty"`
485 // Replace removes the runner that already has this name, if any, before
486 // registering this one: its runner token is revoked at once, as in
487 // RunService.RemoveRunner, and a job it is running is not affected. The new
488 // runner gets a new runner_id. Needs the same scope as registering. Without
489 // replace, a name in use is already_exists. It is how a runner re-registers
490 // after losing its state.
491 Replace bool `protobuf:"varint,7,opt,name=replace,proto3" json:"replace,omitempty"`
492 unknownFields protoimpl.UnknownFields
493 sizeCache protoimpl.SizeCache
494}
495
496func (x *RegisterRunnerRequest) Reset() {
497 *x = RegisterRunnerRequest{}
498 mi := &file_ermite_runner_proto_msgTypes[0]
499 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
500 ms.StoreMessageInfo(mi)
501}
502
503func (x *RegisterRunnerRequest) String() string {
504 return protoimpl.X.MessageStringOf(x)
505}
506
507func (*RegisterRunnerRequest) ProtoMessage() {}
508
509func (x *RegisterRunnerRequest) ProtoReflect() protoreflect.Message {
510 mi := &file_ermite_runner_proto_msgTypes[0]
511 if x != nil {
512 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
513 if ms.LoadMessageInfo() == nil {
514 ms.StoreMessageInfo(mi)
515 }
516 return ms
517 }
518 return mi.MessageOf(x)
519}
520
521// Deprecated: Use RegisterRunnerRequest.ProtoReflect.Descriptor instead.
522func (*RegisterRunnerRequest) Descriptor() ([]byte, []int) {
523 return file_ermite_runner_proto_rawDescGZIP(), []int{0}
524}
525
526func (x *RegisterRunnerRequest) GetName() string {
527 if x != nil {
528 return x.Name
529 }
530 return ""
531}
532
533func (x *RegisterRunnerRequest) GetLabels() []string {
534 if x != nil {
535 return x.Labels
536 }
537 return nil
538}
539
540func (x *RegisterRunnerRequest) GetVersion() string {
541 if x != nil {
542 return x.Version
543 }
544 return ""
545}
546
547func (x *RegisterRunnerRequest) GetIsolation() RunnerIsolation {
548 if x != nil {
549 return x.Isolation
550 }
551 return RunnerIsolation_RUNNER_ISOLATION_UNSPECIFIED
552}
553
554func (x *RegisterRunnerRequest) GetArch() string {
555 if x != nil {
556 return x.Arch
557 }
558 return ""
559}
560
561func (x *RegisterRunnerRequest) GetOs() string {
562 if x != nil {
563 return x.Os
564 }
565 return ""
566}
567
568func (x *RegisterRunnerRequest) GetReplace() bool {
569 if x != nil {
570 return x.Replace
571 }
572 return false
573}
574
575// RegisterRunnerResponse holds the new runner and its secret.
576type RegisterRunnerResponse struct {
577 state protoimpl.MessageState `protogen:"open.v1"`
578 // RunnerId identifies the runner in ListRunners and RemoveRunner. It is not
579 // a secret.
580 RunnerId string `protobuf:"bytes,1,opt,name=runner_id,json=runnerId,proto3" json:"runner_id,omitempty"`
581 // RunnerToken is the secret of the runner, to present as "Authorization:
582 // Bearer <runner_token>" to FetchJob: "ermiterun_" and 43 base64url
583 // characters (32 random bytes, no padding). It is returned once: the server
584 // keeps only its SHA-256, the runner must store it (mode 0600). It stops
585 // working when the runner is removed or replaced.
586 RunnerToken string `protobuf:"bytes,2,opt,name=runner_token,json=runnerToken,proto3" json:"runner_token,omitempty"`
587 unknownFields protoimpl.UnknownFields
588 sizeCache protoimpl.SizeCache
589}
590
591func (x *RegisterRunnerResponse) Reset() {
592 *x = RegisterRunnerResponse{}
593 mi := &file_ermite_runner_proto_msgTypes[1]
594 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
595 ms.StoreMessageInfo(mi)
596}
597
598func (x *RegisterRunnerResponse) String() string {
599 return protoimpl.X.MessageStringOf(x)
600}
601
602func (*RegisterRunnerResponse) ProtoMessage() {}
603
604func (x *RegisterRunnerResponse) ProtoReflect() protoreflect.Message {
605 mi := &file_ermite_runner_proto_msgTypes[1]
606 if x != nil {
607 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
608 if ms.LoadMessageInfo() == nil {
609 ms.StoreMessageInfo(mi)
610 }
611 return ms
612 }
613 return mi.MessageOf(x)
614}
615
616// Deprecated: Use RegisterRunnerResponse.ProtoReflect.Descriptor instead.
617func (*RegisterRunnerResponse) Descriptor() ([]byte, []int) {
618 return file_ermite_runner_proto_rawDescGZIP(), []int{1}
619}
620
621func (x *RegisterRunnerResponse) GetRunnerId() string {
622 if x != nil {
623 return x.RunnerId
624 }
625 return ""
626}
627
628func (x *RegisterRunnerResponse) GetRunnerToken() string {
629 if x != nil {
630 return x.RunnerToken
631 }
632 return ""
633}
634
635// FetchJobRequest asks for a job.
636type FetchJobRequest struct {
637 state protoimpl.MessageState `protogen:"open.v1"`
638 // Labels narrows the labels offered for this call. Empty means all the
639 // labels of the runner, which is the normal case. Otherwise each one must be
640 // a label of the runner (invalid_argument if not) and only jobs whose runs-on
641 // labels are all among them are offered.
642 Labels []string `protobuf:"bytes,1,rep,name=labels,proto3" json:"labels,omitempty"`
643 // PollId identifies this poll, chosen by the client (for example 16 random
644 // bytes in base64url), 1 to 64 characters among letters, digits, "_" and
645 // "-". A client that retries a call whose response it did not get sends the
646 // same poll_id, and gets the assignment the first call made, if it made one
647 // (see FetchJob). A new poll uses a new id. Empty means no retry protection:
648 // a lost assignment is then recovered by the acknowledgement timeout alone.
649 PollId string `protobuf:"bytes,2,opt,name=poll_id,json=pollId,proto3" json:"poll_id,omitempty"`
650 unknownFields protoimpl.UnknownFields
651 sizeCache protoimpl.SizeCache
652}
653
654func (x *FetchJobRequest) Reset() {
655 *x = FetchJobRequest{}
656 mi := &file_ermite_runner_proto_msgTypes[2]
657 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
658 ms.StoreMessageInfo(mi)
659}
660
661func (x *FetchJobRequest) String() string {
662 return protoimpl.X.MessageStringOf(x)
663}
664
665func (*FetchJobRequest) ProtoMessage() {}
666
667func (x *FetchJobRequest) ProtoReflect() protoreflect.Message {
668 mi := &file_ermite_runner_proto_msgTypes[2]
669 if x != nil {
670 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
671 if ms.LoadMessageInfo() == nil {
672 ms.StoreMessageInfo(mi)
673 }
674 return ms
675 }
676 return mi.MessageOf(x)
677}
678
679// Deprecated: Use FetchJobRequest.ProtoReflect.Descriptor instead.
680func (*FetchJobRequest) Descriptor() ([]byte, []int) {
681 return file_ermite_runner_proto_rawDescGZIP(), []int{2}
682}
683
684func (x *FetchJobRequest) GetLabels() []string {
685 if x != nil {
686 return x.Labels
687 }
688 return nil
689}
690
691func (x *FetchJobRequest) GetPollId() string {
692 if x != nil {
693 return x.PollId
694 }
695 return ""
696}
697
698// FetchJobResponse holds the job given to the runner, if any.
699type FetchJobResponse struct {
700 state protoimpl.MessageState `protogen:"open.v1"`
701 // Job is the job to run. Unset when no job was available before the end of
702 // the poll.
703 Job *Job `protobuf:"bytes,1,opt,name=job,proto3" json:"job,omitempty"`
704 // RetryAfter is how long the client waits before its next FetchJob. Unset or
705 // zero means call again at once. The server sets it when it has no job for
706 // the runner and wants to slow polling down (load, shutdown in progress);
707 // clients obey it and may wait longer, never less. Unset when job is set.
708 RetryAfter *durationpb.Duration `protobuf:"bytes,2,opt,name=retry_after,json=retryAfter,proto3" json:"retry_after,omitempty"`
709 unknownFields protoimpl.UnknownFields
710 sizeCache protoimpl.SizeCache
711}
712
713func (x *FetchJobResponse) Reset() {
714 *x = FetchJobResponse{}
715 mi := &file_ermite_runner_proto_msgTypes[3]
716 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
717 ms.StoreMessageInfo(mi)
718}
719
720func (x *FetchJobResponse) String() string {
721 return protoimpl.X.MessageStringOf(x)
722}
723
724func (*FetchJobResponse) ProtoMessage() {}
725
726func (x *FetchJobResponse) ProtoReflect() protoreflect.Message {
727 mi := &file_ermite_runner_proto_msgTypes[3]
728 if x != nil {
729 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
730 if ms.LoadMessageInfo() == nil {
731 ms.StoreMessageInfo(mi)
732 }
733 return ms
734 }
735 return mi.MessageOf(x)
736}
737
738// Deprecated: Use FetchJobResponse.ProtoReflect.Descriptor instead.
739func (*FetchJobResponse) Descriptor() ([]byte, []int) {
740 return file_ermite_runner_proto_rawDescGZIP(), []int{3}
741}
742
743func (x *FetchJobResponse) GetJob() *Job {
744 if x != nil {
745 return x.Job
746 }
747 return nil
748}
749
750func (x *FetchJobResponse) GetRetryAfter() *durationpb.Duration {
751 if x != nil {
752 return x.RetryAfter
753 }
754 return nil
755}
756
757// Job is a job given to a runner: everything needed to run it, nothing more.
758// The runner parses workflow_yaml itself; the protocol does not carry the
759// workflow model, so it does not change when the model grows.
760type Job struct {
761 state protoimpl.MessageState `protogen:"open.v1"`
762 // JobId identifies the job on the server. It is opaque, unique across
763 // repositories and runs, and the same for every attempt of the job. With
764 // attempt it names one execution.
765 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
766 // RunId is the run the job belongs to, the "github.run_id". It is global to
767 // the server.
768 RunId int64 `protobuf:"varint,2,opt,name=run_id,json=runId,proto3" json:"run_id,omitempty"`
769 // Attempt is the attempt of the run this job executes: 1 for the first, and
770 // one more after each RunService.RerunRun. It is the "github.run_attempt".
771 Attempt int32 `protobuf:"varint,3,opt,name=attempt,proto3" json:"attempt,omitempty"`
772 // JobToken is the secret that authenticates this job's UpdateJob,
773 // AppendLog, Heartbeat, WatchJob and CompleteJob calls ("Authorization:
774 // Bearer <job_token>"): "ermitejob_" and 43 base64url characters (32 random
775 // bytes, no padding). It is random, valid from the assignment until the job
776 // ends (and for CompleteJob 24 hours more), survives a server restart and
777 // is shown only in this response, or in a repeat of the same poll_id. It
778 // must stay in the runner host process and never reach the job's code. A new
779 // assignment of the same job has a new token.
780 JobToken string `protobuf:"bytes,4,opt,name=job_token,json=jobToken,proto3" json:"job_token,omitempty"`
781 // WorkflowPath is the path of the workflow file in the repository, for
782 // example ".github/workflows/ci.yml".
783 WorkflowPath string `protobuf:"bytes,5,opt,name=workflow_path,json=workflowPath,proto3" json:"workflow_path,omitempty"`
784 // WorkflowYaml is the content of that file at sha, as is, at most 1 MiB
785 // (larger files fail at planning).
786 WorkflowYaml string `protobuf:"bytes,6,opt,name=workflow_yaml,json=workflowYaml,proto3" json:"workflow_yaml,omitempty"`
787 // JobKey is the key of the job under "jobs:" in the workflow, the
788 // "github.job".
789 JobKey string `protobuf:"bytes,7,opt,name=job_key,json=jobKey,proto3" json:"job_key,omitempty"`
790 // Matrix is the JSON object of the matrix values of this instance of the
791 // job, for example {"os":"linux","go":"1.27"}. "{}" when the job has no
792 // matrix. It is the "matrix" context.
793 Matrix string `protobuf:"bytes,8,opt,name=matrix,proto3" json:"matrix,omitempty"`
794 // Contexts is a JSON object with the contexts that the server computed for
795 // this job: "github", "needs", "strategy", "matrix", "inputs" and "vars", in
796 // the shape GitHub gives them. The contexts "job", "runner", "steps" and
797 // "env" belong to the runner and are not in it. Other keys may be added
798 // later; clients ignore those they do not know.
799 Contexts string `protobuf:"bytes,9,opt,name=contexts,proto3" json:"contexts,omitempty"`
800 // Labels are the runs-on labels of the job, evaluated.
801 Labels []string `protobuf:"bytes,10,rep,name=labels,proto3" json:"labels,omitempty"`
802 // TimeoutMinutes is the timeout of the job in minutes: the value of the
803 // workflow's timeout-minutes, or 360 when it has none. At least 1. The
804 // runner enforces it from the moment it receives the job. The server counts
805 // from the moment of the assignment and adds 60 seconds of slack, so the
806 // runner's own timeout always comes first: when the server's deadline
807 // passes it announces CANCEL_REASON_TIMEOUT, and ends the job itself after
808 // 60 more seconds without a conclusion (see WatchJob).
809 TimeoutMinutes int32 `protobuf:"varint,11,opt,name=timeout_minutes,json=timeoutMinutes,proto3" json:"timeout_minutes,omitempty"`
810 // Repo is the name of the repository.
811 Repo string `protobuf:"bytes,12,opt,name=repo,proto3" json:"repo,omitempty"`
812 // Sha is the full id of the commit the run is for, 40 lowercase
813 // hexadecimal characters for SHA-1. The runner reads the code at it.
814 Sha string `protobuf:"bytes,13,opt,name=sha,proto3" json:"sha,omitempty"`
815 // Ref is the full ref name that triggered the run, for example
816 // "refs/heads/main" or "refs/tags/v1.0.0".
817 Ref string `protobuf:"bytes,14,opt,name=ref,proto3" json:"ref,omitempty"`
818 // GithubToken is the job repository token, the "github.token" and
819 // "secrets.GITHUB_TOKEN" of the job: "ermitegh_" and 43 base64url characters
820 // (32 random bytes, no padding). Unlike job_token it is meant for the code of
821 // the job: the runner gives it to the sandbox (actions/checkout clones with
822 // it). It can only read the repository of the run (read-only, whatever
823 // "permissions:" says), and is valid from the assignment until the job ends
824 // (it is revoked then, on cancellation and when the job is lost). It is a
825 // secret: the runner registers it in its masker before anything runs, and
826 // neither the runner nor the server logs it. It is shown only in this
827 // response, or in a repeat of the same poll_id; a new assignment of the same
828 // job has a new one. Empty from servers without the feature "ci.actions".
829 GithubToken string `protobuf:"bytes,15,opt,name=github_token,json=githubToken,proto3" json:"github_token,omitempty"`
830 unknownFields protoimpl.UnknownFields
831 sizeCache protoimpl.SizeCache
832}
833
834func (x *Job) Reset() {
835 *x = Job{}
836 mi := &file_ermite_runner_proto_msgTypes[4]
837 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
838 ms.StoreMessageInfo(mi)
839}
840
841func (x *Job) String() string {
842 return protoimpl.X.MessageStringOf(x)
843}
844
845func (*Job) ProtoMessage() {}
846
847func (x *Job) ProtoReflect() protoreflect.Message {
848 mi := &file_ermite_runner_proto_msgTypes[4]
849 if x != nil {
850 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
851 if ms.LoadMessageInfo() == nil {
852 ms.StoreMessageInfo(mi)
853 }
854 return ms
855 }
856 return mi.MessageOf(x)
857}
858
859// Deprecated: Use Job.ProtoReflect.Descriptor instead.
860func (*Job) Descriptor() ([]byte, []int) {
861 return file_ermite_runner_proto_rawDescGZIP(), []int{4}
862}
863
864func (x *Job) GetJobId() string {
865 if x != nil {
866 return x.JobId
867 }
868 return ""
869}
870
871func (x *Job) GetRunId() int64 {
872 if x != nil {
873 return x.RunId
874 }
875 return 0
876}
877
878func (x *Job) GetAttempt() int32 {
879 if x != nil {
880 return x.Attempt
881 }
882 return 0
883}
884
885func (x *Job) GetJobToken() string {
886 if x != nil {
887 return x.JobToken
888 }
889 return ""
890}
891
892func (x *Job) GetWorkflowPath() string {
893 if x != nil {
894 return x.WorkflowPath
895 }
896 return ""
897}
898
899func (x *Job) GetWorkflowYaml() string {
900 if x != nil {
901 return x.WorkflowYaml
902 }
903 return ""
904}
905
906func (x *Job) GetJobKey() string {
907 if x != nil {
908 return x.JobKey
909 }
910 return ""
911}
912
913func (x *Job) GetMatrix() string {
914 if x != nil {
915 return x.Matrix
916 }
917 return ""
918}
919
920func (x *Job) GetContexts() string {
921 if x != nil {
922 return x.Contexts
923 }
924 return ""
925}
926
927func (x *Job) GetLabels() []string {
928 if x != nil {
929 return x.Labels
930 }
931 return nil
932}
933
934func (x *Job) GetTimeoutMinutes() int32 {
935 if x != nil {
936 return x.TimeoutMinutes
937 }
938 return 0
939}
940
941func (x *Job) GetRepo() string {
942 if x != nil {
943 return x.Repo
944 }
945 return ""
946}
947
948func (x *Job) GetSha() string {
949 if x != nil {
950 return x.Sha
951 }
952 return ""
953}
954
955func (x *Job) GetRef() string {
956 if x != nil {
957 return x.Ref
958 }
959 return ""
960}
961
962func (x *Job) GetGithubToken() string {
963 if x != nil {
964 return x.GithubToken
965 }
966 return ""
967}
968
969// UpdateJobRequest reports the steps of a running job.
970type UpdateJobRequest struct {
971 state protoimpl.MessageState `protogen:"open.v1"`
972 // JobId is the Job.job_id. It must be the job of the token.
973 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
974 // Steps are the steps whose state changed or that are new. Each one is a
975 // full snapshot of its step, applied by number. At most 1,000 steps per job
976 // (invalid_argument beyond). Steps are numbered like GitHub's log: the
977 // implicit "Set up job" is 1, the steps of the workflow follow in order, and
978 // the implicit "Complete job" is last.
979 Steps []*StepUpdate `protobuf:"bytes,2,rep,name=steps,proto3" json:"steps,omitempty"`
980 // Annotations are the annotations of the steps that the call names: for
981 // each step_number present, all the annotations of that step known so far,
982 // not only the new ones (see the rules on UpdateJob). At most 10 per level
983 // and per step, and each one within the limits of Annotation; otherwise the
984 // whole call is invalid_argument. The server ignores them without the
985 // feature "ci.annotations".
986 Annotations []*Annotation `protobuf:"bytes,3,rep,name=annotations,proto3" json:"annotations,omitempty"`
987 unknownFields protoimpl.UnknownFields
988 sizeCache protoimpl.SizeCache
989}
990
991func (x *UpdateJobRequest) Reset() {
992 *x = UpdateJobRequest{}
993 mi := &file_ermite_runner_proto_msgTypes[5]
994 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
995 ms.StoreMessageInfo(mi)
996}
997
998func (x *UpdateJobRequest) String() string {
999 return protoimpl.X.MessageStringOf(x)
1000}
1001
1002func (*UpdateJobRequest) ProtoMessage() {}
1003
1004func (x *UpdateJobRequest) ProtoReflect() protoreflect.Message {
1005 mi := &file_ermite_runner_proto_msgTypes[5]
1006 if x != nil {
1007 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1008 if ms.LoadMessageInfo() == nil {
1009 ms.StoreMessageInfo(mi)
1010 }
1011 return ms
1012 }
1013 return mi.MessageOf(x)
1014}
1015
1016// Deprecated: Use UpdateJobRequest.ProtoReflect.Descriptor instead.
1017func (*UpdateJobRequest) Descriptor() ([]byte, []int) {
1018 return file_ermite_runner_proto_rawDescGZIP(), []int{5}
1019}
1020
1021func (x *UpdateJobRequest) GetJobId() string {
1022 if x != nil {
1023 return x.JobId
1024 }
1025 return ""
1026}
1027
1028func (x *UpdateJobRequest) GetSteps() []*StepUpdate {
1029 if x != nil {
1030 return x.Steps
1031 }
1032 return nil
1033}
1034
1035func (x *UpdateJobRequest) GetAnnotations() []*Annotation {
1036 if x != nil {
1037 return x.Annotations
1038 }
1039 return nil
1040}
1041
1042// StepUpdate is the state of one step as the runner knows it.
1043type StepUpdate struct {
1044 state protoimpl.MessageState `protogen:"open.v1"`
1045 // Number is the 1-based number of the step in the job. It is the number
1046 // used by AppendLog.
1047 Number int32 `protobuf:"varint,1,opt,name=number,proto3" json:"number,omitempty"`
1048 // Name is the display name of the step, evaluated: the "name" of the
1049 // workflow step, or "Run <first line of the script>", as GitHub shows it.
1050 // At most 1,024 characters; the server cuts longer names.
1051 Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
1052 // State is where the step is.
1053 State StepState `protobuf:"varint,3,opt,name=state,proto3,enum=ermite.StepState" json:"state,omitempty"`
1054 // Conclusion is how the step ended. Required (not UNSPECIFIED) when state is
1055 // COMPLETED, must be UNSPECIFIED otherwise. Allowed values: success,
1056 // failure, cancelled, skipped.
1057 Conclusion CiConclusion `protobuf:"varint,4,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
1058 // StartedAt is when the step started, by the clock of the runner. Required
1059 // from IN_PROGRESS on.
1060 StartedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"`
1061 // CompletedAt is when the step ended, by the clock of the runner. Required
1062 // when state is COMPLETED.
1063 CompletedAt *timestamppb.Timestamp `protobuf:"bytes,6,opt,name=completed_at,json=completedAt,proto3" json:"completed_at,omitempty"`
1064 // Outcome is how the step ended before continue-on-error was applied, GitHub's
1065 // "steps.<id>.outcome", whereas conclusion is the result after it
1066 // ("steps.<id>.conclusion"). Same values as conclusion. They differ only for
1067 // a step with continue-on-error that failed: outcome FAILURE, conclusion
1068 // SUCCESS. Set by the runner when state is COMPLETED and UNSPECIFIED
1069 // otherwise; UNSPECIFIED in a COMPLETED step means the same as conclusion
1070 // (a runner that does not know the field).
1071 Outcome CiConclusion `protobuf:"varint,7,opt,name=outcome,proto3,enum=ermite.CiConclusion" json:"outcome,omitempty"`
1072 unknownFields protoimpl.UnknownFields
1073 sizeCache protoimpl.SizeCache
1074}
1075
1076func (x *StepUpdate) Reset() {
1077 *x = StepUpdate{}
1078 mi := &file_ermite_runner_proto_msgTypes[6]
1079 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1080 ms.StoreMessageInfo(mi)
1081}
1082
1083func (x *StepUpdate) String() string {
1084 return protoimpl.X.MessageStringOf(x)
1085}
1086
1087func (*StepUpdate) ProtoMessage() {}
1088
1089func (x *StepUpdate) ProtoReflect() protoreflect.Message {
1090 mi := &file_ermite_runner_proto_msgTypes[6]
1091 if x != nil {
1092 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1093 if ms.LoadMessageInfo() == nil {
1094 ms.StoreMessageInfo(mi)
1095 }
1096 return ms
1097 }
1098 return mi.MessageOf(x)
1099}
1100
1101// Deprecated: Use StepUpdate.ProtoReflect.Descriptor instead.
1102func (*StepUpdate) Descriptor() ([]byte, []int) {
1103 return file_ermite_runner_proto_rawDescGZIP(), []int{6}
1104}
1105
1106func (x *StepUpdate) GetNumber() int32 {
1107 if x != nil {
1108 return x.Number
1109 }
1110 return 0
1111}
1112
1113func (x *StepUpdate) GetName() string {
1114 if x != nil {
1115 return x.Name
1116 }
1117 return ""
1118}
1119
1120func (x *StepUpdate) GetState() StepState {
1121 if x != nil {
1122 return x.State
1123 }
1124 return StepState_STEP_STATE_UNSPECIFIED
1125}
1126
1127func (x *StepUpdate) GetConclusion() CiConclusion {
1128 if x != nil {
1129 return x.Conclusion
1130 }
1131 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1132}
1133
1134func (x *StepUpdate) GetStartedAt() *timestamppb.Timestamp {
1135 if x != nil {
1136 return x.StartedAt
1137 }
1138 return nil
1139}
1140
1141func (x *StepUpdate) GetCompletedAt() *timestamppb.Timestamp {
1142 if x != nil {
1143 return x.CompletedAt
1144 }
1145 return nil
1146}
1147
1148func (x *StepUpdate) GetOutcome() CiConclusion {
1149 if x != nil {
1150 return x.Outcome
1151 }
1152 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1153}
1154
1155// UpdateJobResponse is empty.
1156type UpdateJobResponse struct {
1157 state protoimpl.MessageState `protogen:"open.v1"`
1158 unknownFields protoimpl.UnknownFields
1159 sizeCache protoimpl.SizeCache
1160}
1161
1162func (x *UpdateJobResponse) Reset() {
1163 *x = UpdateJobResponse{}
1164 mi := &file_ermite_runner_proto_msgTypes[7]
1165 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1166 ms.StoreMessageInfo(mi)
1167}
1168
1169func (x *UpdateJobResponse) String() string {
1170 return protoimpl.X.MessageStringOf(x)
1171}
1172
1173func (*UpdateJobResponse) ProtoMessage() {}
1174
1175func (x *UpdateJobResponse) ProtoReflect() protoreflect.Message {
1176 mi := &file_ermite_runner_proto_msgTypes[7]
1177 if x != nil {
1178 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1179 if ms.LoadMessageInfo() == nil {
1180 ms.StoreMessageInfo(mi)
1181 }
1182 return ms
1183 }
1184 return mi.MessageOf(x)
1185}
1186
1187// Deprecated: Use UpdateJobResponse.ProtoReflect.Descriptor instead.
1188func (*UpdateJobResponse) Descriptor() ([]byte, []int) {
1189 return file_ermite_runner_proto_rawDescGZIP(), []int{7}
1190}
1191
1192// CompleteJobRequest ends a job.
1193type CompleteJobRequest struct {
1194 state protoimpl.MessageState `protogen:"open.v1"`
1195 // JobId is the Job.job_id. It must be the job of the token.
1196 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1197 // Conclusion is how the job ended. Required: a runner reports
1198 // CI_CONCLUSION_SUCCESS, CI_CONCLUSION_FAILURE, CI_CONCLUSION_CANCELLED or
1199 // CI_CONCLUSION_TIMED_OUT; any other value is invalid_argument. Skipped is
1200 // decided by the server and never reported by a runner.
1201 Conclusion CiConclusion `protobuf:"varint,2,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
1202 // Outputs are the outputs of the job, evaluated by the runner. Names are 1
1203 // to 255 characters among letters, digits, "_" and "-" and begin with a
1204 // letter or "_" and are case-insensitive: two names that differ only by case
1205 // are invalid_argument. Each value is at most 1 MiB, and all names and
1206 // values together at most 1 MiB (1,048,576 bytes); beyond that the whole call
1207 // is rejected with invalid_argument and the runner reports the failure of
1208 // the job without outputs, with a line in the log.
1209 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"`
1210 // RunnerShutdown is true when the runner ends the job because it was told to
1211 // stop (service stopped, signal). Only allowed with CI_CONCLUSION_CANCELLED.
1212 // The server then annotates the job with GitHub's message "The runner has
1213 // received a shutdown signal. This can happen when the runner service is
1214 // stopped, or a manually started runner is canceled." The conclusion
1215 // CANCELLED for this case is to be verified against a recording of GitHub.
1216 RunnerShutdown bool `protobuf:"varint,4,opt,name=runner_shutdown,json=runnerShutdown,proto3" json:"runner_shutdown,omitempty"`
1217 // Steps are the final steps, with the same meaning as UpdateJobRequest.steps,
1218 // applied in the same atomic step as the conclusion.
1219 Steps []*StepUpdate `protobuf:"bytes,5,rep,name=steps,proto3" json:"steps,omitempty"`
1220 // Annotations are those of the steps that changed since the last call, with
1221 // the rules of UpdateJobRequest.annotations (all the annotations of each
1222 // step named). The server ignores them without the feature
1223 // "ci.annotations".
1224 Annotations []*Annotation `protobuf:"bytes,6,rep,name=annotations,proto3" json:"annotations,omitempty"`
1225 unknownFields protoimpl.UnknownFields
1226 sizeCache protoimpl.SizeCache
1227}
1228
1229func (x *CompleteJobRequest) Reset() {
1230 *x = CompleteJobRequest{}
1231 mi := &file_ermite_runner_proto_msgTypes[8]
1232 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1233 ms.StoreMessageInfo(mi)
1234}
1235
1236func (x *CompleteJobRequest) String() string {
1237 return protoimpl.X.MessageStringOf(x)
1238}
1239
1240func (*CompleteJobRequest) ProtoMessage() {}
1241
1242func (x *CompleteJobRequest) ProtoReflect() protoreflect.Message {
1243 mi := &file_ermite_runner_proto_msgTypes[8]
1244 if x != nil {
1245 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1246 if ms.LoadMessageInfo() == nil {
1247 ms.StoreMessageInfo(mi)
1248 }
1249 return ms
1250 }
1251 return mi.MessageOf(x)
1252}
1253
1254// Deprecated: Use CompleteJobRequest.ProtoReflect.Descriptor instead.
1255func (*CompleteJobRequest) Descriptor() ([]byte, []int) {
1256 return file_ermite_runner_proto_rawDescGZIP(), []int{8}
1257}
1258
1259func (x *CompleteJobRequest) GetJobId() string {
1260 if x != nil {
1261 return x.JobId
1262 }
1263 return ""
1264}
1265
1266func (x *CompleteJobRequest) GetConclusion() CiConclusion {
1267 if x != nil {
1268 return x.Conclusion
1269 }
1270 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1271}
1272
1273func (x *CompleteJobRequest) GetOutputs() map[string]string {
1274 if x != nil {
1275 return x.Outputs
1276 }
1277 return nil
1278}
1279
1280func (x *CompleteJobRequest) GetRunnerShutdown() bool {
1281 if x != nil {
1282 return x.RunnerShutdown
1283 }
1284 return false
1285}
1286
1287func (x *CompleteJobRequest) GetSteps() []*StepUpdate {
1288 if x != nil {
1289 return x.Steps
1290 }
1291 return nil
1292}
1293
1294func (x *CompleteJobRequest) GetAnnotations() []*Annotation {
1295 if x != nil {
1296 return x.Annotations
1297 }
1298 return nil
1299}
1300
1301// CompleteJobResponse is the stored result of a job.
1302type CompleteJobResponse struct {
1303 state protoimpl.MessageState `protogen:"open.v1"`
1304 // Conclusion is the conclusion of the job as the server stored it. It is the
1305 // one of the request when applied is true.
1306 Conclusion CiConclusion `protobuf:"varint,1,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
1307 // Error is the error text stored with the job, as RunJob.error. Empty when
1308 // there is none.
1309 Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
1310 // Applied is true when this call ended the job, false when the job had
1311 // already ended (a retry, or the server ended it first) and nothing changed.
1312 Applied bool `protobuf:"varint,3,opt,name=applied,proto3" json:"applied,omitempty"`
1313 unknownFields protoimpl.UnknownFields
1314 sizeCache protoimpl.SizeCache
1315}
1316
1317func (x *CompleteJobResponse) Reset() {
1318 *x = CompleteJobResponse{}
1319 mi := &file_ermite_runner_proto_msgTypes[9]
1320 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1321 ms.StoreMessageInfo(mi)
1322}
1323
1324func (x *CompleteJobResponse) String() string {
1325 return protoimpl.X.MessageStringOf(x)
1326}
1327
1328func (*CompleteJobResponse) ProtoMessage() {}
1329
1330func (x *CompleteJobResponse) ProtoReflect() protoreflect.Message {
1331 mi := &file_ermite_runner_proto_msgTypes[9]
1332 if x != nil {
1333 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1334 if ms.LoadMessageInfo() == nil {
1335 ms.StoreMessageInfo(mi)
1336 }
1337 return ms
1338 }
1339 return mi.MessageOf(x)
1340}
1341
1342// Deprecated: Use CompleteJobResponse.ProtoReflect.Descriptor instead.
1343func (*CompleteJobResponse) Descriptor() ([]byte, []int) {
1344 return file_ermite_runner_proto_rawDescGZIP(), []int{9}
1345}
1346
1347func (x *CompleteJobResponse) GetConclusion() CiConclusion {
1348 if x != nil {
1349 return x.Conclusion
1350 }
1351 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1352}
1353
1354func (x *CompleteJobResponse) GetError() string {
1355 if x != nil {
1356 return x.Error
1357 }
1358 return ""
1359}
1360
1361func (x *CompleteJobResponse) GetApplied() bool {
1362 if x != nil {
1363 return x.Applied
1364 }
1365 return false
1366}
1367
1368// JobEnded says that a job has ended. It is sent in WatchJob and attached, as
1369// an error detail, to the failed_precondition errors that RunnerService returns
1370// for a job that has ended.
1371type JobEnded struct {
1372 state protoimpl.MessageState `protogen:"open.v1"`
1373 // Conclusion is how the job ended.
1374 Conclusion CiConclusion `protobuf:"varint,1,opt,name=conclusion,proto3,enum=ermite.CiConclusion" json:"conclusion,omitempty"`
1375 // Error is the error text stored with the job, as RunJob.error. Empty when
1376 // there is none.
1377 Error string `protobuf:"bytes,2,opt,name=error,proto3" json:"error,omitempty"`
1378 unknownFields protoimpl.UnknownFields
1379 sizeCache protoimpl.SizeCache
1380}
1381
1382func (x *JobEnded) Reset() {
1383 *x = JobEnded{}
1384 mi := &file_ermite_runner_proto_msgTypes[10]
1385 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1386 ms.StoreMessageInfo(mi)
1387}
1388
1389func (x *JobEnded) String() string {
1390 return protoimpl.X.MessageStringOf(x)
1391}
1392
1393func (*JobEnded) ProtoMessage() {}
1394
1395func (x *JobEnded) ProtoReflect() protoreflect.Message {
1396 mi := &file_ermite_runner_proto_msgTypes[10]
1397 if x != nil {
1398 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1399 if ms.LoadMessageInfo() == nil {
1400 ms.StoreMessageInfo(mi)
1401 }
1402 return ms
1403 }
1404 return mi.MessageOf(x)
1405}
1406
1407// Deprecated: Use JobEnded.ProtoReflect.Descriptor instead.
1408func (*JobEnded) Descriptor() ([]byte, []int) {
1409 return file_ermite_runner_proto_rawDescGZIP(), []int{10}
1410}
1411
1412func (x *JobEnded) GetConclusion() CiConclusion {
1413 if x != nil {
1414 return x.Conclusion
1415 }
1416 return CiConclusion_CI_CONCLUSION_UNSPECIFIED
1417}
1418
1419func (x *JobEnded) GetError() string {
1420 if x != nil {
1421 return x.Error
1422 }
1423 return ""
1424}
1425
1426// AppendLogRequest carries log lines of one step.
1427type AppendLogRequest struct {
1428 state protoimpl.MessageState `protogen:"open.v1"`
1429 // JobId is the Job.job_id. It must be the job of the token.
1430 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1431 // Step is the number of the step the lines belong to (see
1432 // UpdateJobRequest.steps), at least 1, and at least the step of the last
1433 // stored line. A step that UpdateJob has not announced yet is created by the
1434 // first lines. See the rules on AppendLog.
1435 Step int32 `protobuf:"varint,2,opt,name=step,proto3" json:"step,omitempty"`
1436 // Offset is the number of the first line of the request in the log of the
1437 // job, counted from 0 across all steps. See the rules on AppendLog.
1438 Offset int64 `protobuf:"varint,3,opt,name=offset,proto3" json:"offset,omitempty"`
1439 // Lines are the lines to append, in order: at most 1,000, at most 64 KiB of
1440 // text in total.
1441 Lines []*LogLine `protobuf:"bytes,4,rep,name=lines,proto3" json:"lines,omitempty"`
1442 unknownFields protoimpl.UnknownFields
1443 sizeCache protoimpl.SizeCache
1444}
1445
1446func (x *AppendLogRequest) Reset() {
1447 *x = AppendLogRequest{}
1448 mi := &file_ermite_runner_proto_msgTypes[11]
1449 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1450 ms.StoreMessageInfo(mi)
1451}
1452
1453func (x *AppendLogRequest) String() string {
1454 return protoimpl.X.MessageStringOf(x)
1455}
1456
1457func (*AppendLogRequest) ProtoMessage() {}
1458
1459func (x *AppendLogRequest) ProtoReflect() protoreflect.Message {
1460 mi := &file_ermite_runner_proto_msgTypes[11]
1461 if x != nil {
1462 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1463 if ms.LoadMessageInfo() == nil {
1464 ms.StoreMessageInfo(mi)
1465 }
1466 return ms
1467 }
1468 return mi.MessageOf(x)
1469}
1470
1471// Deprecated: Use AppendLogRequest.ProtoReflect.Descriptor instead.
1472func (*AppendLogRequest) Descriptor() ([]byte, []int) {
1473 return file_ermite_runner_proto_rawDescGZIP(), []int{11}
1474}
1475
1476func (x *AppendLogRequest) GetJobId() string {
1477 if x != nil {
1478 return x.JobId
1479 }
1480 return ""
1481}
1482
1483func (x *AppendLogRequest) GetStep() int32 {
1484 if x != nil {
1485 return x.Step
1486 }
1487 return 0
1488}
1489
1490func (x *AppendLogRequest) GetOffset() int64 {
1491 if x != nil {
1492 return x.Offset
1493 }
1494 return 0
1495}
1496
1497func (x *AppendLogRequest) GetLines() []*LogLine {
1498 if x != nil {
1499 return x.Lines
1500 }
1501 return nil
1502}
1503
1504// LogLine is one line of a job log.
1505type LogLine struct {
1506 state protoimpl.MessageState `protogen:"open.v1"`
1507 // Time is when the line was produced, by the clock of the runner. The server
1508 // keeps it with nanosecond precision (RFC 3339) and does not reorder lines.
1509 Time *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
1510 // Text is the line without its line terminator, valid UTF-8 (the client
1511 // replaces invalid bytes with U+FFFD). It must not contain a line feed; a
1512 // carriage return is kept. It is the line as GitHub's raw log has it,
1513 // including "##[group]" and "##[endgroup]" markers and "##[error]" lines.
1514 Text string `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
1515 // Continued is true when this line is the continuation of the line before
1516 // it, which was too long to send whole. A runner cuts a line of more than
1517 // 64 KiB into pieces at UTF-8 character boundaries, each piece of at most
1518 // 64 KiB, and sets continued on every piece but the first. Each piece is one
1519 // line for numbering and offsets; the server and the raw log join the
1520 // pieces back, so the original line is rebuilt exactly. The first line of a
1521 // job cannot be continued (invalid_argument) and a continued line is in
1522 // the same step as the line before it (failed_precondition otherwise).
1523 Continued bool `protobuf:"varint,3,opt,name=continued,proto3" json:"continued,omitempty"`
1524 unknownFields protoimpl.UnknownFields
1525 sizeCache protoimpl.SizeCache
1526}
1527
1528func (x *LogLine) Reset() {
1529 *x = LogLine{}
1530 mi := &file_ermite_runner_proto_msgTypes[12]
1531 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1532 ms.StoreMessageInfo(mi)
1533}
1534
1535func (x *LogLine) String() string {
1536 return protoimpl.X.MessageStringOf(x)
1537}
1538
1539func (*LogLine) ProtoMessage() {}
1540
1541func (x *LogLine) ProtoReflect() protoreflect.Message {
1542 mi := &file_ermite_runner_proto_msgTypes[12]
1543 if x != nil {
1544 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1545 if ms.LoadMessageInfo() == nil {
1546 ms.StoreMessageInfo(mi)
1547 }
1548 return ms
1549 }
1550 return mi.MessageOf(x)
1551}
1552
1553// Deprecated: Use LogLine.ProtoReflect.Descriptor instead.
1554func (*LogLine) Descriptor() ([]byte, []int) {
1555 return file_ermite_runner_proto_rawDescGZIP(), []int{12}
1556}
1557
1558func (x *LogLine) GetTime() *timestamppb.Timestamp {
1559 if x != nil {
1560 return x.Time
1561 }
1562 return nil
1563}
1564
1565func (x *LogLine) GetText() string {
1566 if x != nil {
1567 return x.Text
1568 }
1569 return ""
1570}
1571
1572func (x *LogLine) GetContinued() bool {
1573 if x != nil {
1574 return x.Continued
1575 }
1576 return false
1577}
1578
1579// AppendLogResponse tells how much of the log the server holds.
1580type AppendLogResponse struct {
1581 state protoimpl.MessageState `protogen:"open.v1"`
1582 // NextOffset is the number of lines of the job log after the call, which is
1583 // the offset of the next request.
1584 NextOffset int64 `protobuf:"varint,1,opt,name=next_offset,json=nextOffset,proto3" json:"next_offset,omitempty"`
1585 unknownFields protoimpl.UnknownFields
1586 sizeCache protoimpl.SizeCache
1587}
1588
1589func (x *AppendLogResponse) Reset() {
1590 *x = AppendLogResponse{}
1591 mi := &file_ermite_runner_proto_msgTypes[13]
1592 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1593 ms.StoreMessageInfo(mi)
1594}
1595
1596func (x *AppendLogResponse) String() string {
1597 return protoimpl.X.MessageStringOf(x)
1598}
1599
1600func (*AppendLogResponse) ProtoMessage() {}
1601
1602func (x *AppendLogResponse) ProtoReflect() protoreflect.Message {
1603 mi := &file_ermite_runner_proto_msgTypes[13]
1604 if x != nil {
1605 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1606 if ms.LoadMessageInfo() == nil {
1607 ms.StoreMessageInfo(mi)
1608 }
1609 return ms
1610 }
1611 return mi.MessageOf(x)
1612}
1613
1614// Deprecated: Use AppendLogResponse.ProtoReflect.Descriptor instead.
1615func (*AppendLogResponse) Descriptor() ([]byte, []int) {
1616 return file_ermite_runner_proto_rawDescGZIP(), []int{13}
1617}
1618
1619func (x *AppendLogResponse) GetNextOffset() int64 {
1620 if x != nil {
1621 return x.NextOffset
1622 }
1623 return 0
1624}
1625
1626// HeartbeatRequest names the job that is alive.
1627type HeartbeatRequest struct {
1628 state protoimpl.MessageState `protogen:"open.v1"`
1629 // JobId is the Job.job_id. It must be the job of the token.
1630 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1631 unknownFields protoimpl.UnknownFields
1632 sizeCache protoimpl.SizeCache
1633}
1634
1635func (x *HeartbeatRequest) Reset() {
1636 *x = HeartbeatRequest{}
1637 mi := &file_ermite_runner_proto_msgTypes[14]
1638 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1639 ms.StoreMessageInfo(mi)
1640}
1641
1642func (x *HeartbeatRequest) String() string {
1643 return protoimpl.X.MessageStringOf(x)
1644}
1645
1646func (*HeartbeatRequest) ProtoMessage() {}
1647
1648func (x *HeartbeatRequest) ProtoReflect() protoreflect.Message {
1649 mi := &file_ermite_runner_proto_msgTypes[14]
1650 if x != nil {
1651 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1652 if ms.LoadMessageInfo() == nil {
1653 ms.StoreMessageInfo(mi)
1654 }
1655 return ms
1656 }
1657 return mi.MessageOf(x)
1658}
1659
1660// Deprecated: Use HeartbeatRequest.ProtoReflect.Descriptor instead.
1661func (*HeartbeatRequest) Descriptor() ([]byte, []int) {
1662 return file_ermite_runner_proto_rawDescGZIP(), []int{14}
1663}
1664
1665func (x *HeartbeatRequest) GetJobId() string {
1666 if x != nil {
1667 return x.JobId
1668 }
1669 return ""
1670}
1671
1672// HeartbeatResponse is empty.
1673type HeartbeatResponse struct {
1674 state protoimpl.MessageState `protogen:"open.v1"`
1675 unknownFields protoimpl.UnknownFields
1676 sizeCache protoimpl.SizeCache
1677}
1678
1679func (x *HeartbeatResponse) Reset() {
1680 *x = HeartbeatResponse{}
1681 mi := &file_ermite_runner_proto_msgTypes[15]
1682 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1683 ms.StoreMessageInfo(mi)
1684}
1685
1686func (x *HeartbeatResponse) String() string {
1687 return protoimpl.X.MessageStringOf(x)
1688}
1689
1690func (*HeartbeatResponse) ProtoMessage() {}
1691
1692func (x *HeartbeatResponse) ProtoReflect() protoreflect.Message {
1693 mi := &file_ermite_runner_proto_msgTypes[15]
1694 if x != nil {
1695 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1696 if ms.LoadMessageInfo() == nil {
1697 ms.StoreMessageInfo(mi)
1698 }
1699 return ms
1700 }
1701 return mi.MessageOf(x)
1702}
1703
1704// Deprecated: Use HeartbeatResponse.ProtoReflect.Descriptor instead.
1705func (*HeartbeatResponse) Descriptor() ([]byte, []int) {
1706 return file_ermite_runner_proto_rawDescGZIP(), []int{15}
1707}
1708
1709// WatchJobRequest names the job to watch.
1710type WatchJobRequest struct {
1711 state protoimpl.MessageState `protogen:"open.v1"`
1712 // JobId is the Job.job_id. It must be the job of the token.
1713 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
1714 unknownFields protoimpl.UnknownFields
1715 sizeCache protoimpl.SizeCache
1716}
1717
1718func (x *WatchJobRequest) Reset() {
1719 *x = WatchJobRequest{}
1720 mi := &file_ermite_runner_proto_msgTypes[16]
1721 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1722 ms.StoreMessageInfo(mi)
1723}
1724
1725func (x *WatchJobRequest) String() string {
1726 return protoimpl.X.MessageStringOf(x)
1727}
1728
1729func (*WatchJobRequest) ProtoMessage() {}
1730
1731func (x *WatchJobRequest) ProtoReflect() protoreflect.Message {
1732 mi := &file_ermite_runner_proto_msgTypes[16]
1733 if x != nil {
1734 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1735 if ms.LoadMessageInfo() == nil {
1736 ms.StoreMessageInfo(mi)
1737 }
1738 return ms
1739 }
1740 return mi.MessageOf(x)
1741}
1742
1743// Deprecated: Use WatchJobRequest.ProtoReflect.Descriptor instead.
1744func (*WatchJobRequest) Descriptor() ([]byte, []int) {
1745 return file_ermite_runner_proto_rawDescGZIP(), []int{16}
1746}
1747
1748func (x *WatchJobRequest) GetJobId() string {
1749 if x != nil {
1750 return x.JobId
1751 }
1752 return ""
1753}
1754
1755// WatchJobResponse is one message of the stream.
1756type WatchJobResponse struct {
1757 state protoimpl.MessageState `protogen:"open.v1"`
1758 // Msg is what the message carries. New kinds may be added: a client ignores
1759 // the ones it does not know.
1760 //
1761 // Types that are valid to be assigned to Msg:
1762 //
1763 // *WatchJobResponse_Keepalive
1764 // *WatchJobResponse_Cancel
1765 // *WatchJobResponse_Ended
1766 Msg isWatchJobResponse_Msg `protobuf_oneof:"msg"`
1767 unknownFields protoimpl.UnknownFields
1768 sizeCache protoimpl.SizeCache
1769}
1770
1771func (x *WatchJobResponse) Reset() {
1772 *x = WatchJobResponse{}
1773 mi := &file_ermite_runner_proto_msgTypes[17]
1774 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1775 ms.StoreMessageInfo(mi)
1776}
1777
1778func (x *WatchJobResponse) String() string {
1779 return protoimpl.X.MessageStringOf(x)
1780}
1781
1782func (*WatchJobResponse) ProtoMessage() {}
1783
1784func (x *WatchJobResponse) ProtoReflect() protoreflect.Message {
1785 mi := &file_ermite_runner_proto_msgTypes[17]
1786 if x != nil {
1787 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1788 if ms.LoadMessageInfo() == nil {
1789 ms.StoreMessageInfo(mi)
1790 }
1791 return ms
1792 }
1793 return mi.MessageOf(x)
1794}
1795
1796// Deprecated: Use WatchJobResponse.ProtoReflect.Descriptor instead.
1797func (*WatchJobResponse) Descriptor() ([]byte, []int) {
1798 return file_ermite_runner_proto_rawDescGZIP(), []int{17}
1799}
1800
1801func (x *WatchJobResponse) GetMsg() isWatchJobResponse_Msg {
1802 if x != nil {
1803 return x.Msg
1804 }
1805 return nil
1806}
1807
1808func (x *WatchJobResponse) GetKeepalive() *Keepalive {
1809 if x != nil {
1810 if x, ok := x.Msg.(*WatchJobResponse_Keepalive); ok {
1811 return x.Keepalive
1812 }
1813 }
1814 return nil
1815}
1816
1817func (x *WatchJobResponse) GetCancel() *CancelRequest {
1818 if x != nil {
1819 if x, ok := x.Msg.(*WatchJobResponse_Cancel); ok {
1820 return x.Cancel
1821 }
1822 }
1823 return nil
1824}
1825
1826func (x *WatchJobResponse) GetEnded() *JobEnded {
1827 if x != nil {
1828 if x, ok := x.Msg.(*WatchJobResponse_Ended); ok {
1829 return x.Ended
1830 }
1831 }
1832 return nil
1833}
1834
1835type isWatchJobResponse_Msg interface {
1836 isWatchJobResponse_Msg()
1837}
1838
1839type WatchJobResponse_Keepalive struct {
1840 // Keepalive: nothing to do, the stream is alive.
1841 Keepalive *Keepalive `protobuf:"bytes,1,opt,name=keepalive,proto3,oneof"`
1842}
1843
1844type WatchJobResponse_Cancel struct {
1845 // Cancel: the job must stop.
1846 Cancel *CancelRequest `protobuf:"bytes,2,opt,name=cancel,proto3,oneof"`
1847}
1848
1849type WatchJobResponse_Ended struct {
1850 // Ended: the job has ended. The last message of a stream: a close without
1851 // it means the client reconnects.
1852 Ended *JobEnded `protobuf:"bytes,3,opt,name=ended,proto3,oneof"`
1853}
1854
1855func (*WatchJobResponse_Keepalive) isWatchJobResponse_Msg() {}
1856
1857func (*WatchJobResponse_Cancel) isWatchJobResponse_Msg() {}
1858
1859func (*WatchJobResponse_Ended) isWatchJobResponse_Msg() {}
1860
1861// Keepalive has no fields.
1862type Keepalive struct {
1863 state protoimpl.MessageState `protogen:"open.v1"`
1864 unknownFields protoimpl.UnknownFields
1865 sizeCache protoimpl.SizeCache
1866}
1867
1868func (x *Keepalive) Reset() {
1869 *x = Keepalive{}
1870 mi := &file_ermite_runner_proto_msgTypes[18]
1871 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1872 ms.StoreMessageInfo(mi)
1873}
1874
1875func (x *Keepalive) String() string {
1876 return protoimpl.X.MessageStringOf(x)
1877}
1878
1879func (*Keepalive) ProtoMessage() {}
1880
1881func (x *Keepalive) ProtoReflect() protoreflect.Message {
1882 mi := &file_ermite_runner_proto_msgTypes[18]
1883 if x != nil {
1884 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1885 if ms.LoadMessageInfo() == nil {
1886 ms.StoreMessageInfo(mi)
1887 }
1888 return ms
1889 }
1890 return mi.MessageOf(x)
1891}
1892
1893// Deprecated: Use Keepalive.ProtoReflect.Descriptor instead.
1894func (*Keepalive) Descriptor() ([]byte, []int) {
1895 return file_ermite_runner_proto_rawDescGZIP(), []int{18}
1896}
1897
1898// CancelRequest asks the runner to stop a job.
1899type CancelRequest struct {
1900 state protoimpl.MessageState `protogen:"open.v1"`
1901 // Reason is why the job must stop. New reasons may be added; a runner that
1902 // does not know one cancels the job and reports CI_CONCLUSION_CANCELLED.
1903 Reason CancelReason `protobuf:"varint,1,opt,name=reason,proto3,enum=ermite.CancelReason" json:"reason,omitempty"`
1904 // Message is a short human-readable explanation, for the job log, for
1905 // example "Canceled by the owner". At most 1,024 characters.
1906 Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
1907 // RequestedAt is when the cancellation was requested, by the clock of the
1908 // server.
1909 RequestedAt *timestamppb.Timestamp `protobuf:"bytes,3,opt,name=requested_at,json=requestedAt,proto3" json:"requested_at,omitempty"`
1910 unknownFields protoimpl.UnknownFields
1911 sizeCache protoimpl.SizeCache
1912}
1913
1914func (x *CancelRequest) Reset() {
1915 *x = CancelRequest{}
1916 mi := &file_ermite_runner_proto_msgTypes[19]
1917 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1918 ms.StoreMessageInfo(mi)
1919}
1920
1921func (x *CancelRequest) String() string {
1922 return protoimpl.X.MessageStringOf(x)
1923}
1924
1925func (*CancelRequest) ProtoMessage() {}
1926
1927func (x *CancelRequest) ProtoReflect() protoreflect.Message {
1928 mi := &file_ermite_runner_proto_msgTypes[19]
1929 if x != nil {
1930 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
1931 if ms.LoadMessageInfo() == nil {
1932 ms.StoreMessageInfo(mi)
1933 }
1934 return ms
1935 }
1936 return mi.MessageOf(x)
1937}
1938
1939// Deprecated: Use CancelRequest.ProtoReflect.Descriptor instead.
1940func (*CancelRequest) Descriptor() ([]byte, []int) {
1941 return file_ermite_runner_proto_rawDescGZIP(), []int{19}
1942}
1943
1944func (x *CancelRequest) GetReason() CancelReason {
1945 if x != nil {
1946 return x.Reason
1947 }
1948 return CancelReason_CANCEL_REASON_UNSPECIFIED
1949}
1950
1951func (x *CancelRequest) GetMessage() string {
1952 if x != nil {
1953 return x.Message
1954 }
1955 return ""
1956}
1957
1958func (x *CancelRequest) GetRequestedAt() *timestamppb.Timestamp {
1959 if x != nil {
1960 return x.RequestedAt
1961 }
1962 return nil
1963}
1964
1965// Annotation is a message attached to a step, and optionally to a place in a
1966// file of the repository, like an annotation of a GitHub check run. The runner
1967// produces them from the workflow commands ::notice, ::warning and ::error and
1968// from problem matchers, after masking.
1969//
1970// Limits, checked by the server: at most 10 annotations of each level per step
1971// (the runner sends no more: the ones beyond only reach the log, as with
1972// GitHub). A call that breaks a limit below is rejected whole with
1973// invalid_argument. Lengths count characters (Unicode code points), not bytes.
1974type Annotation struct {
1975 state protoimpl.MessageState `protogen:"open.v1"`
1976 // Level is the severity. Required.
1977 Level AnnotationLevel `protobuf:"varint,1,opt,name=level,proto3,enum=ermite.AnnotationLevel" json:"level,omitempty"`
1978 // Title is the optional title, at most 255 characters. Empty when not given.
1979 Title string `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
1980 // Message is the text. Required, not empty, at most 4,096 characters; a
1981 // longer one is invalid_argument. The runner never sends a longer one: like
1982 // GitHub, it only logs such an annotation.
1983 Message string `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
1984 // File is the path the annotation is about, relative to the repository when
1985 // the runner can tell, else as given. At most 1,024 characters. Empty when
1986 // the annotation is not about a file.
1987 File string `protobuf:"bytes,4,opt,name=file,proto3" json:"file,omitempty"`
1988 // StartLine is the first line, counted from 1. 0 when not given.
1989 StartLine int32 `protobuf:"varint,5,opt,name=start_line,json=startLine,proto3" json:"start_line,omitempty"`
1990 // EndLine is the last line, counted from 1, not before start_line. 0 when
1991 // not given.
1992 EndLine int32 `protobuf:"varint,6,opt,name=end_line,json=endLine,proto3" json:"end_line,omitempty"`
1993 // StartColumn is the first column, counted from 1. 0 when not given.
1994 StartColumn int32 `protobuf:"varint,7,opt,name=start_column,json=startColumn,proto3" json:"start_column,omitempty"`
1995 // EndColumn is the last column, counted from 1. 0 when not given.
1996 EndColumn int32 `protobuf:"varint,8,opt,name=end_column,json=endColumn,proto3" json:"end_column,omitempty"`
1997 // StepNumber is the number of the step that produced it (see
1998 // StepUpdate.number), from 1 to 1,000. An annotation of a step inside a
1999 // composite action belongs to the step of the workflow that uses the action.
2000 StepNumber int32 `protobuf:"varint,9,opt,name=step_number,json=stepNumber,proto3" json:"step_number,omitempty"`
2001 unknownFields protoimpl.UnknownFields
2002 sizeCache protoimpl.SizeCache
2003}
2004
2005func (x *Annotation) Reset() {
2006 *x = Annotation{}
2007 mi := &file_ermite_runner_proto_msgTypes[20]
2008 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2009 ms.StoreMessageInfo(mi)
2010}
2011
2012func (x *Annotation) String() string {
2013 return protoimpl.X.MessageStringOf(x)
2014}
2015
2016func (*Annotation) ProtoMessage() {}
2017
2018func (x *Annotation) ProtoReflect() protoreflect.Message {
2019 mi := &file_ermite_runner_proto_msgTypes[20]
2020 if x != nil {
2021 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2022 if ms.LoadMessageInfo() == nil {
2023 ms.StoreMessageInfo(mi)
2024 }
2025 return ms
2026 }
2027 return mi.MessageOf(x)
2028}
2029
2030// Deprecated: Use Annotation.ProtoReflect.Descriptor instead.
2031func (*Annotation) Descriptor() ([]byte, []int) {
2032 return file_ermite_runner_proto_rawDescGZIP(), []int{20}
2033}
2034
2035func (x *Annotation) GetLevel() AnnotationLevel {
2036 if x != nil {
2037 return x.Level
2038 }
2039 return AnnotationLevel_ANNOTATION_LEVEL_UNSPECIFIED
2040}
2041
2042func (x *Annotation) GetTitle() string {
2043 if x != nil {
2044 return x.Title
2045 }
2046 return ""
2047}
2048
2049func (x *Annotation) GetMessage() string {
2050 if x != nil {
2051 return x.Message
2052 }
2053 return ""
2054}
2055
2056func (x *Annotation) GetFile() string {
2057 if x != nil {
2058 return x.File
2059 }
2060 return ""
2061}
2062
2063func (x *Annotation) GetStartLine() int32 {
2064 if x != nil {
2065 return x.StartLine
2066 }
2067 return 0
2068}
2069
2070func (x *Annotation) GetEndLine() int32 {
2071 if x != nil {
2072 return x.EndLine
2073 }
2074 return 0
2075}
2076
2077func (x *Annotation) GetStartColumn() int32 {
2078 if x != nil {
2079 return x.StartColumn
2080 }
2081 return 0
2082}
2083
2084func (x *Annotation) GetEndColumn() int32 {
2085 if x != nil {
2086 return x.EndColumn
2087 }
2088 return 0
2089}
2090
2091func (x *Annotation) GetStepNumber() int32 {
2092 if x != nil {
2093 return x.StepNumber
2094 }
2095 return 0
2096}
2097
2098// ActionRef is an action to resolve.
2099type ActionRef struct {
2100 state protoimpl.MessageState `protogen:"open.v1"`
2101 // Uses is the value of "uses" as written, after expression evaluation, for
2102 // example "actions/checkout@v4" or "owner/repo/path/to/action@ref". Required.
2103 Uses string `protobuf:"bytes,1,opt,name=uses,proto3" json:"uses,omitempty"`
2104 unknownFields protoimpl.UnknownFields
2105 sizeCache protoimpl.SizeCache
2106}
2107
2108func (x *ActionRef) Reset() {
2109 *x = ActionRef{}
2110 mi := &file_ermite_runner_proto_msgTypes[21]
2111 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2112 ms.StoreMessageInfo(mi)
2113}
2114
2115func (x *ActionRef) String() string {
2116 return protoimpl.X.MessageStringOf(x)
2117}
2118
2119func (*ActionRef) ProtoMessage() {}
2120
2121func (x *ActionRef) ProtoReflect() protoreflect.Message {
2122 mi := &file_ermite_runner_proto_msgTypes[21]
2123 if x != nil {
2124 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2125 if ms.LoadMessageInfo() == nil {
2126 ms.StoreMessageInfo(mi)
2127 }
2128 return ms
2129 }
2130 return mi.MessageOf(x)
2131}
2132
2133// Deprecated: Use ActionRef.ProtoReflect.Descriptor instead.
2134func (*ActionRef) Descriptor() ([]byte, []int) {
2135 return file_ermite_runner_proto_rawDescGZIP(), []int{21}
2136}
2137
2138func (x *ActionRef) GetUses() string {
2139 if x != nil {
2140 return x.Uses
2141 }
2142 return ""
2143}
2144
2145// ResolveActionsRequest lists the actions to resolve.
2146type ResolveActionsRequest struct {
2147 state protoimpl.MessageState `protogen:"open.v1"`
2148 // JobId is the Job.job_id. It must be the job of the token.
2149 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
2150 // Refs are the actions to resolve, at most 100. Duplicates are allowed and
2151 // answered one by one.
2152 Refs []*ActionRef `protobuf:"bytes,2,rep,name=refs,proto3" json:"refs,omitempty"`
2153 unknownFields protoimpl.UnknownFields
2154 sizeCache protoimpl.SizeCache
2155}
2156
2157func (x *ResolveActionsRequest) Reset() {
2158 *x = ResolveActionsRequest{}
2159 mi := &file_ermite_runner_proto_msgTypes[22]
2160 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2161 ms.StoreMessageInfo(mi)
2162}
2163
2164func (x *ResolveActionsRequest) String() string {
2165 return protoimpl.X.MessageStringOf(x)
2166}
2167
2168func (*ResolveActionsRequest) ProtoMessage() {}
2169
2170func (x *ResolveActionsRequest) ProtoReflect() protoreflect.Message {
2171 mi := &file_ermite_runner_proto_msgTypes[22]
2172 if x != nil {
2173 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2174 if ms.LoadMessageInfo() == nil {
2175 ms.StoreMessageInfo(mi)
2176 }
2177 return ms
2178 }
2179 return mi.MessageOf(x)
2180}
2181
2182// Deprecated: Use ResolveActionsRequest.ProtoReflect.Descriptor instead.
2183func (*ResolveActionsRequest) Descriptor() ([]byte, []int) {
2184 return file_ermite_runner_proto_rawDescGZIP(), []int{22}
2185}
2186
2187func (x *ResolveActionsRequest) GetJobId() string {
2188 if x != nil {
2189 return x.JobId
2190 }
2191 return ""
2192}
2193
2194func (x *ResolveActionsRequest) GetRefs() []*ActionRef {
2195 if x != nil {
2196 return x.Refs
2197 }
2198 return nil
2199}
2200
2201// ResolveActionsResponse holds the resolution of each action.
2202type ResolveActionsResponse struct {
2203 state protoimpl.MessageState `protogen:"open.v1"`
2204 // Actions has one entry per ActionRef of the request, in the same order.
2205 Actions []*ResolvedAction `protobuf:"bytes,1,rep,name=actions,proto3" json:"actions,omitempty"`
2206 unknownFields protoimpl.UnknownFields
2207 sizeCache protoimpl.SizeCache
2208}
2209
2210func (x *ResolveActionsResponse) Reset() {
2211 *x = ResolveActionsResponse{}
2212 mi := &file_ermite_runner_proto_msgTypes[23]
2213 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2214 ms.StoreMessageInfo(mi)
2215}
2216
2217func (x *ResolveActionsResponse) String() string {
2218 return protoimpl.X.MessageStringOf(x)
2219}
2220
2221func (*ResolveActionsResponse) ProtoMessage() {}
2222
2223func (x *ResolveActionsResponse) ProtoReflect() protoreflect.Message {
2224 mi := &file_ermite_runner_proto_msgTypes[23]
2225 if x != nil {
2226 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2227 if ms.LoadMessageInfo() == nil {
2228 ms.StoreMessageInfo(mi)
2229 }
2230 return ms
2231 }
2232 return mi.MessageOf(x)
2233}
2234
2235// Deprecated: Use ResolveActionsResponse.ProtoReflect.Descriptor instead.
2236func (*ResolveActionsResponse) Descriptor() ([]byte, []int) {
2237 return file_ermite_runner_proto_rawDescGZIP(), []int{23}
2238}
2239
2240func (x *ResolveActionsResponse) GetActions() []*ResolvedAction {
2241 if x != nil {
2242 return x.Actions
2243 }
2244 return nil
2245}
2246
2247// ResolvedAction is where to download one action, or why it cannot be.
2248type ResolvedAction struct {
2249 state protoimpl.MessageState `protogen:"open.v1"`
2250 // Ref is the ActionRef.uses of the request, unchanged.
2251 Ref string `protobuf:"bytes,1,opt,name=ref,proto3" json:"ref,omitempty"`
2252 // NameWithOwner is the repository of the action, "owner/repo", with the
2253 // case of the repository as the source gives it. Empty when error is set.
2254 NameWithOwner string `protobuf:"bytes,2,opt,name=name_with_owner,json=nameWithOwner,proto3" json:"name_with_owner,omitempty"`
2255 // Path is the sub-path of the action inside the repository, a clean
2256 // relative path: "path/to/action" for "owner/repo/path/to/action@ref", with
2257 // "/" separators, no leading or trailing slash, no empty, "." or ".."
2258 // element, never absolute. Empty for an action at the root of the
2259 // repository.
2260 Path string `protobuf:"bytes,3,opt,name=path,proto3" json:"path,omitempty"`
2261 // ResolvedSha is the full id of the commit the ref points to, 40 lowercase
2262 // hexadecimal characters for SHA-1 (the commit that an annotated tag points
2263 // to, not the tag object). Stable for a run attempt: every job and every
2264 // call of the attempt gets the same value for the same ref. Empty when error
2265 // is set.
2266 ResolvedSha string `protobuf:"bytes,4,opt,name=resolved_sha,json=resolvedSha,proto3" json:"resolved_sha,omitempty"`
2267 // TarballUrl is where to download the archive of the repository at
2268 // resolved_sha, a gzip-compressed tar with one top-level directory. The
2269 // runner downloads it from the sandbox. Empty when error is set.
2270 TarballUrl string `protobuf:"bytes,5,opt,name=tarball_url,json=tarballUrl,proto3" json:"tarball_url,omitempty"`
2271 // Token authenticates the download: the runner sends it as "Authorization:
2272 // Basic" with the user "x-access-token". Empty for ACTION_SOURCE_GITHUB.
2273 // For ACTION_SOURCE_ERMITE it is a read token for that one repository,
2274 // valid until the job ends, so a job can use an action of another private
2275 // repository of the server that its own repository token cannot read. It is
2276 // issued per job and never shared across jobs (two jobs resolving the same
2277 // action get different tokens). It is a secret: the runner masks it, and neither the runner nor the server logs
2278 // it.
2279 Token string `protobuf:"bytes,6,opt,name=token,proto3" json:"token,omitempty"`
2280 // Source is where the action was found. UNSPECIFIED when error is set.
2281 Source ActionSource `protobuf:"varint,7,opt,name=source,proto3,enum=ermite.ActionSource" json:"source,omitempty"`
2282 // Error is why the reference could not be resolved, in the words of GitHub
2283 // for the same failure. Empty when the action was resolved, in which case
2284 // the other fields describe it.
2285 Error string `protobuf:"bytes,8,opt,name=error,proto3" json:"error,omitempty"`
2286 unknownFields protoimpl.UnknownFields
2287 sizeCache protoimpl.SizeCache
2288}
2289
2290func (x *ResolvedAction) Reset() {
2291 *x = ResolvedAction{}
2292 mi := &file_ermite_runner_proto_msgTypes[24]
2293 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2294 ms.StoreMessageInfo(mi)
2295}
2296
2297func (x *ResolvedAction) String() string {
2298 return protoimpl.X.MessageStringOf(x)
2299}
2300
2301func (*ResolvedAction) ProtoMessage() {}
2302
2303func (x *ResolvedAction) ProtoReflect() protoreflect.Message {
2304 mi := &file_ermite_runner_proto_msgTypes[24]
2305 if x != nil {
2306 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2307 if ms.LoadMessageInfo() == nil {
2308 ms.StoreMessageInfo(mi)
2309 }
2310 return ms
2311 }
2312 return mi.MessageOf(x)
2313}
2314
2315// Deprecated: Use ResolvedAction.ProtoReflect.Descriptor instead.
2316func (*ResolvedAction) Descriptor() ([]byte, []int) {
2317 return file_ermite_runner_proto_rawDescGZIP(), []int{24}
2318}
2319
2320func (x *ResolvedAction) GetRef() string {
2321 if x != nil {
2322 return x.Ref
2323 }
2324 return ""
2325}
2326
2327func (x *ResolvedAction) GetNameWithOwner() string {
2328 if x != nil {
2329 return x.NameWithOwner
2330 }
2331 return ""
2332}
2333
2334func (x *ResolvedAction) GetPath() string {
2335 if x != nil {
2336 return x.Path
2337 }
2338 return ""
2339}
2340
2341func (x *ResolvedAction) GetResolvedSha() string {
2342 if x != nil {
2343 return x.ResolvedSha
2344 }
2345 return ""
2346}
2347
2348func (x *ResolvedAction) GetTarballUrl() string {
2349 if x != nil {
2350 return x.TarballUrl
2351 }
2352 return ""
2353}
2354
2355func (x *ResolvedAction) GetToken() string {
2356 if x != nil {
2357 return x.Token
2358 }
2359 return ""
2360}
2361
2362func (x *ResolvedAction) GetSource() ActionSource {
2363 if x != nil {
2364 return x.Source
2365 }
2366 return ActionSource_ACTION_SOURCE_UNSPECIFIED
2367}
2368
2369func (x *ResolvedAction) GetError() string {
2370 if x != nil {
2371 return x.Error
2372 }
2373 return ""
2374}
2375
2376// UploadSummaryRequest carries the job summary of one step.
2377type UploadSummaryRequest struct {
2378 state protoimpl.MessageState `protogen:"open.v1"`
2379 // JobId is the Job.job_id. It must be the job of the token.
2380 JobId string `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"job_id,omitempty"`
2381 // StepNumber is the number of the step that wrote the summary (see
2382 // StepUpdate.number), from 1 to 1,000.
2383 StepNumber int32 `protobuf:"varint,2,opt,name=step_number,json=stepNumber,proto3" json:"step_number,omitempty"`
2384 // Markdown is the summary, masked, valid UTF-8, at most 1 MiB (1,048,576
2385 // bytes). Empty removes the summary of the step.
2386 Markdown string `protobuf:"bytes,3,opt,name=markdown,proto3" json:"markdown,omitempty"`
2387 unknownFields protoimpl.UnknownFields
2388 sizeCache protoimpl.SizeCache
2389}
2390
2391func (x *UploadSummaryRequest) Reset() {
2392 *x = UploadSummaryRequest{}
2393 mi := &file_ermite_runner_proto_msgTypes[25]
2394 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2395 ms.StoreMessageInfo(mi)
2396}
2397
2398func (x *UploadSummaryRequest) String() string {
2399 return protoimpl.X.MessageStringOf(x)
2400}
2401
2402func (*UploadSummaryRequest) ProtoMessage() {}
2403
2404func (x *UploadSummaryRequest) ProtoReflect() protoreflect.Message {
2405 mi := &file_ermite_runner_proto_msgTypes[25]
2406 if x != nil {
2407 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2408 if ms.LoadMessageInfo() == nil {
2409 ms.StoreMessageInfo(mi)
2410 }
2411 return ms
2412 }
2413 return mi.MessageOf(x)
2414}
2415
2416// Deprecated: Use UploadSummaryRequest.ProtoReflect.Descriptor instead.
2417func (*UploadSummaryRequest) Descriptor() ([]byte, []int) {
2418 return file_ermite_runner_proto_rawDescGZIP(), []int{25}
2419}
2420
2421func (x *UploadSummaryRequest) GetJobId() string {
2422 if x != nil {
2423 return x.JobId
2424 }
2425 return ""
2426}
2427
2428func (x *UploadSummaryRequest) GetStepNumber() int32 {
2429 if x != nil {
2430 return x.StepNumber
2431 }
2432 return 0
2433}
2434
2435func (x *UploadSummaryRequest) GetMarkdown() string {
2436 if x != nil {
2437 return x.Markdown
2438 }
2439 return ""
2440}
2441
2442// UploadSummaryResponse is empty.
2443type UploadSummaryResponse struct {
2444 state protoimpl.MessageState `protogen:"open.v1"`
2445 unknownFields protoimpl.UnknownFields
2446 sizeCache protoimpl.SizeCache
2447}
2448
2449func (x *UploadSummaryResponse) Reset() {
2450 *x = UploadSummaryResponse{}
2451 mi := &file_ermite_runner_proto_msgTypes[26]
2452 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2453 ms.StoreMessageInfo(mi)
2454}
2455
2456func (x *UploadSummaryResponse) String() string {
2457 return protoimpl.X.MessageStringOf(x)
2458}
2459
2460func (*UploadSummaryResponse) ProtoMessage() {}
2461
2462func (x *UploadSummaryResponse) ProtoReflect() protoreflect.Message {
2463 mi := &file_ermite_runner_proto_msgTypes[26]
2464 if x != nil {
2465 ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
2466 if ms.LoadMessageInfo() == nil {
2467 ms.StoreMessageInfo(mi)
2468 }
2469 return ms
2470 }
2471 return mi.MessageOf(x)
2472}
2473
2474// Deprecated: Use UploadSummaryResponse.ProtoReflect.Descriptor instead.
2475func (*UploadSummaryResponse) Descriptor() ([]byte, []int) {
2476 return file_ermite_runner_proto_rawDescGZIP(), []int{26}
2477}
2478
2479var File_ermite_runner_proto protoreflect.FileDescriptor
2480
2481const file_ermite_runner_proto_rawDesc = "" +
2482 "\n" +
2483 "\x13ermite/runner.proto\x12\x06ermite\x1a\x1egoogle/protobuf/duration.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xd2\x01\n" +
2484 "\x15RegisterRunnerRequest\x12\x12\n" +
2485 "\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" +
2486 "\x06labels\x18\x02 \x03(\tR\x06labels\x12\x18\n" +
2487 "\aversion\x18\x03 \x01(\tR\aversion\x125\n" +
2488 "\tisolation\x18\x04 \x01(\x0e2\x17.ermite.RunnerIsolationR\tisolation\x12\x12\n" +
2489 "\x04arch\x18\x05 \x01(\tR\x04arch\x12\x0e\n" +
2490 "\x02os\x18\x06 \x01(\tR\x02os\x12\x18\n" +
2491 "\areplace\x18\a \x01(\bR\areplace\"X\n" +
2492 "\x16RegisterRunnerResponse\x12\x1b\n" +
2493 "\trunner_id\x18\x01 \x01(\tR\brunnerId\x12!\n" +
2494 "\frunner_token\x18\x02 \x01(\tR\vrunnerToken\"B\n" +
2495 "\x0fFetchJobRequest\x12\x16\n" +
2496 "\x06labels\x18\x01 \x03(\tR\x06labels\x12\x17\n" +
2497 "\apoll_id\x18\x02 \x01(\tR\x06pollId\"m\n" +
2498 "\x10FetchJobResponse\x12\x1d\n" +
2499 "\x03job\x18\x01 \x01(\v2\v.ermite.JobR\x03job\x12:\n" +
2500 "\vretry_after\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\n" +
2501 "retryAfter\"\x9d\x03\n" +
2502 "\x03Job\x12\x15\n" +
2503 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x15\n" +
2504 "\x06run_id\x18\x02 \x01(\x03R\x05runId\x12\x18\n" +
2505 "\aattempt\x18\x03 \x01(\x05R\aattempt\x12\x1b\n" +
2506 "\tjob_token\x18\x04 \x01(\tR\bjobToken\x12#\n" +
2507 "\rworkflow_path\x18\x05 \x01(\tR\fworkflowPath\x12#\n" +
2508 "\rworkflow_yaml\x18\x06 \x01(\tR\fworkflowYaml\x12\x17\n" +
2509 "\ajob_key\x18\a \x01(\tR\x06jobKey\x12\x16\n" +
2510 "\x06matrix\x18\b \x01(\tR\x06matrix\x12\x1a\n" +
2511 "\bcontexts\x18\t \x01(\tR\bcontexts\x12\x16\n" +
2512 "\x06labels\x18\n" +
2513 " \x03(\tR\x06labels\x12'\n" +
2514 "\x0ftimeout_minutes\x18\v \x01(\x05R\x0etimeoutMinutes\x12\x12\n" +
2515 "\x04repo\x18\f \x01(\tR\x04repo\x12\x10\n" +
2516 "\x03sha\x18\r \x01(\tR\x03sha\x12\x10\n" +
2517 "\x03ref\x18\x0e \x01(\tR\x03ref\x12!\n" +
2518 "\fgithub_token\x18\x0f \x01(\tR\vgithubToken\"\x89\x01\n" +
2519 "\x10UpdateJobRequest\x12\x15\n" +
2520 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12(\n" +
2521 "\x05steps\x18\x02 \x03(\v2\x12.ermite.StepUpdateR\x05steps\x124\n" +
2522 "\vannotations\x18\x03 \x03(\v2\x12.ermite.AnnotationR\vannotations\"\xc1\x02\n" +
2523 "\n" +
2524 "StepUpdate\x12\x16\n" +
2525 "\x06number\x18\x01 \x01(\x05R\x06number\x12\x12\n" +
2526 "\x04name\x18\x02 \x01(\tR\x04name\x12'\n" +
2527 "\x05state\x18\x03 \x01(\x0e2\x11.ermite.StepStateR\x05state\x124\n" +
2528 "\n" +
2529 "conclusion\x18\x04 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
2530 "conclusion\x129\n" +
2531 "\n" +
2532 "started_at\x18\x05 \x01(\v2\x1a.google.protobuf.TimestampR\tstartedAt\x12=\n" +
2533 "\fcompleted_at\x18\x06 \x01(\v2\x1a.google.protobuf.TimestampR\vcompletedAt\x12.\n" +
2534 "\aoutcome\x18\a \x01(\x0e2\x14.ermite.CiConclusionR\aoutcome\"\x13\n" +
2535 "\x11UpdateJobResponse\"\xe9\x02\n" +
2536 "\x12CompleteJobRequest\x12\x15\n" +
2537 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x124\n" +
2538 "\n" +
2539 "conclusion\x18\x02 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
2540 "conclusion\x12A\n" +
2541 "\aoutputs\x18\x03 \x03(\v2'.ermite.CompleteJobRequest.OutputsEntryR\aoutputs\x12'\n" +
2542 "\x0frunner_shutdown\x18\x04 \x01(\bR\x0erunnerShutdown\x12(\n" +
2543 "\x05steps\x18\x05 \x03(\v2\x12.ermite.StepUpdateR\x05steps\x124\n" +
2544 "\vannotations\x18\x06 \x03(\v2\x12.ermite.AnnotationR\vannotations\x1a:\n" +
2545 "\fOutputsEntry\x12\x10\n" +
2546 "\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
2547 "\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"{\n" +
2548 "\x13CompleteJobResponse\x124\n" +
2549 "\n" +
2550 "conclusion\x18\x01 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
2551 "conclusion\x12\x14\n" +
2552 "\x05error\x18\x02 \x01(\tR\x05error\x12\x18\n" +
2553 "\aapplied\x18\x03 \x01(\bR\aapplied\"V\n" +
2554 "\bJobEnded\x124\n" +
2555 "\n" +
2556 "conclusion\x18\x01 \x01(\x0e2\x14.ermite.CiConclusionR\n" +
2557 "conclusion\x12\x14\n" +
2558 "\x05error\x18\x02 \x01(\tR\x05error\"|\n" +
2559 "\x10AppendLogRequest\x12\x15\n" +
2560 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x12\n" +
2561 "\x04step\x18\x02 \x01(\x05R\x04step\x12\x16\n" +
2562 "\x06offset\x18\x03 \x01(\x03R\x06offset\x12%\n" +
2563 "\x05lines\x18\x04 \x03(\v2\x0f.ermite.LogLineR\x05lines\"k\n" +
2564 "\aLogLine\x12.\n" +
2565 "\x04time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x04time\x12\x12\n" +
2566 "\x04text\x18\x02 \x01(\tR\x04text\x12\x1c\n" +
2567 "\tcontinued\x18\x03 \x01(\bR\tcontinued\"4\n" +
2568 "\x11AppendLogResponse\x12\x1f\n" +
2569 "\vnext_offset\x18\x01 \x01(\x03R\n" +
2570 "nextOffset\")\n" +
2571 "\x10HeartbeatRequest\x12\x15\n" +
2572 "\x06job_id\x18\x01 \x01(\tR\x05jobId\"\x13\n" +
2573 "\x11HeartbeatResponse\"(\n" +
2574 "\x0fWatchJobRequest\x12\x15\n" +
2575 "\x06job_id\x18\x01 \x01(\tR\x05jobId\"\xa7\x01\n" +
2576 "\x10WatchJobResponse\x121\n" +
2577 "\tkeepalive\x18\x01 \x01(\v2\x11.ermite.KeepaliveH\x00R\tkeepalive\x12/\n" +
2578 "\x06cancel\x18\x02 \x01(\v2\x15.ermite.CancelRequestH\x00R\x06cancel\x12(\n" +
2579 "\x05ended\x18\x03 \x01(\v2\x10.ermite.JobEndedH\x00R\x05endedB\x05\n" +
2580 "\x03msg\"\v\n" +
2581 "\tKeepalive\"\x96\x01\n" +
2582 "\rCancelRequest\x12,\n" +
2583 "\x06reason\x18\x01 \x01(\x0e2\x14.ermite.CancelReasonR\x06reason\x12\x18\n" +
2584 "\amessage\x18\x02 \x01(\tR\amessage\x12=\n" +
2585 "\frequested_at\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\vrequestedAt\"\x9c\x02\n" +
2586 "\n" +
2587 "Annotation\x12-\n" +
2588 "\x05level\x18\x01 \x01(\x0e2\x17.ermite.AnnotationLevelR\x05level\x12\x14\n" +
2589 "\x05title\x18\x02 \x01(\tR\x05title\x12\x18\n" +
2590 "\amessage\x18\x03 \x01(\tR\amessage\x12\x12\n" +
2591 "\x04file\x18\x04 \x01(\tR\x04file\x12\x1d\n" +
2592 "\n" +
2593 "start_line\x18\x05 \x01(\x05R\tstartLine\x12\x19\n" +
2594 "\bend_line\x18\x06 \x01(\x05R\aendLine\x12!\n" +
2595 "\fstart_column\x18\a \x01(\x05R\vstartColumn\x12\x1d\n" +
2596 "\n" +
2597 "end_column\x18\b \x01(\x05R\tendColumn\x12\x1f\n" +
2598 "\vstep_number\x18\t \x01(\x05R\n" +
2599 "stepNumber\"\x1f\n" +
2600 "\tActionRef\x12\x12\n" +
2601 "\x04uses\x18\x01 \x01(\tR\x04uses\"U\n" +
2602 "\x15ResolveActionsRequest\x12\x15\n" +
2603 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12%\n" +
2604 "\x04refs\x18\x02 \x03(\v2\x11.ermite.ActionRefR\x04refs\"J\n" +
2605 "\x16ResolveActionsResponse\x120\n" +
2606 "\aactions\x18\x01 \x03(\v2\x16.ermite.ResolvedActionR\aactions\"\xfc\x01\n" +
2607 "\x0eResolvedAction\x12\x10\n" +
2608 "\x03ref\x18\x01 \x01(\tR\x03ref\x12&\n" +
2609 "\x0fname_with_owner\x18\x02 \x01(\tR\rnameWithOwner\x12\x12\n" +
2610 "\x04path\x18\x03 \x01(\tR\x04path\x12!\n" +
2611 "\fresolved_sha\x18\x04 \x01(\tR\vresolvedSha\x12\x1f\n" +
2612 "\vtarball_url\x18\x05 \x01(\tR\n" +
2613 "tarballUrl\x12\x14\n" +
2614 "\x05token\x18\x06 \x01(\tR\x05token\x12,\n" +
2615 "\x06source\x18\a \x01(\x0e2\x14.ermite.ActionSourceR\x06source\x12\x14\n" +
2616 "\x05error\x18\b \x01(\tR\x05error\"j\n" +
2617 "\x14UploadSummaryRequest\x12\x15\n" +
2618 "\x06job_id\x18\x01 \x01(\tR\x05jobId\x12\x1f\n" +
2619 "\vstep_number\x18\x02 \x01(\x05R\n" +
2620 "stepNumber\x12\x1a\n" +
2621 "\bmarkdown\x18\x03 \x01(\tR\bmarkdown\"\x17\n" +
2622 "\x15UploadSummaryResponse*o\n" +
2623 "\bCiStatus\x12\x19\n" +
2624 "\x15CI_STATUS_UNSPECIFIED\x10\x00\x12\x14\n" +
2625 "\x10CI_STATUS_QUEUED\x10\x01\x12\x19\n" +
2626 "\x15CI_STATUS_IN_PROGRESS\x10\x02\x12\x17\n" +
2627 "\x13CI_STATUS_COMPLETED\x10\x03*\xf6\x01\n" +
2628 "\fCiConclusion\x12\x1d\n" +
2629 "\x19CI_CONCLUSION_UNSPECIFIED\x10\x00\x12\x19\n" +
2630 "\x15CI_CONCLUSION_SUCCESS\x10\x01\x12\x19\n" +
2631 "\x15CI_CONCLUSION_FAILURE\x10\x02\x12\x1b\n" +
2632 "\x17CI_CONCLUSION_CANCELLED\x10\x03\x12\x19\n" +
2633 "\x15CI_CONCLUSION_SKIPPED\x10\x04\x12\x1b\n" +
2634 "\x17CI_CONCLUSION_TIMED_OUT\x10\x05\x12\x19\n" +
2635 "\x15CI_CONCLUSION_NEUTRAL\x10\x06\x12!\n" +
2636 "\x1dCI_CONCLUSION_ACTION_REQUIRED\x10\a*u\n" +
2637 "\tStepState\x12\x1a\n" +
2638 "\x16STEP_STATE_UNSPECIFIED\x10\x00\x12\x16\n" +
2639 "\x12STEP_STATE_PENDING\x10\x01\x12\x1a\n" +
2640 "\x16STEP_STATE_IN_PROGRESS\x10\x02\x12\x18\n" +
2641 "\x14STEP_STATE_COMPLETED\x10\x03*\x9e\x01\n" +
2642 "\x0fRunnerIsolation\x12 \n" +
2643 "\x1cRUNNER_ISOLATION_UNSPECIFIED\x10\x00\x12\x17\n" +
2644 "\x13RUNNER_ISOLATION_VM\x10\x01\x12%\n" +
2645 "!RUNNER_ISOLATION_CONTAINER_SYSBOX\x10\x02\x12)\n" +
2646 "%RUNNER_ISOLATION_CONTAINER_PRIVILEGED\x10\x03*}\n" +
2647 "\fCancelReason\x12\x1d\n" +
2648 "\x19CANCEL_REASON_UNSPECIFIED\x10\x00\x12\x16\n" +
2649 "\x12CANCEL_REASON_USER\x10\x01\x12\x1b\n" +
2650 "\x17CANCEL_REASON_FAIL_FAST\x10\x02\x12\x19\n" +
2651 "\x15CANCEL_REASON_TIMEOUT\x10\x03*\x8c\x01\n" +
2652 "\x0fAnnotationLevel\x12 \n" +
2653 "\x1cANNOTATION_LEVEL_UNSPECIFIED\x10\x00\x12\x1b\n" +
2654 "\x17ANNOTATION_LEVEL_NOTICE\x10\x01\x12\x1c\n" +
2655 "\x18ANNOTATION_LEVEL_WARNING\x10\x02\x12\x1c\n" +
2656 "\x18ANNOTATION_LEVEL_FAILURE\x10\x03*a\n" +
2657 "\fActionSource\x12\x1d\n" +
2658 "\x19ACTION_SOURCE_UNSPECIFIED\x10\x00\x12\x18\n" +
2659 "\x14ACTION_SOURCE_GITHUB\x10\x01\x12\x18\n" +
2660 "\x14ACTION_SOURCE_ERMITE\x10\x022\x8d\x05\n" +
2661 "\rRunnerService\x12O\n" +
2662 "\x0eRegisterRunner\x12\x1d.ermite.RegisterRunnerRequest\x1a\x1e.ermite.RegisterRunnerResponse\x12=\n" +
2663 "\bFetchJob\x12\x17.ermite.FetchJobRequest\x1a\x18.ermite.FetchJobResponse\x12@\n" +
2664 "\tUpdateJob\x12\x18.ermite.UpdateJobRequest\x1a\x19.ermite.UpdateJobResponse\x12@\n" +
2665 "\tAppendLog\x12\x18.ermite.AppendLogRequest\x1a\x19.ermite.AppendLogResponse\x12@\n" +
2666 "\tHeartbeat\x12\x18.ermite.HeartbeatRequest\x1a\x19.ermite.HeartbeatResponse\x12?\n" +
2667 "\bWatchJob\x12\x17.ermite.WatchJobRequest\x1a\x18.ermite.WatchJobResponse0\x01\x12F\n" +
2668 "\vCompleteJob\x12\x1a.ermite.CompleteJobRequest\x1a\x1b.ermite.CompleteJobResponse\x12O\n" +
2669 "\x0eResolveActions\x12\x1d.ermite.ResolveActionsRequest\x1a\x1e.ermite.ResolveActionsResponse\x12L\n" +
2670 "\rUploadSummary\x12\x1c.ermite.UploadSummaryRequest\x1a\x1d.ermite.UploadSummaryResponseBr\n" +
2671 "\n" +
2672 "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"
2673
2674var (
2675 file_ermite_runner_proto_rawDescOnce sync.Once
2676 file_ermite_runner_proto_rawDescData []byte
2677)
2678
2679func file_ermite_runner_proto_rawDescGZIP() []byte {
2680 file_ermite_runner_proto_rawDescOnce.Do(func() {
2681 file_ermite_runner_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_ermite_runner_proto_rawDesc), len(file_ermite_runner_proto_rawDesc)))
2682 })
2683 return file_ermite_runner_proto_rawDescData
2684}
2685
2686var file_ermite_runner_proto_enumTypes = make([]protoimpl.EnumInfo, 7)
2687var file_ermite_runner_proto_msgTypes = make([]protoimpl.MessageInfo, 28)
2688var file_ermite_runner_proto_goTypes = []any{
2689 (CiStatus)(0), // 0: ermite.CiStatus
2690 (CiConclusion)(0), // 1: ermite.CiConclusion
2691 (StepState)(0), // 2: ermite.StepState
2692 (RunnerIsolation)(0), // 3: ermite.RunnerIsolation
2693 (CancelReason)(0), // 4: ermite.CancelReason
2694 (AnnotationLevel)(0), // 5: ermite.AnnotationLevel
2695 (ActionSource)(0), // 6: ermite.ActionSource
2696 (*RegisterRunnerRequest)(nil), // 7: ermite.RegisterRunnerRequest
2697 (*RegisterRunnerResponse)(nil), // 8: ermite.RegisterRunnerResponse
2698 (*FetchJobRequest)(nil), // 9: ermite.FetchJobRequest
2699 (*FetchJobResponse)(nil), // 10: ermite.FetchJobResponse
2700 (*Job)(nil), // 11: ermite.Job
2701 (*UpdateJobRequest)(nil), // 12: ermite.UpdateJobRequest
2702 (*StepUpdate)(nil), // 13: ermite.StepUpdate
2703 (*UpdateJobResponse)(nil), // 14: ermite.UpdateJobResponse
2704 (*CompleteJobRequest)(nil), // 15: ermite.CompleteJobRequest
2705 (*CompleteJobResponse)(nil), // 16: ermite.CompleteJobResponse
2706 (*JobEnded)(nil), // 17: ermite.JobEnded
2707 (*AppendLogRequest)(nil), // 18: ermite.AppendLogRequest
2708 (*LogLine)(nil), // 19: ermite.LogLine
2709 (*AppendLogResponse)(nil), // 20: ermite.AppendLogResponse
2710 (*HeartbeatRequest)(nil), // 21: ermite.HeartbeatRequest
2711 (*HeartbeatResponse)(nil), // 22: ermite.HeartbeatResponse
2712 (*WatchJobRequest)(nil), // 23: ermite.WatchJobRequest
2713 (*WatchJobResponse)(nil), // 24: ermite.WatchJobResponse
2714 (*Keepalive)(nil), // 25: ermite.Keepalive
2715 (*CancelRequest)(nil), // 26: ermite.CancelRequest
2716 (*Annotation)(nil), // 27: ermite.Annotation
2717 (*ActionRef)(nil), // 28: ermite.ActionRef
2718 (*ResolveActionsRequest)(nil), // 29: ermite.ResolveActionsRequest
2719 (*ResolveActionsResponse)(nil), // 30: ermite.ResolveActionsResponse
2720 (*ResolvedAction)(nil), // 31: ermite.ResolvedAction
2721 (*UploadSummaryRequest)(nil), // 32: ermite.UploadSummaryRequest
2722 (*UploadSummaryResponse)(nil), // 33: ermite.UploadSummaryResponse
2723 nil, // 34: ermite.CompleteJobRequest.OutputsEntry
2724 (*durationpb.Duration)(nil), // 35: google.protobuf.Duration
2725 (*timestamppb.Timestamp)(nil), // 36: google.protobuf.Timestamp
2726}
2727var file_ermite_runner_proto_depIdxs = []int32{
2728 3, // 0: ermite.RegisterRunnerRequest.isolation:type_name -> ermite.RunnerIsolation
2729 11, // 1: ermite.FetchJobResponse.job:type_name -> ermite.Job
2730 35, // 2: ermite.FetchJobResponse.retry_after:type_name -> google.protobuf.Duration
2731 13, // 3: ermite.UpdateJobRequest.steps:type_name -> ermite.StepUpdate
2732 27, // 4: ermite.UpdateJobRequest.annotations:type_name -> ermite.Annotation
2733 2, // 5: ermite.StepUpdate.state:type_name -> ermite.StepState
2734 1, // 6: ermite.StepUpdate.conclusion:type_name -> ermite.CiConclusion
2735 36, // 7: ermite.StepUpdate.started_at:type_name -> google.protobuf.Timestamp
2736 36, // 8: ermite.StepUpdate.completed_at:type_name -> google.protobuf.Timestamp
2737 1, // 9: ermite.StepUpdate.outcome:type_name -> ermite.CiConclusion
2738 1, // 10: ermite.CompleteJobRequest.conclusion:type_name -> ermite.CiConclusion
2739 34, // 11: ermite.CompleteJobRequest.outputs:type_name -> ermite.CompleteJobRequest.OutputsEntry
2740 13, // 12: ermite.CompleteJobRequest.steps:type_name -> ermite.StepUpdate
2741 27, // 13: ermite.CompleteJobRequest.annotations:type_name -> ermite.Annotation
2742 1, // 14: ermite.CompleteJobResponse.conclusion:type_name -> ermite.CiConclusion
2743 1, // 15: ermite.JobEnded.conclusion:type_name -> ermite.CiConclusion
2744 19, // 16: ermite.AppendLogRequest.lines:type_name -> ermite.LogLine
2745 36, // 17: ermite.LogLine.time:type_name -> google.protobuf.Timestamp
2746 25, // 18: ermite.WatchJobResponse.keepalive:type_name -> ermite.Keepalive
2747 26, // 19: ermite.WatchJobResponse.cancel:type_name -> ermite.CancelRequest
2748 17, // 20: ermite.WatchJobResponse.ended:type_name -> ermite.JobEnded
2749 4, // 21: ermite.CancelRequest.reason:type_name -> ermite.CancelReason
2750 36, // 22: ermite.CancelRequest.requested_at:type_name -> google.protobuf.Timestamp
2751 5, // 23: ermite.Annotation.level:type_name -> ermite.AnnotationLevel
2752 28, // 24: ermite.ResolveActionsRequest.refs:type_name -> ermite.ActionRef
2753 31, // 25: ermite.ResolveActionsResponse.actions:type_name -> ermite.ResolvedAction
2754 6, // 26: ermite.ResolvedAction.source:type_name -> ermite.ActionSource
2755 7, // 27: ermite.RunnerService.RegisterRunner:input_type -> ermite.RegisterRunnerRequest
2756 9, // 28: ermite.RunnerService.FetchJob:input_type -> ermite.FetchJobRequest
2757 12, // 29: ermite.RunnerService.UpdateJob:input_type -> ermite.UpdateJobRequest
2758 18, // 30: ermite.RunnerService.AppendLog:input_type -> ermite.AppendLogRequest
2759 21, // 31: ermite.RunnerService.Heartbeat:input_type -> ermite.HeartbeatRequest
2760 23, // 32: ermite.RunnerService.WatchJob:input_type -> ermite.WatchJobRequest
2761 15, // 33: ermite.RunnerService.CompleteJob:input_type -> ermite.CompleteJobRequest
2762 29, // 34: ermite.RunnerService.ResolveActions:input_type -> ermite.ResolveActionsRequest
2763 32, // 35: ermite.RunnerService.UploadSummary:input_type -> ermite.UploadSummaryRequest
2764 8, // 36: ermite.RunnerService.RegisterRunner:output_type -> ermite.RegisterRunnerResponse
2765 10, // 37: ermite.RunnerService.FetchJob:output_type -> ermite.FetchJobResponse
2766 14, // 38: ermite.RunnerService.UpdateJob:output_type -> ermite.UpdateJobResponse
2767 20, // 39: ermite.RunnerService.AppendLog:output_type -> ermite.AppendLogResponse
2768 22, // 40: ermite.RunnerService.Heartbeat:output_type -> ermite.HeartbeatResponse
2769 24, // 41: ermite.RunnerService.WatchJob:output_type -> ermite.WatchJobResponse
2770 16, // 42: ermite.RunnerService.CompleteJob:output_type -> ermite.CompleteJobResponse
2771 30, // 43: ermite.RunnerService.ResolveActions:output_type -> ermite.ResolveActionsResponse
2772 33, // 44: ermite.RunnerService.UploadSummary:output_type -> ermite.UploadSummaryResponse
2773 36, // [36:45] is the sub-list for method output_type
2774 27, // [27:36] is the sub-list for method input_type
2775 27, // [27:27] is the sub-list for extension type_name
2776 27, // [27:27] is the sub-list for extension extendee
2777 0, // [0:27] is the sub-list for field type_name
2778}
2779
2780func init() { file_ermite_runner_proto_init() }
2781func file_ermite_runner_proto_init() {
2782 if File_ermite_runner_proto != nil {
2783 return
2784 }
2785 file_ermite_runner_proto_msgTypes[17].OneofWrappers = []any{
2786 (*WatchJobResponse_Keepalive)(nil),
2787 (*WatchJobResponse_Cancel)(nil),
2788 (*WatchJobResponse_Ended)(nil),
2789 }
2790 type x struct{}
2791 out := protoimpl.TypeBuilder{
2792 File: protoimpl.DescBuilder{
2793 GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
2794 RawDescriptor: unsafe.Slice(unsafe.StringData(file_ermite_runner_proto_rawDesc), len(file_ermite_runner_proto_rawDesc)),
2795 NumEnums: 7,
2796 NumMessages: 28,
2797 NumExtensions: 0,
2798 NumServices: 1,
2799 },
2800 GoTypes: file_ermite_runner_proto_goTypes,
2801 DependencyIndexes: file_ermite_runner_proto_depIdxs,
2802 EnumInfos: file_ermite_runner_proto_enumTypes,
2803 MessageInfos: file_ermite_runner_proto_msgTypes,
2804 }.Build()
2805 File_ermite_runner_proto = out.File
2806 file_ermite_runner_proto_goTypes = nil
2807 file_ermite_runner_proto_depIdxs = nil
2808}