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