1
=== added file 'utils/ssh/run.go'
2
--- utils/ssh/run.go	1970-01-01 00:00:00 +0000
3
+++ utils/ssh/run.go	2014-01-10 01:56:08 +0000
4
@@ -0,0 +1,80 @@
5
1
// Copyright 2013 Canonical Ltd.
6
2
// Licensed under the AGPLv3, see LICENCE file for details.
7
3
8
4
package ssh
9
5
10
6
import (
11
7
	"bytes"
12
8
	"fmt"
13
9
	"os/exec"
14
10
	"strings"
15
11
	"syscall"
16
12
	"time"
17
13
18
14
	"launchpad.net/juju-core/cmd"
19
15
)
20
16
21
17
// ExecParams are used for the parameters for ExecuteCommandOnMachine.
22
18
type ExecParams struct {
23
19
	IdentityFile string
24
20
	Host         string
25
21
	Command      string
26
22
	Timeout      time.Duration
27
23
}
28
24
29
25
// ExecuteCommandOnMachine will execute the command passed through on
30
26
// the host specified. This is done using ssh, and passing the commands
31
27
// through /bin/bash.  If the command is not finished within the timeout
32
28
// specified, an error is returned.  Any output captured during that time
33
29
// is also returned in the remote response.
34
30
func ExecuteCommandOnMachine(params ExecParams) (result cmd.RemoteResponse, err error) {
35
31
	// execute bash accepting commands on stdin
36
32
	if params.Host == "" {
37
33
		return result, fmt.Errorf("missing host address")
38
34
	}
39
35
	logger.Debugf("execute on %s", params.Host)
40
36
	options := []Option{NoPasswordAuthentication}
41
37
	if params.IdentityFile != "" {
42
38
		options = append(options, Option{"-i", params.IdentityFile})
43
39
	}
44
40
	command := Command(params.Host, []string{"/bin/bash", "-s"}, options...)
45
41
	// start a go routine to do the actual execution
46
42
	var stdout, stderr bytes.Buffer
47
43
	command.Stdout = &stdout
48
44
	command.Stderr = &stderr
49
45
	command.Stdin = strings.NewReader(params.Command + "\n")
50
46
51
47
	if err = command.Start(); err != nil {
52
48
		return result, err
53
49
	}
54
50
	commandDone := make(chan error)
55
51
	go func() {
56
52
		defer close(commandDone)
57
53
		err := command.Wait()
58
54
		logger.Debugf("command.Wait finished: %v", err)
59
55
		commandDone <- err
60
56
	}()
61
57
62
58
	select {
63
59
	case err = <-commandDone:
64
60
		logger.Debugf("select from commandDone channel: %v", err)
65
61
		// command finished and returned us the results
66
62
		if ee, ok := err.(*exec.ExitError); ok && err != nil {
67
63
			status := ee.ProcessState.Sys().(syscall.WaitStatus)
68
64
			if status.Exited() {
69
65
				// A non-zero return code isn't considered an error here.
70
66
				result.Code = status.ExitStatus()
71
67
				err = nil
72
68
			}
73
69
		}
74
70
75
71
	case <-time.After(params.Timeout):
76
72
		logger.Infof("killing the command due to timeout")
77
73
		err = fmt.Errorf("command timed out")
78
74
		command.Process.Kill()
79
75
	}
80
76
	// In either case, gather as much as we have from stdout and stderr
81
77
	result.Stderr = stderr.Bytes()
82
78
	result.Stdout = stdout.Bytes()
83
79
	return result, err
84
80
}
85
0
81
86
=== added file 'utils/ssh/run_test.go'
87
--- utils/ssh/run_test.go	1970-01-01 00:00:00 +0000
88
+++ utils/ssh/run_test.go	2014-01-10 01:56:08 +0000
89
@@ -0,0 +1,116 @@
90
1
// Copyright 2013 Canonical Ltd.
91
2
// Licensed under the AGPLv3, see LICENCE file for details.
92
3
93
4
package ssh_test
94
5
95
6
import (
96
7
	"io/ioutil"
97
8
	"os"
98
9
	"path/filepath"
99
10
100
11
	gc "launchpad.net/gocheck"
101
12
102
13
	"launchpad.net/juju-core/testing"
103
14
	jc "launchpad.net/juju-core/testing/checkers"
104
15
	"launchpad.net/juju-core/testing/testbase"
105
16
	"launchpad.net/juju-core/utils/ssh"
106
17
)
107
18
108
19
type ExecuteSSHCommandSuite struct {
109
20
	testbase.LoggingSuite
110
21
	testbin string
111
22
	fakessh string
112
23
}
113
24
114
25
var _ = gc.Suite(&ExecuteSSHCommandSuite{})
115
26
116
27
func (s *ExecuteSSHCommandSuite) SetUpTest(c *gc.C) {
117
28
	s.LoggingSuite.SetUpTest(c)
118
29
	s.testbin = c.MkDir()
119
30
	s.fakessh = filepath.Join(s.testbin, "ssh")
120
31
	newPath := s.testbin + ":" + os.Getenv("PATH")
121
32
	s.PatchEnvironment("PATH", newPath)
122
33
}
123
34
124
35
func (s *ExecuteSSHCommandSuite) fakeSSH(c *gc.C, cmd string) {
125
36
	err := ioutil.WriteFile(s.fakessh, []byte(cmd), 0755)
126
37
	c.Assert(err, gc.IsNil)
127
38
}
128
39
129
40
func (s *ExecuteSSHCommandSuite) TestCaptureOutput(c *gc.C) {
130
41
	s.fakeSSH(c, echoSSH)
131
42
132
43
	response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
133
44
		Host:    "hostname",
134
45
		Command: "sudo apt-get update\nsudo apt-get upgrade",
135
46
		Timeout: testing.ShortWait,
136
47
	})
137
48
138
49
	c.Assert(err, gc.IsNil)
139
50
	c.Assert(response.Code, gc.Equals, 0)
140
51
	c.Assert(string(response.Stdout), gc.Equals, "sudo apt-get update\nsudo apt-get upgrade\n")
141
52
	c.Assert(string(response.Stderr), gc.Equals,
142
53
		"-o StrictHostKeyChecking no -o PasswordAuthentication no hostname -- /bin/bash -s\n")
143
54
}
144
55
145
56
func (s *ExecuteSSHCommandSuite) TestIdentityFile(c *gc.C) {
146
57
	s.fakeSSH(c, echoSSH)
147
58
148
59
	response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
149
60
		IdentityFile: "identity-file",
150
61
		Host:         "hostname",
151
62
		Timeout:      testing.ShortWait,
152
63
	})
153
64
154
65
	c.Assert(err, gc.IsNil)
155
66
	c.Assert(string(response.Stderr), jc.Contains, " -i identity-file ")
156
67
}
157
68
158
69
func (s *ExecuteSSHCommandSuite) TestTimoutCaptureOutput(c *gc.C) {
159
70
	s.fakeSSH(c, slowSSH)
160
71
161
72
	response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
162
73
		IdentityFile: "identity-file",
163
74
		Host:         "hostname",
164
75
		Command:      "ignored",
165
76
		Timeout:      testing.ShortWait,
166
77
	})
167
78
168
79
	c.Check(err, gc.ErrorMatches, "command timed out")
169
80
	c.Assert(response.Code, gc.Equals, 0)
170
81
	c.Assert(string(response.Stdout), gc.Equals, "stdout\n")
171
82
	c.Assert(string(response.Stderr), gc.Equals, "stderr\n")
172
83
}
173
84
174
85
func (s *ExecuteSSHCommandSuite) TestCapturesReturnCode(c *gc.C) {
175
86
	s.fakeSSH(c, passthroughSSH)
176
87
177
88
	response, err := ssh.ExecuteCommandOnMachine(ssh.ExecParams{
178
89
		IdentityFile: "identity-file",
179
90
		Host:         "hostname",
180
91
		Command:      "echo stdout; exit 42",
181
92
		Timeout:      testing.ShortWait,
182
93
	})
183
94
184
95
	c.Check(err, gc.IsNil)
185
96
	c.Assert(response.Code, gc.Equals, 42)
186
97
	c.Assert(string(response.Stdout), gc.Equals, "stdout\n")
187
98
	c.Assert(string(response.Stderr), gc.Equals, "")
188
99
}
189
100
190
101
// echoSSH outputs the command args to stderr, and copies stdin to stdout
191
102
var echoSSH = `#!/bin/bash
192
103
# Write the args to stderr
193
104
echo "$*" >&2
194
105
cat /dev/stdin
195
106
`
196
107
197
108
// slowSSH sleeps for a while after outputting some text to stdout and stderr
198
109
var slowSSH = `#!/bin/bash
199
110
echo "stderr" >&2
200
111
echo "stdout"
201
112
sleep 5s
202
113
`
203
114
204
115
// passthroughSSH creates an ssh that executes stdin.
205
116
var passthroughSSH = `#!/bin/bash -s`
Status:	Merged
Approved by:	Tim Penhey on 2014-01-10
Approved revision:	no longer in the source branch.
Merged at revision:	2189
Proposed branch:	lp:~thumper/juju-core/ssh-run-on-remote
Merge into:	lp:~go-bot/juju-core/trunk
Diff against target:	205 lines (+196/-0) 2 files modified utils/ssh/run.go (+80/-0) utils/ssh/run_test.go (+116/-0)
To merge this branch:	bzr merge lp:~thumper/juju-core/ssh-run-on-remote
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2014-01-09	Pending
Review via email: mp+201095@code.launchpad.net