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