forked from jenkins-x/jx
-
Notifications
You must be signed in to change notification settings - Fork 0
/
commands.go
158 lines (138 loc) · 3.5 KB
/
commands.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
package util
import (
"os"
"os/exec"
"strings"
"time"
"github.com/cenkalti/backoff"
"github.com/pkg/errors"
"io"
)
// Command is a struct containing the details of an external command to be executed
type Command struct {
attempts int
Errors []error
Dir string
Name string
Args []string
ExponentialBackOff *backoff.ExponentialBackOff
Timeout time.Duration
Out io.Writer
Err io.Writer
}
// CommandInterface defines the interface for a Command
//go:generate pegomock generate github.com/jenkins-x/jx/pkg/util CommandInterface
type CommandInterface interface {
DidError() bool
DidFail() bool
Error() error
Run() (string, error)
RunWithoutRetry() (string, error)
}
// Attempts The number of times the command has been executed
func (c *Command) Attempts() int {
return c.attempts
}
// DidError returns a boolean if any error occurred in any execution of the command
func (c *Command) DidError() bool {
if len(c.Errors) > 0 {
return true
}
return false
}
// DidFail returns a boolean if the command could not complete (errored on every attempt)
func (c *Command) DidFail() bool {
if len(c.Errors) == c.attempts {
return true
}
return false
}
// Error returns the last error
func (c *Command) Error() error {
if len(c.Errors) > 0 {
return c.Errors[len(c.Errors)-1]
}
return nil
}
// Run Execute the command and block waiting for return values
func (c *Command) Run() (string, error) {
os.Setenv("PATH", PathWithBinary(c.Dir))
var r string
var e error
f := func() error {
r, e = c.run()
c.attempts++
if e != nil {
c.Errors = append(c.Errors, e)
return e
}
return nil
}
c.ExponentialBackOff = backoff.NewExponentialBackOff()
if c.Timeout == 0 {
c.Timeout = 3 * time.Minute
}
c.ExponentialBackOff.MaxElapsedTime = c.Timeout
c.ExponentialBackOff.Reset()
err := backoff.Retry(f, c.ExponentialBackOff)
if err != nil {
return "", err
}
return r, nil
}
// RunWithoutRetry Execute the command without retrying on failure and block waiting for return values
func (c *Command) RunWithoutRetry() (string, error) {
os.Setenv("PATH", PathWithBinary(c.Dir))
var r string
var e error
r, e = c.run()
c.attempts++
if e != nil {
c.Errors = append(c.Errors, e)
}
return r, e
}
func (c *Command) run() (string, error) {
e := exec.Command(c.Name, c.Args...)
if c.Dir != "" {
e.Dir = c.Dir
}
if c.Out != nil {
e.Stdout = c.Out
}
if c.Err != nil {
e.Stderr = c.Err
}
var text string
var err error
if c.Out != nil {
err := e.Run()
if err != nil {
return text, errors.Wrapf(err, "failed to run '%s %s' command in directory '%s', output: '%s'",
c.Name, strings.Join(c.Args, " "), c.Dir, text)
}
} else {
data, err := e.CombinedOutput()
output := string(data)
text = strings.TrimSpace(output)
if err != nil {
return text, errors.Wrapf(err, "failed to run '%s %s' command in directory '%s', output: '%s'",
c.Name, strings.Join(c.Args, " "), c.Dir, text)
}
}
return text, err
}
// PathWithBinary Sets the $PATH variable. Accepts an optional slice of strings containing paths to add to $PATH
func PathWithBinary(paths ...string) string {
path := os.Getenv("PATH")
binDir, _ := BinaryLocation()
answer := path + string(os.PathListSeparator) + binDir
mvnBinDir, _ := MavenBinaryLocation()
if mvnBinDir != "" {
answer += string(os.PathListSeparator) + mvnBinDir
}
for _, p := range paths {
answer += string(os.PathListSeparator) + p
}
return answer
}