1
=== modified file 'cmd/jujud/machine.go'
2
--- cmd/jujud/machine.go	2014-01-10 03:48:20 +0000
3
+++ cmd/jujud/machine.go	2014-01-12 20:08:17 +0000
4
@@ -310,7 +310,8 @@
5
310
				if len(cert) == 0 || len(key) == 0 {
310
				if len(cert) == 0 || len(key) == 0 {
6
311
					return nil, &fatalError{"configuration does not have state server cert/key"}
311
					return nil, &fatalError{"configuration does not have state server cert/key"}
7
312
				}
312
				}
9
313
				return apiserver.NewServer(st, fmt.Sprintf(":%d", port), cert, key)
313
				dataDir := a.Conf.config.DataDir()
10
314
				return apiserver.NewServer(st, fmt.Sprintf(":%d", port), cert, key, dataDir)
11
314
			})
315
			})
12
315
			runner.StartWorker("cleaner", func() (worker.Worker, error) {
316
			runner.StartWorker("cleaner", func() (worker.Worker, error) {
13
316
				return cleaner.NewCleaner(st), nil
317
				return cleaner.NewCleaner(st), nil
14
317
318
15
=== modified file 'provider/dummy/environs.go'
16
--- provider/dummy/environs.go	2013-12-20 11:48:03 +0000
17
+++ provider/dummy/environs.go	2014-01-12 20:08:17 +0000
18
@@ -586,7 +586,7 @@
19
586
		if err != nil {
586
		if err != nil {
20
587
			panic(err)
587
			panic(err)
21
588
		}
588
		}
23
589
		estate.apiServer, err = apiserver.NewServer(st, "localhost:0", []byte(testing.ServerCert), []byte(testing.ServerKey))
589
		estate.apiServer, err = apiserver.NewServer(st, "localhost:0", []byte(testing.ServerCert), []byte(testing.ServerKey), "")
24
590
		if err != nil {
590
		if err != nil {
25
591
			panic(err)
591
			panic(err)
26
592
		}
592
		}
27
593
593
28
=== modified file 'state/api/client.go'
29
--- state/api/client.go	2014-01-07 07:35:12 +0000
30
+++ state/api/client.go	2014-01-12 20:08:17 +0000
31
@@ -9,6 +9,7 @@
32
9
	"io/ioutil"
9
	"io/ioutil"
33
10
	"net/http"
10
	"net/http"
34
11
	"os"
11
	"os"
35
12
	"time"
36
12
13
37
13
	"launchpad.net/juju-core/charm"
14
	"launchpad.net/juju-core/charm"
38
14
	"launchpad.net/juju-core/constraints"
15
	"launchpad.net/juju-core/constraints"
39
@@ -398,6 +399,23 @@
40
398
	return c.st.Call("Client", "", "SetEnvironAgentVersion", args, nil)
399
	return c.st.Call("Client", "", "SetEnvironAgentVersion", args, nil)
41
399
}
400
}
42
400
401
43
402
// RunOnAllMachines runs the command on all the machines with the specified
44
403
// timeout.
45
404
func (c *Client) RunOnAllMachines(commands string, timeout time.Duration) ([]params.RunResult, error) {
46
405
	var results params.RunResults
47
406
	args := params.RunParams{Commands: commands, Timeout: timeout}
48
407
	err := c.st.Call("Client", "", "RunOnAllMachines", args, &results)
49
408
	return results.Results, err
50
409
}
51
410
52
411
// Run the Commands specified on the machines identified through the ids
53
412
// provided in the machines, services and units slices.
54
413
func (c *Client) Run(run params.RunParams) ([]params.RunResult, error) {
55
414
	var results params.RunResults
56
415
	err := c.st.Call("Client", "", "Run", run, &results)
57
416
	return results.Results, err
58
417
}
59
418
60
401
// DestroyEnvironment puts the environment into a "dying" state,
419
// DestroyEnvironment puts the environment into a "dying" state,
61
402
// and removes all non-manager machine instances. DestroyEnvironment
420
// and removes all non-manager machine instances. DestroyEnvironment
62
403
// will fail if there are any manually-provisioned non-manager machines
421
// will fail if there are any manually-provisioned non-manager machines
63
404
422
64
=== modified file 'state/api/params/internal.go'
65
--- state/api/params/internal.go	2013-12-17 09:49:11 +0000
66
+++ state/api/params/internal.go	2014-01-12 20:08:17 +0000
67
@@ -4,6 +4,9 @@
68
4
package params
4
package params
69
5
5
70
6
import (
6
import (
71
7
	"time"
72
8
73
9
	"launchpad.net/juju-core/cmd"
74
7
	"launchpad.net/juju-core/constraints"
10
	"launchpad.net/juju-core/constraints"
75
8
	"launchpad.net/juju-core/instance"
11
	"launchpad.net/juju-core/instance"
76
9
	"launchpad.net/juju-core/tools"
12
	"launchpad.net/juju-core/tools"
77
@@ -509,3 +512,29 @@
78
509
	Error    string `json:",omitempty"`
512
	Error    string `json:",omitempty"`
79
510
	CharmURL string `json:",omitempty"`
513
	CharmURL string `json:",omitempty"`
80
511
}
514
}
81
515
82
516
// RunParams is used to provide the parameters to the Run method.
83
517
// Commands and Timeout are expected to have values, and one or more
84
518
// values should be in the Machines, Services, or Units slices.
85
519
type RunParams struct {
86
520
	Commands string
87
521
	Timeout  time.Duration
88
522
	Machines []string
89
523
	Services []string
90
524
	Units    []string
91
525
}
92
526
93
527
// RunResult contains the result from an individual run call on a machine.
94
528
// UnitId is populated if the command was run inside the unit context.
95
529
type RunResult struct {
96
530
	cmd.RemoteResponse
97
531
	MachineId string
98
532
	UnitId    string
99
533
	Error     string
100
534
}
101
535
102
536
// RunResults is used to return the slice of results.  Api server side calls
103
537
// need to return single structure values.
104
538
type RunResults struct {
105
539
	Results []RunResult
106
540
}
107
512
541
108
=== modified file 'state/apiserver/apiserver.go'
109
--- state/apiserver/apiserver.go	2013-12-11 15:19:25 +0000
110
+++ state/apiserver/apiserver.go	2014-01-12 20:08:17 +0000
111
@@ -25,16 +25,17 @@
112
25
25
113
26
// Server holds the server side of the API.
26
// Server holds the server side of the API.
114
27
type Server struct {
27
type Server struct {
119
28
	tomb  tomb.Tomb
28
	tomb    tomb.Tomb
120
29
	wg    sync.WaitGroup
29
	wg      sync.WaitGroup
121
30
	state *state.State
30
	state   *state.State
122
31
	addr  net.Addr
31
	addr    net.Addr
123
32
	dataDir string
124
32
}
33
}
125
33
34
126
34
// Serve serves the given state by accepting requests on the given
35
// Serve serves the given state by accepting requests on the given
127
35
// listener, using the given certificate and key (in PEM format) for
36
// listener, using the given certificate and key (in PEM format) for
128
36
// authentication.
37
// authentication.
130
37
func NewServer(s *state.State, addr string, cert, key []byte) (*Server, error) {
38
func NewServer(s *state.State, addr string, cert, key []byte, datadir string) (*Server, error) {
131
38
	lis, err := net.Listen("tcp", addr)
39
	lis, err := net.Listen("tcp", addr)
132
39
	if err != nil {
40
	if err != nil {
133
40
		return nil, err
41
		return nil, err
134
@@ -45,8 +46,9 @@
135
45
		return nil, err
46
		return nil, err
136
46
	}
47
	}
137
47
	srv := &Server{
48
	srv := &Server{
140
48
		state: s,
49
		state:   s,
141
49
		addr:  lis.Addr(),
50
		addr:    lis.Addr(),
142
51
		dataDir: datadir,
143
50
	}
52
	}
144
51
	// TODO(rog) check that *srvRoot is a valid type for using
53
	// TODO(rog) check that *srvRoot is a valid type for using
145
52
	// as an RPC server.
54
	// as an RPC server.
146
53
55
147
=== modified file 'state/apiserver/client/client.go'
148
--- state/apiserver/client/client.go	2014-01-07 07:35:12 +0000
149
+++ state/apiserver/client/client.go	2014-01-12 20:08:17 +0000
150
@@ -35,6 +35,7 @@
151
35
	auth      common.Authorizer
35
	auth      common.Authorizer
152
36
	resources *common.Resources
36
	resources *common.Resources
153
37
	client    *Client
37
	client    *Client
154
38
	dataDir   string
155
38
}
39
}
156
39
40
157
40
// Client serves client-specific API methods.
41
// Client serves client-specific API methods.
158
@@ -43,11 +44,12 @@
159
43
}
44
}
160
44
45
161
45
// NewAPI creates a new instance of the Client API.
46
// NewAPI creates a new instance of the Client API.
163
46
func NewAPI(st *state.State, resources *common.Resources, authorizer common.Authorizer) *API {
47
func NewAPI(st *state.State, resources *common.Resources, authorizer common.Authorizer, datadir string) *API {
164
47
	r := &API{
48
	r := &API{
165
48
		state:     st,
49
		state:     st,
166
49
		auth:      authorizer,
50
		auth:      authorizer,
167
50
		resources: resources,
51
		resources: resources,
168
52
		dataDir:   datadir,
169
51
	}
53
	}
170
52
	r.client = &Client{
54
	r.client = &Client{
171
53
		api: r,
55
		api: r,
172
54
56
173
=== modified file 'state/apiserver/client/export_test.go'
174
--- state/apiserver/client/export_test.go	2013-09-11 08:56:44 +0000
175
+++ state/apiserver/client/export_test.go	2014-01-12 20:08:17 +0000
176
@@ -4,3 +4,5 @@
177
4
package client
4
package client
178
5
5
179
6
var ParseSettingsCompatible = parseSettingsCompatible
6
var ParseSettingsCompatible = parseSettingsCompatible
180
7
var RemoteParamsForMachine = remoteParamsForMachine
181
8
var GetAllUnitNames = getAllUnitNames
182
7
9
183
=== added file 'state/apiserver/client/run.go'
184
--- state/apiserver/client/run.go	1970-01-01 00:00:00 +0000
185
+++ state/apiserver/client/run.go	2014-01-12 20:08:17 +0000
186
@@ -0,0 +1,179 @@
187
1
// Copyright 2013 Canonical Ltd.
188
2
// Licensed under the AGPLv3, see LICENCE file for details.
189
3
190
4
package client
191
5
192
6
import (
193
7
	"fmt"
194
8
	"launchpad.net/juju-core/state"
195
9
	"launchpad.net/juju-core/utils"
196
10
	"path/filepath"
197
11
	"sort"
198
12
	"sync"
199
13
	"time"
200
14
201
15
	"launchpad.net/juju-core/environs/cloudinit"
202
16
	"launchpad.net/juju-core/instance"
203
17
	"launchpad.net/juju-core/state/api/params"
204
18
	"launchpad.net/juju-core/utils/set"
205
19
	"launchpad.net/juju-core/utils/ssh"
206
20
)
207
21
208
22
// remoteParamsForMachine returns a filled in RemoteExec instance
209
23
// based on the machine, command and timeout params.  If the machine
210
24
// does not have an internal address, the Host is empty. This is caught
211
25
// by the function that actually tries to execute the command.
212
26
func remoteParamsForMachine(machine *state.Machine, command string, timeout time.Duration) *RemoteExec {
213
27
	// magic boolean parameters are bad :-(
214
28
	address := instance.SelectInternalAddress(machine.Addresses(), false)
215
29
	execParams := &RemoteExec{
216
30
		ExecParams: ssh.ExecParams{
217
31
			Command: command,
218
32
			Timeout: timeout,
219
33
		},
220
34
		MachineId: machine.Id(),
221
35
	}
222
36
	if address != "" {
223
37
		execParams.Host = fmt.Sprintf("ubuntu@%s", address)
224
38
	}
225
39
	return execParams
226
40
}
227
41
228
42
// getAllUnitNames returns a sequence of valid Unit objects from state. If any
229
43
// of the service names or unit names are not found, an error is returned.
230
44
func getAllUnitNames(st *state.State, units, services []string) (result []*state.Unit, err error) {
231
45
	unitsSet := set.NewStrings(units...)
232
46
	for _, name := range services {
233
47
		service, err := st.Service(name)
234
48
		if err != nil {
235
49
			return nil, err
236
50
		}
237
51
		units, err := service.AllUnits()
238
52
		if err != nil {
239
53
			return nil, err
240
54
		}
241
55
		for _, unit := range units {
242
56
			unitsSet.Add(unit.Name())
243
57
		}
244
58
	}
245
59
	for _, unitName := range unitsSet.Values() {
246
60
		unit, err := st.Unit(unitName)
247
61
		if err != nil {
248
62
			return nil, err
249
63
		}
250
64
		// We only operate on principal units, and only thise that have an
251
65
		// assigned machines.
252
66
		if unit.IsPrincipal() {
253
67
			if _, err := unit.AssignedMachineId(); err != nil {
254
68
				return nil, err
255
69
			}
256
70
		} else {
257
71
			return nil, fmt.Errorf("%s is not a principal unit", unit)
258
72
		}
259
73
		result = append(result, unit)
260
74
	}
261
75
	return result, nil
262
76
}
263
77
264
78
// Run the commands specified on the machines identified through the
265
79
// list of machines, units and services.
266
80
func (c *Client) Run(run params.RunParams) (results params.RunResults, err error) {
267
81
	units, err := getAllUnitNames(c.api.state, run.Units, run.Services)
268
82
	if err != nil {
269
83
		return results, err
270
84
	}
271
85
	// We want to create a RemoteExec for each unit and each machine.
272
86
	// If we have both a unit and a machine request, we run it twice,
273
87
	// once for the unit inside the exec context using juju-run, and
274
88
	// the other outside the context just using bash.
275
89
	var params []*RemoteExec
276
90
	var quotedCommands = utils.ShQuote(run.Commands)
277
91
	for _, unit := range units {
278
92
		// We know that the unit is both a principal unit, and that it has an
279
93
		// assigned machine.
280
94
		machineId, _ := unit.AssignedMachineId()
281
95
		machine, err := c.api.state.Machine(machineId)
282
96
		if err != nil {
283
97
			return results, err
284
98
		}
285
99
		command := fmt.Sprintf("juju-run %s %s", unit.Name(), quotedCommands)
286
100
		execParam := remoteParamsForMachine(machine, command, run.Timeout)
287
101
		execParam.UnitId = unit.Name()
288
102
		params = append(params, execParam)
289
103
	}
290
104
	for _, machineId := range run.Machines {
291
105
		machine, err := c.api.state.Machine(machineId)
292
106
		if err != nil {
293
107
			return results, err
294
108
		}
295
109
		execParam := remoteParamsForMachine(machine, run.Commands, run.Timeout)
296
110
		params = append(params, execParam)
297
111
	}
298
112
	return ParallelExecute(c.api.dataDir, params), nil
299
113
}
300
114
301
115
// RunOnAllMachines attempts to run the specified command on all the machines.
302
116
func (c *Client) RunOnAllMachines(run params.RunParams) (params.RunResults, error) {
303
117
	machines, err := c.api.state.AllMachines()
304
118
	if err != nil {
305
119
		return params.RunResults{}, err
306
120
	}
307
121
	var params []*RemoteExec
308
122
	for _, machine := range machines {
309
123
		params = append(params, remoteParamsForMachine(machine, run.Commands, run.Timeout))
310
124
	}
311
125
	return ParallelExecute(c.api.dataDir, params), nil
312
126
}
313
127
314
128
// RemoteExec extends the standard ssh.ExecParams by providing the machine and
315
129
// perhaps the unit ids.  These are then returned in the params.RunResult return
316
130
// values.
317
131
type RemoteExec struct {
318
132
	ssh.ExecParams
319
133
	MachineId string
320
134
	UnitId    string
321
135
}
322
136
323
137
// ParallelExecute executes all of the requests defined in the params,
324
138
// using the system identity stored in the dataDir.
325
139
func ParallelExecute(dataDir string, runParams []*RemoteExec) params.RunResults {
326
140
	logger.Debugf("exec %#v", runParams)
327
141
	var outstanding sync.WaitGroup
328
142
	var lock sync.Mutex
329
143
	var result []params.RunResult
330
144
	identity := filepath.Join(dataDir, cloudinit.SystemIdentity)
331
145
	for _, param := range runParams {
332
146
		outstanding.Add(1)
333
147
		logger.Debugf("exec on %s: %#v", param.MachineId, *param)
334
148
		param.IdentityFile = identity
335
149
		go func(param *RemoteExec) {
336
150
			response, err := ssh.ExecuteCommandOnMachine(param.ExecParams)
337
151
			logger.Debugf("reponse from %s: %v (err:%v)", param.MachineId, response, err)
338
152
			execResponse := params.RunResult{
339
153
				RemoteResponse: response,
340
154
				MachineId:      param.MachineId,
341
155
				UnitId:         param.UnitId,
342
156
			}
343
157
			if err != nil {
344
158
				execResponse.Error = fmt.Sprint(err)
345
159
			}
346
160
347
161
			lock.Lock()
348
162
			defer lock.Unlock()
349
163
			result = append(result, execResponse)
350
164
			outstanding.Done()
351
165
		}(param)
352
166
	}
353
167
354
168
	outstanding.Wait()
355
169
	sort.Sort(MachineOrder(result))
356
170
	return params.RunResults{result}
357
171
}
358
172
359
173
// MachineOrder is used to provide the api to sort the results by the machine
360
174
// id.
361
175
type MachineOrder []params.RunResult
362
176
363
177
func (a MachineOrder) Len() int           { return len(a) }
364
178
func (a MachineOrder) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
365
179
func (a MachineOrder) Less(i, j int) bool { return a[i].MachineId < a[j].MachineId }
366
0
180
367
=== added file 'state/apiserver/client/run_test.go'
368
--- state/apiserver/client/run_test.go	1970-01-01 00:00:00 +0000
369
+++ state/apiserver/client/run_test.go	2014-01-12 20:08:17 +0000
370
@@ -0,0 +1,299 @@
371
1
// Copyright 2013 Canonical Ltd.
372
2
// Licensed under the AGPLv3, see LICENCE file for details.
373
3
374
4
package client_test
375
5
376
6
import (
377
7
	"fmt"
378
8
	"io/ioutil"
379
9
	"os"
380
10
	"path/filepath"
381
11
	"time"
382
12
383
13
	gc "launchpad.net/gocheck"
384
14
385
15
	"launchpad.net/juju-core/cmd"
386
16
	"launchpad.net/juju-core/instance"
387
17
	"launchpad.net/juju-core/state"
388
18
	"launchpad.net/juju-core/state/api/params"
389
19
	"launchpad.net/juju-core/state/apiserver/client"
390
20
	"launchpad.net/juju-core/testing"
391
21
	jc "launchpad.net/juju-core/testing/checkers"
392
22
	"launchpad.net/juju-core/utils/ssh"
393
23
)
394
24
395
25
type runSuite struct {
396
26
	baseSuite
397
27
}
398
28
399
29
var _ = gc.Suite(&runSuite{})
400
30
401
31
func (s *runSuite) addMachine(c *gc.C) *state.Machine {
402
32
	machine, err := s.State.AddMachine("quantal", state.JobHostUnits)
403
33
	c.Assert(err, gc.IsNil)
404
34
	return machine
405
35
}
406
36
407
37
func (s *runSuite) addMachineWithAddress(c *gc.C, address string) *state.Machine {
408
38
	machine := s.addMachine(c)
409
39
	machine.SetAddresses([]instance.Address{instance.NewAddress(address)})
410
40
	return machine
411
41
}
412
42
413
43
func (s *runSuite) TestRemoteParamsForMachinePopulates(c *gc.C) {
414
44
	machine := s.addMachine(c)
415
45
	result := client.RemoteParamsForMachine(machine, "command", time.Minute)
416
46
	c.Assert(result.Command, gc.Equals, "command")
417
47
	c.Assert(result.Timeout, gc.Equals, time.Minute)
418
48
	c.Assert(result.MachineId, gc.Equals, machine.Id())
419
49
	// Now an empty host isn't particularly useful, but the machine doesn't
420
50
	// have an address to use.
421
51
	c.Assert(machine.Addresses(), gc.HasLen, 0)
422
52
	c.Assert(result.Host, gc.Equals, "")
423
53
}
424
54
425
55
func (s *runSuite) TestRemoteParamsForMachinePopulatesWithAddress(c *gc.C) {
426
56
	machine := s.addMachineWithAddress(c, "10.3.2.1")
427
57
428
58
	result := client.RemoteParamsForMachine(machine, "command", time.Minute)
429
59
	c.Assert(result.Command, gc.Equals, "command")
430
60
	c.Assert(result.Timeout, gc.Equals, time.Minute)
431
61
	c.Assert(result.MachineId, gc.Equals, machine.Id())
432
62
	c.Assert(result.Host, gc.Equals, "ubuntu@10.3.2.1")
433
63
}
434
64
435
65
func (s *runSuite) addUnit(c *gc.C, service *state.Service) *state.Unit {
436
66
	unit, err := service.AddUnit()
437
67
	c.Assert(err, gc.IsNil)
438
68
	err = unit.AssignToNewMachine()
439
69
	c.Assert(err, gc.IsNil)
440
70
	mId, err := unit.AssignedMachineId()
441
71
	c.Assert(err, gc.IsNil)
442
72
	machine, err := s.State.Machine(mId)
443
73
	c.Assert(err, gc.IsNil)
444
74
	machine.SetAddresses([]instance.Address{instance.NewAddress("10.3.2.1")})
445
75
	return unit
446
76
}
447
77
448
78
func (s *runSuite) TestGetAllUnitNames(c *gc.C) {
449
79
	charm := s.AddTestingCharm(c, "dummy")
450
80
	magic, err := s.State.AddService("magic", "user-admin", charm)
451
81
	s.addUnit(c, magic)
452
82
	s.addUnit(c, magic)
453
83
454
84
	notAssigned, err := s.State.AddService("not-assigned", "user-admin", charm)
455
85
	c.Assert(err, gc.IsNil)
456
86
	_, err = notAssigned.AddUnit()
457
87
	c.Assert(err, gc.IsNil)
458
88
459
89
	_, err = s.State.AddService("no-units", "user-admin", charm)
460
90
	c.Assert(err, gc.IsNil)
461
91
462
92
	for i, test := range []struct {
463
93
		message  string
464
94
		expected []string
465
95
		units    []string
466
96
		services []string
467
97
		error    string
468
98
	}{{
469
99
		message: "no units, expected nil slice",
470
100
	}, {
471
101
		message: "asking for a unit that isn't there",
472
102
		units:   []string{"foo/0"},
473
103
		error:   `unit "foo/0" not found`,
474
104
	}, {
475
105
		message:  "asking for a service that isn't there",
476
106
		services: []string{"foo"},
477
107
		error:    `service "foo" not found`,
478
108
	}, {
479
109
		message:  "service with no units is not really an error",
480
110
		services: []string{"no-units"},
481
111
	}, {
482
112
		message:  "A service with units not assigned is an error",
483
113
		services: []string{"not-assigned"},
484
114
		error:    `unit "not-assigned/0" is not assigned to a machine`,
485
115
	}, {
486
116
		message:  "A service with units",
487
117
		services: []string{"magic"},
488
118
		expected: []string{"magic/0", "magic/1"},
489
119
	}, {
490
120
		message:  "Asking for just a unit",
491
121
		units:    []string{"magic/0"},
492
122
		expected: []string{"magic/0"},
493
123
	}, {
494
124
		message:  "Asking for a unit, and the service",
495
125
		services: []string{"magic"},
496
126
		units:    []string{"magic/0"},
497
127
		expected: []string{"magic/0", "magic/1"},
498
128
	}} {
499
129
		c.Log(fmt.Sprintf("%v: %s", i, test.message))
500
130
		result, err := client.GetAllUnitNames(s.State, test.units, test.services)
501
131
		if test.error == "" {
502
132
			c.Check(err, gc.IsNil)
503
133
			var units []string
504
134
			for _, unit := range result {
505
135
				units = append(units, unit.Name())
506
136
			}
507
137
			c.Check(units, jc.SameContents, test.expected)
508
138
		} else {
509
139
			c.Check(err, gc.ErrorMatches, test.error)
510
140
		}
511
141
	}
512
142
}
513
143
514
144
func (s *runSuite) mockSSH(c *gc.C, cmd string) {
515
145
	testbin := c.MkDir()
516
146
	fakessh := filepath.Join(testbin, "ssh")
517
147
	newPath := testbin + ":" + os.Getenv("PATH")
518
148
	s.PatchEnvironment("PATH", newPath)
519
149
	err := ioutil.WriteFile(fakessh, []byte(cmd), 0755)
520
150
	c.Assert(err, gc.IsNil)
521
151
}
522
152
523
153
func (s *runSuite) TestParallelExecuteErrorsOnBlankHost(c *gc.C) {
524
154
	s.mockSSH(c, echoInputShowArgs)
525
155
526
156
	params := []*client.RemoteExec{
527
157
		&client.RemoteExec{
528
158
			ExecParams: ssh.ExecParams{
529
159
				Command: "foo",
530
160
				Timeout: testing.ShortWait,
531
161
			},
532
162
		},
533
163
	}
534
164
535
165
	runResults := client.ParallelExecute("/some/dir", params)
536
166
	c.Assert(runResults.Results, gc.HasLen, 1)
537
167
	result := runResults.Results[0]
538
168
	c.Assert(result.Error, gc.Equals, "missing host address")
539
169
}
540
170
541
171
func (s *runSuite) TestParallelExecuteAddsIdentity(c *gc.C) {
542
172
	s.mockSSH(c, echoInputShowArgs)
543
173
544
174
	params := []*client.RemoteExec{
545
175
		&client.RemoteExec{
546
176
			ExecParams: ssh.ExecParams{
547
177
				Host:    "localhost",
548
178
				Command: "foo",
549
179
				Timeout: testing.ShortWait,
550
180
			},
551
181
		},
552
182
	}
553
183
554
184
	runResults := client.ParallelExecute("/some/dir", params)
555
185
	c.Assert(runResults.Results, gc.HasLen, 1)
556
186
	result := runResults.Results[0]
557
187
	c.Assert(result.Error, gc.Equals, "")
558
188
	c.Assert(string(result.Stderr), jc.Contains, "-i /some/dir/system-identity")
559
189
}
560
190
561
191
func (s *runSuite) TestParallelExecuteCopiesAcrossMachineAndUnit(c *gc.C) {
562
192
	s.mockSSH(c, echoInputShowArgs)
563
193
564
194
	params := []*client.RemoteExec{
565
195
		&client.RemoteExec{
566
196
			ExecParams: ssh.ExecParams{
567
197
				Host:    "localhost",
568
198
				Command: "foo",
569
199
				Timeout: testing.ShortWait,
570
200
			},
571
201
			MachineId: "machine-id",
572
202
			UnitId:    "unit-id",
573
203
		},
574
204
	}
575
205
576
206
	runResults := client.ParallelExecute("/some/dir", params)
577
207
	c.Assert(runResults.Results, gc.HasLen, 1)
578
208
	result := runResults.Results[0]
579
209
	c.Assert(result.Error, gc.Equals, "")
580
210
	c.Assert(result.MachineId, gc.Equals, "machine-id")
581
211
	c.Assert(result.UnitId, gc.Equals, "unit-id")
582
212
}
583
213
584
214
func (s *runSuite) TestRunOnAllMachines(c *gc.C) {
585
215
	// Make three machines.
586
216
	s.addMachineWithAddress(c, "10.3.2.1")
587
217
	s.addMachineWithAddress(c, "10.3.2.2")
588
218
	s.addMachineWithAddress(c, "10.3.2.3")
589
219
590
220
	s.mockSSH(c, echoInput)
591
221
592
222
	// hmm... this seems to be going through the api client, and from there
593
223
	// through to the apiserver implementation. Not ideal, but it is how the
594
224
	// other client tests are written.
595
225
	client := s.APIState.Client()
596
226
	results, err := client.RunOnAllMachines("hostname", testing.ShortWait)
597
227
	c.Assert(err, gc.IsNil)
598
228
	c.Assert(results, gc.HasLen, 3)
599
229
	var expectedResults []params.RunResult
600
230
	for i := 0; i < 3; i++ {
601
231
		expectedResults = append(expectedResults,
602
232
			params.RunResult{
603
233
				RemoteResponse: cmd.RemoteResponse{Stdout: []byte("hostname\n")},
604
234
				MachineId:      fmt.Sprint(i),
605
235
			})
606
236
	}
607
237
608
238
	c.Assert(results, jc.DeepEquals, expectedResults)
609
239
}
610
240
611
241
func (s *runSuite) TestRunMachineAndService(c *gc.C) {
612
242
	// Make three machines.
613
243
	s.addMachineWithAddress(c, "10.3.2.1")
614
244
615
245
	charm := s.AddTestingCharm(c, "dummy")
616
246
	magic, err := s.State.AddService("magic", "user-admin", charm)
617
247
	s.addUnit(c, magic)
618
248
	s.addUnit(c, magic)
619
249
620
250
	s.mockSSH(c, echoInput)
621
251
622
252
	// hmm... this seems to be going through the api client, and from there
623
253
	// through to the apiserver implementation. Not ideal, but it is how the
624
254
	// other client tests are written.
625
255
	client := s.APIState.Client()
626
256
	results, err := client.Run(
627
257
		params.RunParams{
628
258
			Commands: "hostname",
629
259
			Timeout:  testing.ShortWait,
630
260
			Machines: []string{"0"},
631
261
			Services: []string{"magic"},
632
262
		})
633
263
	c.Assert(err, gc.IsNil)
634
264
	c.Assert(results, gc.HasLen, 3)
635
265
	expectedResults := []params.RunResult{
636
266
		params.RunResult{
637
267
			RemoteResponse: cmd.RemoteResponse{Stdout: []byte("hostname\n")},
638
268
			MachineId:      "0",
639
269
		},
640
270
		params.RunResult{
641
271
			RemoteResponse: cmd.RemoteResponse{Stdout: []byte("juju-run magic/0 'hostname'\n")},
642
272
			MachineId:      "1",
643
273
			UnitId:         "magic/0",
644
274
		},
645
275
		params.RunResult{
646
276
			RemoteResponse: cmd.RemoteResponse{Stdout: []byte("juju-run magic/1 'hostname'\n")},
647
277
			MachineId:      "2",
648
278
			UnitId:         "magic/1",
649
279
		},
650
280
	}
651
281
652
282
	c.Assert(results, jc.DeepEquals, expectedResults)
653
283
}
654
284
655
285
var echoInputShowArgs = `#!/bin/bash
656
286
# Write the args to stderr
657
287
echo "$*" >&2
658
288
# And echo stdin to stdout
659
289
while read line
660
290
do echo $line
661
291
done <&0
662
292
`
663
293
664
294
var echoInput = `#!/bin/bash
665
295
# And echo stdin to stdout
666
296
while read line
667
297
do echo $line
668
298
done <&0
669
299
`
670
0
300
671
=== modified file 'state/apiserver/login_test.go'
672
--- state/apiserver/login_test.go	2013-12-12 07:58:43 +0000
673
+++ state/apiserver/login_test.go	2014-01-12 20:08:17 +0000
674
@@ -50,6 +50,7 @@
675
50
		"localhost:0",
50
		"localhost:0",
676
51
		[]byte(coretesting.ServerCert),
51
		[]byte(coretesting.ServerCert),
677
52
		[]byte(coretesting.ServerKey),
52
		[]byte(coretesting.ServerKey),
678
53
		"",
679
53
	)
54
	)
680
54
	c.Assert(err, gc.IsNil)
55
	c.Assert(err, gc.IsNil)
681
55
	info := &api.Info{
56
	info := &api.Info{
682
56
57
683
=== modified file 'state/apiserver/root.go'
684
--- state/apiserver/root.go	2013-12-11 07:40:14 +0000
685
+++ state/apiserver/root.go	2014-01-12 20:08:17 +0000
686
@@ -66,7 +66,7 @@
687
66
			logger.Errorf("error closing the RPC connection: %v", err)
66
			logger.Errorf("error closing the RPC connection: %v", err)
688
67
		}
67
		}
689
68
	}
68
	}
691
69
	r.clientAPI.API = client.NewAPI(r.srv.state, r.resources, r)
69
	r.clientAPI.API = client.NewAPI(r.srv.state, r.resources, r, r.srv.dataDir)
692
70
	r.pingTimeout = newPingTimeout(action, maxPingInterval)
70
	r.pingTimeout = newPingTimeout(action, maxPingInterval)
693
71
	return r
71
	return r
694
72
}
72
}
695
73
73
696
=== modified file 'state/apiserver/server_test.go'
697
--- state/apiserver/server_test.go	2013-12-12 17:23:45 +0000
698
+++ state/apiserver/server_test.go	2014-01-12 20:08:17 +0000
699
@@ -36,7 +36,7 @@
700
36
func (s *serverSuite) TestStop(c *gc.C) {
36
func (s *serverSuite) TestStop(c *gc.C) {
701
37
	// Start our own instance of the server so we have
37
	// Start our own instance of the server so we have
702
38
	// a handle on it to stop it.
38
	// a handle on it to stop it.
704
39
	srv, err := apiserver.NewServer(s.State, "localhost:0", []byte(coretesting.ServerCert), []byte(coretesting.ServerKey))
39
	srv, err := apiserver.NewServer(s.State, "localhost:0", []byte(coretesting.ServerCert), []byte(coretesting.ServerKey), "")
705
40
	c.Assert(err, gc.IsNil)
40
	c.Assert(err, gc.IsNil)
706
41
	defer srv.Stop()
41
	defer srv.Stop()
707
42
42
Status:	Merged
Approved by:	Tim Penhey on 2014-01-12
Approved revision:	no longer in the source branch.
Merged at revision:	2192
Proposed branch:	lp:~thumper/juju-core/api-juju-run
Merge into:	lp:~go-bot/juju-core/trunk
Prerequisite:	lp:~thumper/juju-core/ssh-run-on-remote
Diff against target:	706 lines (+545/-12) 12 files modified cmd/jujud/machine.go (+2/-1) provider/dummy/environs.go (+1/-1) state/api/client.go (+18/-0) state/api/params/internal.go (+29/-0) state/apiserver/apiserver.go (+9/-7) state/apiserver/client/client.go (+3/-1) state/apiserver/client/export_test.go (+2/-0) state/apiserver/client/run.go (+179/-0) state/apiserver/client/run_test.go (+299/-0) state/apiserver/login_test.go (+1/-0) state/apiserver/root.go (+1/-1) state/apiserver/server_test.go (+1/-1)
To merge this branch:	bzr merge lp:~thumper/juju-core/api-juju-run
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2014-01-09	Pending
Review via email: mp+201103@code.launchpad.net