-
Notifications
You must be signed in to change notification settings - Fork 786
/
commands.go
253 lines (220 loc) · 5.85 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
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
package util
import (
"fmt"
"io"
"os"
"os/exec"
"strings"
"time"
"github.com/cenkalti/backoff"
)
// 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
Env map[string]string
}
// CommandError is the error object encapsulating an error from a Command
type CommandError struct {
Command Command
Output string
cause error
}
func (c CommandError) Error() string {
// sanitise any password arguments before printing the error string. The actual sensitive argument is still present
// in the Command object
sanitisedArgs := make([]string, len(c.Command.Args))
copy(sanitisedArgs, c.Command.Args)
for i, arg := range sanitisedArgs {
if strings.Contains(strings.ToLower(arg), "password") && i <= len(sanitisedArgs)-1 {
// sanitise the subsequent argument to any 'password' fields
sanitisedArgs[i+1] = "*****"
}
}
return fmt.Sprintf("failed to run '%s %s' command in directory '%s', output: '%s'",
c.Command.Name, strings.Join(sanitisedArgs, " "), c.Command.Dir, c.Output)
}
// SetName Setter method for Name to enable use of interface instead of Command struct
func (c *Command) SetName(name string) {
c.Name = name
}
// CurrentName returns the current name of the command
func (c *Command) CurrentName() string {
return c.Name
}
// SetDir Setter method for Dir to enable use of interface instead of Command struct
func (c *Command) SetDir(dir string) {
c.Dir = dir
}
// CurrentDir returns the current Dir
func (c *Command) CurrentDir() string {
return c.Dir
}
// SetArgs Setter method for Args to enable use of interface instead of Command struct
func (c *Command) SetArgs(args []string) {
c.Args = args
}
// CurrentArgs returns the current command arguments
func (c *Command) CurrentArgs() []string {
return c.Args
}
// SetTimeout Setter method for Timeout to enable use of interface instead of Command struct
func (c *Command) SetTimeout(timeout time.Duration) {
c.Timeout = timeout
}
// SetExponentialBackOff Setter method for ExponentialBackOff to enable use of interface instead of Command struct
func (c *Command) SetExponentialBackOff(backoff *backoff.ExponentialBackOff) {
c.ExponentialBackOff = backoff
}
// SetEnv Setter method for Env to enable use of interface instead of Command struct
func (c *Command) SetEnv(env map[string]string) {
c.Env = env
}
// CurrentEnv returns the current envrionment variables
func (c *Command) CurrentEnv() map[string]string {
return c.Env
}
// SetEnvVariable sets an environment variable into the environment
func (c *Command) SetEnvVariable(name string, value string) {
if c.Env == nil {
c.Env = map[string]string{}
}
c.Env[name] = value
}
// 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 len(c.Env) > 0 {
m := map[string]string{}
environ := os.Environ()
for _, kv := range environ {
paths := strings.SplitN(kv, "=", 2)
if len(paths) == 2 {
m[paths[0]] = paths[1]
}
}
for k, v := range c.Env {
m[k] = v
}
envVars := []string{}
for k, v := range m {
envVars = append(envVars, k+"="+v)
}
e.Env = envVars
}
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, CommandError{
Command: *c,
cause: err,
}
}
} else {
data, err := e.CombinedOutput()
output := string(data)
text = strings.TrimSpace(output)
if err != nil {
return text, CommandError{
Command: *c,
Output: text,
cause: err,
}
}
}
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, _ := JXBinLocation()
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
}