forked from tektoncd/pipeline
/
taskrun_types.go
551 lines (477 loc) · 20.8 KB
/
taskrun_types.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
/*
Copyright 2019 The Tekton Authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package v1beta1
import (
"context"
"fmt"
"time"
"github.com/tektoncd/pipeline/pkg/apis/config"
apisconfig "github.com/tektoncd/pipeline/pkg/apis/config"
"github.com/tektoncd/pipeline/pkg/apis/pipeline"
pod "github.com/tektoncd/pipeline/pkg/apis/pipeline/pod"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime/schema"
"k8s.io/apimachinery/pkg/types"
"k8s.io/utils/clock"
"knative.dev/pkg/apis"
duckv1 "knative.dev/pkg/apis/duck/v1"
)
// TaskRunSpec defines the desired state of TaskRun
type TaskRunSpec struct {
// +optional
Debug *TaskRunDebug `json:"debug,omitempty"`
// +optional
// +listType=atomic
Params Params `json:"params,omitempty"`
// Deprecated: Unused, preserved only for backwards compatibility
// +optional
Resources *TaskRunResources `json:"resources,omitempty"`
// +optional
ServiceAccountName string `json:"serviceAccountName"`
// no more than one of the TaskRef and TaskSpec may be specified.
// +optional
TaskRef *TaskRef `json:"taskRef,omitempty"`
// +optional
TaskSpec *TaskSpec `json:"taskSpec,omitempty"`
// Used for cancelling a TaskRun (and maybe more later on)
// +optional
Status TaskRunSpecStatus `json:"status,omitempty"`
// Status message for cancellation.
// +optional
StatusMessage TaskRunSpecStatusMessage `json:"statusMessage,omitempty"`
// Retries represents how many times this TaskRun should be retried in the event of Task failure.
// +optional
Retries int `json:"retries,omitempty"`
// Time after which one retry attempt times out. Defaults to 1 hour.
// Refer Go's ParseDuration documentation for expected format: https://golang.org/pkg/time/#ParseDuration
// +optional
Timeout *metav1.Duration `json:"timeout,omitempty"`
// PodTemplate holds pod specific configuration
PodTemplate *pod.PodTemplate `json:"podTemplate,omitempty"`
// Workspaces is a list of WorkspaceBindings from volumes to workspaces.
// +optional
// +listType=atomic
Workspaces []WorkspaceBinding `json:"workspaces,omitempty"`
// Overrides to apply to Steps in this TaskRun.
// If a field is specified in both a Step and a StepOverride,
// the value from the StepOverride will be used.
// This field is only supported when the alpha feature gate is enabled.
// +optional
// +listType=atomic
StepOverrides []TaskRunStepOverride `json:"stepOverrides,omitempty"`
// Overrides to apply to Sidecars in this TaskRun.
// If a field is specified in both a Sidecar and a SidecarOverride,
// the value from the SidecarOverride will be used.
// This field is only supported when the alpha feature gate is enabled.
// +optional
// +listType=atomic
SidecarOverrides []TaskRunSidecarOverride `json:"sidecarOverrides,omitempty"`
// Compute resources to use for this TaskRun
ComputeResources *corev1.ResourceRequirements `json:"computeResources,omitempty"`
}
// TaskRunSpecStatus defines the TaskRun spec status the user can provide
type TaskRunSpecStatus string
const (
// TaskRunSpecStatusCancelled indicates that the user wants to cancel the task,
// if not already cancelled or terminated
TaskRunSpecStatusCancelled = "TaskRunCancelled"
)
// TaskRunSpecStatusMessage defines human readable status messages for the TaskRun.
type TaskRunSpecStatusMessage string
const (
// TaskRunCancelledByPipelineMsg indicates that the PipelineRun of which this
// TaskRun was a part of has been cancelled.
TaskRunCancelledByPipelineMsg TaskRunSpecStatusMessage = "TaskRun cancelled as the PipelineRun it belongs to has been cancelled."
// TaskRunCancelledByPipelineTimeoutMsg indicates that the TaskRun was cancelled because the PipelineRun running it timed out.
TaskRunCancelledByPipelineTimeoutMsg TaskRunSpecStatusMessage = "TaskRun cancelled as the PipelineRun it belongs to has timed out."
)
const (
// EnabledOnFailureBreakpoint is the value for TaskRunDebug.Breakpoints.OnFailure that means the breakpoint onFailure is enabled
EnabledOnFailureBreakpoint = "enabled"
)
// TaskRunDebug defines the breakpoint config for a particular TaskRun
type TaskRunDebug struct {
// +optional
Breakpoints *TaskBreakpoints `json:"breakpoints,omitempty"`
}
// TaskBreakpoints defines the breakpoint config for a particular Task
type TaskBreakpoints struct {
// if enabled, pause TaskRun on failure of a step
// failed step will not exit
// +optional
OnFailure string `json:"onFailure,omitempty"`
}
// NeedsDebugOnFailure return true if the TaskRun is configured to debug on failure
func (trd *TaskRunDebug) NeedsDebugOnFailure() bool {
if trd.Breakpoints == nil {
return false
}
return trd.Breakpoints.OnFailure == EnabledOnFailureBreakpoint
}
// StepNeedsDebug return true if the step is configured to debug
func (trd *TaskRunDebug) StepNeedsDebug(stepName string) bool {
return trd.NeedsDebugOnFailure()
}
// NeedsDebug return true if defined onfailure or have any before, after steps
func (trd *TaskRunDebug) NeedsDebug() bool {
return trd.NeedsDebugOnFailure()
}
var taskRunCondSet = apis.NewBatchConditionSet()
// TaskRunStatus defines the observed state of TaskRun
type TaskRunStatus struct {
duckv1.Status `json:",inline"`
// TaskRunStatusFields inlines the status fields.
TaskRunStatusFields `json:",inline"`
}
// TaskRunConditionType is an enum used to store TaskRun custom
// conditions such as one used in spire results verification
type TaskRunConditionType string
const (
// TaskRunConditionResultsVerified is a Condition Type that indicates that the results were verified by spire
TaskRunConditionResultsVerified TaskRunConditionType = "SignedResultsVerified"
)
func (t TaskRunConditionType) String() string {
return string(t)
}
// TaskRunReason is an enum used to store all TaskRun reason for
// the Succeeded condition that are controlled by the TaskRun itself. Failure
// reasons that emerge from underlying resources are not included here
type TaskRunReason string
const (
// TaskRunReasonStarted is the reason set when the TaskRun has just started
TaskRunReasonStarted TaskRunReason = "Started"
// TaskRunReasonRunning is the reason set when the TaskRun is running
TaskRunReasonRunning TaskRunReason = "Running"
// TaskRunReasonSuccessful is the reason set when the TaskRun completed successfully
TaskRunReasonSuccessful TaskRunReason = "Succeeded"
// TaskRunReasonFailed is the reason set when the TaskRun completed with a failure
TaskRunReasonFailed TaskRunReason = "Failed"
// TaskRunReasonToBeRetried is the reason set when the last TaskRun execution failed, and will be retried
TaskRunReasonToBeRetried TaskRunReason = "ToBeRetried"
// TaskRunReasonCancelled is the reason set when the TaskRun is cancelled by the user
TaskRunReasonCancelled TaskRunReason = "TaskRunCancelled"
// TaskRunReasonTimedOut is the reason set when one TaskRun execution has timed out
TaskRunReasonTimedOut TaskRunReason = "TaskRunTimeout"
// TaskRunReasonResolvingTaskRef indicates that the TaskRun is waiting for
// its taskRef to be asynchronously resolved.
TaskRunReasonResolvingTaskRef = "ResolvingTaskRef"
// TaskRunReasonImagePullFailed is the reason set when the step of a task fails due to image not being pulled
TaskRunReasonImagePullFailed TaskRunReason = "TaskRunImagePullFailed"
// TaskRunReasonResultsVerified is the reason set when the TaskRun results are verified by spire
TaskRunReasonResultsVerified TaskRunReason = "TaskRunResultsVerified"
// TaskRunReasonsResultsVerificationFailed is the reason set when the TaskRun results are failed to verify by spire
TaskRunReasonsResultsVerificationFailed TaskRunReason = "TaskRunResultsVerificationFailed"
// AwaitingTaskRunResults is the reason set when waiting upon `TaskRun` results and signatures to verify
AwaitingTaskRunResults TaskRunReason = "AwaitingTaskRunResults"
// TaskRunReasonResultLargerThanAllowedLimit is the reason set when one of the results exceeds its maximum allowed limit of 1 KB
TaskRunReasonResultLargerThanAllowedLimit TaskRunReason = "TaskRunResultLargerThanAllowedLimit"
// TaskRunReasonStopSidecarFailed indicates that the sidecar is not properly stopped.
TaskRunReasonStopSidecarFailed = "TaskRunStopSidecarFailed"
)
func (t TaskRunReason) String() string {
return string(t)
}
// GetStartedReason returns the reason set to the "Succeeded" condition when
// InitializeConditions is invoked
func (trs *TaskRunStatus) GetStartedReason() string {
return TaskRunReasonStarted.String()
}
// GetRunningReason returns the reason set to the "Succeeded" condition when
// the TaskRun starts running. This is used indicate that the resource
// could be validated is starting to perform its job.
func (trs *TaskRunStatus) GetRunningReason() string {
return TaskRunReasonRunning.String()
}
// MarkResourceOngoing sets the ConditionSucceeded condition to ConditionUnknown
// with the reason and message.
func (trs *TaskRunStatus) MarkResourceOngoing(reason TaskRunReason, message string) {
taskRunCondSet.Manage(trs).SetCondition(apis.Condition{
Type: apis.ConditionSucceeded,
Status: corev1.ConditionUnknown,
Reason: reason.String(),
Message: message,
})
}
// MarkResourceFailed sets the ConditionSucceeded condition to ConditionFalse
// based on an error that occurred and a reason
func (trs *TaskRunStatus) MarkResourceFailed(reason TaskRunReason, err error) {
taskRunCondSet.Manage(trs).SetCondition(apis.Condition{
Type: apis.ConditionSucceeded,
Status: corev1.ConditionFalse,
Reason: reason.String(),
Message: err.Error(),
})
succeeded := trs.GetCondition(apis.ConditionSucceeded)
trs.CompletionTime = &succeeded.LastTransitionTime.Inner
}
// TaskRunStatusFields holds the fields of TaskRun's status. This is defined
// separately and inlined so that other types can readily consume these fields
// via duck typing.
type TaskRunStatusFields struct {
// PodName is the name of the pod responsible for executing this task's steps.
PodName string `json:"podName"`
// StartTime is the time the build is actually started.
StartTime *metav1.Time `json:"startTime,omitempty"`
// CompletionTime is the time the build completed.
CompletionTime *metav1.Time `json:"completionTime,omitempty"`
// Steps describes the state of each build step container.
// +optional
// +listType=atomic
Steps []StepState `json:"steps,omitempty"`
// CloudEvents describe the state of each cloud event requested via a
// CloudEventResource.
//
// Deprecated: Removed in v0.44.0.
//
// +optional
// +listType=atomic
CloudEvents []CloudEventDelivery `json:"cloudEvents,omitempty"`
// RetriesStatus contains the history of TaskRunStatus in case of a retry in order to keep record of failures.
// All TaskRunStatus stored in RetriesStatus will have no date within the RetriesStatus as is redundant.
// +optional
// +listType=atomic
RetriesStatus []TaskRunStatus `json:"retriesStatus,omitempty"`
// Results from Resources built during the TaskRun.
// This is tomb-stoned along with the removal of pipelineResources
// Deprecated: this field is not populated and is preserved only for backwards compatibility
// +optional
// +listType=atomic
ResourcesResult []PipelineResourceResult `json:"resourcesResult,omitempty"`
// TaskRunResults are the list of results written out by the task's containers
// +optional
// +listType=atomic
TaskRunResults []TaskRunResult `json:"taskResults,omitempty"`
// The list has one entry per sidecar in the manifest. Each entry is
// represents the imageid of the corresponding sidecar.
// +listType=atomic
Sidecars []SidecarState `json:"sidecars,omitempty"`
// TaskSpec contains the Spec from the dereferenced Task definition used to instantiate this TaskRun.
TaskSpec *TaskSpec `json:"taskSpec,omitempty"`
// Provenance contains some key authenticated metadata about how a software artifact was built (what sources, what inputs/outputs, etc.).
// +optional
Provenance *Provenance `json:"provenance,omitempty"`
// SpanContext contains tracing span context fields
SpanContext map[string]string `json:"spanContext,omitempty"`
}
// TaskRunStepOverride is used to override the values of a Step in the corresponding Task.
type TaskRunStepOverride struct {
// The name of the Step to override.
Name string `json:"name"`
// The resource requirements to apply to the Step.
Resources corev1.ResourceRequirements `json:"resources"`
}
// TaskRunSidecarOverride is used to override the values of a Sidecar in the corresponding Task.
type TaskRunSidecarOverride struct {
// The name of the Sidecar to override.
Name string `json:"name"`
// The resource requirements to apply to the Sidecar.
Resources corev1.ResourceRequirements `json:"resources"`
}
// GetGroupVersionKind implements kmeta.OwnerRefable.
func (*TaskRun) GetGroupVersionKind() schema.GroupVersionKind {
return SchemeGroupVersion.WithKind(pipeline.TaskRunControllerName)
}
// GetStatusCondition returns the task run status as a ConditionAccessor
func (tr *TaskRun) GetStatusCondition() apis.ConditionAccessor {
return &tr.Status
}
// GetCondition returns the Condition matching the given type.
func (trs *TaskRunStatus) GetCondition(t apis.ConditionType) *apis.Condition {
return taskRunCondSet.Manage(trs).GetCondition(t)
}
// InitializeConditions will set all conditions in taskRunCondSet to unknown for the TaskRun
// and set the started time to the current time
func (trs *TaskRunStatus) InitializeConditions() {
started := false
if trs.StartTime.IsZero() {
trs.StartTime = &metav1.Time{Time: time.Now()}
started = true
}
conditionManager := taskRunCondSet.Manage(trs)
conditionManager.InitializeConditions()
// Ensure the started reason is set for the "Succeeded" condition
if started {
initialCondition := conditionManager.GetCondition(apis.ConditionSucceeded)
initialCondition.Reason = TaskRunReasonStarted.String()
conditionManager.SetCondition(*initialCondition)
}
}
// SetCondition sets the condition, unsetting previous conditions with the same
// type as necessary.
func (trs *TaskRunStatus) SetCondition(newCond *apis.Condition) {
if newCond != nil {
taskRunCondSet.Manage(trs).SetCondition(*newCond)
}
}
// StepState reports the results of running a step in a Task.
type StepState struct {
corev1.ContainerState `json:",inline"`
Name string `json:"name,omitempty"`
ContainerName string `json:"container,omitempty"`
ImageID string `json:"imageID,omitempty"`
}
// SidecarState reports the results of running a sidecar in a Task.
type SidecarState struct {
corev1.ContainerState `json:",inline"`
Name string `json:"name,omitempty"`
ContainerName string `json:"container,omitempty"`
ImageID string `json:"imageID,omitempty"`
}
// CloudEventDelivery is the target of a cloud event along with the state of
// delivery.
type CloudEventDelivery struct {
// Target points to an addressable
Target string `json:"target,omitempty"`
Status CloudEventDeliveryState `json:"status,omitempty"`
}
// CloudEventCondition is a string that represents the condition of the event.
type CloudEventCondition string
const (
// CloudEventConditionUnknown means that the condition for the event to be
// triggered was not met yet, or we don't know the state yet.
CloudEventConditionUnknown CloudEventCondition = "Unknown"
// CloudEventConditionSent means that the event was sent successfully
CloudEventConditionSent CloudEventCondition = "Sent"
// CloudEventConditionFailed means that there was one or more attempts to
// send the event, and none was successful so far.
CloudEventConditionFailed CloudEventCondition = "Failed"
)
// CloudEventDeliveryState reports the state of a cloud event to be sent.
type CloudEventDeliveryState struct {
// Current status
Condition CloudEventCondition `json:"condition,omitempty"`
// SentAt is the time at which the last attempt to send the event was made
// +optional
SentAt *metav1.Time `json:"sentAt,omitempty"`
// Error is the text of error (if any)
Error string `json:"message"`
// RetryCount is the number of attempts of sending the cloud event
RetryCount int32 `json:"retryCount"`
}
// +genclient
// +genreconciler:krshapedlogic=false
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// +k8s:openapi-gen=true
// TaskRun represents a single execution of a Task. TaskRuns are how the steps
// specified in a Task are executed; they specify the parameters and resources
// used to run the steps in a Task.
//
// Deprecated: Please use v1.TaskRun instead.
type TaskRun struct {
metav1.TypeMeta `json:",inline"`
// +optional
metav1.ObjectMeta `json:"metadata,omitempty"`
// +optional
Spec TaskRunSpec `json:"spec,omitempty"`
// +optional
Status TaskRunStatus `json:"status,omitempty"`
}
// +k8s:deepcopy-gen:interfaces=k8s.io/apimachinery/pkg/runtime.Object
// TaskRunList contains a list of TaskRun
type TaskRunList struct {
metav1.TypeMeta `json:",inline"`
// +optional
metav1.ListMeta `json:"metadata,omitempty"`
Items []TaskRun `json:"items"`
}
// GetPipelineRunPVCName for TaskRun gets pipelinerun
func (tr *TaskRun) GetPipelineRunPVCName() string {
if tr == nil {
return ""
}
for _, ref := range tr.GetOwnerReferences() {
if ref.Kind == pipeline.PipelineRunControllerName {
return fmt.Sprintf("%s-pvc", ref.Name)
}
}
return ""
}
// HasPipelineRunOwnerReference returns true of TaskRun has
// owner reference of type PipelineRun
func (tr *TaskRun) HasPipelineRunOwnerReference() bool {
for _, ref := range tr.GetOwnerReferences() {
if ref.Kind == pipeline.PipelineRunControllerName {
return true
}
}
return false
}
// IsDone returns true if the TaskRun's status indicates that it is done.
func (tr *TaskRun) IsDone() bool {
return !tr.Status.GetCondition(apis.ConditionSucceeded).IsUnknown()
}
// HasStarted function check whether TaskRun has valid start time set in its status
func (tr *TaskRun) HasStarted() bool {
return tr.Status.StartTime != nil && !tr.Status.StartTime.IsZero()
}
// IsSuccessful returns true if the TaskRun's status indicates that it has succeeded.
func (tr *TaskRun) IsSuccessful() bool {
return tr != nil && tr.Status.GetCondition(apis.ConditionSucceeded).IsTrue()
}
// IsFailure returns true if the TaskRun's status indicates that it has failed.
func (tr *TaskRun) IsFailure() bool {
return tr != nil && tr.Status.GetCondition(apis.ConditionSucceeded).IsFalse()
}
// IsCancelled returns true if the TaskRun's spec status is set to Cancelled state
func (tr *TaskRun) IsCancelled() bool {
return tr.Spec.Status == TaskRunSpecStatusCancelled
}
// IsTaskRunResultVerified returns true if the TaskRun's results have been validated by spire.
func (tr *TaskRun) IsTaskRunResultVerified() bool {
return tr.Status.GetCondition(apis.ConditionType(TaskRunConditionResultsVerified.String())).IsTrue()
}
// IsTaskRunResultDone returns true if the TaskRun's results are available for verification
func (tr *TaskRun) IsTaskRunResultDone() bool {
return !tr.Status.GetCondition(apis.ConditionType(TaskRunConditionResultsVerified.String())).IsUnknown()
}
// IsRetriable returns true if the TaskRun's Retries is not exhausted.
func (tr *TaskRun) IsRetriable() bool {
return len(tr.Status.RetriesStatus) < tr.Spec.Retries
}
// HasTimedOut returns true if the TaskRun runtime is beyond the allowed timeout
func (tr *TaskRun) HasTimedOut(ctx context.Context, c clock.PassiveClock) bool {
if tr.Status.StartTime.IsZero() {
return false
}
timeout := tr.GetTimeout(ctx)
// If timeout is set to 0 or defaulted to 0, there is no timeout.
if timeout == apisconfig.NoTimeoutDuration {
return false
}
runtime := c.Since(tr.Status.StartTime.Time)
return runtime > timeout
}
// GetTimeout returns the timeout for the TaskRun, or the default if not specified
func (tr *TaskRun) GetTimeout(ctx context.Context) time.Duration {
// Use the platform default is no timeout is set
if tr.Spec.Timeout == nil {
defaultTimeout := time.Duration(config.FromContextOrDefaults(ctx).Defaults.DefaultTimeoutMinutes)
return defaultTimeout * time.Minute //nolint:durationcheck
}
return tr.Spec.Timeout.Duration
}
// GetNamespacedName returns a k8s namespaced name that identifies this TaskRun
func (tr *TaskRun) GetNamespacedName() types.NamespacedName {
return types.NamespacedName{Namespace: tr.Namespace, Name: tr.Name}
}
// HasVolumeClaimTemplate returns true if TaskRun contains volumeClaimTemplates that is
// used for creating PersistentVolumeClaims with an OwnerReference for each run
func (tr *TaskRun) HasVolumeClaimTemplate() bool {
for _, ws := range tr.Spec.Workspaces {
if ws.VolumeClaimTemplate != nil {
return true
}
}
return false
}