1
=== modified file 'cmd/juju/addmachine.go'
2
--- cmd/juju/addmachine.go	2014-04-09 22:01:03 +0000
3
+++ cmd/juju/addmachine.go	2014-04-23 06:25:18 +0000
4
@@ -5,7 +5,6 @@
5
5
5
6
6
import (
6
import (
7
7
	"fmt"
7
	"fmt"
8
8
	"strings"
9
9
8
10
10
	"launchpad.net/gnuflag"
9
	"launchpad.net/gnuflag"
11
11
10
12
@@ -60,10 +59,9 @@
13
60
	// If specified, use this series, else use the environment default-series
59
	// If specified, use this series, else use the environment default-series
14
61
	Series string
60
	Series string
15
62
	// If specified, these constraints are merged with those already in the environment.
61
	// If specified, these constraints are merged with those already in the environment.
20
63
	Constraints   constraints.Value
62
	Constraints constraints.Value
21
64
	MachineId     string
63
	// Placement is passed verbatim to the API, to be parsed and evaluated server-side.
22
65
	ContainerType instance.ContainerType
64
	Placement *instance.Placement
19
66
	SSHHost       string
23
67
}
65
}
24
68
66
25
69
func (c *AddMachineCommand) Info() *cmd.Info {
67
func (c *AddMachineCommand) Info() *cmd.Info {
26
@@ -89,33 +87,25 @@
27
89
	if c.Constraints.Container != nil {
87
	if c.Constraints.Container != nil {
28
90
		return fmt.Errorf("container constraint %q not allowed when adding a machine", *c.Constraints.Container)
88
		return fmt.Errorf("container constraint %q not allowed when adding a machine", *c.Constraints.Container)
29
91
	}
89
	}
51
92
	containerSpec, err := cmd.ZeroOrOneArgs(args)
90
	placement, err := cmd.ZeroOrOneArgs(args)
52
93
	if err != nil {
91
	if err != nil {
53
94
		return err
92
		return err
54
95
	}
93
	}
55
96
	if containerSpec == "" {
94
	c.Placement, err = instance.ParsePlacement(placement)
56
97
		return nil
95
	if err == instance.ErrPlacementScopeMissing {
57
98
	}
96
		placement = c.EnvironName() + ":" + placement
58
99
	if strings.HasPrefix(containerSpec, sshHostPrefix) {
97
		c.Placement, err = instance.ParsePlacement(placement)
59
100
		c.SSHHost = containerSpec[len(sshHostPrefix):]
98
	}
60
101
	} else {
99
	if err != nil {
61
102
		// container arg can either be 'type:machine' or 'type'
100
		return err
62
103
		if c.ContainerType, err = instance.ParseContainerType(containerSpec); err != nil {
101
	}
63
104
			if names.IsMachine(containerSpec) || !cmd.IsMachineOrNewContainer(containerSpec) {
102
	return nil
43
105
				return fmt.Errorf("malformed container argument %q", containerSpec)
44
106
			}
45
107
			sep := strings.Index(containerSpec, ":")
46
108
			c.MachineId = containerSpec[sep+1:]
47
109
			c.ContainerType, err = instance.ParseContainerType(containerSpec[:sep])
48
110
		}
49
111
	}
50
112
	return err
64
113
}
103
}
65
114
104
66
115
func (c *AddMachineCommand) Run(ctx *cmd.Context) error {
105
func (c *AddMachineCommand) Run(ctx *cmd.Context) error {
68
116
	if c.SSHHost != "" {
106
	if c.Placement != nil && c.Placement.Scope == "ssh" {
69
117
		args := manual.ProvisionMachineArgs{
107
		args := manual.ProvisionMachineArgs{
71
118
			Host:    c.SSHHost,
108
			Host:    c.Placement.Directive,
72
119
			EnvName: c.EnvName,
109
			EnvName: c.EnvName,
73
120
			Stdin:   ctx.Stdin,
110
			Stdin:   ctx.Stdin,
74
121
			Stdout:  ctx.Stdout,
111
			Stdout:  ctx.Stdout,
75
@@ -131,27 +121,51 @@
76
131
	}
121
	}
77
132
	defer client.Close()
122
	defer client.Close()
78
133
123
79
124
	if c.Placement != nil && c.Placement.Scope == instance.MachineScope {
80
125
		// It does not make sense to add-machine <id>.
81
126
		return fmt.Errorf("machine-id cannot be specified when adding machines")
82
127
	}
83
128
84
134
	machineParams := params.AddMachineParams{
129
	machineParams := params.AddMachineParams{
90
135
		ParentId:      c.MachineId,
130
		Placement:   c.Placement,
91
136
		ContainerType: c.ContainerType,
131
		Series:      c.Series,
92
137
		Series:        c.Series,
132
		Constraints: c.Constraints,
93
138
		Constraints:   c.Constraints,
133
		Jobs:        []params.MachineJob{params.JobHostUnits},
89
139
		Jobs:          []params.MachineJob{params.JobHostUnits},
94
140
	}
134
	}
95
141
	results, err := client.AddMachines([]params.AddMachineParams{machineParams})
135
	results, err := client.AddMachines([]params.AddMachineParams{machineParams})
96
136
	if params.IsCodeNotImplemented(err) {
97
137
		if c.Placement != nil {
98
138
			containerType, parseErr := instance.ParseContainerType(c.Placement.Scope)
99
139
			if parseErr != nil {
100
140
				// The user specified a non-container placement directive:
101
141
				// return original API not implemented error.
102
142
				return err
103
143
			}
104
144
			machineParams.ContainerType = containerType
105
145
			machineParams.ParentId = c.Placement.Directive
106
146
			machineParams.Placement = nil
107
147
		}
108
148
		logger.Infof(
109
149
			"AddMachinesWithPlacement not supported by the API server, " +
110
150
				"falling back to 1.18 compatibility mode",
111
151
		)
112
152
		results, err = client.AddMachines1dot18([]params.AddMachineParams{machineParams})
113
153
	}
114
142
	if err != nil {
154
	if err != nil {
115
143
		return err
155
		return err
116
144
	}
156
	}
117
157
118
145
	// Currently, only one machine is added, but in future there may be several added in one call.
158
	// Currently, only one machine is added, but in future there may be several added in one call.
119
146
	machineInfo := results[0]
159
	machineInfo := results[0]
120
147
	if machineInfo.Error != nil {
160
	if machineInfo.Error != nil {
121
148
		return machineInfo.Error
161
		return machineInfo.Error
122
149
	}
162
	}
123
150
	machineId := machineInfo.Machine
163
	machineId := machineInfo.Machine
126
151
	if c.ContainerType == "" {
164
127
152
		logger.Infof("created machine %v", machineId)
165
	if names.IsContainerMachine(machineId) {
128
166
		ctx.Infof("created container %v", machineId)
129
153
	} else {
167
	} else {
131
154
		logger.Infof("created %q container on machine %v", c.ContainerType, machineId)
168
		ctx.Infof("created machine %v", machineId)
132
155
	}
169
	}
133
156
	return nil
170
	return nil
134
157
}
171
}
135
158
172
136
=== modified file 'cmd/juju/addmachine_test.go'
137
--- cmd/juju/addmachine_test.go	2014-03-13 07:54:56 +0000
138
+++ cmd/juju/addmachine_test.go	2014-04-23 06:25:18 +0000
139
@@ -107,13 +107,17 @@
140
107
107
141
108
func (s *AddMachineSuite) TestAddMachineErrors(c *gc.C) {
108
func (s *AddMachineSuite) TestAddMachineErrors(c *gc.C) {
142
109
	err := runAddMachine(c, ":lxc")
109
	err := runAddMachine(c, ":lxc")
144
110
	c.Assert(err, gc.ErrorMatches, `malformed container argument ":lxc"`)
110
	c.Check(err, gc.ErrorMatches, `cannot add a new machine: :lxc placement is invalid`)
145
111
	err = runAddMachine(c, "lxc:")
111
	err = runAddMachine(c, "lxc:")
147
112
	c.Assert(err, gc.ErrorMatches, `malformed container argument "lxc:"`)
112
	c.Check(err, gc.ErrorMatches, `invalid value "" for "lxc" scope: expected machine-id`)
148
113
	err = runAddMachine(c, "2")
113
	err = runAddMachine(c, "2")
150
114
	c.Assert(err, gc.ErrorMatches, `malformed container argument "2"`)
114
	c.Check(err, gc.ErrorMatches, `machine-id cannot be specified when adding machines`)
151
115
	err = runAddMachine(c, "foo")
115
	err = runAddMachine(c, "foo")
153
116
	c.Assert(err, gc.ErrorMatches, `malformed container argument "foo"`)
116
	c.Check(err, gc.ErrorMatches, `cannot add a new machine: foo placement is invalid`)
154
117
	err = runAddMachine(c, "foo:bar")
155
118
	c.Check(err, gc.ErrorMatches, `invalid environment name "foo"`)
156
119
	err = runAddMachine(c, "dummyenv:invalid")
157
120
	c.Check(err, gc.ErrorMatches, `cannot add a new machine: invalid placement is invalid`)
158
117
	err = runAddMachine(c, "lxc", "--constraints", "container=lxc")
121
	err = runAddMachine(c, "lxc", "--constraints", "container=lxc")
160
118
	c.Assert(err, gc.ErrorMatches, `container constraint "lxc" not allowed when adding a machine`)
122
	c.Check(err, gc.ErrorMatches, `container constraint "lxc" not allowed when adding a machine`)
161
119
}
123
}
162
120
124
163
=== modified file 'environs/broker.go'
164
--- environs/broker.go	2014-04-18 16:37:28 +0000
165
+++ environs/broker.go	2014-04-23 06:25:18 +0000
166
@@ -25,6 +25,11 @@
167
25
	// MachineConfig describes the machine's configuration.
25
	// MachineConfig describes the machine's configuration.
168
26
	MachineConfig *cloudinit.MachineConfig
26
	MachineConfig *cloudinit.MachineConfig
169
27
27
170
28
	// Placement, if non-empty, contains an environment-specific
171
29
	// placement directive that may be used to decide how the
172
30
	// instance should be started.
173
31
	Placement string
174
32
175
28
	// DistributionGroup, if non-nil, is a function
33
	// DistributionGroup, if non-nil, is a function
176
29
	// that returns a slice of instance.Ids that belong
34
	// that returns a slice of instance.Ids that belong
177
30
	// to the same distribution group as the machine
35
	// to the same distribution group as the machine
178
31
36
179
=== modified file 'environs/jujutest/livetests.go'
180
--- environs/jujutest/livetests.go	2014-04-21 23:10:05 +0000
181
+++ environs/jujutest/livetests.go	2014-04-23 06:25:18 +0000
182
@@ -162,7 +162,8 @@
183
162
	if !ok {
162
	if !ok {
184
163
		return
163
		return
185
164
	}
164
	}
187
165
	err := prechecker.PrecheckInstance("precise", constraints.Value{})
165
	const placement = ""
188
166
	err := prechecker.PrecheckInstance("precise", constraints.Value{}, placement)
189
166
	c.Assert(err, gc.IsNil)
167
	c.Assert(err, gc.IsNil)
190
167
}
168
}
191
168
169
192
169
170
193
=== added file 'instance/placement.go'
194
--- instance/placement.go	1970-01-01 00:00:00 +0000
195
+++ instance/placement.go	2014-04-23 06:25:18 +0000
196
@@ -0,0 +1,85 @@
197
1
// Copyright 2014 Canonical Ltd.
198
2
// Licensed under the AGPLv3, see LICENCE file for details.
199
3
200
4
package instance
201
5
202
6
import (
203
7
	"fmt"
204
8
	"strings"
205
9
206
10
	"launchpad.net/juju-core/names"
207
11
)
208
12
209
13
const (
210
14
	// MachineScope is a special scope name that is used
211
15
	// for machine placement directives (e.g. --to 0).
212
16
	MachineScope = "#"
213
17
)
214
18
215
19
var ErrPlacementScopeMissing = fmt.Errorf("placement scope missing")
216
20
217
21
// Placement defines a placement directive, which has a scope
218
22
// and a value that is scope-specific.
219
23
type Placement struct {
220
24
	// Scope is the scope of the placement directive. Scope may
221
25
	// be a container type (lxc, kvm), instance.MachineScope, or
222
26
	// an environment name.
223
27
	//
224
28
	// If Scope is empty, then it must be inferred from the context.
225
29
	Scope string
226
30
227
31
	// Directive is a scope-specific placement idrective.
228
32
	//
229
33
	// For MachineScope or a container scope, this may be empty or
230
34
	// the ID of an existing machine.
231
35
	Directive string
232
36
}
233
37
234
38
func (p *Placement) String() string {
235
39
	return fmt.Sprintf("%s:%s", p.Scope, p.Directive)
236
40
}
237
41
238
42
func isContainerType(s string) bool {
239
43
	_, err := ParseContainerType(s)
240
44
	return err == nil
241
45
}
242
46
243
47
// ParsePlacement attempts to parse the specified string and create a
244
48
// corresponding Placement structure.
245
49
//
246
50
// If the placement directive is non-empty and missing a scope,
247
51
// ErrPlacementScopeMissing will be returned as well as a Placement
248
52
// with an empty Scope field.
249
53
func ParsePlacement(directive string) (*Placement, error) {
250
54
	if directive == "" {
251
55
		return nil, nil
252
56
	}
253
57
	if colon := strings.IndexRune(directive, ':'); colon != -1 {
254
58
		scope, directive := directive[:colon], directive[colon+1:]
255
59
		if scope == "" {
256
60
			return nil, ErrPlacementScopeMissing
257
61
		}
258
62
		// Sanity check: machine/container scopes require a machine ID as the value.
259
63
		if (scope == MachineScope || isContainerType(scope)) && !names.IsMachine(directive) {
260
64
			return nil, fmt.Errorf("invalid value %q for %q scope: expected machine-id", directive, scope)
261
65
		}
262
66
		return &Placement{Scope: scope, Directive: directive}, nil
263
67
	}
264
68
	if names.IsMachine(directive) {
265
69
		return &Placement{Scope: MachineScope, Directive: directive}, nil
266
70
	}
267
71
	if isContainerType(directive) {
268
72
		return &Placement{Scope: directive}, nil
269
73
	}
270
74
	return nil, ErrPlacementScopeMissing
271
75
}
272
76
273
77
// MustParsePlacement attempts to parse the specified string and create
274
78
// a corresponding Placement structure, panicking if an error occurs.
275
79
func MustParsePlacement(directive string) *Placement {
276
80
	placement, err := ParsePlacement(directive)
277
81
	if err != nil {
278
82
		panic(err)
279
83
	}
280
84
	return placement
281
85
}
282
0
86
283
=== added file 'instance/placement_test.go'
284
--- instance/placement_test.go	1970-01-01 00:00:00 +0000
285
+++ instance/placement_test.go	2014-04-23 06:25:18 +0000
286
@@ -0,0 +1,76 @@
287
1
// Copyright 2014 Canonical Ltd.
288
2
// Licensed under the AGPLv3, see LICENCE file for details.
289
3
290
4
package instance_test
291
5
292
6
import (
293
7
	gc "launchpad.net/gocheck"
294
8
295
9
	"launchpad.net/juju-core/instance"
296
10
)
297
11
298
12
type PlacementSuite struct{}
299
13
300
14
var _ = gc.Suite(&PlacementSuite{})
301
15
302
16
func (s *PlacementSuite) TestParsePlacement(c *gc.C) {
303
17
	parsePlacementTests := []struct {
304
18
		arg                          string
305
19
		expectScope, expectDirective string
306
20
		err                          string
307
21
	}{{
308
22
		arg: "",
309
23
	}, {
310
24
		arg:             "0",
311
25
		expectScope:     instance.MachineScope,
312
26
		expectDirective: "0",
313
27
	}, {
314
28
		arg:             "0/lxc/0",
315
29
		expectScope:     instance.MachineScope,
316
30
		expectDirective: "0/lxc/0",
317
31
	}, {
318
32
		arg: "#:x",
319
33
		err: `invalid value "x" for "#" scope: expected machine-id`,
320
34
	}, {
321
35
		arg: "lxc:x",
322
36
		err: `invalid value "x" for "lxc" scope: expected machine-id`,
323
37
	}, {
324
38
		arg: "kvm:x",
325
39
		err: `invalid value "x" for "kvm" scope: expected machine-id`,
326
40
	}, {
327
41
		arg:             "kvm:123",
328
42
		expectScope:     string(instance.KVM),
329
43
		expectDirective: "123",
330
44
	}, {
331
45
		arg:         "lxc",
332
46
		expectScope: string(instance.LXC),
333
47
	}, {
334
48
		arg: "non-standard",
335
49
		err: "placement scope missing",
336
50
	}, {
337
51
		arg: ":non-standard",
338
52
		err: "placement scope missing",
339
53
	}, {
340
54
		arg:             "non:standard",
341
55
		expectScope:     "non",
342
56
		expectDirective: "standard",
343
57
	}}
344
58
345
59
	for i, t := range parsePlacementTests {
346
60
		c.Logf("test %d: %s", i, t.arg)
347
61
		p, err := instance.ParsePlacement(t.arg)
348
62
		if t.err != "" {
349
63
			c.Assert(err, gc.ErrorMatches, t.err)
350
64
		} else {
351
65
			c.Assert(err, gc.IsNil)
352
66
		}
353
67
		if t.expectScope == "" && t.expectDirective == "" {
354
68
			c.Assert(p, gc.IsNil)
355
69
		} else {
356
70
			c.Assert(p, gc.DeepEquals, &instance.Placement{
357
71
				Scope:     t.expectScope,
358
72
				Directive: t.expectDirective,
359
73
			})
360
74
		}
361
75
	}
362
76
}
363
0
77
364
=== modified file 'names/machine.go'
365
--- names/machine.go	2013-11-25 05:03:44 +0000
366
+++ names/machine.go	2014-04-23 06:25:18 +0000
367
@@ -21,6 +21,11 @@
368
21
	return validMachine.MatchString(id)
21
	return validMachine.MatchString(id)
369
22
}
22
}
370
23
23
371
24
// IsMachine returns whether id is a valid container machine id.
372
25
func IsContainerMachine(id string) bool {
373
26
	return validMachine.MatchString(id) && strings.Contains(id, "/")
374
27
}
375
28
376
24
// MachineTag returns the tag for the machine with the given id.
29
// MachineTag returns the tag for the machine with the given id.
377
25
func MachineTag(id string) string {
30
func MachineTag(id string) string {
378
26
	tag := makeTag(MachineTagKind, id)
31
	tag := makeTag(MachineTagKind, id)
379
27
32
380
=== modified file 'names/machine_test.go'
381
--- names/machine_test.go	2013-08-06 09:20:36 +0000
382
+++ names/machine_test.go	2014-04-23 06:25:18 +0000
383
@@ -26,8 +26,9 @@
384
26
}
26
}
385
27
27
386
28
var machineIdTests = []struct {
28
var machineIdTests = []struct {
389
29
	pattern string
29
	pattern   string
390
30
	valid   bool
30
	valid     bool
391
31
	container bool
392
31
}{
32
}{
393
32
	{pattern: "42", valid: true},
33
	{pattern: "42", valid: true},
394
33
	{pattern: "042", valid: false},
34
	{pattern: "042", valid: false},
395
@@ -37,7 +38,7 @@
396
37
	{pattern: "55/", valid: false},
38
	{pattern: "55/", valid: false},
397
38
	{pattern: "1/foo", valid: false},
39
	{pattern: "1/foo", valid: false},
398
39
	{pattern: "2/foo/", valid: false},
40
	{pattern: "2/foo/", valid: false},
400
40
	{pattern: "3/lxc/42", valid: true},
41
	{pattern: "3/lxc/42", valid: true, container: true},
401
41
	{pattern: "3/lxc-nodash/42", valid: false},
42
	{pattern: "3/lxc-nodash/42", valid: false},
402
42
	{pattern: "0/lxc/00", valid: false},
43
	{pattern: "0/lxc/00", valid: false},
403
43
	{pattern: "0/lxc/0/", valid: false},
44
	{pattern: "0/lxc/0/", valid: false},
404
@@ -45,7 +46,7 @@
405
45
	{pattern: "3/lxc/042", valid: false},
46
	{pattern: "3/lxc/042", valid: false},
406
46
	{pattern: "4/foo/bar", valid: false},
47
	{pattern: "4/foo/bar", valid: false},
407
47
	{pattern: "5/lxc/42/foo", valid: false},
48
	{pattern: "5/lxc/42/foo", valid: false},
409
48
	{pattern: "6/lxc/42/kvm/0", valid: true},
49
	{pattern: "6/lxc/42/kvm/0", valid: true, container: true},
410
49
	{pattern: "06/lxc/42/kvm/0", valid: false},
50
	{pattern: "06/lxc/42/kvm/0", valid: false},
411
50
	{pattern: "6/lxc/042/kvm/0", valid: false},
51
	{pattern: "6/lxc/042/kvm/0", valid: false},
412
51
	{pattern: "6/lxc/42/kvm/00", valid: false},
52
	{pattern: "6/lxc/42/kvm/00", valid: false},
413
@@ -56,5 +57,6 @@
414
56
	for i, test := range machineIdTests {
57
	for i, test := range machineIdTests {
415
57
		c.Logf("test %d: %q", i, test.pattern)
58
		c.Logf("test %d: %q", i, test.pattern)
416
58
		c.Assert(names.IsMachine(test.pattern), gc.Equals, test.valid)
59
		c.Assert(names.IsMachine(test.pattern), gc.Equals, test.valid)
417
60
		c.Assert(names.IsContainerMachine(test.pattern), gc.Equals, test.container)
418
59
	}
61
	}
419
60
}
62
}
420
61
63
421
=== modified file 'provider/azure/environ.go'
422
--- provider/azure/environ.go	2014-04-21 23:50:20 +0000
423
+++ provider/azure/environ.go	2014-04-23 06:25:18 +0000
424
@@ -434,7 +434,10 @@
425
434
}
434
}
426
435
435
427
436
// PrecheckInstance is defined on the state.Prechecker interface.
436
// PrecheckInstance is defined on the state.Prechecker interface.
429
437
func (env *azureEnviron) PrecheckInstance(series string, cons constraints.Value) error {
437
func (env *azureEnviron) PrecheckInstance(series string, cons constraints.Value, placement string) error {
430
438
	if placement != "" {
431
439
		return fmt.Errorf("unknown placement directive: %s", placement)
432
440
	}
433
438
	if !cons.HasInstanceType() {
441
	if !cons.HasInstanceType() {
434
439
		return nil
442
		return nil
435
440
	}
443
	}
436
441
444
437
=== modified file 'provider/azure/instancetype_test.go'
438
--- provider/azure/instancetype_test.go	2014-04-17 06:44:49 +0000
439
+++ provider/azure/instancetype_test.go	2014-04-23 06:25:18 +0000
440
@@ -449,13 +449,15 @@
441
449
func (s *instanceTypeSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
449
func (s *instanceTypeSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
442
450
	env := s.setupEnvWithDummyMetadata(c)
450
	env := s.setupEnvWithDummyMetadata(c)
443
451
	cons := constraints.MustParse("instance-type=Large")
451
	cons := constraints.MustParse("instance-type=Large")
445
452
	err := env.PrecheckInstance("precise", cons)
452
	placement := ""
446
453
	err := env.PrecheckInstance("precise", cons, placement)
447
453
	c.Assert(err, gc.IsNil)
454
	c.Assert(err, gc.IsNil)
448
454
}
455
}
449
455
456
450
456
func (s *instanceTypeSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
457
func (s *instanceTypeSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
451
457
	env := s.setupEnvWithDummyMetadata(c)
458
	env := s.setupEnvWithDummyMetadata(c)
452
458
	cons := constraints.MustParse("instance-type=Super")
459
	cons := constraints.MustParse("instance-type=Super")
454
459
	err := env.PrecheckInstance("precise", cons)
460
	placement := ""
455
461
	err := env.PrecheckInstance("precise", cons, placement)
456
460
	c.Assert(err, gc.ErrorMatches, `invalid Azure instance "Super" specified`)
462
	c.Assert(err, gc.ErrorMatches, `invalid Azure instance "Super" specified`)
457
461
}
463
}
458
462
464
459
=== modified file 'provider/common/policies.go'
460
--- provider/common/policies.go	2014-04-17 03:10:18 +0000
461
+++ provider/common/policies.go	2014-04-23 06:25:18 +0000
462
@@ -3,11 +3,6 @@
463
3
3
464
4
package common
4
package common
465
5
5
466
6
import (
467
7
	"launchpad.net/juju-core/constraints"
468
8
	"launchpad.net/juju-core/state"
469
9
)
470
10
471
11
// SupportsUnitPlacementPolicy provides an
6
// SupportsUnitPlacementPolicy provides an
472
12
// implementation of SupportsUnitPlacement
7
// implementation of SupportsUnitPlacement
473
13
// that never returns an error, and is
8
// that never returns an error, and is
474
@@ -18,13 +13,3 @@
475
18
func (*SupportsUnitPlacementPolicy) SupportsUnitPlacement() error {
13
func (*SupportsUnitPlacementPolicy) SupportsUnitPlacement() error {
476
19
	return nil
14
	return nil
477
20
}
15
}
478
21
479
22
// NopPrecheckerPolicy provides an implementation of the
480
23
// state.Prechecker interface that passes all checks.
481
24
type NopPrecheckerPolicy struct{}
482
25
483
26
var _ state.Prechecker = (*NopPrecheckerPolicy)(nil)
484
27
485
28
func (*NopPrecheckerPolicy) PrecheckInstance(series string, cons constraints.Value) error {
486
29
	return nil
487
30
}
488
31
16
489
=== modified file 'provider/dummy/environs.go'
490
--- provider/dummy/environs.go	2014-04-21 23:10:05 +0000
491
+++ provider/dummy/environs.go	2014-04-23 06:25:18 +0000
492
@@ -184,7 +184,6 @@
493
184
// environ represents a client's connection to a given environment's
184
// environ represents a client's connection to a given environment's
494
185
// state.
185
// state.
495
186
type environ struct {
186
type environ struct {
496
187
	common.NopPrecheckerPolicy
497
188
	common.SupportsUnitPlacementPolicy
187
	common.SupportsUnitPlacementPolicy
498
189
188
499
190
	name         string
189
	name         string
500
@@ -543,6 +542,14 @@
501
543
	return true
542
	return true
502
544
}
543
}
503
545
544
504
545
// PrecheckInstance is specified in the state.Prechecker interface.
505
546
func (*environ) PrecheckInstance(series string, cons constraints.Value, placement string) error {
506
547
	if placement != "" && placement != "valid" {
507
548
		return fmt.Errorf("%s placement is invalid", placement)
508
549
	}
509
550
	return nil
510
551
}
511
552
512
546
// GetImageSources returns a list of sources which are used to search for simplestreams image metadata.
553
// GetImageSources returns a list of sources which are used to search for simplestreams image metadata.
513
547
func (e *environ) GetImageSources() ([]simplestreams.DataSource, error) {
554
func (e *environ) GetImageSources() ([]simplestreams.DataSource, error) {
514
548
	return []simplestreams.DataSource{
555
	return []simplestreams.DataSource{
515
549
556
516
=== modified file 'provider/ec2/ec2.go'
517
--- provider/ec2/ec2.go	2014-04-21 23:50:20 +0000
518
+++ provider/ec2/ec2.go	2014-04-23 06:25:18 +0000
519
@@ -385,7 +385,10 @@
520
385
}
385
}
521
386
386
522
387
// PrecheckInstance is defined on the state.Prechecker interface.
387
// PrecheckInstance is defined on the state.Prechecker interface.
524
388
func (e *environ) PrecheckInstance(series string, cons constraints.Value) error {
388
func (e *environ) PrecheckInstance(series string, cons constraints.Value, placement string) error {
525
389
	if placement != "" {
526
390
		return fmt.Errorf("unknown placement directive: %s", placement)
527
391
	}
528
389
	if !cons.HasInstanceType() {
392
	if !cons.HasInstanceType() {
529
390
		return nil
393
		return nil
530
391
	}
394
	}
531
392
395
532
=== modified file 'provider/ec2/local_test.go'
533
--- provider/ec2/local_test.go	2014-04-18 13:51:46 +0000
534
+++ provider/ec2/local_test.go	2014-04-23 06:25:18 +0000
535
@@ -381,21 +381,24 @@
536
381
func (t *localServerSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
381
func (t *localServerSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
537
382
	env := t.Prepare(c)
382
	env := t.Prepare(c)
538
383
	cons := constraints.MustParse("instance-type=m1.small root-disk=1G")
383
	cons := constraints.MustParse("instance-type=m1.small root-disk=1G")
540
384
	err := env.PrecheckInstance("precise", cons)
384
	placement := ""
541
385
	err := env.PrecheckInstance("precise", cons, placement)
542
385
	c.Assert(err, gc.IsNil)
386
	c.Assert(err, gc.IsNil)
543
386
}
387
}
544
387
388
545
388
func (t *localServerSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
389
func (t *localServerSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
546
389
	env := t.Prepare(c)
390
	env := t.Prepare(c)
547
390
	cons := constraints.MustParse("instance-type=m1.invalid")
391
	cons := constraints.MustParse("instance-type=m1.invalid")
549
391
	err := env.PrecheckInstance("precise", cons)
392
	placement := ""
550
393
	err := env.PrecheckInstance("precise", cons, placement)
551
392
	c.Assert(err, gc.ErrorMatches, `invalid AWS instance type "m1.invalid" specified`)
394
	c.Assert(err, gc.ErrorMatches, `invalid AWS instance type "m1.invalid" specified`)
552
393
}
395
}
553
394
396
554
395
func (t *localServerSuite) TestPrecheckInstanceUnsupportedArch(c *gc.C) {
397
func (t *localServerSuite) TestPrecheckInstanceUnsupportedArch(c *gc.C) {
555
396
	env := t.Prepare(c)
398
	env := t.Prepare(c)
556
397
	cons := constraints.MustParse("instance-type=cc1.4xlarge arch=i386")
399
	cons := constraints.MustParse("instance-type=cc1.4xlarge arch=i386")
558
398
	err := env.PrecheckInstance("precise", cons)
400
	placement := ""
559
401
	err := env.PrecheckInstance("precise", cons, placement)
560
399
	c.Assert(err, gc.ErrorMatches, `invalid AWS instance type "cc1.4xlarge" and arch "i386" specified`)
402
	c.Assert(err, gc.ErrorMatches, `invalid AWS instance type "cc1.4xlarge" and arch "i386" specified`)
561
400
}
403
}
562
401
404
563
402
405
564
=== modified file 'provider/joyent/environ.go'
565
--- provider/joyent/environ.go	2014-04-17 06:53:42 +0000
566
+++ provider/joyent/environ.go	2014-04-23 06:25:18 +0000
567
@@ -76,7 +76,10 @@
568
76
}
76
}
569
77
77
570
78
// PrecheckInstance is defined on the state.Prechecker interface.
78
// PrecheckInstance is defined on the state.Prechecker interface.
572
79
func (env *joyentEnviron) PrecheckInstance(series string, cons constraints.Value) error {
79
func (env *joyentEnviron) PrecheckInstance(series string, cons constraints.Value, placement string) error {
573
80
	if placement != "" {
574
81
		return fmt.Errorf("unknown placement directive: %s", placement)
575
82
	}
576
80
	if !cons.HasInstanceType() {
83
	if !cons.HasInstanceType() {
577
81
		return nil
84
		return nil
578
82
	}
85
	}
579
83
86
580
=== modified file 'provider/local/environ.go'
581
--- provider/local/environ.go	2014-04-21 23:10:05 +0000
582
+++ provider/local/environ.go	2014-04-23 06:25:18 +0000
583
@@ -58,7 +58,6 @@
584
58
var _ envtools.SupportsCustomSources = (*localEnviron)(nil)
58
var _ envtools.SupportsCustomSources = (*localEnviron)(nil)
585
59
59
586
60
type localEnviron struct {
60
type localEnviron struct {
587
61
	common.NopPrecheckerPolicy
588
62
	common.SupportsUnitPlacementPolicy
61
	common.SupportsUnitPlacementPolicy
589
63
62
590
64
	localMutex       sync.Mutex
63
	localMutex       sync.Mutex
591
@@ -88,6 +87,13 @@
592
88
	return false
87
	return false
593
89
}
88
}
594
90
89
595
90
func (*localEnviron) PrecheckInstance(series string, cons constraints.Value, placement string) error {
596
91
	if placement != "" {
597
92
		return fmt.Errorf("unknown placement directive: %s", placement)
598
93
	}
599
94
	return nil
600
95
}
601
96
602
91
// Name is specified in the Environ interface.
97
// Name is specified in the Environ interface.
603
92
func (env *localEnviron) Name() string {
98
func (env *localEnviron) Name() string {
604
93
	return env.name
99
	return env.name
605
94
100
606
=== modified file 'provider/maas/environ.go'
607
--- provider/maas/environ.go	2014-04-21 23:10:05 +0000
608
+++ provider/maas/environ.go	2014-04-23 06:25:18 +0000
609
@@ -51,7 +51,6 @@
610
51
}
51
}
611
52
52
612
53
type maasEnviron struct {
53
type maasEnviron struct {
613
54
	common.NopPrecheckerPolicy
614
55
	common.SupportsUnitPlacementPolicy
54
	common.SupportsUnitPlacementPolicy
615
56
55
616
57
	name string
56
	name string
617
@@ -171,6 +170,15 @@
618
171
	return caps.Contains(capNetworksManagement)
170
	return caps.Contains(capNetworksManagement)
619
172
}
171
}
620
173
172
621
173
func (env *maasEnviron) PrecheckInstance(series string, cons constraints.Value, placement string) error {
622
174
	// TODO(axw) 2014-04-22 #1237709
623
175
	// Handle maas-name placement directive.
624
176
	if placement != "" {
625
177
		return fmt.Errorf("unknown placement directive: %s", placement)
626
178
	}
627
179
	return nil
628
180
}
629
181
630
174
const capNetworksManagement = "networks-management"
182
const capNetworksManagement = "networks-management"
631
175
183
632
176
// getCapabilities asks the MAAS server for its capabilities, if
184
// getCapabilities asks the MAAS server for its capabilities, if
633
177
185
634
=== modified file 'provider/manual/environ.go'
635
--- provider/manual/environ.go	2014-04-21 23:10:05 +0000
636
+++ provider/manual/environ.go	2014-04-23 06:25:18 +0000
637
@@ -61,7 +61,6 @@
638
61
}
61
}
639
62
62
640
63
var _ envtools.SupportsCustomSources = (*manualEnviron)(nil)
63
var _ envtools.SupportsCustomSources = (*manualEnviron)(nil)
641
64
var _ state.Prechecker = (*manualEnviron)(nil)
642
65
64
643
66
var errNoStartInstance = errors.New("manual provider cannot start instances")
65
var errNoStartInstance = errors.New("manual provider cannot start instances")
644
67
var errNoStopInstance = errors.New("manual provider cannot stop instances")
66
var errNoStopInstance = errors.New("manual provider cannot stop instances")
645
@@ -262,7 +261,7 @@
646
262
	return err
261
	return err
647
263
}
262
}
648
264
263
650
265
func (*manualEnviron) PrecheckInstance(series string, cons constraints.Value) error {
264
func (*manualEnviron) PrecheckInstance(series string, _ constraints.Value, placement string) error {
651
266
	return errors.New(`use "juju add-machine ssh:[user@]<host>" to provision machines`)
265
	return errors.New(`use "juju add-machine ssh:[user@]<host>" to provision machines`)
652
267
}
266
}
653
268
267
654
269
268
655
=== modified file 'provider/openstack/local_test.go'
656
--- provider/openstack/local_test.go	2014-04-21 23:50:20 +0000
657
+++ provider/openstack/local_test.go	2014-04-23 06:25:18 +0000
658
@@ -716,14 +716,16 @@
659
716
func (s *localServerSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
716
func (s *localServerSuite) TestPrecheckInstanceValidInstanceType(c *gc.C) {
660
717
	env := s.Open(c)
717
	env := s.Open(c)
661
718
	cons := constraints.MustParse("instance-type=m1.small")
718
	cons := constraints.MustParse("instance-type=m1.small")
663
719
	err := env.PrecheckInstance("precise", cons)
719
	placement := ""
664
720
	err := env.PrecheckInstance("precise", cons, placement)
665
720
	c.Assert(err, gc.IsNil)
721
	c.Assert(err, gc.IsNil)
666
721
}
722
}
667
722
723
668
723
func (s *localServerSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
724
func (s *localServerSuite) TestPrecheckInstanceInvalidInstanceType(c *gc.C) {
669
724
	env := s.Open(c)
725
	env := s.Open(c)
670
725
	cons := constraints.MustParse("instance-type=m1.large")
726
	cons := constraints.MustParse("instance-type=m1.large")
672
726
	err := env.PrecheckInstance("precise", cons)
727
	placement := ""
673
728
	err := env.PrecheckInstance("precise", cons, placement)
674
727
	c.Assert(err, gc.ErrorMatches, `invalid Openstack flavour "m1.large" specified`)
729
	c.Assert(err, gc.ErrorMatches, `invalid Openstack flavour "m1.large" specified`)
675
728
}
730
}
676
729
731
677
730
732
678
=== modified file 'provider/openstack/provider.go'
679
--- provider/openstack/provider.go	2014-04-21 23:50:20 +0000
680
+++ provider/openstack/provider.go	2014-04-23 06:25:18 +0000
681
@@ -538,7 +538,10 @@
682
538
}
538
}
683
539
539
684
540
// PrecheckInstance is defined on the state.Prechecker interface.
540
// PrecheckInstance is defined on the state.Prechecker interface.
686
541
func (e *environ) PrecheckInstance(series string, cons constraints.Value) error {
541
func (e *environ) PrecheckInstance(series string, cons constraints.Value, placement string) error {
687
542
	if placement != "" {
688
543
		return fmt.Errorf("unknown placement directive: %s", placement)
689
544
	}
690
542
	if !cons.HasInstanceType() {
545
	if !cons.HasInstanceType() {
691
543
		return nil
546
		return nil
692
544
	}
547
	}
693
545
548
694
=== modified file 'state/addmachine.go'
695
--- state/addmachine.go	2014-04-21 23:10:05 +0000
696
+++ state/addmachine.go	2014-04-23 06:25:18 +0000
697
@@ -69,6 +69,10 @@
698
69
	// as unclean for unit-assignment purposes.
69
	// as unclean for unit-assignment purposes.
699
70
	Dirty bool
70
	Dirty bool
700
71
71
701
72
	// Placement holds the placement directive that will be associated
702
73
	// with the machine.
703
74
	Placement string
704
75
705
72
	// principals holds the principal units that will
76
	// principals holds the principal units that will
706
73
	// associated with the machine.
77
	// associated with the machine.
707
74
	principals []string
78
	principals []string
708
@@ -234,7 +238,7 @@
709
234
		return nil, nil, err
238
		return nil, nil, err
710
235
	}
239
	}
711
236
	if template.InstanceId == "" {
240
	if template.InstanceId == "" {
713
237
		if err := st.precheckInstance(template.Series, template.Constraints); err != nil {
241
		if err := st.precheckInstance(template.Series, template.Constraints, template.Placement); err != nil {
714
238
			return nil, nil, err
242
			return nil, nil, err
715
239
		}
243
		}
716
240
	}
244
	}
717
@@ -359,13 +363,13 @@
718
359
		return nil, nil, fmt.Errorf("no container type specified")
363
		return nil, nil, fmt.Errorf("no container type specified")
719
360
	}
364
	}
720
361
	if parentTemplate.InstanceId == "" {
365
	if parentTemplate.InstanceId == "" {
721
362
		if err := st.precheckInstance(parentTemplate.Series, parentTemplate.Constraints); err != nil {
722
363
			return nil, nil, err
723
364
		}
724
365
		// Adding a machine within a machine implies add-machine or placement.
366
		// Adding a machine within a machine implies add-machine or placement.
725
366
		if err := st.supportsUnitPlacement(); err != nil {
367
		if err := st.supportsUnitPlacement(); err != nil {
726
367
			return nil, nil, err
368
			return nil, nil, err
727
368
		}
369
		}
728
370
		if err := st.precheckInstance(parentTemplate.Series, parentTemplate.Constraints, parentTemplate.Placement); err != nil {
729
371
			return nil, nil, err
730
372
		}
731
369
	}
373
	}
732
370
374
733
371
	parentDoc := machineDocForTemplate(parentTemplate, strconv.Itoa(seq))
375
	parentDoc := machineDocForTemplate(parentTemplate, strconv.Itoa(seq))
734
@@ -403,6 +407,7 @@
735
403
		Nonce:      template.Nonce,
407
		Nonce:      template.Nonce,
736
404
		Addresses:  instanceAddressesToAddresses(template.Addresses),
408
		Addresses:  instanceAddressesToAddresses(template.Addresses),
737
405
		NoVote:     template.NoVote,
409
		NoVote:     template.NoVote,
738
410
		Placement:  template.Placement,
739
406
	}
411
	}
740
407
}
412
}
741
408
413
742
409
414
743
=== modified file 'state/api/client.go'
744
--- state/api/client.go	2014-04-17 19:01:44 +0000
745
+++ state/api/client.go	2014-04-23 06:25:18 +0000
746
@@ -227,13 +227,26 @@
747
227
	return results.CharmRelations, err
227
	return results.CharmRelations, err
748
228
}
228
}
749
229
229
750
230
// AddMachines1dot18 adds new machines with the supplied parameters.
751
231
//
752
232
// TODO(axw) 2014-04-11 #XXX
753
233
// This exists for backwards compatibility; remove in 1.21 (client only).
754
234
func (c *Client) AddMachines1dot18(machineParams []params.AddMachineParams) ([]params.AddMachinesResult, error) {
755
235
	args := params.AddMachines{
756
236
		MachineParams: machineParams,
757
237
	}
758
238
	results := new(params.AddMachinesResults)
759
239
	err := c.call("AddMachines", args, results)
760
240
	return results.Machines, err
761
241
}
762
242
763
230
// AddMachines adds new machines with the supplied parameters.
243
// AddMachines adds new machines with the supplied parameters.
764
231
func (c *Client) AddMachines(machineParams []params.AddMachineParams) ([]params.AddMachinesResult, error) {
244
func (c *Client) AddMachines(machineParams []params.AddMachineParams) ([]params.AddMachinesResult, error) {
765
232
	args := params.AddMachines{
245
	args := params.AddMachines{
766
233
		MachineParams: machineParams,
246
		MachineParams: machineParams,
767
234
	}
247
	}
768
235
	results := new(params.AddMachinesResults)
248
	results := new(params.AddMachinesResults)
770
236
	err := c.call("AddMachines", args, results)
249
	err := c.call("AddMachinesV2", args, results)
771
237
	return results.Machines, err
250
	return results.Machines, err
772
238
}
251
}
773
239
252
774
240
253
775
=== modified file 'state/api/params/internal.go'
776
--- state/api/params/internal.go	2014-04-18 16:37:28 +0000
777
+++ state/api/params/internal.go	2014-04-23 06:25:18 +0000
778
@@ -599,3 +599,23 @@
779
599
type AgentVersionResult struct {
599
type AgentVersionResult struct {
780
600
	Version version.Number
600
	Version version.Number
781
601
}
601
}
782
602
783
603
// ProvisioningInfo holds machine provisioning info.
784
604
type ProvisioningInfo struct {
785
605
	Constraints     constraints.Value
786
606
	Series          string
787
607
	Placement       string
788
608
	IncludeNetworks []string
789
609
	ExcludeNetworks []string
790
610
}
791
611
792
612
// ProvisioningInfoResult holds machine provisioning info or an error.
793
613
type ProvisioningInfoResult struct {
794
614
	Error  *Error
795
615
	Result *ProvisioningInfo
796
616
}
797
617
798
618
// ProvisioningInfoResults holds multiple machine provisioning info results.
799
619
type ProvisioningInfoResults struct {
800
620
	Results []ProvisioningInfoResult
801
621
}
802
602
622
803
=== modified file 'state/api/params/params.go'
804
--- state/api/params/params.go	2014-04-12 05:53:58 +0000
805
+++ state/api/params/params.go	2014-04-23 06:25:18 +0000
806
@@ -92,6 +92,10 @@
807
92
	Constraints constraints.Value
92
	Constraints constraints.Value
808
93
	Jobs        []MachineJob
93
	Jobs        []MachineJob
809
94
94
810
95
	// If Placement is non-nil, it contains a placement directive
811
96
	// that will be used to decide how to instantiate the machine.
812
97
	Placement *instance.Placement
813
98
814
95
	// If ParentId is non-empty, it specifies the id of the
99
	// If ParentId is non-empty, it specifies the id of the
815
96
	// parent machine within which the new machine will
100
	// parent machine within which the new machine will
816
97
	// be created. In that case, ContainerType must also be
101
	// be created. In that case, ContainerType must also be
817
@@ -117,7 +121,8 @@
818
117
	Addrs                   []instance.Address
121
	Addrs                   []instance.Address
819
118
}
122
}
820
119
123
822
120
// AddMachines holds the parameters for making the AddMachines call.
124
// AddMachines holds the parameters for making the
823
125
// AddMachinesWithPlacement call.
824
121
type AddMachines struct {
126
type AddMachines struct {
825
122
	MachineParams []AddMachineParams
127
	MachineParams []AddMachineParams
826
123
}
128
}
827
124
129
828
=== modified file 'state/api/provisioner/machine.go'
829
--- state/api/provisioner/machine.go	2014-04-13 11:06:42 +0000
830
+++ state/api/provisioner/machine.go	2014-04-23 06:25:18 +0000
831
@@ -7,7 +7,6 @@
832
7
	"errors"
7
	"errors"
833
8
	"fmt"
8
	"fmt"
834
9
9
835
10
	"launchpad.net/juju-core/constraints"
836
11
	"launchpad.net/juju-core/instance"
10
	"launchpad.net/juju-core/instance"
837
12
	"launchpad.net/juju-core/names"
11
	"launchpad.net/juju-core/names"
838
13
	"launchpad.net/juju-core/state/api/params"
12
	"launchpad.net/juju-core/state/api/params"
839
@@ -55,23 +54,22 @@
840
55
	return nil
54
	return nil
841
56
}
55
}
842
57
56
847
58
// RequestedNetworks returns a pair of lists of networks to
57
// ProvisioningInfo returns the information required to provisiong a machine.
848
59
// enable/disable on the machine.
58
func (m *Machine) ProvisioningInfo() (*params.ProvisioningInfo, error) {
849
60
func (m *Machine) RequestedNetworks() (includeNetworks, excludeNetworks []string, err error) {
59
	var results params.ProvisioningInfoResults
846
61
	var results params.RequestedNetworksResults
850
62
	args := params.Entities{Entities: []params.Entity{{m.tag}}}
60
	args := params.Entities{Entities: []params.Entity{{m.tag}}}
852
63
	err = m.st.call("RequestedNetworks", args, &results)
61
	err := m.st.call("ProvisioningInfo", args, &results)
853
64
	if err != nil {
62
	if err != nil {
855
65
		return nil, nil, err
63
		return nil, err
856
66
	}
64
	}
857
67
	if len(results.Results) != 1 {
65
	if len(results.Results) != 1 {
859
68
		return nil, nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
66
		return nil, fmt.Errorf("expected 1 result, got %d", len(results.Results))
860
69
	}
67
	}
861
70
	result := results.Results[0]
68
	result := results.Results[0]
862
71
	if result.Error != nil {
69
	if result.Error != nil {
864
72
		return nil, nil, result.Error
70
		return nil, result.Error
865
73
	}
71
	}
867
74
	return result.IncludeNetworks, result.ExcludeNetworks, nil
72
	return result.Result, nil
868
75
}
73
}
869
76
74
870
77
// SetStatus sets the status of the machine.
75
// SetStatus sets the status of the machine.
871
@@ -109,28 +107,6 @@
872
109
	return result.Status, result.Info, nil
107
	return result.Status, result.Info, nil
873
110
}
108
}
874
111
109
875
112
// Constraints returns the exact constraints that should apply when provisioning
876
113
// an instance for the machine.
877
114
func (m *Machine) Constraints() (constraints.Value, error) {
878
115
	nothing := constraints.Value{}
879
116
	var results params.ConstraintsResults
880
117
	args := params.Entities{
881
118
		Entities: []params.Entity{{Tag: m.tag}},
882
119
	}
883
120
	err := m.st.call("Constraints", args, &results)
884
121
	if err != nil {
885
122
		return nothing, err
886
123
	}
887
124
	if len(results.Results) != 1 {
888
125
		return nothing, fmt.Errorf("expected 1 result, got %d", len(results.Results))
889
126
	}
890
127
	result := results.Results[0]
891
128
	if result.Error != nil {
892
129
		return nothing, result.Error
893
130
	}
894
131
	return result.Constraints, nil
895
132
}
896
133
897
134
// EnsureDead sets the machine lifecycle to Dead if it is Alive or
110
// EnsureDead sets the machine lifecycle to Dead if it is Alive or
898
135
// Dying. It does nothing otherwise.
111
// Dying. It does nothing otherwise.
899
136
func (m *Machine) EnsureDead() error {
112
func (m *Machine) EnsureDead() error {
900
137
113
901
=== modified file 'state/api/provisioner/provisioner_test.go'
902
--- state/api/provisioner/provisioner_test.go	2014-04-18 15:31:56 +0000
903
+++ state/api/provisioner/provisioner_test.go	2014-04-23 06:25:18 +0000
904
@@ -388,55 +388,41 @@
905
388
	c.Assert(err, jc.Satisfies, params.IsCodeNotFound)
388
	c.Assert(err, jc.Satisfies, params.IsCodeNotFound)
906
389
}
389
}
907
390
390
934
391
func (s *provisionerSuite) TestConstraints(c *gc.C) {
391
func (s *provisionerSuite) TestProvisioningInfo(c *gc.C) {
909
392
	// Create a fresh machine with some constraints.
910
393
	template := state.MachineTemplate{
911
394
		Series:      "quantal",
912
395
		Jobs:        []state.MachineJob{state.JobHostUnits},
913
396
		Constraints: constraints.MustParse("cpu-cores=12", "mem=8G"),
914
397
	}
915
398
	consMachine, err := s.State.AddOneMachine(template)
916
399
	c.Assert(err, gc.IsNil)
917
400
918
401
	apiMachine, err := s.provisioner.Machine(consMachine.Tag())
919
402
	c.Assert(err, gc.IsNil)
920
403
	cons, err := apiMachine.Constraints()
921
404
	c.Assert(err, gc.IsNil)
922
405
	c.Assert(cons, gc.DeepEquals, template.Constraints)
923
406
924
407
	// Now try machine 0.
925
408
	apiMachine, err = s.provisioner.Machine(s.machine.Tag())
926
409
	c.Assert(err, gc.IsNil)
927
410
	cons, err = apiMachine.Constraints()
928
411
	c.Assert(err, gc.IsNil)
929
412
	c.Assert(cons, gc.DeepEquals, constraints.Value{})
930
413
}
931
414
932
415
func (s *provisionerSuite) TestRequestedNetworks(c *gc.C) {
933
416
	// Create a fresh machine with some requested networks.
935
417
	template := state.MachineTemplate{
392
	template := state.MachineTemplate{
936
418
		Series:          "quantal",
393
		Series:          "quantal",
937
419
		Jobs:            []state.MachineJob{state.JobHostUnits},
394
		Jobs:            []state.MachineJob{state.JobHostUnits},
938
395
		Placement:       "valid",
939
396
		Constraints:     constraints.MustParse("cpu-cores=12", "mem=8G"),
940
420
		IncludeNetworks: []string{"net1", "net2"},
397
		IncludeNetworks: []string{"net1", "net2"},
941
421
		ExcludeNetworks: []string{"net3", "net4"},
398
		ExcludeNetworks: []string{"net3", "net4"},
942
422
	}
399
	}
960
423
	netsMachine, err := s.State.AddOneMachine(template)
400
	machine, err := s.State.AddOneMachine(template)
961
424
	c.Assert(err, gc.IsNil)
401
	c.Assert(err, gc.IsNil)
962
425
402
	apiMachine, err := s.provisioner.Machine(machine.Tag())
963
426
	apiMachine, err := s.provisioner.Machine(netsMachine.Tag())
403
	c.Assert(err, gc.IsNil)
964
427
	c.Assert(err, gc.IsNil)
404
	provisioningInfo, err := apiMachine.ProvisioningInfo()
965
428
	includeNetworks, excludeNetworks, err := apiMachine.RequestedNetworks()
405
	c.Assert(err, gc.IsNil)
966
429
	c.Assert(err, gc.IsNil)
406
	c.Assert(provisioningInfo.Series, gc.Equals, template.Series)
967
430
	c.Assert(includeNetworks, gc.DeepEquals, template.IncludeNetworks)
407
	c.Assert(provisioningInfo.Placement, gc.Equals, template.Placement)
968
431
	c.Assert(excludeNetworks, gc.DeepEquals, template.ExcludeNetworks)
408
	c.Assert(provisioningInfo.Constraints, gc.DeepEquals, template.Constraints)
969
432
409
	c.Assert(provisioningInfo.IncludeNetworks, gc.DeepEquals, template.IncludeNetworks)
970
433
	// Now try machine 0.
410
	c.Assert(provisioningInfo.ExcludeNetworks, gc.DeepEquals, template.ExcludeNetworks)
971
434
	apiMachine, err = s.provisioner.Machine(s.machine.Tag())
411
}
972
435
	c.Assert(err, gc.IsNil)
412
973
436
	includeNetworks, excludeNetworks, err = apiMachine.RequestedNetworks()
413
func (s *provisionerSuite) TestProvisioningInfoMachineNotFound(c *gc.C) {
974
437
	c.Assert(err, gc.IsNil)
414
	stateMachine, err := s.State.AddMachine("quantal", state.JobHostUnits)
975
438
	c.Assert(includeNetworks, gc.HasLen, 0)
415
	c.Assert(err, gc.IsNil)
976
439
	c.Assert(excludeNetworks, gc.HasLen, 0)
416
	apiMachine, err := s.provisioner.Machine(stateMachine.Tag())
977
417
	c.Assert(err, gc.IsNil)
978
418
	err = apiMachine.EnsureDead()
979
419
	c.Assert(err, gc.IsNil)
980
420
	err = apiMachine.Remove()
981
421
	c.Assert(err, gc.IsNil)
982
422
	_, err = apiMachine.ProvisioningInfo()
983
423
	c.Assert(err, gc.ErrorMatches, "machine 1 not found")
984
424
	c.Assert(err, jc.Satisfies, params.IsCodeNotFound)
985
425
	// auth tests in apiserver
986
440
}
426
}
987
441
427
988
442
func (s *provisionerSuite) TestWatchContainers(c *gc.C) {
428
func (s *provisionerSuite) TestWatchContainers(c *gc.C) {
989
443
429
990
=== modified file 'state/apiserver/client/client.go'
991
--- state/apiserver/client/client.go	2014-04-17 12:53:23 +0000
992
+++ state/apiserver/client/client.go	2014-04-23 06:25:18 +0000
993
@@ -587,6 +587,11 @@
994
587
587
995
588
// AddMachines adds new machines with the supplied parameters.
588
// AddMachines adds new machines with the supplied parameters.
996
589
func (c *Client) AddMachines(args params.AddMachines) (params.AddMachinesResults, error) {
589
func (c *Client) AddMachines(args params.AddMachines) (params.AddMachinesResults, error) {
997
590
	return c.AddMachinesV2(args)
998
591
}
999
592
1000
593
// AddMachinesV2 adds new machines with the supplied parameters.
1001
594
func (c *Client) AddMachinesV2(args params.AddMachines) (params.AddMachinesResults, error) {
1002
590
	results := params.AddMachinesResults{
595
	results := params.AddMachinesResults{
1003
591
		Machines: make([]params.AddMachinesResult, len(args.MachineParams)),
596
		Machines: make([]params.AddMachinesResult, len(args.MachineParams)),
1004
592
	}
597
	}
1005
@@ -606,23 +611,50 @@
1006
606
}
611
}
1007
607
612
1008
608
func (c *Client) addOneMachine(p params.AddMachineParams) (*state.Machine, error) {
613
func (c *Client) addOneMachine(p params.AddMachineParams) (*state.Machine, error) {
1013
609
	if p.Series == "" {
614
	if p.ParentId != "" && p.ContainerType == "" {
1014
610
		conf, err := c.api.state.EnvironConfig()
615
		return nil, fmt.Errorf("parent machine specified without container type")
1015
611
		if err != nil {
616
	}
1016
612
			return nil, err
617
	if p.ContainerType != "" && p.Placement != nil {
1017
618
		return nil, fmt.Errorf("container type and placement are mutually exclusive")
1018
619
	}
1019
620
	if p.Placement != nil {
1020
621
		// Extract container type and parent from container placement directives.
1021
622
		containerType, err := instance.ParseContainerType(p.Placement.Scope)
1022
623
		if err == nil {
1023
624
			p.ContainerType = containerType
1024
625
			p.ParentId = p.Placement.Directive
1025
626
			p.Placement = nil
1026
613
		}
627
		}
1027
614
		p.Series = config.PreferredSeries(conf)
1028
615
	}
628
	}
1030
616
	if p.ContainerType != "" {
629
1031
630
	if p.ContainerType != "" || p.Placement != nil {
1032
617
		// Guard against dubious client by making sure that
631
		// Guard against dubious client by making sure that
1033
618
		// the following attributes can only be set when we're
632
		// the following attributes can only be set when we're
1035
619
		// not making a new container.
633
		// not using placement.
1036
620
		p.InstanceId = ""
634
		p.InstanceId = ""
1037
621
		p.Nonce = ""
635
		p.Nonce = ""
1038
622
		p.HardwareCharacteristics = instance.HardwareCharacteristics{}
636
		p.HardwareCharacteristics = instance.HardwareCharacteristics{}
1039
623
		p.Addrs = nil
637
		p.Addrs = nil
1042
624
	} else if p.ParentId != "" {
638
	}
1043
625
		return nil, fmt.Errorf("parent machine specified without container type")
639
1044
640
	if p.Series == "" {
1045
641
		conf, err := c.api.state.EnvironConfig()
1046
642
		if err != nil {
1047
643
			return nil, err
1048
644
		}
1049
645
		p.Series = config.PreferredSeries(conf)
1050
646
	}
1051
647
1052
648
	var placementDirective string
1053
649
	if p.Placement != nil {
1054
650
		env, err := c.api.state.Environment()
1055
651
		if err != nil {
1056
652
			return nil, err
1057
653
		}
1058
654
		if p.Placement.Scope != env.Name() {
1059
655
			return nil, fmt.Errorf("invalid environment name %q", p.Placement.Scope)
1060
656
		}
1061
657
		placementDirective = p.Placement.Directive
1062
626
	}
658
	}
1063
627
659
1064
628
	jobs, err := stateJobs(p.Jobs)
660
	jobs, err := stateJobs(p.Jobs)
1065
@@ -637,6 +669,7 @@
1066
637
		Nonce:       p.Nonce,
669
		Nonce:       p.Nonce,
1067
638
		HardwareCharacteristics: p.HardwareCharacteristics,
670
		HardwareCharacteristics: p.HardwareCharacteristics,
1068
639
		Addresses:               p.Addrs,
671
		Addresses:               p.Addrs,
1069
672
		Placement:               placementDirective,
1070
640
	}
673
	}
1071
641
	if p.ContainerType == "" {
674
	if p.ContainerType == "" {
1072
642
		return c.api.state.AddOneMachine(template)
675
		return c.api.state.AddOneMachine(template)
1073
643
676
1074
=== modified file 'state/apiserver/client/client_test.go'
1075
--- state/apiserver/client/client_test.go	2014-04-17 12:53:23 +0000
1076
+++ state/apiserver/client/client_test.go	2014-04-23 06:25:18 +0000
1077
@@ -1665,8 +1665,8 @@
1078
1665
1665
1079
1666
	machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{{
1666
	machines, err := s.APIState.Client().AddMachines([]params.AddMachineParams{{
1080
1667
		Jobs:          []params.MachineJob{params.JobHostUnits},
1667
		Jobs:          []params.MachineJob{params.JobHostUnits},
1081
1668
		ContainerType: instance.LXC,
1082
1668
		ParentId:      "0",
1669
		ParentId:      "0",
1083
1669
		ContainerType: instance.LXC,
1084
1670
		Series:        "quantal",
1670
		Series:        "quantal",
1085
1671
	}})
1671
	}})
1086
1672
	c.Assert(err, gc.IsNil)
1672
	c.Assert(err, gc.IsNil)
1087
@@ -1692,13 +1692,65 @@
1088
1692
	}
1692
	}
1089
1693
}
1693
}
1090
1694
1694
1091
1695
func (s *clientSuite) TestClientAddMachinesWithPlacement(c *gc.C) {
1092
1696
	apiParams := make([]params.AddMachineParams, 4)
1093
1697
	for i := range apiParams {
1094
1698
		apiParams[i] = params.AddMachineParams{
1095
1699
			Jobs: []params.MachineJob{params.JobHostUnits},
1096
1700
		}
1097
1701
	}
1098
1702
	apiParams[0].Placement = instance.MustParsePlacement("lxc")
1099
1703
	apiParams[1].Placement = instance.MustParsePlacement("lxc:0")
1100
1704
	apiParams[1].ContainerType = instance.LXC
1101
1705
	apiParams[2].Placement = instance.MustParsePlacement("dummyenv:invalid")
1102
1706
	apiParams[3].Placement = instance.MustParsePlacement("dummyenv:valid")
1103
1707
	machines, err := s.APIState.Client().AddMachines(apiParams)
1104
1708
	c.Assert(err, gc.IsNil)
1105
1709
	c.Assert(len(machines), gc.Equals, 4)
1106
1710
	c.Assert(machines[0].Machine, gc.Equals, "0/lxc/0")
1107
1711
	c.Assert(machines[1].Error, gc.ErrorMatches, "container type and placement are mutually exclusive")
1108
1712
	c.Assert(machines[2].Error, gc.ErrorMatches, "cannot add a new machine: invalid placement is invalid")
1109
1713
	c.Assert(machines[3].Machine, gc.Equals, "1")
1110
1714
1111
1715
	m, err := s.BackingState.Machine(machines[3].Machine)
1112
1716
	c.Assert(err, gc.IsNil)
1113
1717
	c.Assert(m.Placement(), gc.DeepEquals, apiParams[3].Placement.Directive)
1114
1718
}
1115
1719
1116
1720
func (s *clientSuite) TestClientAddMachines1dot18(c *gc.C) {
1117
1721
	apiParams := make([]params.AddMachineParams, 2)
1118
1722
	for i := range apiParams {
1119
1723
		apiParams[i] = params.AddMachineParams{
1120
1724
			Jobs: []params.MachineJob{params.JobHostUnits},
1121
1725
		}
1122
1726
	}
1123
1727
	apiParams[1].ContainerType = instance.LXC
1124
1728
	apiParams[1].ParentId = "0"
1125
1729
	machines, err := s.APIState.Client().AddMachines1dot18(apiParams)
1126
1730
	c.Assert(err, gc.IsNil)
1127
1731
	c.Assert(len(machines), gc.Equals, 2)
1128
1732
	c.Assert(machines[0].Machine, gc.Equals, "0")
1129
1733
	c.Assert(machines[1].Machine, gc.Equals, "0/lxc/0")
1130
1734
}
1131
1735
1132
1736
func (s *clientSuite) TestClientAddMachines1dot18SomeErrors(c *gc.C) {
1133
1737
	apiParams := []params.AddMachineParams{{
1134
1738
		Jobs:     []params.MachineJob{params.JobHostUnits},
1135
1739
		ParentId: "123",
1136
1740
	}}
1137
1741
	machines, err := s.APIState.Client().AddMachines1dot18(apiParams)
1138
1742
	c.Assert(err, gc.IsNil)
1139
1743
	c.Assert(len(machines), gc.Equals, 1)
1140
1744
	c.Check(machines[0].Error, gc.ErrorMatches, "parent machine specified without container type")
1141
1745
}
1142
1746
1143
1695
func (s *clientSuite) TestClientAddMachinesSomeErrors(c *gc.C) {
1747
func (s *clientSuite) TestClientAddMachinesSomeErrors(c *gc.C) {
1144
1696
	// Here we check that adding a number of containers correctly handles the
1748
	// Here we check that adding a number of containers correctly handles the
1145
1697
	// case that some adds succeed and others fail and report the errors
1749
	// case that some adds succeed and others fail and report the errors
1146
1698
	// accordingly.
1750
	// accordingly.
1148
1699
	// We will set up params to the AddMachines API to attempt to create 4 machines.
1751
	// We will set up params to the AddMachines API to attempt to create 3 machines.
1149
1700
	// Machines 0 and 1 will be added successfully.
1752
	// Machines 0 and 1 will be added successfully.
1151
1701
	// Mchines 2 and 3 will fail due to different reasons.
1753
	// Remaining machines will fail due to different reasons.
1152
1702
1754
1153
1703
	// Create a machine to host the requested containers.
1755
	// Create a machine to host the requested containers.
1154
1704
	host, err := s.State.AddMachine("quantal", state.JobHostUnits)
1756
	host, err := s.State.AddMachine("quantal", state.JobHostUnits)
1155
@@ -1707,32 +1759,26 @@
1156
1707
	err = host.SetSupportedContainers([]instance.ContainerType{instance.LXC})
1759
	err = host.SetSupportedContainers([]instance.ContainerType{instance.LXC})
1157
1708
	c.Assert(err, gc.IsNil)
1760
	c.Assert(err, gc.IsNil)
1158
1709
1761
1162
1710
	// Set up params for adding 4 containers.
1762
	// Set up params for adding 3 containers.
1163
1711
	apiParams := make([]params.AddMachineParams, 4)
1763
	apiParams := make([]params.AddMachineParams, 3)
1164
1712
	for i := 0; i < 4; i++ {
1764
	for i := range apiParams {
1165
1713
		apiParams[i] = params.AddMachineParams{
1765
		apiParams[i] = params.AddMachineParams{
1166
1714
			Jobs: []params.MachineJob{params.JobHostUnits},
1766
			Jobs: []params.MachineJob{params.JobHostUnits},
1167
1715
		}
1767
		}
1168
1716
	}
1768
	}
1169
1717
	// Make it so that machines 2 and 3 will fail to be added.
1170
1718
	// This will cause a machine add to fail because of an invalid parent.
1171
1719
	apiParams[2].ParentId = "123"
1172
1720
	// This will cause a machine add to fail due to an unsupported container.
1769
	// This will cause a machine add to fail due to an unsupported container.
1175
1721
	apiParams[3].ParentId = host.Id()
1770
	apiParams[2].ContainerType = instance.KVM
1176
1722
	apiParams[3].ContainerType = instance.KVM
1771
	apiParams[2].ParentId = host.Id()
1177
1723
	machines, err := s.APIState.Client().AddMachines(apiParams)
1772
	machines, err := s.APIState.Client().AddMachines(apiParams)
1178
1724
	c.Assert(err, gc.IsNil)
1773
	c.Assert(err, gc.IsNil)
1180
1725
	c.Assert(len(machines), gc.Equals, 4)
1774
	c.Assert(len(machines), gc.Equals, 3)
1181
1726
1775
1182
1727
	// Check the results - machines 2 and 3 will have errors.
1776
	// Check the results - machines 2 and 3 will have errors.
1183
1728
	c.Check(machines[0].Machine, gc.Equals, "1")
1777
	c.Check(machines[0].Machine, gc.Equals, "1")
1184
1729
	c.Check(machines[0].Error, gc.IsNil)
1778
	c.Check(machines[0].Error, gc.IsNil)
1185
1730
	c.Check(machines[1].Machine, gc.Equals, "2")
1779
	c.Check(machines[1].Machine, gc.Equals, "2")
1186
1731
	c.Check(machines[1].Error, gc.IsNil)
1780
	c.Check(machines[1].Error, gc.IsNil)
1191
1732
	c.Assert(machines[2].Error, gc.NotNil)
1781
	c.Check(machines[2].Error, gc.ErrorMatches, "cannot add a new machine: machine 0 cannot host kvm containers")
1188
1733
	c.Check(machines[2].Error, gc.ErrorMatches, "parent machine specified without container type")
1189
1734
	c.Assert(machines[2].Error, gc.NotNil)
1190
1735
	c.Check(machines[3].Error, gc.ErrorMatches, "cannot add a new machine: machine 0 cannot host kvm containers")
1192
1736
}
1782
}
1193
1737
1783
1194
1738
func (s *clientSuite) TestClientAddMachinesWithInstanceIdSomeErrors(c *gc.C) {
1784
func (s *clientSuite) TestClientAddMachinesWithInstanceIdSomeErrors(c *gc.C) {
1195
1739
1785
1196
=== modified file 'state/apiserver/provisioner/provisioner.go'
1197
--- state/apiserver/provisioner/provisioner.go	2014-04-18 15:31:56 +0000
1198
+++ state/apiserver/provisioner/provisioner.go	2014-04-23 06:25:18 +0000
1199
@@ -285,6 +285,49 @@
1200
285
	return result, nil
285
	return result, nil
1201
286
}
286
}
1202
287
287
1203
288
// ProvisioningInfo returns the provisioning information for each given machine entity.
1204
289
func (p *ProvisionerAPI) ProvisioningInfo(args params.Entities) (params.ProvisioningInfoResults, error) {
1205
290
	result := params.ProvisioningInfoResults{
1206
291
		Results: make([]params.ProvisioningInfoResult, len(args.Entities)),
1207
292
	}
1208
293
	canAccess, err := p.getAuthFunc()
1209
294
	if err != nil {
1210
295
		return result, err
1211
296
	}
1212
297
	for i, entity := range args.Entities {
1213
298
		machine, err := p.getMachine(canAccess, entity.Tag)
1214
299
		if err == nil {
1215
300
			result.Results[i].Result, err = getProvisioningInfo(machine)
1216
301
		}
1217
302
		result.Results[i].Error = common.ServerError(err)
1218
303
	}
1219
304
	return result, nil
1220
305
}
1221
306
1222
307
func getProvisioningInfo(m *state.Machine) (*params.ProvisioningInfo, error) {
1223
308
	cons, err := m.Constraints()
1224
309
	if err != nil {
1225
310
		return nil, err
1226
311
	}
1227
312
	// TODO(dimitern) For now, since network names and
1228
313
	// provider ids are the same, we return what we got
1229
314
	// from state. In the future, when networks can be
1230
315
	// added before provisioning, we should convert both
1231
316
	// slices from juju network names to provider-specific
1232
317
	// ids before returning them.
1233
318
	includeNetworks, excludeNetworks, err := m.RequestedNetworks()
1234
319
	if err != nil {
1235
320
		return nil, err
1236
321
	}
1237
322
	return &params.ProvisioningInfo{
1238
323
		Constraints:     cons,
1239
324
		Series:          m.Series(),
1240
325
		Placement:       m.Placement(),
1241
326
		IncludeNetworks: includeNetworks,
1242
327
		ExcludeNetworks: excludeNetworks,
1243
328
	}, nil
1244
329
}
1245
330
1246
288
// DistributionGroup returns, for each given machine entity,
331
// DistributionGroup returns, for each given machine entity,
1247
289
// a slice of instance.Ids that belong to the same distribution
332
// a slice of instance.Ids that belong to the same distribution
1248
290
// group as that machine. This information may be used to
333
// group as that machine. This information may be used to
1249
291
334
1250
=== modified file 'state/apiserver/provisioner/provisioner_test.go'
1251
--- state/apiserver/provisioner/provisioner_test.go	2014-04-18 15:31:56 +0000
1252
+++ state/apiserver/provisioner/provisioner_test.go	2014-04-23 06:25:18 +0000
1253
@@ -726,6 +726,87 @@
1254
726
	})
726
	})
1255
727
}
727
}
1256
728
728
1257
729
func (s *withoutStateServerSuite) TestProvisioningInfo(c *gc.C) {
1258
730
	template := state.MachineTemplate{
1259
731
		Series:          "quantal",
1260
732
		Jobs:            []state.MachineJob{state.JobHostUnits},
1261
733
		Constraints:     constraints.MustParse("cpu-cores=123", "mem=8G"),
1262
734
		Placement:       "valid",
1263
735
		IncludeNetworks: []string{"net1", "net2"},
1264
736
		ExcludeNetworks: []string{"net3", "net4"},
1265
737
	}
1266
738
	placementMachine, err := s.State.AddOneMachine(template)
1267
739
	c.Assert(err, gc.IsNil)
1268
740
1269
741
	args := params.Entities{Entities: []params.Entity{
1270
742
		{Tag: s.machines[0].Tag()},
1271
743
		{Tag: placementMachine.Tag()},
1272
744
		{Tag: "machine-42"},
1273
745
		{Tag: "unit-foo-0"},
1274
746
		{Tag: "service-bar"},
1275
747
	}}
1276
748
	result, err := s.provisioner.ProvisioningInfo(args)
1277
749
	c.Assert(err, gc.IsNil)
1278
750
	c.Assert(result, gc.DeepEquals, params.ProvisioningInfoResults{
1279
751
		Results: []params.ProvisioningInfoResult{
1280
752
			{
1281
753
				Result: &params.ProvisioningInfo{
1282
754
					Series:          "quantal",
1283
755
					IncludeNetworks: []string{},
1284
756
					ExcludeNetworks: []string{},
1285
757
				},
1286
758
			},
1287
759
			{
1288
760
				Result: &params.ProvisioningInfo{
1289
761
					Series:          "quantal",
1290
762
					Constraints:     template.Constraints,
1291
763
					Placement:       template.Placement,
1292
764
					IncludeNetworks: template.IncludeNetworks,
1293
765
					ExcludeNetworks: template.ExcludeNetworks,
1294
766
				},
1295
767
			},
1296
768
			{Error: apiservertesting.NotFoundError("machine 42")},
1297
769
			{Error: apiservertesting.ErrUnauthorized},
1298
770
			{Error: apiservertesting.ErrUnauthorized},
1299
771
		},
1300
772
	})
1301
773
}
1302
774
1303
775
func (s *withoutStateServerSuite) TestProvisioningInfoPermissions(c *gc.C) {
1304
776
	// Login as a machine agent for machine 0.
1305
777
	anAuthorizer := s.authorizer
1306
778
	anAuthorizer.MachineAgent = true
1307
779
	anAuthorizer.EnvironManager = false
1308
780
	anAuthorizer.Tag = s.machines[0].Tag()
1309
781
	aProvisioner, err := provisioner.NewProvisionerAPI(s.State, s.resources, anAuthorizer)
1310
782
	c.Assert(err, gc.IsNil)
1311
783
	c.Assert(aProvisioner, gc.NotNil)
1312
784
1313
785
	args := params.Entities{Entities: []params.Entity{
1314
786
		{Tag: s.machines[0].Tag()},
1315
787
		{Tag: s.machines[0].Tag() + "-lxc-0"},
1316
788
		{Tag: "machine-42"},
1317
789
		{Tag: s.machines[1].Tag()},
1318
790
		{Tag: "service-bar"},
1319
791
	}}
1320
792
1321
793
	// Only machine 0 and containers therein can be accessed.
1322
794
	results, err := aProvisioner.ProvisioningInfo(args)
1323
795
	c.Assert(results, gc.DeepEquals, params.ProvisioningInfoResults{
1324
796
		Results: []params.ProvisioningInfoResult{
1325
797
			{Result: &params.ProvisioningInfo{
1326
798
				Series:          "quantal",
1327
799
				IncludeNetworks: []string{},
1328
800
				ExcludeNetworks: []string{},
1329
801
			}},
1330
802
			{Error: apiservertesting.NotFoundError("machine 0/lxc/0")},
1331
803
			{Error: apiservertesting.ErrUnauthorized},
1332
804
			{Error: apiservertesting.ErrUnauthorized},
1333
805
			{Error: apiservertesting.ErrUnauthorized},
1334
806
		},
1335
807
	})
1336
808
}
1337
809
1338
729
func (s *withoutStateServerSuite) TestConstraints(c *gc.C) {
810
func (s *withoutStateServerSuite) TestConstraints(c *gc.C) {
1339
730
	// Add a machine with some constraints.
811
	// Add a machine with some constraints.
1340
731
	template := state.MachineTemplate{
812
	template := state.MachineTemplate{
1341
732
813
1342
=== modified file 'state/machine.go'
1343
--- state/machine.go	2014-04-21 23:10:05 +0000
1344
+++ state/machine.go	2014-04-23 06:25:18 +0000
1345
@@ -114,6 +114,9 @@
1346
114
	// machine is capable of hosting.
114
	// machine is capable of hosting.
1347
115
	SupportedContainersKnown bool
115
	SupportedContainersKnown bool
1348
116
	SupportedContainers      []instance.ContainerType `bson:",omitempty"`
116
	SupportedContainers      []instance.ContainerType `bson:",omitempty"`
1349
117
	// Placement is the placement directive that should be used when provisioning
1350
118
	// an instance for the machine.
1351
119
	Placement string `bson:",omitempty"`
1352
117
	// Deprecated. InstanceId, now lives on instanceData.
120
	// Deprecated. InstanceId, now lives on instanceData.
1353
118
	// This attribute is retained so that data from existing machines can be read.
121
	// This attribute is retained so that data from existing machines can be read.
1354
119
	// SCHEMACHANGE
122
	// SCHEMACHANGE
1355
@@ -1090,6 +1093,12 @@
1356
1090
	return m.doc.Id
1093
	return m.doc.Id
1357
1091
}
1094
}
1358
1092
1095
1359
1096
// Placement returns the machine's Placement structure that should be used when
1360
1097
// provisioning an instance for the machine.
1361
1098
func (m *Machine) Placement() string {
1362
1099
	return m.doc.Placement
1363
1100
}
1364
1101
1365
1093
// Constraints returns the exact constraints that should apply when provisioning
1102
// Constraints returns the exact constraints that should apply when provisioning
1366
1094
// an instance for the machine.
1103
// an instance for the machine.
1367
1095
func (m *Machine) Constraints() (constraints.Value, error) {
1104
func (m *Machine) Constraints() (constraints.Value, error) {
1368
1096
1105
1369
=== modified file 'state/policy.go'
1370
--- state/policy.go	2014-04-21 23:24:57 +0000
1371
+++ state/policy.go	2014-04-23 06:25:18 +0000
1372
@@ -49,7 +49,7 @@
1373
49
	// all invalid parameters. If PrecheckInstance returns nil, it is not
49
	// all invalid parameters. If PrecheckInstance returns nil, it is not
1374
50
	// guaranteed that the constraints are valid; if a non-nil error is
50
	// guaranteed that the constraints are valid; if a non-nil error is
1375
51
	// returned, then the constraints are definitely invalid.
51
	// returned, then the constraints are definitely invalid.
1377
52
	PrecheckInstance(series string, cons constraints.Value) error
52
	PrecheckInstance(series string, cons constraints.Value, placement string) error
1378
53
}
53
}
1379
54
54
1380
55
// ConfigValidator is a policy interface that is provided to State
55
// ConfigValidator is a policy interface that is provided to State
1381
@@ -78,7 +78,7 @@
1382
78
78
1383
79
// precheckInstance calls the state's assigned policy, if non-nil, to obtain
79
// precheckInstance calls the state's assigned policy, if non-nil, to obtain
1384
80
// a Prechecker, and calls PrecheckInstance if a non-nil Prechecker is returned.
80
// a Prechecker, and calls PrecheckInstance if a non-nil Prechecker is returned.
1386
81
func (st *State) precheckInstance(series string, cons constraints.Value) error {
81
func (st *State) precheckInstance(series string, cons constraints.Value, placement string) error {
1387
82
	if st.policy == nil {
82
	if st.policy == nil {
1388
83
		return nil
83
		return nil
1389
84
	}
84
	}
1390
@@ -95,7 +95,7 @@
1391
95
	if prechecker == nil {
95
	if prechecker == nil {
1392
96
		return fmt.Errorf("policy returned nil prechecker without an error")
96
		return fmt.Errorf("policy returned nil prechecker without an error")
1393
97
	}
97
	}
1395
98
	return prechecker.PrecheckInstance(series, cons)
98
	return prechecker.PrecheckInstance(series, cons, placement)
1396
99
}
99
}
1397
100
100
1398
101
func (st *State) constraintsValidator() (constraints.Validator, error) {
101
func (st *State) constraintsValidator() (constraints.Validator, error) {
1399
102
102
1400
=== modified file 'state/prechecker_test.go'
1401
--- state/prechecker_test.go	2014-04-21 23:10:05 +0000
1402
+++ state/prechecker_test.go	2014-04-23 06:25:18 +0000
1403
@@ -26,11 +26,13 @@
1404
26
	precheckInstanceError       error
26
	precheckInstanceError       error
1405
27
	precheckInstanceSeries      string
27
	precheckInstanceSeries      string
1406
28
	precheckInstanceConstraints constraints.Value
28
	precheckInstanceConstraints constraints.Value
1407
29
	precheckInstancePlacement   string
1408
29
}
30
}
1409
30
31
1411
31
func (p *mockPrechecker) PrecheckInstance(series string, cons constraints.Value) error {
32
func (p *mockPrechecker) PrecheckInstance(series string, cons constraints.Value, placement string) error {
1412
32
	p.precheckInstanceSeries = series
33
	p.precheckInstanceSeries = series
1413
33
	p.precheckInstanceConstraints = cons
34
	p.precheckInstanceConstraints = cons
1414
35
	p.precheckInstancePlacement = placement
1415
34
	return p.precheckInstanceError
36
	return p.precheckInstanceError
1416
35
}
37
}
1417
36
38
1418
@@ -44,13 +46,15 @@
1419
44
46
1420
45
func (s *PrecheckerSuite) TestPrecheckInstance(c *gc.C) {
47
func (s *PrecheckerSuite) TestPrecheckInstance(c *gc.C) {
1421
46
	// PrecheckInstance should be called with the specified
48
	// PrecheckInstance should be called with the specified
1425
47
	// series, and the specified constraints merged with the
49
	// series and placement, and the specified constraints
1426
48
	// environment constraints, when attempting to create an
50
	// merged with the environment constraints, when attempting
1427
49
	// instance.
51
	// to create an instance.
1428
50
	envCons := constraints.MustParse("mem=4G")
52
	envCons := constraints.MustParse("mem=4G")
1430
51
	template, err := s.addOneMachine(c, envCons)
53
	placement := "abc123"
1431
54
	template, err := s.addOneMachine(c, envCons, placement)
1432
52
	c.Assert(err, gc.IsNil)
55
	c.Assert(err, gc.IsNil)
1433
53
	c.Assert(s.prechecker.precheckInstanceSeries, gc.Equals, template.Series)
56
	c.Assert(s.prechecker.precheckInstanceSeries, gc.Equals, template.Series)
1434
57
	c.Assert(s.prechecker.precheckInstancePlacement, gc.Equals, placement)
1435
54
	validator := constraints.NewValidator()
58
	validator := constraints.NewValidator()
1436
55
	cons, err := validator.Merge(envCons, template.Constraints)
59
	cons, err := validator.Merge(envCons, template.Constraints)
1437
56
	c.Assert(err, gc.IsNil)
60
	c.Assert(err, gc.IsNil)
1438
@@ -60,14 +64,14 @@
1439
60
func (s *PrecheckerSuite) TestPrecheckErrors(c *gc.C) {
64
func (s *PrecheckerSuite) TestPrecheckErrors(c *gc.C) {
1440
61
	// Ensure that AddOneMachine fails when PrecheckInstance returns an error.
65
	// Ensure that AddOneMachine fails when PrecheckInstance returns an error.
1441
62
	s.prechecker.precheckInstanceError = fmt.Errorf("no instance for you")
66
	s.prechecker.precheckInstanceError = fmt.Errorf("no instance for you")
1443
63
	_, err := s.addOneMachine(c, constraints.Value{})
67
	_, err := s.addOneMachine(c, constraints.Value{}, "placement")
1444
64
	c.Assert(err, gc.ErrorMatches, ".*no instance for you")
68
	c.Assert(err, gc.ErrorMatches, ".*no instance for you")
1445
65
69
1446
66
	// If the policy's Prechecker method fails, that will be returned first.
70
	// If the policy's Prechecker method fails, that will be returned first.
1447
67
	s.policy.getPrechecker = func(*config.Config) (state.Prechecker, error) {
71
	s.policy.getPrechecker = func(*config.Config) (state.Prechecker, error) {
1448
68
		return nil, fmt.Errorf("no prechecker for you")
72
		return nil, fmt.Errorf("no prechecker for you")
1449
69
	}
73
	}
1451
70
	_, err = s.addOneMachine(c, constraints.Value{})
74
	_, err = s.addOneMachine(c, constraints.Value{}, "placement")
1452
71
	c.Assert(err, gc.ErrorMatches, ".*no prechecker for you")
75
	c.Assert(err, gc.ErrorMatches, ".*no prechecker for you")
1453
72
}
76
}
1454
73
77
1455
@@ -76,10 +80,10 @@
1456
76
	s.policy.getPrechecker = func(*config.Config) (state.Prechecker, error) {
80
	s.policy.getPrechecker = func(*config.Config) (state.Prechecker, error) {
1457
77
		return nil, precheckerErr
81
		return nil, precheckerErr
1458
78
	}
82
	}
1460
79
	_, err := s.addOneMachine(c, constraints.Value{})
83
	_, err := s.addOneMachine(c, constraints.Value{}, "placement")
1461
80
	c.Assert(err, gc.ErrorMatches, "cannot add a new machine: policy returned nil prechecker without an error")
84
	c.Assert(err, gc.ErrorMatches, "cannot add a new machine: policy returned nil prechecker without an error")
1462
81
	precheckerErr = errors.NotImplementedf("Prechecker")
85
	precheckerErr = errors.NotImplementedf("Prechecker")
1464
82
	_, err = s.addOneMachine(c, constraints.Value{})
86
	_, err = s.addOneMachine(c, constraints.Value{}, "placement")
1465
83
	c.Assert(err, gc.IsNil)
87
	c.Assert(err, gc.IsNil)
1466
84
}
88
}
1467
85
89
1468
@@ -89,11 +93,11 @@
1469
89
		return nil, nil
93
		return nil, nil
1470
90
	}
94
	}
1471
91
	state.SetPolicy(s.State, nil)
95
	state.SetPolicy(s.State, nil)
1473
92
	_, err := s.addOneMachine(c, constraints.Value{})
96
	_, err := s.addOneMachine(c, constraints.Value{}, "placement")
1474
93
	c.Assert(err, gc.IsNil)
97
	c.Assert(err, gc.IsNil)
1475
94
}
98
}
1476
95
99
1478
96
func (s *PrecheckerSuite) addOneMachine(c *gc.C, envCons constraints.Value) (state.MachineTemplate, error) {
100
func (s *PrecheckerSuite) addOneMachine(c *gc.C, envCons constraints.Value, placement string) (state.MachineTemplate, error) {
1479
97
	err := s.State.SetEnvironConstraints(envCons)
101
	err := s.State.SetEnvironConstraints(envCons)
1480
98
	c.Assert(err, gc.IsNil)
102
	c.Assert(err, gc.IsNil)
1481
99
	oneJob := []state.MachineJob{state.JobHostUnits}
103
	oneJob := []state.MachineJob{state.JobHostUnits}
1482
@@ -102,6 +106,7 @@
1483
102
		Series:      "precise",
106
		Series:      "precise",
1484
103
		Constraints: extraCons,
107
		Constraints: extraCons,
1485
104
		Jobs:        oneJob,
108
		Jobs:        oneJob,
1486
109
		Placement:   placement,
1487
105
	}
110
	}
1488
106
	_, err = s.State.AddOneMachine(template)
111
	_, err = s.State.AddOneMachine(template)
1489
107
	return template, err
112
	return template, err
1490
@@ -113,22 +118,26 @@
1491
113
		Series:     "precise",
118
		Series:     "precise",
1492
114
		Nonce:      state.BootstrapNonce,
119
		Nonce:      state.BootstrapNonce,
1493
115
		Jobs:       []state.MachineJob{state.JobManageEnviron},
120
		Jobs:       []state.MachineJob{state.JobManageEnviron},
1494
121
		Placement:  "anyoldthing",
1495
116
	}
122
	}
1496
117
	_, err := s.State.AddOneMachine(template)
123
	_, err := s.State.AddOneMachine(template)
1497
118
	c.Assert(err, gc.IsNil)
124
	c.Assert(err, gc.IsNil)
1498
119
	// PrecheckInstance should not have been called, as we've
125
	// PrecheckInstance should not have been called, as we've
1499
120
	// injected a machine with an existing instance.
126
	// injected a machine with an existing instance.
1500
121
	c.Assert(s.prechecker.precheckInstanceSeries, gc.Equals, "")
127
	c.Assert(s.prechecker.precheckInstanceSeries, gc.Equals, "")
1501
128
	c.Assert(s.prechecker.precheckInstancePlacement, gc.Equals, "")
1502
122
}
129
}
1503
123
130
1504
124
func (s *PrecheckerSuite) TestPrecheckContainerNewMachine(c *gc.C) {
131
func (s *PrecheckerSuite) TestPrecheckContainerNewMachine(c *gc.C) {
1505
125
	// Attempting to add a container to a new machine should cause
132
	// Attempting to add a container to a new machine should cause
1506
126
	// PrecheckInstance to be called.
133
	// PrecheckInstance to be called.
1507
127
	template := state.MachineTemplate{
134
	template := state.MachineTemplate{
1510
128
		Series: "precise",
135
		Series:    "precise",
1511
129
		Jobs:   []state.MachineJob{state.JobHostUnits},
136
		Jobs:      []state.MachineJob{state.JobHostUnits},
1512
137
		Placement: "intertubes",
1513
130
	}
138
	}
1514
131
	_, err := s.State.AddMachineInsideNewMachine(template, template, instance.LXC)
139
	_, err := s.State.AddMachineInsideNewMachine(template, template, instance.LXC)
1515
132
	c.Assert(err, gc.IsNil)
140
	c.Assert(err, gc.IsNil)
1516
133
	c.Assert(s.prechecker.precheckInstanceSeries, gc.Equals, template.Series)
141
	c.Assert(s.prechecker.precheckInstanceSeries, gc.Equals, template.Series)
1517
142
	c.Assert(s.prechecker.precheckInstancePlacement, gc.Equals, template.Placement)
1518
134
}
143
}
1519
135
144
1520
=== modified file 'worker/provisioner/provisioner_task.go'
1521
--- worker/provisioner/provisioner_task.go	2014-04-18 16:37:28 +0000
1522
+++ worker/provisioner/provisioner_task.go	2014-04-23 06:25:18 +0000
1523
@@ -5,6 +5,7 @@
1524
5
5
1525
6
import (
6
import (
1526
7
	"fmt"
7
	"fmt"
1527
8
	"time"
1528
8
9
1529
9
	"launchpad.net/tomb"
10
	"launchpad.net/tomb"
1530
10
11
1531
@@ -450,26 +451,19 @@
1532
450
}
451
}
1533
451
452
1534
452
func (task *provisionerTask) startMachine(machine *apiprovisioner.Machine) error {
453
func (task *provisionerTask) startMachine(machine *apiprovisioner.Machine) error {
1548
453
	cons, err := machine.Constraints()
454
	provisioningInfo, err := task.provisioningInfo(machine)
1549
454
	if err != nil {
455
	if err != nil {
1550
455
		return err
456
		return err
1551
456
	}
457
	}
1552
457
	series, err := machine.Series()
458
	possibleTools, err := task.possibleTools(provisioningInfo.Series, provisioningInfo.Constraints)
1540
458
	if err != nil {
1541
459
		return err
1542
460
	}
1543
461
	possibleTools, err := task.possibleTools(series, cons)
1544
462
	if err != nil {
1545
463
		return err
1546
464
	}
1547
465
	machineConfig, err := task.machineConfig(machine)
1553
466
	if err != nil {
459
	if err != nil {
1554
467
		return err
460
		return err
1555
468
	}
461
	}
1556
469
	inst, metadata, networkInfo, err := task.broker.StartInstance(environs.StartInstanceParams{
462
	inst, metadata, networkInfo, err := task.broker.StartInstance(environs.StartInstanceParams{
1558
470
		Constraints:       cons,
463
		Constraints:       provisioningInfo.Constraints,
1559
471
		Tools:             possibleTools,
464
		Tools:             possibleTools,
1561
472
		MachineConfig:     machineConfig,
465
		MachineConfig:     provisioningInfo.MachineConfig,
1562
466
		Placement:         provisioningInfo.Placement,
1563
473
		DistributionGroup: machine.DistributionGroup,
467
		DistributionGroup: machine.DistributionGroup,
1564
474
	})
468
	})
1565
475
	if err != nil {
469
	if err != nil {
1566
@@ -478,7 +472,7 @@
1567
478
		// error; just keep going with the other machines.
472
		// error; just keep going with the other machines.
1568
479
		return task.setErrorStatus("cannot start instance for machine %q: %v", machine, err)
473
		return task.setErrorStatus("cannot start instance for machine %q: %v", machine, err)
1569
480
	}
474
	}
1571
481
	nonce := machineConfig.MachineNonce
475
	nonce := provisioningInfo.MachineConfig.MachineNonce
1572
482
	networks, ifaces := task.prepareNetworkAndInterfaces(networkInfo)
476
	networks, ifaces := task.prepareNetworkAndInterfaces(networkInfo)
1573
483
477
1574
484
	err = machine.SetInstanceInfo(inst.Id(), nonce, metadata, networks, ifaces)
478
	err = machine.SetInstanceInfo(inst.Id(), nonce, metadata, networks, ifaces)
1575
@@ -512,7 +506,14 @@
1576
512
	panic(fmt.Errorf("broker of type %T does not provide any tools", task.broker))
506
	panic(fmt.Errorf("broker of type %T does not provide any tools", task.broker))
1577
513
}
507
}
1578
514
508
1580
515
func (task *provisionerTask) machineConfig(machine *apiprovisioner.Machine) (*cloudinit.MachineConfig, error) {
509
type provisioningInfo struct {
1581
510
	Constraints   constraints.Value
1582
511
	Series        string
1583
512
	Placement     string
1584
513
	MachineConfig *cloudinit.MachineConfig
1585
514
}
1586
515
1587
516
func (task *provisionerTask) provisioningInfo(machine *apiprovisioner.Machine) (*provisioningInfo, error) {
1588
516
	stateInfo, apiInfo, err := task.auth.SetupAuthentication(machine)
517
	stateInfo, apiInfo, err := task.auth.SetupAuthentication(machine)
1589
517
	if err != nil {
518
	if err != nil {
1590
518
		logger.Errorf("failed to setup authentication: %v", err)
519
		logger.Errorf("failed to setup authentication: %v", err)
1591
@@ -525,11 +526,32 @@
1592
525
	if err != nil {
526
	if err != nil {
1593
526
		return nil, err
527
		return nil, err
1594
527
	}
528
	}
1597
528
	includeNetworks, excludeNetworks, err := machine.RequestedNetworks()
529
	// ProvisioningInfo is new in 1.20; wait for the API server to be upgraded
1598
529
	if err != nil {
530
	// so we don't spew errors on upgrade.
1599
531
	var pInfo *params.ProvisioningInfo
1600
532
	for {
1601
533
		if pInfo, err = machine.ProvisioningInfo(); err == nil {
1602
534
			break
1603
535
		}
1604
536
		if params.IsCodeNotImplemented(err) {
1605
537
			logger.Infof("waiting for state server to be upgraded")
1606
538
			select {
1607
539
			case <-task.tomb.Dying():
1608
540
				return nil, tomb.ErrDying
1609
541
			case <-time.After(15 * time.Second):
1610
542
				continue
1611
543
			}
1612
544
		}
1613
530
		return nil, err
545
		return nil, err
1614
531
	}
546
	}
1615
547
	includeNetworks := pInfo.IncludeNetworks
1616
548
	excludeNetworks := pInfo.ExcludeNetworks
1617
532
	nonce := fmt.Sprintf("%s:%s", task.machineTag, uuid.String())
549
	nonce := fmt.Sprintf("%s:%s", task.machineTag, uuid.String())
1618
533
	machineConfig := environs.NewMachineConfig(machine.Id(), nonce, includeNetworks, excludeNetworks, stateInfo, apiInfo)
550
	machineConfig := environs.NewMachineConfig(machine.Id(), nonce, includeNetworks, excludeNetworks, stateInfo, apiInfo)
1620
534
	return machineConfig, nil
551
	return &provisioningInfo{
1621
552
		Constraints:   pInfo.Constraints,
1622
553
		Series:        pInfo.Series,
1623
554
		Placement:     pInfo.Placement,
1624
555
		MachineConfig: machineConfig,
1625
556
	}, nil
1626
535
}
557
}
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2014-04-08	Pending
Review via email: mp+214761@code.launchpad.net