Merge lp:~axwalk/juju-core/state-environcapability into lp:~go-bot/juju-core/trunk

[Andrew Wilkins]

Add EnvironCapability to state.Policy

environs.EnvironCapability is moved to the
state package, extended with the
SupportsUnitPlacement method, and added to
the state.Policy interface.

Methods for creating machines and assigning
units to them are now modified to use the
SupportsUnitPlacement method to enable
policy implementations to block adding of
empty machines (juju add-machine) and to
block unit placement (deploy/add-unit --to).

Also, a new EnvironBase type is added to
provider/common, which implements some
default behaviour common to all providers
such as the new SupportsUnitPlacement
method.

A followup will override the default
behaviour of SupportsUnitPlacement in the
Azure provider, blocking placement if in
availability-sets-enabled mode.

https://codereview.appspot.com/77820044/

Add EnvironCapability to state.Policy

environs.EnvironCapability is moved to the
state package, extended with the
SupportsUnitPlacement method, and added to
the state.Policy interface.

Methods for creating machines and assigning
units to them are now modified to use the
SupportsUnitPlacement method to enable
policy implementations to block adding of
empty machines (juju add-machine) and to
block unit placement (deploy/add-unit --to).

Also, a new EnvironBase type is added to
provider/common, which implements some
default behaviour common to all providers
such as the new SupportsUnitPlacement
method.

A followup will override the default
behaviour of SupportsUnitPlacement in the
Azure provider, blocking placement if in
availability-sets-enabled mode.

https://codereview.appspot.com/77820044/

[Andrew Wilkins (axwalk)]

Reviewers: mp+211749_code.launchpad.net,

Message:
Please take a look.

Description:
Add EnvironCapability to state.Policy

environs.EnvironCapability is moved to the
state package, extended with the
SupportsUnitPlacement method, and added to
the state.Policy interface.

Methods for creating machines and assigning
units to them are now modified to use the
SupportsUnitPlacement method to enable
policy implementations to block adding of
empty machines (juju add-machine) and to
block unit placement (deploy/add-unit --to).

Also, a new EnvironBase type is added to
provider/common, which implements some
default behaviour common to all providers
such as the new SupportsUnitPlacement
method.

A followup will override the default
behaviour of SupportsUnitPlacement in the
Azure provider, blocking placement if in
availability-sets-enabled mode.

https://code.launchpad.net/~axwalk/juju-core/state-environcapability/+merge/211749

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/77820044/

Affected files (+232, -32 lines):
   A [revision details]
   M environs/interface.go
   M environs/statepolicy.go
   M provider/azure/environ.go
   A provider/common/environbase.go
   M provider/dummy/environs.go
   M provider/ec2/ec2.go
   M provider/joyent/environ.go
   M provider/local/environ.go
   M provider/maas/environ.go
   M provider/manual/environ.go
   M provider/openstack/provider.go
   M state/addmachine.go
   M state/conn_test.go
   A state/environcapability_test.go
   M state/policy.go
   M state/unit.go

[William Reade (fwereade)]

LGTM. Don't quite love the "Base" name but I guess its semantic payload
is close enough to reality that I'm not going to fight it. If you can
think of something better, though...

https://codereview.appspot.com/77820044/

[Horacio Durán (hduran-8)]

On 2014/03/19 15:15:17, fwereade wrote:
> LGTM. Don't quite love the "Base" name but I guess its semantic
payload is close
> enough to reality that I'm not going to fight it. If you can think of
something
> better, though...

You could user Common instead of Base altough I am not sure if it
represents correctly reality

https://codereview.appspot.com/77820044/

[Andrew Wilkins (axwalk)]

On 2014/03/19 18:37:43, hduran wrote:
> On 2014/03/19 15:15:17, fwereade wrote:
> > LGTM. Don't quite love the "Base" name but I guess its semantic
payload is
> close
> > enough to reality that I'm not going to fight it. If you can think
of
> something
> > better, though...

> You could user Common instead of Base altough I am not sure if it
represents
> correctly reality

Kind of, but not really. Some providers may override the behaviour.

After discussing with rogpeppe on IRC, I decided to replace EnvironBase
with two types: NopPrechecker and DoesSupportUnitPlacement. They're
more specific, and have non-generic names to imply non-changing
behaviour.
If we just use "DefaultPrechecker" then someone may change the default
behaviour without considering how it affects one of the providers.

https://codereview.appspot.com/77820044/

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/77820044/

[William Reade (fwereade)]

LGTM modulo further naming quibbles which I will leave to your judgment.

https://codereview.appspot.com/77820044/diff/20001/provider/azure/environ.go
File provider/azure/environ.go (right):

https://codereview.appspot.com/77820044/diff/20001/provider/azure/environ.go#newcode55
provider/azure/environ.go:55: common.DoesSupportUnitPlacement
Not honestly loving these names either (although they're certainly
better). Would you be OK tacking "Policy" onto those names to make their
intent a little clearer to the reader? Alternatively, tell me that's a
stupid idea, and go ahead with what you have.

https://codereview.appspot.com/77820044/

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/77820044/diff/20001/provider/azure/environ.go
File provider/azure/environ.go (right):

https://codereview.appspot.com/77820044/diff/20001/provider/azure/environ.go#newcode55
provider/azure/environ.go:55: common.DoesSupportUnitPlacement
On 2014/03/24 09:45:57, fwereade wrote:
> Not honestly loving these names either (although they're certainly
better).
> Would you be OK tacking "Policy" onto those names to make their intent
a little
> clearer to the reader? Alternatively, tell me that's a stupid idea,
and go ahead
> with what you have.

Renamed NopPrechecker to NopPrecheckerPolicy, DoesSupportUnitPlacement
to SupportsUnitPlacementPolicy.

https://codereview.appspot.com/77820044/

[William Reade (fwereade)]

On 2014/03/24 14:46:38, axw wrote:
> Please take a look.

https://codereview.appspot.com/77820044/diff/20001/provider/azure/environ.go
> File provider/azure/environ.go (right):

https://codereview.appspot.com/77820044/diff/20001/provider/azure/environ.go#newcode55
> provider/azure/environ.go:55: common.DoesSupportUnitPlacement
> On 2014/03/24 09:45:57, fwereade wrote:
> > Not honestly loving these names either (although they're certainly
better).
> > Would you be OK tacking "Policy" onto those names to make their
intent a
> little
> > clearer to the reader? Alternatively, tell me that's a stupid idea,
and go
> ahead
> > with what you have.

> Renamed NopPrechecker to NopPrecheckerPolicy, DoesSupportUnitPlacement
to
> SupportsUnitPlacementPolicy.

If that's all you did this still LGTM

https://codereview.appspot.com/77820044/

[Andrew Wilkins (axwalk)]

Please take a look.

https://codereview.appspot.com/77820044/

=== modified file 'agent/bootstrap_test.go'
--- agent/bootstrap_test.go	2014-04-02 15:30:58 +0000
+++ agent/bootstrap_test.go	2014-04-03 03:38:42 +0000
@@ -12,6 +12,7 @@
 	"launchpad.net/juju-core/environs"
 	"launchpad.net/juju-core/environs/config"
 	"launchpad.net/juju-core/instance"
+	"launchpad.net/juju-core/provider/dummy"
 	"launchpad.net/juju-core/state"
 	"launchpad.net/juju-core/state/api/params"
 	"launchpad.net/juju-core/testing"
@@ -81,8 +82,9 @@
 		Characteristics: expectHW,
 		SharedSecret:    "abc123",
 	}
-	envAttrs := testing.FakeConfig().Delete("admin-secret").Merge(testing.Attrs{
+	envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{
 		"agent-version": version.Current.Number.String(),
+		"state-id":      "1", // needed so policy can Open config
 	})
 	envCfg, err := config.New(config.NoDefaults, envAttrs)
 	c.Assert(err, gc.IsNil)
@@ -193,8 +195,9 @@
 		InstanceId:      "i-bootstrap",
 		Characteristics: expectHW,
 	}
-	envAttrs := testing.FakeConfig().Delete("admin-secret").Merge(testing.Attrs{
+	envAttrs := dummy.SampleConfig().Delete("admin-secret").Merge(testing.Attrs{
 		"agent-version": version.Current.Number.String(),
+		"state-id":      "1", // needed so policy can Open config
 	})
 	envCfg, err := config.New(config.NoDefaults, envAttrs)
 	c.Assert(err, gc.IsNil)

=== modified file 'environs/interface.go'
--- environs/interface.go	2014-04-02 11:35:49 +0000
+++ environs/interface.go	2014-04-03 03:38:42 +0000
@@ -15,18 +15,6 @@
 	"launchpad.net/juju-core/state/api"
 )
 
-// EnvironCapability implements access to metadata about the capabilities
-// of an environment.
-type EnvironCapability interface {
-	// SupportedArchitectures returns the image architectures which can
-	// be hosted by this environment.
-	SupportedArchitectures() ([]string, error)
-
-	// SupportNetworks returns whether the environment has support to
-	// specify networks for services and machines.
-	SupportNetworks() bool
-}
-
 // A EnvironProvider represents a computing and storage provider.
 type EnvironProvider interface {
 	// Prepare prepares an environment for use. Any additional
@@ -123,7 +111,7 @@
 	ConfigGetter
 
 	// EnvironCapability allows access to this environment's capabilities.
-	EnvironCapability
+	state.EnvironCapability
 
 	// SetConfig updates the Environ's configuration.
 	//
@@ -168,9 +156,7 @@
 	// Provider returns the EnvironProvider that created this Environ.
 	Provider() EnvironProvider
 
-	// TODO(axw) 2014-02-11 #pending-review
-	//     Embed state.Prechecker, and introduce an EnvironBase
-	//     that embeds a no-op prechecker implementation.
+	state.Prechecker
 }
 
 // BootstrapContext is an interface that is passed to

=== modified file 'environs/statepolicy.go'
--- environs/statepolicy.go	2014-03-25 13:01:16 +0000
+++ environs/statepolicy.go	2014-04-03 03:38:42 +0000
@@ -5,7 +5,6 @@
 
 import (
 	"launchpad.net/juju-core/environs/config"
-	"launchpad.net/juju-core/errors"
 	"launchpad.net/juju-core/state"
 )
 
@@ -23,17 +22,16 @@
 }
 
 func (environStatePolicy) Prechecker(cfg *config.Config) (state.Prechecker, error) {
-	env, err := New(cfg)
-	if err != nil {
-		return nil, err
-	}
-
-	if p, ok := env.(state.Prechecker); ok {
-		return p, nil
-	}
-	return nil, errors.NewNotImplementedError("Prechecker")
+	// Environ implements state.Prechecker.
+	return New(cfg)
 }
 
 func (environStatePolicy) ConfigValidator(providerType string) (state.ConfigValidator, error) {
+	// EnvironProvider implements state.ConfigValidator.
 	return Provider(providerType)
 }
+
+func (environStatePolicy) EnvironCapability(cfg *config.Config) (state.EnvironCapability, error) {
+	// Environ implements state.EnvironCapability.
+	return New(cfg)
+}

=== modified file 'provider/azure/environ.go'
--- provider/azure/environ.go	2014-04-02 07:44:08 +0000
+++ provider/azure/environ.go	2014-04-03 03:38:42 +0000
@@ -51,6 +51,9 @@
 )
 
 type azureEnviron struct {
+	common.NopPrecheckerPolicy
+	common.SupportsUnitPlacementPolicy
+
 	// Except where indicated otherwise, all fields in this object should
 	// only be accessed using a lock or a snapshot.
 	sync.Mutex

=== added file 'provider/common/policies.go'
--- provider/common/policies.go	1970-01-01 00:00:00 +0000
+++ provider/common/policies.go	2014-04-03 03:38:42 +0000
@@ -0,0 +1,30 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package common
+
+import (
+	"launchpad.net/juju-core/constraints"
+	"launchpad.net/juju-core/state"
+)
+
+// SupportsUnitPlacementPolicy provides an
+// implementation of SupportsUnitPlacement
+// that never returns an error, and is
+// intended for embedding in environs.Environ
+// implementations.
+type SupportsUnitPlacementPolicy struct{}
+
+func (*SupportsUnitPlacementPolicy) SupportsUnitPlacement() error {
+	return nil
+}
+
+// NopPrecheckerPolicy provides an implementation of the
+// state.Prechecker interface that passes all checks.
+type NopPrecheckerPolicy struct{}
+
+var _ state.Prechecker = (*NopPrecheckerPolicy)(nil)
+
+func (*NopPrecheckerPolicy) PrecheckInstance(series string, cons constraints.Value) error {
+	return nil
+}

=== modified file 'provider/dummy/environs.go'
--- provider/dummy/environs.go	2014-04-02 11:35:49 +0000
+++ provider/dummy/environs.go	2014-04-03 03:38:42 +0000
@@ -182,6 +182,9 @@
 // environ represents a client's connection to a given environment's
 // state.
 type environ struct {
+	common.NopPrecheckerPolicy
+	common.SupportsUnitPlacementPolicy
+
 	name         string
 	ecfgMutex    sync.Mutex
 	ecfgUnlocked *environConfig

=== modified file 'provider/ec2/ec2.go'
--- provider/ec2/ec2.go	2014-04-02 11:35:49 +0000
+++ provider/ec2/ec2.go	2014-04-03 03:38:42 +0000
@@ -47,6 +47,9 @@
 var providerInstance environProvider
 
 type environ struct {
+	common.NopPrecheckerPolicy
+	common.SupportsUnitPlacementPolicy
+
 	name string
 
 	// archMutex gates access to supportedArchitectures

=== modified file 'provider/joyent/environ.go'
--- provider/joyent/environ.go	2014-04-02 11:35:49 +0000
+++ provider/joyent/environ.go	2014-04-03 03:38:42 +0000
@@ -20,6 +20,9 @@
 // This file contains the core of the Joyent Environ implementation.
 
 type joyentEnviron struct {
+	common.NopPrecheckerPolicy
+	common.SupportsUnitPlacementPolicy
+
 	name string
 
 	// supportedArchitectures caches the architectures

=== modified file 'provider/local/environ.go'
--- provider/local/environ.go	2014-04-02 07:44:08 +0000
+++ provider/local/environ.go	2014-04-03 03:38:42 +0000
@@ -56,6 +56,9 @@
 var _ envtools.SupportsCustomSources = (*localEnviron)(nil)
 
 type localEnviron struct {
+	common.NopPrecheckerPolicy
+	common.SupportsUnitPlacementPolicy
+
 	localMutex       sync.Mutex
 	config           *environConfig
 	name             string

=== modified file 'provider/maas/environ.go'
--- provider/maas/environ.go	2014-04-02 07:50:15 +0000
+++ provider/maas/environ.go	2014-04-03 03:38:42 +0000
@@ -47,6 +47,9 @@
 }
 
 type maasEnviron struct {
+	common.NopPrecheckerPolicy
+	common.SupportsUnitPlacementPolicy
+
 	name string
 
 	// archMutex gates access to supportedArchitectures

=== modified file 'provider/manual/environ.go'
--- provider/manual/environ.go	2014-04-03 02:57:11 +0000
+++ provider/manual/environ.go	2014-04-03 03:38:42 +0000
@@ -49,6 +49,8 @@
 var logger = loggo.GetLogger("juju.provider.manual")
 
 type manualEnviron struct {
+	common.SupportsUnitPlacementPolicy
+
 	cfg                 *environConfig
 	cfgmutex            sync.Mutex
 	storage             storage.Storage

=== modified file 'provider/openstack/provider.go'
--- provider/openstack/provider.go	2014-04-02 11:35:49 +0000
+++ provider/openstack/provider.go	2014-04-03 03:38:42 +0000
@@ -275,6 +275,9 @@
 }
 
 type environ struct {
+	common.NopPrecheckerPolicy
+	common.SupportsUnitPlacementPolicy
+
 	name string
 
 	// archMutex gates access to supportedArchitectures

=== modified file 'state/addmachine.go'
--- state/addmachine.go	2014-04-03 02:57:11 +0000
+++ state/addmachine.go	2014-04-03 03:38:42 +0000
@@ -133,6 +133,13 @@
 	var ops []txn.Op
 	var mdocs []*machineDoc
 	for _, template := range templates {
+		// Adding a machine without any principals is
+		// only permitted unit placement is supported.
+		if len(template.principals) == 0 {
+			if err := st.supportsUnitPlacement(); err != nil {
+				return nil, err
+			}
+		}
 		mdoc, addOps, err := st.addMachineOps(template)
 		if err != nil {
 			return nil, err
@@ -292,6 +299,10 @@
 	if containerType == "" {
 		return nil, nil, fmt.Errorf("no container type specified")
 	}
+	// Adding a machine within a machine implies add-machine or placement.
+	if err := st.supportsUnitPlacement(); err != nil {
+		return nil, nil, err
+	}
 
 	// If a parent machine is specified, make sure it exists
 	// and can support the requested container type.
@@ -352,6 +363,10 @@
 		if err := st.precheckInstance(parentTemplate.Series, parentTemplate.Constraints); err != nil {
 			return nil, nil, err
 		}
+		// Adding a machine within a machine implies add-machine or placement.
+		if err := st.supportsUnitPlacement(); err != nil {
+			return nil, nil, err
+		}
 	}
 
 	parentDoc := machineDocForTemplate(parentTemplate, strconv.Itoa(seq))

=== modified file 'state/conn_test.go'
--- state/conn_test.go	2014-03-25 14:51:19 +0000
+++ state/conn_test.go	2014-04-03 03:38:42 +0000
@@ -101,8 +101,9 @@
 }
 
 type mockPolicy struct {
-	getPrechecker      func(*config.Config) (state.Prechecker, error)
-	getConfigValidator func(string) (state.ConfigValidator, error)
+	getPrechecker        func(*config.Config) (state.Prechecker, error)
+	getConfigValidator   func(string) (state.ConfigValidator, error)
+	getEnvironCapability func(*config.Config) (state.EnvironCapability, error)
 }
 
 func (p *mockPolicy) Prechecker(cfg *config.Config) (state.Prechecker, error) {
@@ -118,3 +119,10 @@
 	}
 	return nil, errors.NewNotImplementedError("ConfigValidator")
 }
+
+func (p *mockPolicy) EnvironCapability(cfg *config.Config) (state.EnvironCapability, error) {
+	if p.getEnvironCapability != nil {
+		return p.getEnvironCapability(cfg)
+	}
+	return nil, errors.NewNotImplementedError("EnvironCapability")
+}

=== added file 'state/environcapability_test.go'
--- state/environcapability_test.go	1970-01-01 00:00:00 +0000
+++ state/environcapability_test.go	2014-04-03 03:38:42 +0000
@@ -0,0 +1,116 @@
+// Copyright 2014 Canonical Ltd.
+// Licensed under the AGPLv3, see LICENCE file for details.
+
+package state_test
+
+import (
+	"fmt"
+
+	gc "launchpad.net/gocheck"
+
+	"launchpad.net/juju-core/environs/config"
+	"launchpad.net/juju-core/errors"
+	"launchpad.net/juju-core/instance"
+	"launchpad.net/juju-core/state"
+)
+
+type EnvironCapabilitySuite struct {
+	ConnSuite
+	capability mockEnvironCapability
+}
+
+var _ = gc.Suite(&EnvironCapabilitySuite{})
+
+type mockEnvironCapability struct {
+	supportsUnitPlacementError error
+}
+
+func (p *mockEnvironCapability) SupportedArchitectures() ([]string, error) {
+	panic("unused")
+}
+
+func (p *mockEnvironCapability) SupportNetworks() bool {
+	panic("unused")
+}
+
+func (p *mockEnvironCapability) SupportsUnitPlacement() error {
+	return p.supportsUnitPlacementError
+}
+
+func (s *EnvironCapabilitySuite) SetUpTest(c *gc.C) {
+	s.ConnSuite.SetUpTest(c)
+	s.capability = mockEnvironCapability{}
+	s.policy.getEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
+		return &s.capability, nil
+	}
+}
+
+func (s *EnvironCapabilitySuite) addOneMachine(c *gc.C) (*state.Machine, error) {
+	return s.State.AddOneMachine(state.MachineTemplate{
+		Series: "quantal",
+		Jobs:   []state.MachineJob{state.JobHostUnits},
+	})
+}
+
+func (s *EnvironCapabilitySuite) addMachineInsideNewMachine(c *gc.C) error {
+	template := state.MachineTemplate{
+		Series: "quantal",
+		Jobs:   []state.MachineJob{state.JobHostUnits},
+	}
+	_, err := s.State.AddMachineInsideNewMachine(template, template, instance.LXC)
+	return err
+}
+
+func (s *EnvironCapabilitySuite) TestSupportsUnitPlacementAddMachine(c *gc.C) {
+	// Ensure that AddOneMachine fails when PrecheckInstance returns an error.
+	s.capability.supportsUnitPlacementError = fmt.Errorf("no add-machine for you")
+	_, err := s.addOneMachine(c)
+	c.Assert(err, gc.ErrorMatches, ".*no add-machine for you")
+	err = s.addMachineInsideNewMachine(c)
+	c.Assert(err, gc.ErrorMatches, ".*no add-machine for you")
+	// If the policy's EnvironCapability method fails, that will be returned first.
+	s.policy.getEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
+		return nil, fmt.Errorf("incapable of EnvironCapability")
+	}
+	_, err = s.addOneMachine(c)
+	c.Assert(err, gc.ErrorMatches, ".*incapable of EnvironCapability")
+}
+
+func (s *EnvironCapabilitySuite) TestSupportsUnitPlacementUnitAssignment(c *gc.C) {
+	m, err := s.addOneMachine(c)
+	c.Assert(err, gc.IsNil)
+
+	charm := s.AddTestingCharm(c, "wordpress")
+	service := s.AddTestingService(c, "wordpress", charm)
+	unit, err := service.AddUnit()
+	c.Assert(err, gc.IsNil)
+
+	s.capability.supportsUnitPlacementError = fmt.Errorf("no unit placement for you")
+	err = unit.AssignToMachine(m)
+	c.Assert(err, gc.ErrorMatches, ".*no unit placement for you")
+
+	err = unit.AssignToNewMachine()
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *EnvironCapabilitySuite) TestEnvironCapabilityUnimplemented(c *gc.C) {
+	var capabilityErr error
+	s.policy.getEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
+		return nil, capabilityErr
+	}
+	_, err := s.addOneMachine(c)
+	c.Assert(err, gc.ErrorMatches, "cannot add a new machine: policy returned nil EnvironCapability without an error")
+	capabilityErr = errors.NewNotImplementedError("EnvironCapability")
+	_, err = s.addOneMachine(c)
+	c.Assert(err, gc.IsNil)
+}
+
+func (s *EnvironCapabilitySuite) TestSupportsUnitPlacementNoPolicy(c *gc.C) {
+	s.policy.getEnvironCapability = func(*config.Config) (state.EnvironCapability, error) {
+		c.Errorf("should not have been invoked")
+		return nil, nil
+	}
+	state.SetPolicy(s.State, nil)
+	_, err := s.addOneMachine(c)
+	c.Assert(err, gc.IsNil)
+}

=== modified file 'state/policy.go'
--- state/policy.go	2014-04-03 02:57:11 +0000
+++ state/policy.go	2014-04-03 03:38:42 +0000
@@ -25,9 +25,13 @@
 	// a (possibly nil) Prechecker or an error.
 	Prechecker(*config.Config) (Prechecker, error)
 
-	// ConfigValidator takes a string (environ type) and returns
+	// ConfigValidator takes a provider type name and returns
 	// a (possibly nil) ConfigValidator or an error.
-	ConfigValidator(string) (ConfigValidator, error)
+	ConfigValidator(providerType string) (ConfigValidator, error)
+
+	// EnvironCapability takes a *config.Config and returns
+	// a (possibly nil) EnvironCapability or an error.
+	EnvironCapability(*config.Config) (EnvironCapability, error)
 }
 
 // Prechecker is a policy interface that is provided to State
@@ -50,6 +54,24 @@
 	Validate(cfg, old *config.Config) (valid *config.Config, err error)
 }
 
+// EnvironCapability implements access to metadata about the capabilities
+// of an environment.
+type EnvironCapability interface {
+	// SupportedArchitectures returns the image architectures which can
+	// be hosted by this environment.
+	SupportedArchitectures() ([]string, error)
+
+	// SupportNetworks returns whether the environment has support to
+	// specify networks for services and machines.
+	SupportNetworks() bool
+
+	// SupportsUnitAssignment returns an error which, if non-nil, indicates
+	// that the environment does not support unit placement. If the environment
+	// does not support unit placement, then machines may not be created
+	// without units, and units cannot be placed explcitly.
+	SupportsUnitPlacement() error
+}
+
 // precheckInstance calls the state's assigned policy, if non-nil, to obtain
 // a Prechecker, and calls PrecheckInstance if a non-nil Prechecker is returned.
 func (st *State) precheckInstance(series string, cons constraints.Value) error {
@@ -73,7 +95,8 @@
 }
 
 // validate calls the state's assigned policy, if non-nil, to obtain
-// a Validator, and calls validate if a non-nil Validator is returned.
+// a ConfigValidator, and calls Validate if a non-nil ConfigValidator is
+// returned.
 func (st *State) validate(cfg, old *config.Config) (valid *config.Config, err error) {
 	if st.policy == nil {
 		return cfg, nil
@@ -89,3 +112,26 @@
 	}
 	return configValidator.Validate(cfg, old)
 }
+
+// supportsUnitPlacement calls the state's assigned policy, if non-nil,
+// to obtain an EnvironCapability, and calls SupportsUnitPlacement if a
+// non-nil EnvironCapability is returned.
+func (st *State) supportsUnitPlacement() error {
+	if st.policy == nil {
+		return nil
+	}
+	cfg, err := st.EnvironConfig()
+	if err != nil {
+		return err
+	}
+	capability, err := st.policy.EnvironCapability(cfg)
+	if errors.IsNotImplementedError(err) {
+		return nil
+	} else if err != nil {
+		return err
+	}
+	if capability == nil {
+		return fmt.Errorf("policy returned nil EnvironCapability without an error")
+	}
+	return capability.SupportsUnitPlacement()
+}

=== modified file 'state/unit.go'
--- state/unit.go	2014-04-02 11:35:49 +0000
+++ state/unit.go	2014-04-03 03:38:42 +0000
@@ -823,6 +823,11 @@
 	if !canHost {
 		return fmt.Errorf("machine %q cannot host units", m)
 	}
+	// assignToMachine implies assignment to an existing machine,
+	// which is only permitted if unit placement is supported.
+	if err := u.st.supportsUnitPlacement(); err != nil {
+		return err
+	}
 	assert := append(isAliveDoc, bson.D{
 		{"$or", []bson.D{
 			{{"machineid", ""}},