-
Notifications
You must be signed in to change notification settings - Fork 1.8k
/
entrypointer.go
264 lines (234 loc) · 8.42 KB
/
entrypointer.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
/*
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 entrypoint
import (
"context"
"errors"
"fmt"
"io/ioutil"
"log"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"time"
"github.com/tektoncd/pipeline/pkg/apis/pipeline"
"github.com/tektoncd/pipeline/pkg/apis/pipeline/v1beta1"
"github.com/tektoncd/pipeline/pkg/termination"
"go.uber.org/zap"
)
// RFC3339 with millisecond
const (
timeFormat = "2006-01-02T15:04:05.000Z07:00"
ContinueOnError = "continue"
FailOnError = "stopAndFail"
)
// Entrypointer holds fields for running commands with redirected
// entrypoints.
type Entrypointer struct {
// Entrypoint is the original specified entrypoint, if any.
Entrypoint string
// Args are the original specified args, if any.
Args []string
// WaitFiles is the set of files to wait for. If empty, execution
// begins immediately.
WaitFiles []string
// WaitFileContent indicates the WaitFile should have non-zero size
// before continuing with execution.
WaitFileContent bool
// PostFile is the file to write when complete. If not specified, no
// file is written.
PostFile string
// Termination path is the path of a file to write the starting time of this endpopint
TerminationPath string
// Waiter encapsulates waiting for files to exist.
Waiter Waiter
// Runner encapsulates running commands.
Runner Runner
// PostWriter encapsulates writing files when complete.
PostWriter PostWriter
// Results is the set of files that might contain task results
Results []string
// Timeout is an optional user-specified duration within which the Step must complete
Timeout *time.Duration
// BreakpointOnFailure helps determine if entrypoint execution needs to adapt debugging requirements
BreakpointOnFailure bool
// OnError defines exiting behavior of the entrypoint
// set it to "stopAndFail" to indicate the entrypoint to exit the taskRun if the container exits with non zero exit code
// set it to "continue" to indicate the entrypoint to continue executing the rest of the steps irrespective of the container exit code
OnError string
// StepMetadataDir is the directory for a step where the step related metadata can be stored
StepMetadataDir string
// StepMetadataDirLink is the directory which needs to be linked to the StepMetadataDir
// the symlink is mainly created for providing easier access to the step metadata
// i.e. use `/tekton/steps/0/exitCode` instead of `/tekton/steps/my-awesome-step/exitCode`
StepMetadataDirLink string
}
// Waiter encapsulates waiting for files to exist.
type Waiter interface {
// Wait blocks until the specified file exists.
Wait(file string, expectContent bool, breakpointOnFailure bool) error
}
// Runner encapsulates running commands.
type Runner interface {
Run(ctx context.Context, args ...string) error
}
// PostWriter encapsulates writing a file when complete.
type PostWriter interface {
// Write writes to the path when complete.
Write(file, content string)
// CreateDirWithSymlink creates directory and a symlink
CreateDirWithSymlink(source, link string)
}
// Go optionally waits for a file, runs the command, and writes a
// post file.
func (e Entrypointer) Go() error {
prod, _ := zap.NewProduction()
logger := prod.Sugar()
output := []v1beta1.PipelineResourceResult{}
defer func() {
if wErr := termination.WriteMessage(e.TerminationPath, output); wErr != nil {
logger.Fatalf("Error while writing message: %s", wErr)
}
_ = logger.Sync()
}()
// Create the directory where we will store the exit codes (and eventually other metadata) of Steps.
// Create a symlink to the directory for easier access by the index instead of a step name.
e.PostWriter.CreateDirWithSymlink(e.StepMetadataDir, e.StepMetadataDirLink)
for _, f := range e.WaitFiles {
if err := e.Waiter.Wait(f, e.WaitFileContent, e.BreakpointOnFailure); err != nil {
// An error happened while waiting, so we bail
// *but* we write postfile to make next steps bail too.
// In case of breakpoint on failure do not write post file.
if !e.BreakpointOnFailure {
e.WritePostFile(e.PostFile, err)
}
output = append(output, v1beta1.PipelineResourceResult{
Key: "StartedAt",
Value: time.Now().Format(timeFormat),
ResultType: v1beta1.InternalTektonResultType,
})
return err
}
}
if e.Entrypoint != "" {
e.Args = append([]string{e.Entrypoint}, e.Args...)
}
output = append(output, v1beta1.PipelineResourceResult{
Key: "StartedAt",
Value: time.Now().Format(timeFormat),
ResultType: v1beta1.InternalTektonResultType,
})
var err error
if e.Timeout != nil && *e.Timeout < time.Duration(0) {
err = fmt.Errorf("negative timeout specified")
}
if err == nil {
ctx := context.Background()
var cancel context.CancelFunc
if e.Timeout != nil && *e.Timeout != time.Duration(0) {
ctx, cancel = context.WithTimeout(ctx, *e.Timeout)
defer cancel()
}
err = e.Runner.Run(ctx, e.Args...)
if err == context.DeadlineExceeded {
output = append(output, v1beta1.PipelineResourceResult{
Key: "Reason",
Value: "TimeoutExceeded",
ResultType: v1beta1.InternalTektonResultType,
})
}
}
var ee *exec.ExitError
switch {
case err != nil && e.BreakpointOnFailure:
logger.Info("Skipping writing to PostFile")
case e.OnError == ContinueOnError && errors.As(err, &ee):
// with continue on error and an ExitError, write non-zero exit code and a post file
exitCode := strconv.Itoa(ee.ExitCode())
output = append(output, v1beta1.PipelineResourceResult{
Key: "ExitCode",
Value: exitCode,
ResultType: v1beta1.InternalTektonResultType,
})
e.WritePostFile(e.PostFile, nil)
e.WriteExitCodeFile(e.StepMetadataDir, exitCode)
case err == nil:
// if err is nil, write zero exit code and a post file
e.WritePostFile(e.PostFile, nil)
e.WriteExitCodeFile(e.StepMetadataDirLink, "0")
default:
// for a step without continue on error and any error, write a post file with .err
e.WritePostFile(e.PostFile, err)
}
// strings.Split(..) with an empty string returns an array that contains one element, an empty string.
// This creates an error when trying to open the result folder as a file.
if len(e.Results) >= 1 && e.Results[0] != "" {
if err := e.readResultsFromDisk(); err != nil {
logger.Fatalf("Error while handling results: %s", err)
}
}
return err
}
func (e Entrypointer) readResultsFromDisk() error {
output := []v1beta1.PipelineResourceResult{}
for _, resultFile := range e.Results {
if resultFile == "" {
continue
}
fileContents, err := ioutil.ReadFile(filepath.Join(pipeline.DefaultResultPath, resultFile))
if os.IsNotExist(err) {
continue
} else if err != nil {
return err
}
// if the file doesn't exist, ignore it
output = append(output, v1beta1.PipelineResourceResult{
Key: resultFile,
Value: string(fileContents),
ResultType: v1beta1.TaskRunResultType,
})
}
// push output to termination path
if len(output) != 0 {
if err := termination.WriteMessage(e.TerminationPath, output); err != nil {
return err
}
}
return nil
}
// BreakpointExitCode reads the post file and returns the exit code it contains
func (e Entrypointer) BreakpointExitCode(breakpointExitPostFile string) (int, error) {
exitCode, err := ioutil.ReadFile(breakpointExitPostFile)
if os.IsNotExist(err) {
return 0, fmt.Errorf("breakpoint postfile %s not found", breakpointExitPostFile)
}
strExitCode := strings.TrimSuffix(string(exitCode), "\n")
log.Println("Breakpoint exiting with exit code " + strExitCode)
return strconv.Atoi(strExitCode)
}
// WritePostFile write the postfile
func (e Entrypointer) WritePostFile(postFile string, err error) {
if err != nil && postFile != "" {
postFile = fmt.Sprintf("%s.err", postFile)
}
if postFile != "" {
e.PostWriter.Write(postFile, "")
}
}
// WriteExitCodeFile write the exitCodeFile
func (e Entrypointer) WriteExitCodeFile(stepPath, content string) {
exitCodeFile := filepath.Join(stepPath, "exitCode")
e.PostWriter.Write(exitCodeFile, content)
}