Merge lp:~fwereade/pyjuju/shadow-trunk-1204 into lp:pyjuju

[William Reade]

Constraints feature

End result of many branches merged into lp:~fwereade/juju/shadow-trunk-1204
over the last couple of weeks. Includes provider-specific constraint
registration (not global), provision for legacy deployments, and environment
constraints.

https://codereview.appspot.com/5971047/

[William Reade (fwereade)]

Please take a look.

[William Reade (fwereade)]

Reviewers: mp+100195_code.launchpad.net,

Message:
Please take a look.

Description:
Constraints feature

End result of many branches merged into
lp:~fwereade/juju/shadow-trunk-1204
over the last couple of weeks. Includes provider-specific constraint
registration (not global), provision for legacy deployments, and
environment
constraints.

https://code.launchpad.net/~fwereade/juju/shadow-trunk-1204/+merge/100195

(do not edit description out of merge proposal)

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

Affected files:
   A [revision details]
   A docs/source/internals/constraints-notes.rst
   M juju/agents/provision.py
   M juju/agents/tests/common.py
   M juju/agents/tests/test_machine.py
   M juju/agents/tests/test_provision.py
   M juju/control/__init__.py
   M juju/control/add_unit.py
   M juju/control/bootstrap.py
   A juju/control/constraints_get.py
   M juju/control/constraints_set.py
   M juju/control/deploy.py
   M juju/control/initialize.py
   A juju/control/legacy.py
   M juju/control/terminate_machine.py
   M juju/control/tests/test_add_relation.py
   M juju/control/tests/test_add_unit.py
   M juju/control/tests/test_bootstrap.py
   M juju/control/tests/test_config_get.py
   M juju/control/tests/test_config_set.py
   A juju/control/tests/test_constraints_get.py
   M juju/control/tests/test_constraints_set.py
   M juju/control/tests/test_control.py
   M juju/control/tests/test_debug_hooks.py
   M juju/control/tests/test_debug_log.py
   M juju/control/tests/test_deploy.py
   M juju/control/tests/test_destroy_service.py
   M juju/control/tests/test_initialize.py
   M juju/control/tests/test_remove_unit.py
   M juju/control/tests/test_resolved.py
   M juju/control/tests/test_scp.py
   M juju/control/tests/test_ssh.py
   M juju/control/tests/test_status.py
   M juju/control/tests/test_terminate_machine.py
   M juju/control/tests/test_upgrade_charm.py
   M juju/control/tests/test_utils.py
   M juju/control/utils.py
   M juju/environment/config.py
   M juju/environment/tests/test_config.py
   M juju/hooks/tests/test_invoker.py
   M juju/machine/constraints.py
   M juju/machine/tests/test_constraints.py
   M juju/machine/unit.py
   M juju/providers/common/base.py
   M juju/providers/common/bootstrap.py
   M juju/providers/common/cloudinit.py
   M juju/providers/common/launch.py
   M juju/providers/common/tests/data/cloud_init_bootstrap
   M juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers
   M juju/providers/common/tests/data/cloud_init_distro
   M juju/providers/common/tests/data/cloud_init_ppa
   M juju/providers/common/tests/test_base.py
   M juju/providers/common/tests/test_bootstrap.py
   M juju/providers/common/tests/test_cloudinit.py
   M juju/providers/common/tests/test_launch.py
   M juju/providers/dummy.py
   M juju/providers/ec2/__init__.py
   M juju/providers/ec2/launch.py
   M juju/providers/ec2/tests/common.py
   M juju/providers/ec2/tests/data/bootstrap_cloud_init
   M juju/providers/ec2/tests/test_bootstrap.py
   M juju/providers/ec2/tests/test_launch.py
   M juju/providers/ec2/tests/test_provider.py
   M juju/providers/ec2/tests/test_utils.py
   M juju/providers/ec2/utils.py
   M juju...

[William Reade (fwereade)]

*** Submitted:

Constraints feature

End result of many branches merged into
lp:~fwereade/juju/shadow-trunk-1204
over the last couple of weeks. Includes provider-specific constraint
registration (not global), provision for legacy deployments, and
environment
constraints.

R=
CC=
https://codereview.appspot.com/5971047

https://codereview.appspot.com/5971047/

=== added file 'docs/source/internals/constraints-notes.rst'
--- docs/source/internals/constraints-notes.rst	1970-01-01 00:00:00 +0000
+++ docs/source/internals/constraints-notes.rst	2012-03-30 16:56:32 +0000
@@ -0,0 +1,78 @@
+Notes on the current state of machine constraints
+=================================================
+
+Summary
+-------
+
+EC2 constraints and generic constraints can each be used to provision EC2 machines as intended. Orchestra support is not implemented, and should remain on hold until we get some clarity about MaaS. Environment constraints are not implemented; machine reuse is limited but predictable. Unit constraints, and a get-constraints command, should probably be added despite not being in the initial spec.
+
+We should prepare the ground for, and implement, environment constraints above all else. Adding a --constraints argument to add-unit will be very easy, and adding a get-constraints command won't be much harder, and the feature will feel much more complete with these capabilities, so they should come next. After that we should, with care and discretion, start tweaking the unit/machine matching algorithms such that we do the Right Thing more often without running the risk of doing a surprising and/or costly Wrong Thing.
+
+
+Code overview
+-------------
+
+`juju.machine.constraints` contains a `Constraints` type and a `_Constraint` type (which holds the configuration for a given constraint). The actual configuration is set up in `juju.machine.constraints_info` by means of calls to `register_constraint` and `register_conflicts`. Note that `ubuntu-series` and `provider-type` are themselves modelled as constraints (largely for ease/ consitency of representation) but are not exposed via `from_strs`, thereby preventing users from specifying things that should only be set by the code.
+
+The juju defaults are contained in the individual configured `_Constraint` objects; empty values are converted to defaults at `from_strs` time (when a provider type and a list of strings are used to construct a `Constraints` object). Therefore, the juju defaults are not themselves a separate `Constraints` object.
+
+Once created, `Constraints` objects store everything in their `_layer_data` dict, which contains keys for (1) every constraint specified explicitly and (2) every constraint conflicting with one specified explicitly (these are set to None). When storing constraints in ZK, all you need to do is serialise this dict (exposed as `layer_data`); `Constraints` objects can then be reconstructed directly from such dicts.
+
+This layer data does not necessarily include all possible constraints; so, when a `Constraints` is being used as a dict, we ensure we return default values for every key not in `_layer_data` (we also convert values from their textual representations to more-easily-consumable ones; so, eg, a mem of "4G" becomes 4096.0). However, we don't have any reason to store unset constraints at any stage; doing so would make it far harder to update one `Constraints` object with another. This is because `_layer_data` is effectively a mask: by updating A with B, the conflict Nones in B will overwrite any values set in A; while any keys not overridden will retain their values or conflict Nones, which ensures that we don't accidentally insert defaults due to missing values.  Consider:
+
+A = "orchestra-name=jimbob" (masks arch, cpu, mem, orchestra-classes)
+B = "arch=arm orchestra-classes=ultralightweight" (masks orchestra-name)
+
+Now, if we A.update(B): orchestra-name gets masked out; cpu and mem remain masked out from before; the only remaining (user-visible) constraints are arch and orchestra-classes. Because the "ultralightweight" orchestra-class could easily be referring to a set of machines with very low cpu values, we *don't* want to reapply the default cpu constraint: we want to keep it masked as None, so we don't end up with a surprisingly unfulfillable request.
+
+It's a bit tricker on EC2: if arch overrides ec2-instance-type, this masks out cpu and mem as before and will therefore, in the absence of other constraints, deliver a t1.micro. IMO this is acceptable because: if someone's already thinking in instance-types, that's what they'll use in practice, so it's an edge case anyway; the results are actually not unreasonable; and the cost of incorrect behaviour is very low. The alternative -- of treating ec2-instance-type constraints as implicit arch/cpu/mem constraints, (so the update would end up with: a blank ec2-instance type; arch from the strings; and cpu/mem from the previous layer's ec2-instance-type) -- seems to me to be more likely to lead to surprising and potentially costly behaviour. This behaviour could be bolted on with little effort if deemed helpful, though.
+
+There are a couple of extra notes on EC2 in the source, both in `constraints_info` and in the ec2 provider code itself. (Note that ec2 constraints are defined in `constraints_info`, not the provider itself, because I want to be sure (without excessive magic or circular imports) that all constraints have been registered *before* any `Constraints` object is constructed, lest one be constructed with a incorrect mask. (It would be quick and easy to notify `_Constraint` once a `Constraints` is constructed, and refuse to register further constraints and conflicts, to ensure nobody does this accidentally; I only just thought if this though.) Most of the code for interpreting constraints is in the ec2 provider, though; this is because it only comes into play at provisioning time.
+
+
+Usage
+-----
+
+Actual use is pretty trivial, but involved an irritating weight of API changes: service states, unit states, and machine states all now require constraints, and it's tricky to figure out what the right "default" would be. (Well, we could grab provider-type from `GlobalSettingsStateManager` and construct it from an empty string list, but I have a disinclination to access such things without a very good reason; and since now, I think, all the "real" uses (as opposed to "test") can be expected to have constraints readily available, the inconvenience of changing all the tests doesn't seem like a valid argument against explicit specification. Does pollute the diffs a bit, though; sorry.)
+
+Basically, constraints are set on a service via `deploy` or `set-constraints`; then, when a unit is added, they're copied from the service to the unit (note: will be trivial to combine with env constraints and save the combined constraints... that is, when we actually have some env constraints); then, when a machine is added for a unit, the constraints are matched against existing machines' states, or used to construct a new one onto which the unit will be placed; and finally, those machine constraints are eventually passed into the provider by the provisioning agent.
+
+Bootstrap remains less than ideal -- but since we know the ubuntu-series and the provider-type, both on the client and on the bootstrap node, we can construct a full `Constraints` object and just use the default values for the other constraints; and, we can do so both when provisioning the initial machine (on the client) and when creating the bootstrap node's machine state (on the bootstrap node itself). When we have env constraints, we'll need to use them for provisioning *and* feed them through to the initialize command on the bootstrap node, so we can set up the correct machine state (in addition to the environment constraint state we'll need to set up).
+
+
+Merge pipeline
+--------------
+
+* placement-spec (Just the spec. Despite the MaaS-related inaccuracies, worth merging, IMO.)
+
+* constraint-types (Add `juju.machine.constraints` and `juju.machine.constraints_info`. Oh, and `juju.errors.ConstraintError`.)
+
+* set-service-constraints (Add `set-constraints` command; add param to `deploy` command; store constraints in service state.)
+
+* apply-machine-constraints (Constraints are set on the unit state by the service state, and on the machine state by (or from) the unit state; `initialize` command sets default constraints on machine/0.)
+
+* pa-start-machine-constraints (When launching machines, the provisioning agent passes "constraints" in machine_data, which are now actually used by the ec2 provider (I couldn't break this up further: once the constraints were passed in, ec2 had to change). Also removed "default-instance-type" and "default-ami" from ec2 environment config, and set bootstrap to provision a machine from juju defaults. Note: appears to actually work as expected.)
+
+
+Known problems
+--------------
+
+* Most horrifyingly: MaaS plans imply that we shouldn't depend on being able to specify `arch`, `cpu`, `mem`, or `orchestra-classes`, and I'm more than somewhat blindsided by this... certainly, with those (er) constraints, the eventual implementation cannot match the spec as currently written.
+
+* No environment constraints are implemented; it's not hard per se (add handling to `bootstrap` and `set-constraints`; store them somewhere sensible; get and combine them at unit-add time) but (as discussed) it would be a good idea to make the environment settings behaviour saner *before* we add constraints to the mix. Once that's done, we need to remember to actually use the information at bootstrap time, both for provisioning the bootstrap node and constructing its ZK state.
+
+  * I think it's fine for people to specify non-connection info inside their environments.yaml~s; but I think all such settings should be in a sub-dict called "initial" (or "bootstrap", or possibly even "default", as discussed at P-rally; I'm not sure which word carries the most appropriate semantic payload, but I'm not sure "default" is quite right).
+
+* Unused machines are not reused very sensibly: we just grab the first one we see that fulfils the relevant service unit's constraints. It would be trivial to build up a list of matching machines; it's not immediately clear just how we should go about picking the most appropriate machine from such a list.
+
+  * Well, ok, it's pretty clear -- we can "just" define a cost method on `Constraints`, and pick the cheapest. (But should we really reuse a cc1.4xlarge for a job that only demands an m1.small? Even if that's an easy question, what about orchestra? If we're interested in picking cheap machines -- and even assuming we can come up with a universally appropriate cost function -- we still need to consider the unused machines as well if we want to get a good answer.)
+
+  I remain convinced that it'll have to take the provider into consideration somehow -- and, tangentially, that we'll need to be a bit more sophisticated about matching `ec2-instance-type` constraints against generic constraints and vice versa -- and so I'm getting a little concerned that the "single type for Constraints" preference expressed by you and Gustavo is not going to be workable in the long term (but it's set up to require a provider-type to create a `Constraints` anyway, so it should be trivial to factoryise it by provider-type anyway).
+
+* We should probably bulk out machine constraints with actual data from the provider, once they've been provisioned (so we can tell, for example, what ec2-zone we ended up in (if it was left unspecified)). This affects how well we can match existing machines with new units; but what with MaaS, it remains an open question how much of this we'll even be able to do on orchestra(-without-landscape, anyway).
+
+  Note that this functionality -- and other upgrades in machine-reuse sophistication, like the previous bullet -- should IMO be added slowly and incrementally; I think we'll inevitably make mistakes here, at least until we've properly figured out the usage patterns, and I think for our users' sake it's more important that the rules be *clear* than that they be clever.
+
+* No `get-constraints` command exists. This command makes sense for all of env, service, unit, and machine; and on reflection, IMO, it should display the full constraints-as-dict in all cases (not just the layer data) so there's no chance of ambiguity; however, we should consider the implications of exporting explicit constraints as they were set, or as they "are" -- ie if we output mem as "4G" it will be irritating for machines but convenient for humans, while 4096.0 will be better suited for machine consumption (and also gives visibility into exactly what params will be passed to the provider itself). Not specced, but hard to justify leaving out.
+
+* No explicit unit constraints are implemented; the code as it stands would make it *very* easy to set them at add-unit time, and some constraints (well, orchestra-name in particular) only really make sense at the unit level. Nonetheless, it was deliberately left out of the spec, and can be worked around by users where necesssary, so it's not really a priority; but IMO the benefit outwieghs the very small cost of implementing it.

=== modified file 'juju/agents/provision.py'
--- juju/agents/provision.py	2012-02-01 15:39:08 +0000
+++ juju/agents/provision.py	2012-03-30 16:56:32 +0000
@@ -6,7 +6,7 @@
 from juju.environment.config import EnvironmentsConfig
 from juju.errors import ProviderError
 from juju.lib.twistutils import concurrent_execution_guard
-from juju.state.errors import MachineStateNotFound, StateChanged, StopWatcher
+from juju.state.errors import MachineStateNotFound, StopWatcher
 from juju.state.firewall import FirewallManager
 from juju.state.machine import MachineStateManager
 from juju.state.service import ServiceStateManager
@@ -223,8 +223,9 @@
         # Verify a machine id has state and is running, else launch it.
         if instance_id is None or not instance_id in provider_machine_map:
             log.info("Starting machine id:%s ...", machine_state.id)
+            constraints = yield machine_state.get_constraints()
             machines = yield self.provider.start_machine(
-                {"machine-id": machine_state.id})
+                {"machine-id": machine_state.id, "constraints": constraints})
             instance_id = machines[0].instance_id
             yield machine_state.set_instance_id(instance_id)
 

=== modified file 'juju/agents/tests/common.py'
--- juju/agents/tests/common.py	2011-11-28 12:28:57 +0000
+++ juju/agents/tests/common.py	2012-03-30 16:56:32 +0000
@@ -5,30 +5,23 @@
 from txzookeeper.tests.utils import deleteTree
 
 from juju.agents.base import TwistedOptionNamespace
-from juju.environment.config import EnvironmentsConfig
 from juju.state.tests.common import StateTestBase
 from juju.tests.common import get_test_zookeeper_address
 
 
-SAMPLE_ENV = """\
-environments:
-  myfirstenv:
-    type: dummy
-    foo: bar
-    storage-directory: %s
-"""
-
-
 class AgentTestBase(StateTestBase):
 
     agent_class = None
     juju_directory = None
+    setup_environment = True
 
     @inlineCallbacks
     def setUp(self):
         self.juju_directory = self.makeDir()
         yield super(AgentTestBase, self).setUp()
         assert self.agent_class, "Agent Class must be specified on test"
+        if self.setup_environment:
+            yield self.push_default_config()
         self.agent = self.agent_class()
         self.options = yield self.get_agent_config()
         self.agent.configure(self.options)
@@ -42,15 +35,6 @@
             deleteTree("/", self.client.handle)
             self.client.close()
 
-    def get_test_environment_config(self):
-        sample_config = SAMPLE_ENV % self.makeDir()
-        config = EnvironmentsConfig()
-        config.parse(sample_config)
-        return config
-
-    def get_test_environment(self):
-        return self.get_test_environment_config().get_default()
-
     def get_agent_config(self):
         options = TwistedOptionNamespace()
         options["juju_directory"] = self.juju_directory

=== modified file 'juju/agents/tests/test_machine.py'
--- juju/agents/tests/test_machine.py	2012-03-16 16:54:43 +0000
+++ juju/agents/tests/test_machine.py	2012-03-30 16:56:32 +0000
@@ -2,8 +2,7 @@
 import logging
 import os
 
-from twisted.internet.defer import (
-    inlineCallbacks, returnValue, succeed, fail, Deferred)
+from twisted.internet.defer import inlineCallbacks, returnValue, fail, Deferred
 
 from juju.agents.base import TwistedOptionNamespace
 from juju.agents.machine import MachineAgent
@@ -14,8 +13,8 @@
 from juju.charm.tests import local_charm_id
 from juju.charm.tests.test_repository import RepositoryTestBase
 from juju.lib.mocker import MATCH
-from juju.machine.constraints import Constraints
-from juju.state.environment import EnvironmentStateManager
+from juju.machine.tests.test_constraints import (
+    dummy_constraints, series_constraints)
 from juju.state.machine import MachineStateManager, MachineState
 from juju.state.service import ServiceStateManager
 from juju.tests.common import get_test_zookeeper_address
@@ -36,13 +35,7 @@
         yield super(MachineAgentTest, self).setUp()
 
         self.output = self.capture_logging(level=logging.DEBUG)
-
-        config = self.get_test_environment_config()
-        environment = config.get_default()
-
-        # Store the environment to zookeeper
-        environment_state_manager = EnvironmentStateManager(self.client)
-        yield environment_state_manager.set_config_state(config, "myfirstenv")
+        environment = self.config.get_default()
 
         # Load the environment with the charm state and charm binary
         self.provider = environment.get_machine_provider()
@@ -58,8 +51,7 @@
         # the machine.
         self.service_state_manager = ServiceStateManager(self.client)
         self.service = yield self.service_state_manager.add_service_state(
-            "fatality-blog", self.charm_state,
-            Constraints.from_strs("dummy", []))
+            "fatality-blog", self.charm_state, dummy_constraints)
 
     @inlineCallbacks
     def get_agent_config(self):
@@ -68,7 +60,7 @@
         machine_state_manager = MachineStateManager(self.client)
 
         self.machine_state = yield machine_state_manager.add_machine_state(
-            Constraints.from_strs("dummy", []).with_series("series"))
+            series_constraints)
 
         self.change_environment(
             JUJU_MACHINE_ID="0",

=== modified file 'juju/agents/tests/test_provision.py'
--- juju/agents/tests/test_provision.py	2012-01-09 16:57:13 +0000
+++ juju/agents/tests/test_provision.py	2012-03-30 16:56:32 +0000
@@ -1,18 +1,12 @@
 import logging
 
-import zookeeper
-
 from twisted.internet.defer import inlineCallbacks, fail, succeed
 from twisted.internet import reactor
 
-from txzookeeper.client import ZOO_OPEN_ACL_UNSAFE
-
 from juju.agents.provision import ProvisioningAgent
 from juju.environment.environment import Environment
-from juju.environment.config import EnvironmentsConfig
 from juju.environment.errors import EnvironmentsConfigError
-from juju.environment.tests.test_config import SAMPLE_ENV
-from juju.machine.constraints import Constraints
+from juju.machine.tests.test_constraints import dummy_cs, series_constraints
 from juju.errors import ProviderInteractionError
 from juju.lib.mocker import MATCH
 from juju.providers.dummy import DummyMachine
@@ -37,23 +31,21 @@
         yield super(ProvisioningTestBase, self).setUp()
         self.machine_manager = MachineStateManager(self.client)
 
-    def add_machine_state(self):
+    def add_machine_state(self, constraints=None):
         return self.machine_manager.add_machine_state(
-            Constraints.from_strs("dummy", []).with_series("series"))
-
-    def get_serialized_environment(self):
-        config = EnvironmentsConfig()
-        config.parse(SAMPLE_ENV)
-        return config.serialize("myfirstenv")
+            constraints or series_constraints)
 
 
 class ProvisioningAgentStartupTest(ProvisioningTestBase):
 
+    setup_environment = False
+
     @inlineCallbacks
     def setUp(self):
         yield super(ProvisioningAgentStartupTest, self).setUp()
         yield self.agent.connect()
 
+    @inlineCallbacks
     def test_agent_waits_for_environment(self):
         """
         When the agent starts it waits for the /environment node to exist.
@@ -61,31 +53,20 @@
         deserialize it into an environment object.
         """
         env_loaded_deferred = self.agent.configure_environment()
-
-        def verify_environment(result):
-            self.assertTrue(isinstance(result, Environment))
-            self.assertEqual(result.name, "myfirstenv")
-
-        env_loaded_deferred.addCallback(verify_environment)
-
-        def create_environment_node():
-            self.assertFalse(env_loaded_deferred.called)
-            return self.client.create(
-                "/environment", self.get_serialized_environment())
-
-        reactor.callLater(0.3, create_environment_node)
-        return env_loaded_deferred
+        reactor.callLater(
+            0.3, self.push_default_config, with_constraints=False)
+        result = yield env_loaded_deferred
+        self.assertTrue(isinstance(result, Environment))
+        self.assertEqual(result.name, "firstenv")
 
     @inlineCallbacks
     def test_agent_with_existing_environment(self):
         """An agent should load an existing environment to configure itself."""
-
-        yield self.client.create(
-            "/environment", self.get_serialized_environment())
+        yield self.push_default_config()
 
         def verify_environment(result):
             self.assertTrue(isinstance(result, Environment))
-            self.assertEqual(result.name, "myfirstenv")
+            self.assertEqual(result.name, "firstenv")
 
         d = self.agent.configure_environment()
         d.addCallback(verify_environment)
@@ -103,15 +84,13 @@
         while the agent is processing the NoNodeException, it should detect
         this and configure normally.
         """
-        data = self.get_serialized_environment()
         exists_and_watch = self.agent.client.exists_and_watch
 
         mock_client = self.mocker.patch(self.agent.client)
         mock_client.exists_and_watch("/environment")
 
         def inject_creation(path):
-            zookeeper.create(
-                self.agent.client.handle, path, data, [ZOO_OPEN_ACL_UNSAFE])
+            self.push_default_config(with_constraints=False)
             return exists_and_watch(path)
 
         self.mocker.call(inject_creation)
@@ -131,8 +110,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ProvisioningAgentTest, self).setUp()
-        yield self.client.create(
-            "/environment", self.get_serialized_environment())
         self.agent.set_watch_enabled(False)
         yield self.agent.startService()
         self.output = self.capture_logging("juju.agents.provision",
@@ -268,8 +245,7 @@
         If the environment changes the agent reconfigures itself
         """
         provider = self.agent.provider
-        data = self.get_serialized_environment()
-        yield self.client.set("/environment", data)
+        yield self.push_default_config()
         yield self.sleep(0.2)
         self.assertNotIdentical(provider, self.agent.provider)
 
@@ -314,14 +290,22 @@
         If there's an error when processing changes, the agent should log
         the error and continue.
         """
-        machine_state0 = yield self.add_machine_state()
-        machine_state1 = yield self.add_machine_state()
+        machine_state0 = yield self.add_machine_state(
+            dummy_cs.parse(["cpu=10"]).with_series("series"))
+        machine_state1 = yield self.add_machine_state(
+            dummy_cs.parse(["cpu=20"]).with_series("series"))
 
         mock_provider = self.mocker.patch(self.agent.provider)
-        mock_provider.start_machine({"machine-id": 0})
+        mock_provider.start_machine({
+            "machine-id": 0, "constraints": {
+                "arch": "amd64", "cpu": 10, "mem": 512,
+                "provider-type": "dummy", "ubuntu-series": "series"}})
         self.mocker.result(fail(ProviderInteractionError()))
 
-        mock_provider.start_machine({"machine-id": 1})
+        mock_provider.start_machine({
+            "machine-id": 1, "constraints": {
+                "arch": "amd64", "cpu": 20, "mem": 512,
+                "provider-type": "dummy", "ubuntu-series": "series"}})
         self.mocker.passthrough()
         self.mocker.replay()
 
@@ -476,8 +460,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(FirewallManagerTest, self).setUp()
-        yield self.client.create(
-            "/environment", self.get_serialized_environment())
         self.agent.set_watch_enabled(False)
         yield self.agent.startService()
 
@@ -509,11 +491,14 @@
         # Modify services, while subsequently poking to ensure service
         # watch is processed on each modification
         yield self.add_service("wordpress")
-        yield self.poke_zk()
+        while len(seen) < 1:
+            yield self.poke_zk()
         mysql = yield self.add_service("mysql")
-        yield self.poke_zk()
+        while len(seen) < 2:
+            yield self.poke_zk()
         yield self.service_state_manager.remove_service_state(mysql)
-        yield self.poke_zk()
+        while len(seen) < 3:
+            yield self.poke_zk()
 
         self.assertEqual(
             seen,

=== modified file 'juju/control/__init__.py'
--- juju/control/__init__.py	2011-12-15 17:12:26 +0000
+++ juju/control/__init__.py	2012-03-30 16:56:32 +0000
@@ -12,6 +12,7 @@
 import bootstrap
 import config_get
 import config_set
+import constraints_get
 import constraints_set
 import debug_hooks
 import debug_log
@@ -39,6 +40,7 @@
     bootstrap,
     config_get,
     config_set,
+    constraints_get,
     constraints_set,
     debug_log,
     debug_hooks,

=== modified file 'juju/control/add_unit.py'
--- juju/control/add_unit.py	2011-11-29 22:50:38 +0000
+++ juju/control/add_unit.py	2012-03-30 16:56:32 +0000
@@ -2,7 +2,8 @@
 
 from twisted.internet.defer import inlineCallbacks
 
-from juju.control.utils import get_environment
+from juju.control import legacy
+from juju.control.utils import get_environment, sync_environment_state
 from juju.state.placement import place_unit
 from juju.state.service import ServiceStateManager
 
@@ -44,6 +45,10 @@
     client = yield provider.connect()
 
     try:
+        yield legacy.check_environment(
+            client, provider.get_legacy_config_keys())
+        yield sync_environment_state(client, config, environment.name)
+
         service_manager = ServiceStateManager(client)
         service_state = yield service_manager.get_service_state(service_name)
         for i in range(num_units):

=== modified file 'juju/control/bootstrap.py'
--- juju/control/bootstrap.py	2011-09-22 13:23:00 +0000
+++ juju/control/bootstrap.py	2012-03-30 16:56:32 +0000
@@ -1,6 +1,7 @@
 from twisted.internet.defer import inlineCallbacks
 
-from juju.control.utils import get_environment
+from juju.control import legacy
+from juju.control.utils import expand_constraints, get_environment
 
 
 def configure_subparser(subparsers):
@@ -9,6 +10,11 @@
     sub_parser.add_argument(
         "--environment", "-e",
         help="juju environment to operate in.")
+    sub_parser.add_argument(
+        "--constraints",
+        help="default hardware constraints for this environment.",
+        default=[],
+        type=expand_constraints)
     return sub_parser
 
 
@@ -19,6 +25,14 @@
     """
     environment = get_environment(options)
     provider = environment.get_machine_provider()
+    legacy_keys = provider.get_legacy_config_keys()
+    if legacy_keys:
+        legacy.error(legacy_keys)
+
+    constraint_set = yield provider.get_constraint_set()
+    constraints = constraint_set.parse(options.constraints)
+    constraints = constraints.with_series(environment.default_series)
+
     options.log.info("Bootstrapping environment %r (type: %s)..." % (
         environment.name, environment.type))
-    yield provider.bootstrap()
+    yield provider.bootstrap(constraints)

=== added file 'juju/control/constraints_get.py'
--- juju/control/constraints_get.py	1970-01-01 00:00:00 +0000
+++ juju/control/constraints_get.py	2012-03-30 16:56:32 +0000
@@ -0,0 +1,75 @@
+import argparse
+import sys
+import yaml
+
+from twisted.internet.defer import inlineCallbacks
+
+from juju.control.utils import get_environment, sync_environment_state
+from juju.state.environment import EnvironmentStateManager
+from juju.state.machine import MachineStateManager
+from juju.state.service import ServiceStateManager
+
+
+def configure_subparser(subparsers):
+    sub_parser = subparsers.add_parser(
+        "get-constraints",
+        help=command.__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description=constraints_get.__doc__)
+
+    sub_parser.add_argument(
+        "--environment", "-e",
+        help="Environment to affect")
+
+    sub_parser.add_argument(
+        "entities",
+        nargs="*",
+        help="names of machines, units or services")
+
+    return sub_parser
+
+
+def command(options):
+    """Show currently applicable constraints"""
+    environment = get_environment(options)
+    return constraints_get(
+        options.environments, environment, options.entities, options.log)
+
+
+@inlineCallbacks
+def constraints_get(env_config, environment, entity_names, log):
+    """
+    Show the complete set of applicable constraints for each specified entity.
+
+    This will show the final computed values of all constraints (including
+    internal constraints which cannot be set directly via set-constraints).
+    """
+    provider = environment.get_machine_provider()
+    client = yield provider.connect()
+    result = {}
+    try:
+        yield sync_environment_state(client, env_config, environment.name)
+        if entity_names:
+            msm = MachineStateManager(client)
+            ssm = ServiceStateManager(client)
+            for name in entity_names:
+                if name.isdigit():
+                    kind = "machine"
+                    entity = yield msm.get_machine_state(name)
+                elif "/" in name:
+                    kind = "service unit"
+                    entity = yield ssm.get_unit_state(name)
+                else:
+                    kind = "service"
+                    entity = yield ssm.get_service_state(name)
+                log.info("Fetching constraints for %s %s", kind, name)
+                constraints = yield entity.get_constraints()
+                result[name] = dict(constraints)
+        else:
+            esm = EnvironmentStateManager(client)
+            log.info("Fetching constraints for environment")
+            constraints = yield esm.get_constraints()
+            result = dict(constraints)
+        yaml.safe_dump(result, sys.stdout)
+    finally:
+        yield client.close()

=== modified file 'juju/control/constraints_set.py'
--- juju/control/constraints_set.py	2012-03-09 09:02:06 +0000
+++ juju/control/constraints_set.py	2012-03-30 16:56:32 +0000
@@ -2,8 +2,9 @@
 
 from twisted.internet.defer import inlineCallbacks
 
-from juju.control.utils import get_environment
-from juju.machine.constraints import Constraints
+from juju.control import legacy
+from juju.control.utils import get_environment, sync_environment_state
+from juju.state.environment import EnvironmentStateManager
 from juju.state.service import ServiceStateManager
 
 
@@ -34,36 +35,43 @@
     """Set machine constraints for the environment, or for a named service.
     """
     environment = get_environment(options)
+    env_config = options.environments
     return constraints_set(
-        environment, options.service, options.constraints)
+        env_config, environment, options.service, options.constraints)
 
 
 @inlineCallbacks
-def constraints_set(environment, service_name, constraint_strs):
+def constraints_set(env_config, environment, service_name, constraint_strs):
     """
     Machine constraints allow you to pick the hardware to which your services
     will be deployed. Examples:
 
     $ juju set-constraints --service-name mysql mem=8G cpu=4
 
-    $ juju set-constraints ec2-instance-type=t1.micro
-
-    "arch", "cpu" and "mem" are always available; other constraints are
-    provider-specific, and will be ignored if specified in an environment of
-    the wrong kind. The recognised constraints are currently:
-
-    * arch (CPU architecture: x86/amd64/arm; unset by default)
-    * cpu (processing power in Amazon ECU; 1 by default)
-    * mem (memory in [MGT]iB; 512M by default)
-    * ec2-region (us-east-1 by default)
-    * ec2-zone (unset by default)
-    * ec2-instance-type (unset by default)
-    * orchestra-classes (unset by default)
-    * orchestra-name (unset by default)
+    $ juju set-constraints instance-type=t1.micro
+
+    Available constraints vary by provider type, and will be ignored if not
+    understood by the current environment's provider. The current set of
+    available constraints across all providers is:
+
+    On Amazon EC2:
+
+        * arch (CPU architecture: i386/amd64/arm; amd64 by default)
+        * cpu (processing power in Amazon ECU; 1 by default)
+        * mem (memory in [MGT]iB; 512M by default)
+        * instance-type (unset by default)
+        * ec2-zone (unset by default)
+
+    On Orchestra:
+
+        * orchestra-classes (unset by default)
+
+    On MAAS:
+
+        * maas-name (unset by default)
 
     Service settings, if specified, will override environment settings, which
-    will in turn override the juju defaults of mem=512M, cpu=1,
-    ec2-region=us-east-1.
+    will in turn override the juju defaults of mem=512M, cpu=1, arch=amd64.
 
     New constraints set on an entity will completely replace that entity's
     pre-existing constraints.
@@ -72,17 +80,22 @@
     service constraints, just specify "name=" (rather than just not specifying
     the constraint at all, which will cause it to inherit the environment's
     value).
+
+    To entirely unset a constraint, specify "name=any".
     """
-    constraints = Constraints.from_strs(environment.type, constraint_strs)
-
-    if service_name is None:
-        raise NotImplementedError("Environment constraints not implemented")
-
     provider = environment.get_machine_provider()
+    constraint_set = yield provider.get_constraint_set()
+    constraints = constraint_set.parse(constraint_strs)
     client = yield provider.connect()
     try:
-        service_state_manager = ServiceStateManager(client)
-        service = yield service_state_manager.get_service_state(service_name)
-        yield service.set_constraints(constraints)
+        yield legacy.check_constraints(client, constraint_strs)
+        yield sync_environment_state(client, env_config, environment.name)
+        if service_name is None:
+            esm = EnvironmentStateManager(client)
+            yield esm.set_constraints(constraints)
+        else:
+            ssm = ServiceStateManager(client)
+            service = yield ssm.get_service_state(service_name)
+            yield service.set_constraints(constraints)
     finally:
         yield client.close()

=== modified file 'juju/control/deploy.py'
--- juju/control/deploy.py	2012-03-22 16:15:02 +0000
+++ juju/control/deploy.py	2012-03-30 16:56:32 +0000
@@ -4,26 +4,20 @@
 
 from twisted.internet.defer import inlineCallbacks
 
-from juju.control.utils import get_environment, expand_path
+from juju.control import legacy
+from juju.control.utils import (
+    expand_constraints, expand_path, get_environment, sync_environment_state)
 
 from juju.charm.errors import ServiceConfigValueError
 from juju.charm.publisher import CharmPublisher
 from juju.charm.repository import resolve
 from juju.errors import CharmError
-from juju.machine.constraints import Constraints
 from juju.state.endpoint import RelationEndpoint
-from juju.state.environment import EnvironmentStateManager
 from juju.state.placement import place_unit
 from juju.state.relation import RelationStateManager
 from juju.state.service import ServiceStateManager
 
 
-def _expand_constraints(s):
-    if s:
-        return s.split(" ")
-    return []
-
-
 def configure_subparser(subparsers):
     sub_parser = subparsers.add_parser("deploy", help=command.__doc__,
             description=deploy.__doc__)
@@ -50,7 +44,7 @@
         "--constraints",
         help="Hardware constraints for the service",
         default=[],
-        type=_expand_constraints)
+        type=expand_constraints)
 
     sub_parser.add_argument(
         "charm", nargs=None,
@@ -134,23 +128,23 @@
         service_options = parse_config_options(
             config_file, service_name, charm)
 
-    constraints = Constraints.from_strs(environment.type, constraint_strs)
-
     charm = yield repo.find(charm_url)
     charm_id = str(charm_url.with_revision(charm.get_revision()))
 
     provider = environment.get_machine_provider()
     placement_policy = provider.get_placement_policy()
+    constraint_set = yield provider.get_constraint_set()
+    constraints = constraint_set.parse(constraint_strs)
     client = yield provider.connect()
 
     try:
+        yield legacy.check_constraints(client, constraint_strs)
+        yield legacy.check_environment(
+            client, provider.get_legacy_config_keys())
+        yield sync_environment_state(client, env_config, environment.name)
+
+        # Publish the charm to juju
         storage = yield provider.get_file_storage()
-        service_manager = ServiceStateManager(client)
-        environment_state_manager = EnvironmentStateManager(client)
-        yield environment_state_manager.set_config_state(
-            env_config, environment.name)
-
-        # Publish the charm to juju
         publisher = CharmPublisher(client, storage)
         yield publisher.add_charm(charm_id, charm)
         result = yield publisher.publish()
@@ -161,6 +155,7 @@
         charm_state = result[0]
 
         # Create the service state
+        service_manager = ServiceStateManager(client)
         service_state = yield service_manager.add_service_state(
             service_name, charm_state, constraints)
 

=== modified file 'juju/control/initialize.py'
--- juju/control/initialize.py	2011-09-23 20:35:02 +0000
+++ juju/control/initialize.py	2012-03-30 16:56:32 +0000
@@ -1,4 +1,6 @@
+from base64 import b64decode
 import os
+import yaml
 
 from twisted.internet.defer import inlineCallbacks
 
@@ -12,11 +14,13 @@
     sub_parser.add_argument(
         "--instance-id", required=True,
         help="Provider instance id for the bootstrap node")
-
     sub_parser.add_argument(
         "--admin-identity", required=True,
         help="Admin access control identity for zookeeper ACLs")
     sub_parser.add_argument(
+        "--constraints-data", required=True,
+        help="Base64-encoded yaml dump of the environment constraints data")
+    sub_parser.add_argument(
         "--provider-type", required=True,
         help="Environment machine provider type")
     return sub_parser
@@ -30,10 +34,12 @@
     zk_address = os.environ.get("ZOOKEEPER_ADDRESS", "127.0.0.1:2181")
     client = yield ZookeeperClient(zk_address).connect()
     try:
+        constraints_data = yaml.load(b64decode(options.constraints_data))
         hierarchy = StateHierarchy(
             client,
             options.admin_identity,
             options.instance_id,
+            constraints_data,
             options.provider_type)
         yield hierarchy.initialize()
     finally:

=== added file 'juju/control/legacy.py'
--- juju/control/legacy.py	1970-01-01 00:00:00 +0000
+++ juju/control/legacy.py	2012-03-30 16:56:32 +0000
@@ -0,0 +1,41 @@
+from twisted.internet.defer import inlineCallbacks
+
+from juju.errors import JujuError
+from juju.state.environment import EnvironmentStateManager
+
+_ERROR = """
+Your environments.yaml contains deprecated keys; they must not be used other
+than in legacy deployments. The affected keys are:
+
+    %s
+
+This error can be resolved according to the instructions available at:
+
+    https://juju.ubuntu.com/DeprecatedEnvironmentSettings
+"""
+
+
+def error(keys):
+    raise JujuError(_ERROR % "\n    ".join(sorted(keys)))
+
+
+@inlineCallbacks
+def check_environment(client, keys):
+    if not keys:
+        return
+    esm = EnvironmentStateManager(client)
+    if not (yield esm.get_in_legacy_environment()):
+        error(keys)
+
+
+@inlineCallbacks
+def check_constraints(client, constraint_strs):
+    if not constraint_strs:
+        return
+    esm = EnvironmentStateManager(client)
+    if (yield esm.get_in_legacy_environment()):
+        raise JujuError(
+            "Constraints are not valid in legacy deployments. To use machine "
+            "constraints, please deploy your environment again from scratch. "
+            "You can continue to use this environment as before, but any "
+            "attempt to set constraints will fail.")

=== modified file 'juju/control/terminate_machine.py'
--- juju/control/terminate_machine.py	2011-09-15 18:50:23 +0000
+++ juju/control/terminate_machine.py	2012-03-30 16:56:32 +0000
@@ -2,6 +2,7 @@
 
 from twisted.internet.defer import inlineCallbacks
 
+from juju.control.utils import sync_environment_state
 from juju.errors import CannotTerminateMachine
 from juju.environment.errors import EnvironmentsConfigError
 from juju.state.errors import MachineStateNotFound
@@ -57,6 +58,7 @@
     client = yield provider.connect()
     terminated_machine_ids = []
     try:
+        yield sync_environment_state(client, config, environment.name)
         machine_state_manager = MachineStateManager(client)
         for machine_id in machine_ids:
             if machine_id == 0:

=== modified file 'juju/control/tests/test_add_relation.py'
--- juju/control/tests/test_add_relation.py	2012-02-09 03:52:45 +0000
+++ juju/control/tests/test_add_relation.py	2012-03-30 16:56:32 +0000
@@ -1,5 +1,4 @@
 import logging
-import yaml
 
 from twisted.internet.defer import inlineCallbacks
 
@@ -15,12 +14,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlAddRelationTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"}}}
-        self.write_config(yaml.dump(config))
-        self.config.load()
         self.output = self.capture_logging()
         self.stderr = self.capture_stream("stderr")
 

=== modified file 'juju/control/tests/test_add_unit.py'
--- juju/control/tests/test_add_unit.py	2012-02-01 11:27:42 +0000
+++ juju/control/tests/test_add_unit.py	2012-03-30 16:56:32 +0000
@@ -1,7 +1,9 @@
+from yaml import dump
+
 from twisted.internet.defer import inlineCallbacks
-from yaml import dump
 
 from juju.control import main
+from juju.state.environment import EnvironmentStateManager
 
 from .common import MachineControlToolTest
 
@@ -11,11 +13,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlAddUnitTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
         self.service_state1 = yield self.add_service_from_charm("mysql")
         self.service_unit1 = yield self.service_state1.add_unit_state()
         self.machine_state1 = yield self.add_machine_state()
@@ -36,9 +33,15 @@
         finished = self.setup_cli_reactor()
         self.setup_exit(0)
         self.mocker.replay()
+        # trash environment to check syncing
+        yield self.client.delete("/environment")
         main(["add-unit", "mysql"])
         yield finished
 
+        # verify the env state was synced
+        esm = EnvironmentStateManager(self.client)
+        yield esm.get_config()
+
         # verify the unit and its machine assignment.
         unit_names = yield self.service_state1.get_unit_names()
         self.assertEqual(len(unit_names), 2)
@@ -121,9 +124,7 @@
             "environments": {"firstenv": {
                     "placement": "local",
                     "type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
+        yield self.push_config("firstenv", config)
 
         ms0 = yield self.machine_state_manager.get_machine_state(0)
         yield self.service_unit1.unassign_from_machine()
@@ -149,3 +150,37 @@
             self.output.getvalue())
         # adding a second unit still assigns to machine 0 with local policy
         yield self.assert_machine_assignments("mysql", [0, 0])
+
+    @inlineCallbacks
+    def test_legacy_option_in_legacy_env(self):
+        yield self.client.delete("/constraints")
+
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        main(["add-unit", "mysql"])
+        yield finished
+
+        unit_names = yield self.service_state1.get_unit_names()
+        self.assertEqual(len(unit_names), 2)
+
+    @inlineCallbacks
+    def test_legacy_option_in_fresh_env(self):
+        local_config = {
+            "environments": {"firstenv": {
+                    "some-legacy-key": "blah",
+                    "type": "dummy"}}}
+        self.write_config(dump(local_config))
+        self.config.load()
+
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        main(["add-unit", "mysql"])
+        yield finished
+
+        output = self.output.getvalue()
+        self.assertIn(
+            "Your environments.yaml contains deprecated keys", output)
+        unit_names = yield self.service_state1.get_unit_names()
+        self.assertEqual(len(unit_names), 1)

=== modified file 'juju/control/tests/test_bootstrap.py'
--- juju/control/tests/test_bootstrap.py	2011-09-22 13:23:00 +0000
+++ juju/control/tests/test_bootstrap.py	2012-03-30 16:56:32 +0000
@@ -19,32 +19,29 @@
         config = {
             "environments": {
                 "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"},
+                    "type": "dummy", "default-series": "homer"},
                 "secondenv": {
-                    "type": "dummy", "admin-secret": "marge"}}}
+                    "type": "dummy", "default-series": "marge"}}}
 
         self.write_config(dump(config))
         finished = self.setup_cli_reactor()
         self.setup_exit(0)
 
-        envs = set(("firstenv", "secondenv"))
-
-        def track_bootstrap_call(self):
-            envs.remove(self.environment_name)
-            return succeed(True)
-
         provider = self.mocker.patch(MachineProvider)
-
-        provider.bootstrap()
-        self.mocker.call(track_bootstrap_call, with_object=True)
+        provider.bootstrap({
+            "ubuntu-series": "homer",
+            "provider-type": "dummy",
+            "arch": "arm",
+            "cpu": 2.0,
+            "mem": 512.0})
+        self.mocker.result(succeed(True))
         self.mocker.replay()
 
         self.capture_stream("stderr")
-        main(["bootstrap", "-e", "firstenv"])
+        main(["bootstrap", "-e", "firstenv",
+              "--constraints", "arch=arm cpu=2"])
         yield finished
 
-        self.assertEqual(envs, set(["secondenv"]))
-
         lines = filter(None, self.log.getvalue().split("\n"))
         self.assertEqual(
             lines,
@@ -96,3 +93,25 @@
         msg = "Invalid environment 'thirdenv'"
         self.assertIn(msg, self.log.getvalue())
         self.assertIn(msg, output.getvalue())
+
+    @inlineCallbacks
+    def test_bootstrap_legacy_config_keys(self):
+        """
+        If the environment specified does not exist an error message is given.
+        """
+        config = {
+            "environments": {
+                "firstenv": {
+                    "type": "dummy", "some-legacy-key": "blah"}}}
+        self.write_config(dump(config))
+        finished = self.setup_cli_reactor()
+        self.setup_exit(1)
+        self.mocker.replay()
+
+        output = self.capture_stream("stderr")
+        main(["bootstrap"])
+        yield finished
+
+        msg = "Your environments.yaml contains deprecated keys"
+        self.assertIn(msg, self.log.getvalue())
+        self.assertIn(msg, output.getvalue())

=== modified file 'juju/control/tests/test_config_get.py'
--- juju/control/tests/test_config_get.py	2012-01-30 22:20:37 +0000
+++ juju/control/tests/test_config_get.py	2012-03-30 16:56:32 +0000
@@ -13,10 +13,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlJujuGetTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-        self.write_config(yaml.dump(config))
-        self.config.load()
         self.stderr = self.capture_stream("stderr")
 
     @inlineCallbacks

=== modified file 'juju/control/tests/test_config_set.py'
--- juju/control/tests/test_config_set.py	2012-03-09 13:24:58 +0000
+++ juju/control/tests/test_config_set.py	2012-03-30 16:56:32 +0000
@@ -12,10 +12,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlJujuSetTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-        self.write_config(dump(config))
-        self.config.load()
         self.service_state = yield self.add_service_from_charm("wordpress")
         self.service_unit = yield self.service_state.add_unit_state()
         self.environment = self.config.get_default()

=== added file 'juju/control/tests/test_constraints_get.py'
--- juju/control/tests/test_constraints_get.py	1970-01-01 00:00:00 +0000
+++ juju/control/tests/test_constraints_get.py	2012-03-30 16:56:32 +0000
@@ -0,0 +1,116 @@
+import yaml
+
+from twisted.internet.defer import inlineCallbacks
+
+from juju.control import main
+from juju.machine.tests.test_constraints import dummy_cs
+from juju.state.environment import EnvironmentStateManager
+
+from .common import MachineControlToolTest
+
+env_log = "Fetching constraints for environment"
+machine_log = "Fetching constraints for machine 1"
+service_log = "Fetching constraints for service mysql"
+unit_log = "Fetching constraints for service unit mysql/0"
+
+
+class ConstraintsGetTest(MachineControlToolTest):
+
+    @inlineCallbacks
+    def setUp(self):
+        yield super(ConstraintsGetTest, self).setUp()
+        env_constraints = dummy_cs.parse(["mem=1024"])
+        esm = EnvironmentStateManager(self.client)
+        yield esm.set_constraints(env_constraints)
+        self.expect_env = {
+            "arch": "amd64", "cpu": 1.0, "mem": 1024.0,
+            "provider-type": "dummy", "ubuntu-series": None}
+
+        service_constraints = dummy_cs.parse(["cpu=10"])
+        service = yield self.add_service_from_charm(
+            "mysql", constraints=service_constraints)
+        # unit will snapshot the state of service when added
+        unit = yield service.add_unit_state()
+        self.expect_unit = {
+            "arch": "amd64", "cpu": 10.0, "mem": 1024.0,
+            "provider-type": "dummy", "ubuntu-series": "series"}
+
+        # machine gets its own constraints
+        machine_constraints = dummy_cs.parse(["cpu=15", "mem=8G"])
+        machine = yield self.add_machine_state(
+            constraints=machine_constraints.with_series("series"))
+        self.expect_machine = {
+            "arch": "amd64", "cpu": 15.0, "mem": 8192.0,
+            "provider-type": "dummy", "ubuntu-series": "series"}
+        yield unit.assign_to_machine(machine)
+
+        # service gets new constraints, leaves unit untouched
+        yield service.set_constraints(dummy_cs.parse(["mem=16G"]))
+        self.expect_service = {
+            "arch": "amd64", "cpu": 1.0, "mem": 16384.0,
+            "provider-type": "dummy", "ubuntu-series": "series"}
+
+        self.log = self.capture_logging()
+        self.stdout = self.capture_stream("stdout")
+        self.finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+
+    def assert_messages(self, *messages):
+        log = self.log.getvalue()
+        for message in messages:
+            self.assertIn(message, log)
+
+    @inlineCallbacks
+    def test_env(self):
+        main(["get-constraints"])
+        yield self.finished
+        result = yaml.load(self.stdout.getvalue())
+        self.assertEquals(result, self.expect_env)
+        self.assert_messages(env_log)
+
+    @inlineCallbacks
+    def test_service(self):
+        main(["get-constraints", "mysql"])
+        yield self.finished
+        result = yaml.load(self.stdout.getvalue())
+        self.assertEquals(result, {"mysql": self.expect_service})
+        self.assert_messages(service_log)
+
+    @inlineCallbacks
+    def test_unit(self):
+        main(["get-constraints", "mysql/0"])
+        yield self.finished
+        result = yaml.load(self.stdout.getvalue())
+        self.assertEquals(result, {"mysql/0": self.expect_unit})
+        self.assert_messages(unit_log)
+
+    @inlineCallbacks
+    def test_machine(self):
+        main(["get-constraints", "1"])
+        yield self.finished
+        result = yaml.load(self.stdout.getvalue())
+        self.assertEquals(result, {"1": self.expect_machine})
+        self.assert_messages(machine_log)
+
+    @inlineCallbacks
+    def test_all(self):
+        main(["get-constraints", "mysql", "mysql/0", "1"])
+        yield self.finished
+        result = yaml.load(self.stdout.getvalue())
+        expect = {"mysql": self.expect_service,
+                  "mysql/0": self.expect_unit,
+                  "1": self.expect_machine}
+        self.assertEquals(result, expect)
+        self.assert_messages(service_log, unit_log, machine_log)
+
+    @inlineCallbacks
+    def test_syncs_environment(self):
+        """If the environment were not synced, it would be impossible to create
+        the Constraints, so tool success proves sync."""
+        yield self.client.delete("/environment")
+        main(["get-constraints", "mysql/0"])
+        yield self.finished
+        result = yaml.load(self.stdout.getvalue())
+        self.assertEquals(result, {"mysql/0": self.expect_unit})
+        self.assert_messages(unit_log)

=== modified file 'juju/control/tests/test_constraints_set.py'
--- juju/control/tests/test_constraints_set.py	2012-03-09 09:02:06 +0000
+++ juju/control/tests/test_constraints_set.py	2012-03-30 16:56:32 +0000
@@ -1,8 +1,7 @@
-from yaml import dump
-
 from twisted.internet.defer import inlineCallbacks
 
 from juju.control import main
+from juju.state.environment import EnvironmentStateManager
 
 from .common import MachineControlToolTest
 
@@ -12,11 +11,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlSetConstraintsTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
         self.service_state = yield self.add_service_from_charm("mysql")
         self.output = self.capture_logging()
         self.stderr = self.capture_stream("stderr")
@@ -31,7 +25,7 @@
 
         constraints = yield self.service_state.get_constraints()
         expect = {
-            "arch": None, "cpu": 8, "mem": 1024,
+            "arch": "amd64", "cpu": 8, "mem": 1024,
             "provider-type": "dummy", "ubuntu-series": "series"}
         self.assertEquals(constraints, expect)
 
@@ -53,15 +47,32 @@
 
     @inlineCallbacks
     def test_environment_constraint(self):
-        initial_constraints = yield self.service_state.get_constraints()
-        finished = self.setup_cli_reactor()
-        self.setup_exit(1)
-        self.mocker.replay()
-        main(["set-constraints", "arch=arm"])
+        yield self.client.delete("/environment")
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        main(["set-constraints", "arch=arm", "cpu=any"])
+        yield finished
+
+        esm = EnvironmentStateManager(self.client)
+        yield esm.get_config()
+        constraints = yield esm.get_constraints()
+        self.assertEquals(constraints, {
+            "ubuntu-series": None,
+            "provider-type": "dummy",
+            "arch": "arm",
+            "cpu": None,
+            "mem": 512.0})
+
+    @inlineCallbacks
+    def test_legacy_environment(self):
+        yield self.client.delete("/constraints")
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        main(["set-constraints", "arch=arm", "cpu=any"])
         yield finished
 
         self.assertIn(
-            "Environment constraints not implemented", self.stderr.getvalue())
-
-        constraints = yield self.service_state.get_constraints()
-        self.assertEquals(constraints, initial_constraints)
+            "Constraints are not valid in legacy deployments.",
+            self.stderr.getvalue())

=== modified file 'juju/control/tests/test_control.py'
--- juju/control/tests/test_control.py	2011-09-15 19:24:47 +0000
+++ juju/control/tests/test_control.py	2012-03-30 16:56:32 +0000
@@ -4,7 +4,6 @@
 
 from StringIO import StringIO
 from argparse import Namespace
-from yaml import dump
 
 from twisted.internet.defer import inlineCallbacks
 
@@ -12,6 +11,7 @@
 from juju.control import setup_logging, main, setup_parser
 from juju.control.options import ensure_abs_path
 from juju.control.command import Commander
+from juju.state.tests.common import StateTestBase
 
 from juju.lib.testing import TestCase
 
@@ -36,17 +36,12 @@
             self.fail("EnvironmentsConfigError not raised")
 
 
-class ControlOutputTest(ControlToolTest):
+class ControlOutputTest(ControlToolTest, StateTestBase):
 
+    @inlineCallbacks
     def setUp(self):
-        super(ControlOutputTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"},
-                "secondenv": {
-                    "type": "dummy", "admin-secret": "marge"}}}
-        self.write_config(dump(config))
+        yield super(ControlOutputTest, self).setUp()
+        yield self.push_default_config()
 
     def test_sans_args_produces_help(self):
         """

=== modified file 'juju/control/tests/test_debug_hooks.py'
--- juju/control/tests/test_debug_hooks.py	2012-02-01 11:27:42 +0000
+++ juju/control/tests/test_debug_hooks.py	2012-03-30 16:56:32 +0000
@@ -1,8 +1,6 @@
 import logging
 import os
 
-import yaml
-
 from twisted.internet.defer import (
     inlineCallbacks, returnValue, succeed, Deferred)
 
@@ -22,13 +20,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlDebugHookTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"}}}
-        self.write_config(yaml.dump(config))
-        self.config.load()
-
         self.environment = self.config.get_default()
         self.provider = self.environment.get_machine_provider()
 

=== modified file 'juju/control/tests/test_debug_log.py'
--- juju/control/tests/test_debug_log.py	2011-09-15 19:24:47 +0000
+++ juju/control/tests/test_debug_log.py	2012-03-30 16:56:32 +0000
@@ -1,5 +1,4 @@
 import json
-import yaml
 
 from twisted.internet.defer import inlineCallbacks
 
@@ -13,12 +12,7 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlDebugLogTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"}}}
-        self.write_config(yaml.dump(config))
-        self.config.load()
+        yield self.push_default_config()
 
     @inlineCallbacks
     def test_replay(self):

=== modified file 'juju/control/tests/test_deploy.py'
--- juju/control/tests/test_deploy.py	2012-03-09 20:13:36 +0000
+++ juju/control/tests/test_deploy.py	2012-03-30 16:56:32 +0000
@@ -32,7 +32,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlDeployTest, self).setUp()
-
         config = {
             "environments": {
                 "firstenv": {
@@ -40,8 +39,7 @@
                     "admin-secret": "homer",
                     "placement": "unassigned",
                     "default-series": "series"}}}
-        self.write_config(yaml.dump(config))
-        self.config.load()
+        yield self.push_config("firstenv", config)
 
     def test_deploy_multiple_environments_none_specified(self):
         """
@@ -228,7 +226,7 @@
         self.assertEquals(charm_id, "local:series/sample-2")
         constraints = yield service_state.get_constraints()
         expect_constraints = {
-            "arch": None, "cpu": 123, "mem": 512,
+            "arch": "amd64", "cpu": 123, "mem": 512,
             "provider-type": "dummy", "ubuntu-series": "series"}
         self.assertEquals(constraints, expect_constraints)
 
@@ -490,9 +488,7 @@
                     "placement": "local",
                     "type": "dummy",
                     "default-series": "series"}}}
-
-        self.write_config(yaml.dump(config))
-        self.config.load()
+        yield self.push_config("firstenv", config)
 
         finished = self.setup_cli_reactor()
         self.setup_exit(0)
@@ -508,3 +504,66 @@
         unit = units[0]
         machine_id = yield unit.get_assigned_machine_id()
         self.assertEqual(machine_id, 0)
+
+    @inlineCallbacks
+    def test_deploy_legacy_keys_in_legacy_env(self):
+        yield self.client.delete("/constraints")
+
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+
+        main(["deploy", "--repository", self.unbundled_repo_path,
+              "local:sample", "beekeeper"])
+        yield finished
+
+        service_manager = ServiceStateManager(self.client)
+        yield service_manager.get_service_state("beekeeper")
+
+    @inlineCallbacks
+    def test_deploy_legacy_keys_in_fresh_env(self):
+        yield self.push_default_config()
+        local_config = {
+            "environments": {"firstenv": {
+                    "type": "dummy",
+                    "some-legacy-key": "blah",
+                    "default-series": "series"}}}
+        self.write_config(yaml.dump(local_config))
+        self.config.load()
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        stderr = self.capture_stream("stderr")
+
+        main(["deploy", "--repository", self.unbundled_repo_path,
+              "local:sample", "beekeeper"])
+        yield finished
+
+        self.assertIn(
+            "Your environments.yaml contains deprecated keys",
+            stderr.getvalue())
+        service_manager = ServiceStateManager(self.client)
+        yield self.assertFailure(
+            service_manager.get_service_state("beekeeper"),
+            ServiceStateNotFound)
+
+    @inlineCallbacks
+    def test_deploy_constraints_in_legacy_env(self):
+        yield self.client.delete("/constraints")
+
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        stderr = self.capture_stream("stderr")
+
+        main(["deploy", "--repository", self.unbundled_repo_path,
+              "local:sample", "beekeeper", "--constraints", "arch=i386"])
+        yield finished
+
+        self.assertIn(
+            "Constraints are not valid in legacy deployments.",
+            stderr.getvalue())
+        service_manager = ServiceStateManager(self.client)
+        yield self.assertFailure(
+            service_manager.get_service_state("beekeeper"),
+            ServiceStateNotFound)

=== modified file 'juju/control/tests/test_destroy_service.py'
--- juju/control/tests/test_destroy_service.py	2011-09-15 19:24:47 +0000
+++ juju/control/tests/test_destroy_service.py	2012-03-30 16:56:32 +0000
@@ -1,5 +1,4 @@
 from twisted.internet.defer import inlineCallbacks
-from yaml import dump
 
 from juju.control import main
 
@@ -15,11 +14,7 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlStopServiceTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
 
-        self.write_config(dump(config))
-        self.config.load()
         self.service_state1 = yield self.add_service_from_charm("mysql")
         self.service1_unit = yield self.service_state1.add_unit_state()
         self.service_state2 = yield self.add_service_from_charm("wordpress")

=== modified file 'juju/control/tests/test_initialize.py'
--- juju/control/tests/test_initialize.py	2011-09-23 20:35:02 +0000
+++ juju/control/tests/test_initialize.py	2012-03-30 16:56:32 +0000
@@ -1,3 +1,6 @@
+from base64 import b64encode
+from yaml import safe_dump
+
 from twisted.internet.defer import succeed
 
 from txzookeeper import ZookeeperClient
@@ -26,7 +29,27 @@
         self.setup_exit(0)
         self.mocker.replay()
 
-        admin(["initialize",
-               "--instance-id", "foobar",
-               "--admin-identity", "admin:genie",
+        constraints_data = b64encode(safe_dump({
+            "ubuntu-series": "foo", "provider-type": "bar"}))
+
+        admin(["initialize",
+               "--instance-id", "foobar",
+               "--admin-identity", "admin:genie",
+               "--constraints-data", constraints_data,
+               "--provider-type", "dummy"])
+
+    def test_bad_constraints_data(self):
+        """Test that failing to unpack --constraints-data aborts initialize"""
+        client = self.mocker.patch(ZookeeperClient)
+        self.setup_cli_reactor()
+        client.connect()
+        self.mocker.result(succeed(client))
+        self.capture_stream('stderr')
+        self.setup_exit(1)
+        self.mocker.replay()
+
+        admin(["initialize",
+               "--instance-id", "foobar",
+               "--admin-identity", "admin:genie",
+               "--constraints-data", "zaphod's just this guy, you know?",
                "--provider-type", "dummy"])

=== modified file 'juju/control/tests/test_remove_unit.py'
--- juju/control/tests/test_remove_unit.py	2012-02-01 11:27:42 +0000
+++ juju/control/tests/test_remove_unit.py	2012-03-30 16:56:32 +0000
@@ -2,7 +2,6 @@
 import sys
 
 from twisted.internet.defer import inlineCallbacks
-from yaml import dump
 import zookeeper
 
 from .common import ControlToolTest
@@ -18,11 +17,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlRemoveUnitTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
 
         self.environment = self.config.get_default()
         self.provider = self.environment.get_machine_provider()

=== modified file 'juju/control/tests/test_resolved.py'
--- juju/control/tests/test_resolved.py	2012-03-27 22:06:24 +0000
+++ juju/control/tests/test_resolved.py	2012-03-30 16:56:32 +0000
@@ -1,5 +1,4 @@
 from twisted.internet.defer import inlineCallbacks, returnValue
-from yaml import dump
 
 from juju.control import main
 from juju.control.tests.common import ControlToolTest
@@ -20,11 +19,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlResolvedTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
 
         yield self.add_relation_state("wordpress", "mysql")
         yield self.add_relation_state("wordpress", "varnish")

=== modified file 'juju/control/tests/test_scp.py'
--- juju/control/tests/test_scp.py	2012-02-01 11:27:42 +0000
+++ juju/control/tests/test_scp.py	2012-03-30 16:56:32 +0000
@@ -19,14 +19,7 @@
     @inlineCallbacks
     def setUp(self):
         yield super(SCPTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"}}}
-        self.write_config(dump(config))
         self.setup_exit(0)
-
-        self.config.load()
         self.environment = self.config.get_default()
         self.provider = self.environment.get_machine_provider()
 
@@ -53,10 +46,6 @@
     @inlineCallbacks
     def test_scp_unit_name(self):
         """Verify scp command is invoked against the host for a unit name."""
-        mock_environment = self.mocker.patch(Environment)
-        mock_environment.get_machine_provider()
-        self.mocker.result(self.provider)
-
         # Verify expected call against scp
         mock_exec = self.mocker.replace(os.execvp)
         mock_exec("scp", [
@@ -79,6 +68,8 @@
     @inlineCallbacks
     def test_scp_machine_id(self):
         """Verify scp command is invoked against the host for a machine ID."""
+        # We need to do this because separate instances of DummyProvider don't
+        # share instance state.
         mock_environment = self.mocker.patch(Environment)
         mock_environment.get_machine_provider()
         self.mocker.result(self.provider)
@@ -111,10 +102,6 @@
 
           $ juju scp -o "ConnectTimeout 60" foo mysql/0:/foo/bar
         """
-        mock_environment = self.mocker.patch(Environment)
-        mock_environment.get_machine_provider()
-        self.mocker.result(self.provider)
-
         # Verify expected call against scp
         mock_exec = self.mocker.replace(os.execvp)
         mock_exec("scp", [
@@ -141,11 +128,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ParseErrorsTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
         self.stderr = self.capture_stream("stderr")
 
     def test_passthrough_args_parse_error(self):

=== modified file 'juju/control/tests/test_ssh.py'
--- juju/control/tests/test_ssh.py	2012-03-23 02:13:50 +0000
+++ juju/control/tests/test_ssh.py	2012-03-30 16:56:32 +0000
@@ -23,14 +23,7 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlShellTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"}}}
-        self.write_config(dump(config))
         self.setup_exit(0)
-
-        self.config.load()
         self.environment = self.config.get_default()
         self.provider = self.environment.get_machine_provider()
 
@@ -346,10 +339,6 @@
     def test_shell_with_unassigned_unit(self):
         """If the service unit is not assigned, attempting to
         connect, raises an error."""
-        mock_environment = self.mocker.patch(Environment)
-        mock_environment.get_machine_provider()
-        self.mocker.result(self.provider)
-
         finished = self.setup_cli_reactor()
         self.mocker.replay()
 
@@ -384,11 +373,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ParseErrorsTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
         self.stderr = self.capture_stream("stderr")
 
     def test_passthrough_args_parse_error(self):

=== modified file 'juju/control/tests/test_status.py'
--- juju/control/tests/test_status.py	2012-03-29 02:50:29 +0000
+++ juju/control/tests/test_status.py	2012-03-30 16:56:32 +0000
@@ -46,14 +46,6 @@
         yield settings.set_provider_type("dummy")
         self.log = self.capture_logging()
 
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy",
-                    "admin-secret": "homer"}}}
-        self.write_config(yaml.dump(config))
-        self.config.load()
-
         self.environment = self.config.get_default()
         self.provider = self.environment.get_machine_provider()
         self.machine_count = 0

=== modified file 'juju/control/tests/test_terminate_machine.py'
--- juju/control/tests/test_terminate_machine.py	2012-01-09 16:57:13 +0000
+++ juju/control/tests/test_terminate_machine.py	2012-03-30 16:56:32 +0000
@@ -1,5 +1,4 @@
 import logging
-import yaml
 
 from twisted.internet.defer import inlineCallbacks
 
@@ -7,6 +6,7 @@
 from juju.control.tests.common import MachineControlToolTest
 from juju.errors import CannotTerminateMachine
 from juju.state.errors import MachineStateInUse, MachineStateNotFound
+from juju.state.environment import EnvironmentStateManager
 
 
 class ControlTerminateMachineTest(MachineControlToolTest):
@@ -14,12 +14,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlTerminateMachineTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"}}}
-        self.write_config(yaml.dump(config))
-        self.config.load()
         self.output = self.capture_logging()
         self.stderr = self.capture_stream("stderr")
 
@@ -113,8 +107,16 @@
         yield wordpress_unit_state.unassign_from_machine()
         yield mysql_unit_state.unassign_from_machine()
         yield self.assert_machine_states([0, 1, 2, 3], [])
+
+        # trash environment to check syncing
+        yield self.client.delete("/environment")
         main(["terminate-machine", "1", "3"])
         yield wait_on_reactor_stopped
+
+        # check environment synced
+        esm = EnvironmentStateManager(self.client)
+        yield esm.get_config()
+
         self.assertIn(
             "Machines terminated: 1, 3", self.output.getvalue())
         yield self.assert_machine_states([0, 2], [1, 3])

=== modified file 'juju/control/tests/test_upgrade_charm.py'
--- juju/control/tests/test_upgrade_charm.py	2012-03-26 17:22:23 +0000
+++ juju/control/tests/test_upgrade_charm.py	2012-03-30 16:56:32 +0000
@@ -56,11 +56,7 @@
     @inlineCallbacks
     def setUp(self):
         yield super(ControlCharmUpgradeTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
 
-        self.write_config(dump(config))
-        self.config.load()
         self.service_state1 = yield self.add_service_from_charm("mysql")
         self.service_unit1 = yield self.service_state1.add_unit_state()
 
@@ -459,12 +455,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(RemoteUpgradeCharmTest, self).setUp()
-        config = {
-            "environments": {"firstenv": {"type": "dummy"}}}
-
-        self.write_config(dump(config))
-        self.config.load()
-
         charm = CharmDirectory(os.path.join(
             test_repository_path, "series", "mysql"))
         self.charm_state_manager.add_charm_state(

=== modified file 'juju/control/tests/test_utils.py'
--- juju/control/tests/test_utils.py	2012-03-09 13:24:58 +0000
+++ juju/control/tests/test_utils.py	2012-03-30 16:56:32 +0000
@@ -24,12 +24,6 @@
     @inlineCallbacks
     def setUp(self):
         yield super(LookupTest, self).setUp()
-        config = {
-            "environments": {
-                "firstenv": {
-                    "type": "dummy", "admin-secret": "homer"}}}
-        self.write_config(dump(config))
-        self.config.load()
         self.environment = self.config.get_default()
         self.provider = self.environment.get_machine_provider()
 

=== modified file 'juju/control/utils.py'
--- juju/control/utils.py	2012-02-15 23:32:23 +0000
+++ juju/control/utils.py	2012-03-30 16:56:32 +0000
@@ -5,6 +5,7 @@
 
 from juju.environment.errors import EnvironmentsConfigError
 from juju.state.errors import ServiceUnitStateMachineNotAssigned
+from juju.state.environment import EnvironmentStateManager
 from juju.state.machine import MachineStateManager
 from juju.state.service import ServiceStateManager
 
@@ -20,6 +21,26 @@
     return environment
 
 
+def sync_environment_state(client, config, name):
+    """Push the local environment config to zookeeper.
+
+    This needs to be done:
+
+      * On any command which can cause the provisioning agent to take action
+        against the provider (ie create/destroy a machine), because the PA
+        needs to use credentials stored in the environment config to do so.
+      * On any command which uses constraints-related code (even if indirectly)
+        because Constraints objects are provider-specific, and need to be
+        created with the help of a MachineProvider; and the only way state code
+        can get a MachineProvider is by getting one from ZK (we certainly don't
+        want to thread the relevant provider from juju.control and/or the PA
+        itself all the way through the state code). So, we sync, to ensure
+        that state code can use an EnvironmentStateManager to get a provider.
+    """
+    esm = EnvironmentStateManager(client)
+    return esm.set_config_state(config, name)
+
+
 @inlineCallbacks
 def get_ip_address_for_machine(client, provider, machine_id):
     """Returns public DNS name and machine state for the machine id.
@@ -59,6 +80,12 @@
     return os.path.abspath(os.path.expanduser(p))
 
 
+def expand_constraints(s):
+    if s:
+        return s.split(" ")
+    return []
+
+
 class ParseError(Exception):
     """Used to support returning custom parse errors in passthrough parsing.
 

=== modified file 'juju/environment/config.py'
--- juju/environment/config.py	2012-02-29 20:38:01 +0000
+++ juju/environment/config.py	2012-03-30 16:56:32 +0000
@@ -4,20 +4,10 @@
 
 from juju.environment.environment import Environment
 from juju.environment.errors import EnvironmentsConfigError
-from juju.errors import (
-    FileAlreadyExists,
-    FileNotFound,
-    )
+from juju.errors import FileAlreadyExists, FileNotFound
 from juju.lib.schema import (
-    Constant,
-    Dict,
-    KeyDict,
-    OAuthString,
-    OneOf,
-    SchemaError,
-    SelectDict,
-    String,
-    )
+    Constant, Dict, KeyDict, OAuthString, OneOf, SchemaError, SelectDict,
+    String)
 
 
 DEFAULT_CONFIG_PATH = "~/.juju/environments.yaml"
@@ -31,56 +21,60 @@
     default-series: oneiric
 """
 
+_EITHER_PLACEMENT = OneOf(Constant("unassigned"), Constant("local"))
 
 SCHEMA = KeyDict({
     "default": String(),
     "environments": Dict(String(), SelectDict("type", {
-        "ec2": KeyDict({"control-bucket": String(),
-                        "admin-secret": String(),
-                        "access-key": String(),
-                        "secret-key": String(),
-                        "region": OneOf(
-                            Constant("us-east-1"),
-                            Constant("us-west-1"),
-                            Constant("us-west-2"),
-                            Constant("eu-west-1"),
-                            Constant("sa-east-1"),
-                            Constant("ap-northeast-1"),
-                            Constant("ap-southeast-1")),
-                        "default-instance-type": String(),
-                        "default-ami": String(),
-                        "ec2-uri": String(),
-                        "s3-uri": String(),
-                        "placement": OneOf(
-                                Constant("unassigned"),
-                                Constant("local")),
-                        "default-series": String()},
-                       optional=["access-key", "secret-key",
-                                 "default-instance-type", "default-ami",
-                                 "region", "ec2-uri", "s3-uri", "placement"]),
-        "orchestra": KeyDict({"orchestra-server": String(),
-                              "orchestra-user": String(),
-                              "orchestra-pass": String(),
-                              "admin-secret": String(),
-                              "acquired-mgmt-class": String(),
-                              "available-mgmt-class": String(),
-                              "storage-url": String(),
-                              "storage-user": String(),
-                              "storage-pass": String(),
-                              "placement": String(),
-                              "default-series": String()},
-                             optional=["storage-url", "storage-user",
-                                       "storage-pass", "placement"]),
+        "ec2": KeyDict({
+            "control-bucket": String(),
+            "admin-secret": String(),
+            "access-key": String(),
+            "secret-key": String(),
+            "region": OneOf(
+                Constant("us-east-1"),
+                Constant("us-west-1"),
+                Constant("us-west-2"),
+                Constant("eu-west-1"),
+                Constant("sa-east-1"),
+                Constant("ap-northeast-1"),
+                Constant("ap-southeast-1")),
+            "ec2-uri": String(),
+            "s3-uri": String(),
+            "placement": _EITHER_PLACEMENT,
+            "default-series": String()},
+            optional=[
+                "access-key", "secret-key", "region", "ec2-uri", "s3-uri",
+                "placement"]),
+        "orchestra": KeyDict({
+            "orchestra-server": String(),
+            "orchestra-user": String(),
+            "orchestra-pass": String(),
+            "admin-secret": String(),
+            "acquired-mgmt-class": String(),
+            "available-mgmt-class": String(),
+            "storage-url": String(),
+            "storage-user": String(),
+            "storage-pass": String(),
+            "placement": _EITHER_PLACEMENT,
+            "default-series": String()},
+            optional=[
+                "storage-url", "storage-user", "storage-pass", "placement"]),
         "maas": KeyDict({
             "maas-server": String(),
             "maas-oauth": OAuthString(),
             "admin-secret": String(),
-            }),
-        "local": KeyDict({"admin-secret": String(),
-                        "data-dir": String(),
-                        "placement": Constant("local"),
-                        "default-series": String()},
-                       optional=["placement"]),
+            "placement": _EITHER_PLACEMENT,
+            # MAAS currently only provisions precise; any other default-series
+            # would just lead to errors down the line.
+            "default-series": Constant("precise")},
+            optional=["placement"]),
+        "local": KeyDict({
+            "admin-secret": String(),
+            "data-dir": String(),
+            "placement": Constant("local"),
+            "default-series": String()},
+            optional=["placement"]),
         "dummy": KeyDict({})}))},
     optional=["default"])
 

=== modified file 'juju/environment/tests/test_config.py'
--- juju/environment/tests/test_config.py	2011-10-06 22:24:21 +0000
+++ juju/environment/tests/test_config.py	2012-03-30 16:56:32 +0000
@@ -8,6 +8,7 @@
 from juju.environment.environment import Environment
 from juju.environment.errors import EnvironmentsConfigError
 from juju.errors import FileNotFound, FileAlreadyExists
+from juju.state.environment import EnvironmentStateManager
 
 from juju.lib.testing import TestCase
 
@@ -38,6 +39,16 @@
     default-series: oneiric
 """
 
+SAMPLE_MAAS = """
+environments:
+  sample:
+    type: maas
+    maas-server: somewhe.re
+    maas-oauth: foo:bar:baz
+    admin-secret: garden
+    default-series: precise
+"""
+
 SAMPLE_LOCAL = """
 ensemble: environments
 
@@ -58,7 +69,7 @@
         self.patch(environment, "LSB_RELEASE_PATH", release_path)
         self.old_home = os.environ.get("HOME")
         self.tmp_home = self.makeDir()
-        self.change_environment(HOME=self.tmp_home)
+        self.change_environment(HOME=self.tmp_home, PATH=os.environ["PATH"])
         self.default_path = os.path.join(self.tmp_home,
                                          ".juju/environments.yaml")
         self.other_path = os.path.join(self.tmp_home,
@@ -76,6 +87,30 @@
         with open(path, "w") as file:
             file.write(config_text)
 
+    # The following methods expect to be called *after* a subclass has set
+    # self.client.
+
+    def push_config(self, name, config):
+        self.write_config(yaml.dump(config))
+        self.config.load()
+        esm = EnvironmentStateManager(self.client)
+        return esm.set_config_state(self.config, name)
+
+    @inlineCallbacks
+    def push_env_constraints(self, *constraint_strs):
+        esm = EnvironmentStateManager(self.client)
+        constraint_set = yield esm.get_constraint_set()
+        yield esm.set_constraints(constraint_set.parse(constraint_strs))
+
+    @inlineCallbacks
+    def push_default_config(self, with_constraints=True):
+        config = {
+            "environments": {"firstenv": {
+                "type": "dummy", "storage-directory": self.makeDir()}}}
+        yield self.push_config("firstenv", config)
+        if with_constraints:
+            yield self.push_env_constraints()
+
 
 class EnvironmentsConfigTest(EnvironmentsConfigTestBase):
 
@@ -540,6 +575,9 @@
     def test_ec2_sample_config_without_admin_secret(self):
         self.assert_ec2_sample_config("admin-secret")
 
+    def test_ec2_sample_config_without_default_series(self):
+        self.assert_ec2_sample_config("default-series")
+
     def test_ec2_sample_config_without_control_buckets(self):
         self.assert_ec2_sample_config("control-bucket")
 
@@ -603,7 +641,6 @@
 
     def test_orchestra_respects_default_series(self):
         config = yaml.load(SAMPLE_ORCHESTRA)
-
         config["environments"]["sample"]["default-series"] = "magnificent"
         self.write_config(yaml.dump(config), other_path=True)
         self.config.load(self.other_path)
@@ -613,6 +650,58 @@
 
     def test_orchestra_verifies_placement(self):
         config = yaml.load(SAMPLE_ORCHESTRA)
+        config["environments"]["sample"]["placement"] = "random"
+        self.write_config(yaml.dump(config), other_path=True)
+        e = self.assertRaises(
+            EnvironmentsConfigError, self.config.load, self.other_path)
+        self.assertIn("expected 'unassigned', got 'random'",
+                       str(e))
+
+        config["environments"]["sample"]["placement"] = "local"
+        self.write_config(yaml.dump(config), other_path=True)
+        self.config.load(self.other_path)
+
+        data = self.config.get_default().placement
+        self.assertEqual(data, "local")
+
+    def test_maas_schema_requires(self):
+        requires = "maas-server maas-oauth admin-secret default-series".split()
+        for require in requires:
+            config = yaml.load(SAMPLE_MAAS)
+            del config["environments"]["sample"][require]
+            self.write_config(yaml.dump(config), other_path=True)
+
+            try:
+                self.config.load(self.other_path)
+            except EnvironmentsConfigError as error:
+                self.assertEquals(str(error),
+                                  "Environments configuration error: %s: "
+                                  "environments.sample.%s: "
+                                  "required value not found"
+                                  % (self.other_path, require))
+            else:
+                self.fail("Did not properly require %s when type == maas"
+                          % require)
+
+    def test_maas_default_series(self):
+        config = yaml.load(SAMPLE_MAAS)
+        config["environments"]["sample"]["default-series"] = "magnificent"
+        self.write_config(yaml.dump(config), other_path=True)
+        e = self.assertRaises(
+            EnvironmentsConfigError, self.config.load, self.other_path)
+        self.assertIn(
+            "environments.sample.default-series: expected 'precise', got "
+            "'magnificent'",
+            str(e))
+
+    def test_maas_verifies_placement(self):
+        config = yaml.load(SAMPLE_MAAS)
+        config["environments"]["sample"]["placement"] = "random"
+        self.write_config(yaml.dump(config), other_path=True)
+        e = self.assertRaises(
+            EnvironmentsConfigError, self.config.load, self.other_path)
+        self.assertIn("expected 'unassigned', got 'random'",
+                       str(e))
 
         config["environments"]["sample"]["placement"] = "local"
         self.write_config(yaml.dump(config), other_path=True)
@@ -623,25 +712,17 @@
 
     def test_lxc_requires_data_dir(self):
         """lxc dev only supports local placement."""
-        self.config.write_sample()
         config = yaml.load(SAMPLE_LOCAL)
-
         self.write_config(yaml.dump(config), other_path=True)
         error = self.assertRaises(
-            EnvironmentsConfigError,
-            self.config.load,
-            self.other_path)
+            EnvironmentsConfigError, self.config.load, self.other_path)
         self.assertIn("data-dir: required value not found", str(error))
 
     def test_lxc_verifies_placement(self):
         """lxc dev only supports local placement."""
-        self.config.write_sample()
         config = yaml.load(SAMPLE_LOCAL)
-
         config["environments"]["sample"]["placement"] = "unassigned"
         self.write_config(yaml.dump(config), other_path=True)
         error = self.assertRaises(
-            EnvironmentsConfigError,
-            self.config.load,
-            self.other_path)
+            EnvironmentsConfigError, self.config.load, self.other_path)
         self.assertIn("expected 'local', got 'unassigned'", str(error))

=== modified file 'juju/hooks/tests/test_invoker.py'
--- juju/hooks/tests/test_invoker.py	2012-03-29 02:50:29 +0000
+++ juju/hooks/tests/test_invoker.py	2012-03-30 16:56:32 +0000
@@ -12,12 +12,12 @@
 import juju
 from juju import errors
 from juju.control.tests.test_status import StatusTestBase
+from juju.environment.tests.test_config import EnvironmentsConfigTestBase
 from juju.lib.pick import pick_attr
 from juju.hooks import invoker
 from juju.hooks import commands
 from juju.hooks.protocol import UnitSettingsFactory
 from juju.lib.mocker import MATCH
-from juju.lib.testing import TestCase
 from juju.lib.twistutils import get_module_directory
 from juju.state import hook
 from juju.state.endpoint import RelationEndpoint
@@ -132,7 +132,12 @@
     return ":".join(search_path)
 
 
-class InvokerTestBase(TestCase):
+class InvokerTestBase(EnvironmentsConfigTestBase):
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        yield super(InvokerTestBase, self).setUp()
+        yield self.push_default_config()
 
     def update_invoker_env(self, local_unit, remote_unit):
         """Update os.env for a hook invocation.

=== modified file 'juju/machine/constraints.py'
--- juju/machine/constraints.py	2012-03-09 13:24:58 +0000
+++ juju/machine/constraints.py	2012-03-30 16:56:32 +0000
@@ -1,64 +1,197 @@
+import logging
 import operator
-from string import ascii_lowercase
 from UserDict import DictMixin
 
 from juju.errors import ConstraintError, UnknownConstraintError
 
-
-class Constraints(object, DictMixin):
-    """A Constraints object encapsulates a set of machine constraints.
-
-    Constraints objects are expected to be initially constructed using the
-    `from_strs` method to parse user input; they can subsequently be serialised
-    as a `data` dict and reconstructed directly from same.
-
-    They also implement a dict interface, which exposes all constraints for
-    the appropriate provider, and is the expected mode of usage for clients
-    not concerned with the construction or comparison of Constraints objects.
-
-    A Constraints object only ever contains a single "layer" of data, but can
-    be combined with other Constraints objects in such a way as to produce a
-    single object following the rules laid down in internals/placement-spec.
-
-    Constraints objects can be compared, in a limited sense, by using the
-    `can_satisfy` method.
+log = logging.getLogger("juju.machine.constraints")
+
+# To allow providers to construct ConstraintSets which silently ignore known-
+# but-inapplicable constraints (ec2-zone on orchestra, for example), we keep
+# a hardcoded global registry here. It will not be hard to remember to update
+# this when working with providers, because _ConstraintTypes with unknown
+# names cannot be created and will cause test failures so long as the added
+# constraint registration code is exercised in the provider tests.
+ALL_NAMES = (
+    "ubuntu-series", "provider-type",
+    "arch", "cpu", "mem", "instance-type",
+    "ec2-zone",
+    "maas-name",
+    "orchestra-classes",
+)
+
+
+def _dont_convert(s):
+    return s
+
+
+class _ConstraintType(object):
+    """Defines a constraint.
+
+    :param str name: The constraint's name
+    :param default: The default value as a str, or None to indicate "unset"
+    :param converter: Function to convert str value to "real" value (and
+        thereby implicitly validate it; should raise ValueError)
+    :param comparer: Function used to determine whether one constraint
+        satisfies another
+    :param bool visible: If False, indicates a computed constraint which
+        should not be settable by a user.
+
+    Merely creating a Constraint does not activate it; you also need to
+    register it with a specific ConstraintSet.
     """
 
-    def __init__(self, data):
-        # To avoid inconsistency, all Constraints objects must be constructed
-        # with the same set of _Constraint~s (and conflicts) in play.
-        _Constraint.freeze()
-        assert data.get("provider-type"), "missing provider-type"
-        for k, v in data.items():
-            _Constraint.get(k).convert(v)
-        self._data = data
-
-    @classmethod
-    def from_strs(cls, provider, strs):
-        """Create from strings (as used on the command line)"""
-        data = {"provider-type": provider}
-        relevant_names = _Constraint.names(provider)
+    def __init__(self, name, default, converter, comparer, visible):
+        assert name in ALL_NAMES, "please update ALL_NAMES"
+        self.name = name
+        self.default = default
+        self._converter = converter
+        self._comparer = comparer
+        self.visible = visible
+
+    def convert(self, s):
+        """Convert a string representation of a constraint into a useful form.
+        """
+        if s is None:
+            return
+        try:
+            return self._converter(s)
+        except ValueError as e:
+            raise ConstraintError(
+                "Bad %r constraint %r: %s" % (self.name, s, e))
+
+    def can_satisfy(self, candidate, benchmark):
+        """Check whether candidate can satisfy benchmark"""
+        return self._comparer(candidate, benchmark)
+
+
+class ConstraintSet(object):
+    """A ConstraintSet represents all constraints applicable to a provider.
+
+    Individual providers can construct ConstraintSets which will be used to
+    construct Constraints objects directly relevant to that provider."""
+
+    def __init__(self, provider_type):
+        self._provider_type = provider_type
+        self._registry = {}
+        self._conflicts = {}
+
+        # These constraints must always be available (but are not user-visible
+        # or -settable).
+        self.register("ubuntu-series", visible=False)
+        self.register("provider-type", visible=False)
+
+    def register(self, name, default=None, converter=_dont_convert,
+                 comparer=operator.eq, visible=True):
+        """Register a constraint to be handled by this ConstraintSet.
+
+        :param str name: The constraint's name
+        :param default: The default value as a str, or None to indicate "unset"
+        :param converter: Function to convert str value to "real" value (and
+            thereby implicitly validate it; should raise ValueError)
+        :param comparer: Function used to determine whether one constraint
+            satisfies another
+        :param bool visible: If False, indicates a computed constraint which
+            should not be settable by a user.
+        """
+        self._registry[name] = _ConstraintType(
+            name, default, converter, comparer, visible)
+        self._conflicts[name] = set()
+
+    def register_conflicts(self, reds, blues):
+        """Set cross-constraint override behaviour.
+
+        :param reds: list of constraint names which affect all constraints
+            specified in `blues`
+        :param blues: list of constraint names which affect all constraints
+            specified in `reds`
+
+        When two constraints conflict:
+
+        * It is an error to set both constraints in the same Constraints.
+        * When a Constraints overrides another which specifies a conflicting
+          constraint, the value in the overridden Constraints is cleared.
+        """
+        for red in reds:
+            self._conflicts[red].update(blues)
+        for blue in blues:
+            self._conflicts[blue].update(reds)
+
+    def register_generics(self, instance_type_names):
+        """Register a common set of constraints.
+
+        This always includes arch, cpu, and mem; and will include instance-type
+        if instance_type_names is not empty. This is because we believe
+        instance-type to be a broadly applicable concept, even though the only
+        provider that registers names here (and hence accepts the constraint)
+        is currently EC2.
+        """
+        self.register("arch", default="amd64", converter=_convert_arch)
+        self.register(
+            "cpu", default="1", converter=_convert_cpu, comparer=operator.ge)
+        self.register(
+            "mem", default="512M", converter=_convert_mem,
+            comparer=operator.ge)
+
+        if instance_type_names:
+
+            def convert(instance_type_name):
+                if instance_type_name in instance_type_names:
+                    return instance_type_name
+                raise ValueError("unknown instance type")
+
+            self.register("instance-type", converter=convert)
+            self.register_conflicts(["cpu", "mem"], ["instance-type"])
+
+    def names(self):
+        """Get the names of all registered constraints."""
+        return self._registry.keys()
+
+    def get(self, name):
+        """Get the (internal) _ConstraintType object corresponding to `name`.
+
+        If `name` is known, but not registered in this ConstraintSet, None will
+        be returned; if the constraint name is entirely unknown, an
+        UnknownConstraintError will be raised.
+        """
+        try:
+            return self._registry[name]
+        except KeyError:
+            if name not in ALL_NAMES:
+                raise UnknownConstraintError(name)
+
+    def parse(self, strs):
+        """Create a Constraints from strings (as used on the command line)"""
+        data = {"provider-type": self._provider_type}
         for s in strs:
             try:
                 name, value = s.split("=", 1)
-                constraint = _Constraint.get(name)
-            except KeyError:
-                raise UnknownConstraintError(name)
+                constraint = self.get(name)
+                if constraint is None:
+                    # A constraint called name does exist for some provider (if
+                    # it didn't exist anywhere, .get would have raised) but is
+                    # not relevant for this provider.
+                    log.warn(
+                        "ignored irrelevant %r constraint", name)
+                    continue
+                if value == "any":
+                    value = None
+                if value == "":
+                    value = constraint.default
+                constraint.convert(value)
             except ValueError as e:
                 raise ConstraintError(
                     "Could not interpret %r constraint: %s" % (s, e))
-            if name not in relevant_names:
-                continue
             if not constraint.visible:
                 raise ConstraintError(
                     "Cannot set computed constraint: %r" % name)
-            data[name] = value or constraint.default
+            data[name] = value
 
         conflicts = set()
         for name in sorted(data):
-            for conflict in sorted(_Constraint.get(name).conflicts):
-                if conflict not in relevant_names:
-                    continue
+            if data[name] is None:
+                continue
+            for conflict in sorted(self._conflicts[name]):
                 if conflict in data:
                     raise ConstraintError(
                         "Ambiguous constraints: %r overlaps with %r"
@@ -66,13 +199,54 @@
                 conflicts.add(conflict)
 
         data.update(dict((conflict, None) for conflict in conflicts))
-        return Constraints(data)
+        return Constraints(self, data)
+
+    def load(self, data):
+        """Convert a data dict to a Constraints"""
+        for k, v in data.items():
+            self.get(k).convert(v)
+        return Constraints(self, data)
+
+
+class Constraints(object, DictMixin):
+    """A Constraints object encapsulates a set of machine constraints.
+
+    Constraints instances should not be constructed directly; please use
+    ConstraintSet's parse and load methods instead.
+
+    They implement a dict interface, which exposes all constraints for the
+    appropriate provider, and is the expected mode of usage for clients not
+    concerned with the construction or comparison of Constraints objects.
+
+    A Constraints object only ever contains a single "layer" of data, but can
+    be combined with other Constraints objects in such a way as to produce a
+    single object following the rules laid down in internals/placement-spec.
+
+    Constraints objects can be compared, in a limited sense, by using the
+    `can_satisfy` method.
+    """
+
+    def __init__(self, available, data):
+        self._available = available
+        self._data = data
+
+    def keys(self):
+        """DictMixin"""
+        return self._available.names()
+
+    def __getitem__(self, name):
+        """DictMixin"""
+        if name not in self.keys():
+            raise KeyError(name)
+        constraint = self._available.get(name)
+        raw_value = self.data.get(name, constraint.default)
+        return constraint.convert(raw_value)
 
     def with_series(self, series):
         """Return a Constraints with the "ubuntu-series" set to `series`"""
         data = dict(self._data)
         data["ubuntu-series"] = series
-        return Constraints(data)
+        return self._available.load(data)
 
     @property
     def complete(self):
@@ -108,7 +282,11 @@
                 # place unit on machine
         """
         if not (self.complete and other.complete):
-            raise ConstraintError("Cannot compare incomplete constraints")
+            # Incomplete constraints cannot satisfy or be satisfied; we should
+            # only ever hit this branch if we're running new code (that knows
+            # about constraints) against an old deployment (which will contain
+            # at least *some* services/machines which don't have constraints).
+            return False
 
         for (name, unit_value) in other.items():
             if unit_value is None:
@@ -116,168 +294,29 @@
                 continue
             machine_value = self[name]
             if machine_value is None:
-                # The unit *does* care, and the machine value isn't specified,
-                # so we can't guarantee a match. If we were to update machine
-                # constraints after provisioning (ie when we knew the values of
-                # the constraints left unspecified) we'd hit this branch less
-                # often.
-                # We may also need to do something clever here to get sensible
-                # machine reuse on ec2 -- in what circumstances, if ever, is it
-                # OK to place a unit specced for one instance-type on a machine
-                # of another type? Does it matter if either or both were derived
-                # from generic constraints? What about cost?
+                # The unit *does* care, and the machine value isn't
+                # specified, so we can't guarantee a match. If we were
+                # to update machine constraints after provisioning (ie
+                # when we knew the values of the constraints left
+                # unspecified) we'd hit this branch less often.  We
+                # may also need to do something clever here to get
+                # sensible machine reuse on ec2 -- in what
+                # circumstances, if ever, is it OK to place a unit
+                # specced for one instance-type on a machine of
+                # another type? Does it matter if either or both were
+                # derived from generic constraints? What about cost?
                 return False
-            if not _Constraint.get(name).can_satisfy(machine_value, unit_value):
+            constraint = self._available.get(name)
+            if not constraint.can_satisfy(machine_value, unit_value):
                 # The machine's value is definitely not ok for the unit.
                 return False
 
         return True
 
-    # DictMixin methods
-
-    def keys(self):
-        return _Constraint.names(self._data.get("provider-type"))
-
-    def __getitem__(self, name):
-        if name not in self.keys():
-            raise KeyError(name)
-        constraint = _Constraint.get(name)
-        raw_value = self.data.get(name, constraint.default)
-        return constraint.convert(raw_value)
-
-
-#======================================================================
-# Constraint type registration
-
-def _dont_convert(s):
-    return s
-
-
-class _Constraint(object):
-
-    _registry = {}
-    _conflicts = {}
-    _frozen = False
-
-    def __init__(self, name, default, converter, comparer, provider, visible):
-        self._name = name
-        self._default = default
-        self._converter = converter
-        self._comparer = comparer
-        self._provider = provider
-        self._visible = visible
-
-    @classmethod
-    def freeze(cls):
-        """Once called, prevents register and register_conflicts from working.
-
-        Intent is to enforce consistency of Constraints construction and
-        overriding: if the set of constraints or the registered overlaps
-        were to change at runtime, the same operations could end up
-        producing different results.
-        """
-        cls._frozen = True
-
-    @classmethod
-    def register(cls, name, default=None, converter=_dont_convert,
-                 comparer=operator.eq, provider=None, visible=True):
-        """Define a constraint.
-
-        :param str name: The constraint's name
-        :param default: The default value as a str, or None to indicate "unset"
-        :param converter: Function to convert str value to "real" value
-        :param comparer: Function used to determine whether one constraint
-            satisfies another
-        :param provider: The name of the provider for which this constraint is
-            meaningful (None indicates always meaningful)
-        :param bool visible: If False, indicates a computed constraint which
-            should not be settable by a user.
-
-        In service of consistency, is an error to attempt to register a new
-        constraint once a Constraints object has been created.
-        """
-        assert not cls._frozen
-        inst = cls(name, default, converter, comparer, provider, visible)
-        cls._registry[name] = inst
-        cls._conflicts[name] = set()
-
-    @classmethod
-    def register_conflicts(cls, reds, blues):
-        """Set cross-constraint override behaviour.
-
-        :param reds: list of constraint names which affect all constraints
-            specified in `blues`
-        :param blues: list of constraint names which affect all constraints
-            specified in `reds`
-
-        When two constraints conflict:
-
-        * It is an error to set both constraints in the same Constraints.
-        * When a Constraints overrides another which specifies a conflicting
-          constraint, the value in the overridden Constraints is cleared.
-
-        In service of consistency, is an error to attempt to register any new
-        conflicts once a Constraints object has been created.
-        """
-        assert not cls._frozen
-        for red in reds:
-            cls._conflicts[red].update(blues)
-        for blue in blues:
-            cls._conflicts[blue].update(reds)
-
-    @classmethod
-    def get(cls, name):
-        try:
-            return cls._registry[name]
-        except KeyError:
-            raise UnknownConstraintError(name)
-
-    @classmethod
-    def names(cls, provider):
-        return [
-            name for (name, constraint) in cls._registry.items()
-            if constraint.provider in set([None, provider])]
-
-    @property
-    def conflicts(self):
-        return self._conflicts[self._name]
-
-    @property
-    def default(self):
-        return self._default
-
-    @property
-    def provider(self):
-        return self._provider
-
-    @property
-    def visible(self):
-        return self._visible
-
-    def convert(self, s):
-        if s is None:
-            return
-        try:
-            return self._converter(s)
-        except ValueError as e:
-            raise ConstraintError(
-                "Bad %r constraint %r: %s" % (self._name, s, e))
-
-    def can_satisfy(self, candidate, benchmark):
-        return self._comparer(candidate, benchmark)
-
-
-#======================================================================
-# Generic (but not user-visible) constraints; always relevant
-_Constraint.register("ubuntu-series", visible=False)
-_Constraint.register("provider-type", visible=False)
-
-
-#======================================================================
-# Generic (user-visible) constraints; always relevant
-
+
+#==============================================================================
+# Generic constraint information (used by multiple providers).
 _VALID_ARCHS = ("i386", "amd64", "arm")
-
 _MEGABYTES = 1
 _GIGABYTES = _MEGABYTES * 1024
 _TERABYTES = _GIGABYTES * 1024
@@ -292,7 +331,7 @@
 
 def _convert_cpu(s):
     value = float(s)
-    if value > 0:
+    if value >= 0:
         return value
     raise ValueError("must be non-negative")
 
@@ -302,56 +341,6 @@
         value = float(s[:-1]) * _MEM_SUFFIXES[s[-1]]
     else:
         value = float(s)
-    if value > 0:
+    if value >= 0:
         return value
     raise ValueError("must be non-negative")
-
-
-_Constraint.register("arch", converter=_convert_arch)
-_Constraint.register(
-    "mem", default="512M", converter=_convert_mem, comparer=operator.ge)
-_Constraint.register(
-    "cpu", default="1", converter=_convert_cpu, comparer=operator.ge)
-
-
-#======================================================================
-# Orchestra-only
-
-def _convert_orchestra_classes(s):
-    return s.split(",")
-
-
-def _compare_orchestra_classes(candidate, benchmark):
-    return set(candidate) >= set(benchmark)
-
-
-_Constraint.register(
-    "orchestra-classes", converter=_convert_orchestra_classes,
-    comparer=_compare_orchestra_classes, provider="orchestra")
-_Constraint.register("orchestra-name", provider="orchestra")
-
-
-#======================================================================
-# EC2-only
-
-def _convert_ec2_zone(s):
-    if s not in ascii_lowercase:
-        raise ValueError("expected lowercase ascii char")
-    return s
-
-
-_Constraint.register("ec2-instance-type", provider="ec2")
-_Constraint.register("ec2-zone", converter=_convert_ec2_zone, provider="ec2")
-
-
-#======================================================================
-# All conflicts
-
-_Constraint.register_conflicts(["orchestra-name"], ["orchestra-classes"])
-_Constraint.register_conflicts(
-    ["ec2-instance-type", "orchestra-name"], ["arch", "cpu", "mem"])
-
-#=====================================================================
-# Ensure consistency
-
-_Constraint.freeze()

=== modified file 'juju/machine/tests/test_constraints.py'
--- juju/machine/tests/test_constraints.py	2012-03-09 13:24:58 +0000
+++ juju/machine/tests/test_constraints.py	2012-03-30 16:56:32 +0000
@@ -1,270 +1,168 @@
+import operator
+
 from juju.errors import ConstraintError
 from juju.lib.testing import TestCase
-from juju.machine.constraints import Constraints
+from juju.machine.constraints import Constraints, ConstraintSet
 
+# These objects exist for the convenience of other test files
+dummy_cs = ConstraintSet("dummy")
+dummy_cs.register_generics([])
+dummy_constraints = dummy_cs.parse([])
+series_constraints = dummy_constraints.with_series("series")
 
 generic_defaults = {
-    "arch": None, "cpu": 1, "mem": 512,
+    "arch": "amd64", "cpu": 1, "mem": 512,
     "ubuntu-series": None, "provider-type": None}
 dummy_defaults = dict(generic_defaults, **{
     "provider-type": "dummy"})
 ec2_defaults = dict(generic_defaults, **{
     "provider-type": "ec2",
     "ec2-zone": None,
-    "ec2-instance-type": None})
-orchestra_defaults = dict(generic_defaults, **{
+    "instance-type": None})
+orchestra_defaults = {
     "provider-type": "orchestra",
-    "orchestra-name": None,
-    "orchestra-classes": None})
+    "ubuntu-series": None,
+    "orchestra-classes": None}
 
 all_providers = ["dummy", "ec2", "orchestra"]
 
+
 class ConstraintsTestCase(TestCase):
 
     def assert_error(self, message, *raises_args):
         e = self.assertRaises(ConstraintError, *raises_args)
         self.assertEquals(str(e), message)
 
-    def assert_roundtrip_equal(self, constraints, expected):
+    def assert_roundtrip_equal(self, cs, constraints, expected):
+        self.assertEquals(dict(constraints), expected)
         self.assertEquals(constraints, expected)
-        self.assertEquals(Constraints(constraints.data), expected)
+        self.assertEquals(dict(cs.load(constraints.data)), expected)
+        self.assertEquals(cs.load(constraints.data), expected)
 
 
 class ConstraintsTest(ConstraintsTestCase):
 
-    def test_defaults(self):
-        constraints = Constraints.from_strs("orchestra", [])
-        self.assert_roundtrip_equal(constraints, orchestra_defaults)
-        constraints = Constraints.from_strs("ec2", [])
-        self.assert_roundtrip_equal(constraints, ec2_defaults)
-        constraints = Constraints.from_strs("dummy", [])
-        self.assert_roundtrip_equal(constraints, dummy_defaults)
+    def test_equality(self):
+        self.assert_roundtrip_equal(
+            dummy_cs, dummy_constraints, dummy_defaults)
 
     def test_complete(self):
-        incomplete_constraints = Constraints.from_strs("womble", [])
-        self.assertFalse(incomplete_constraints.complete)
+        incomplete_constraints = dummy_cs.parse([])
         complete_constraints = incomplete_constraints.with_series("wandering")
         self.assertTrue(complete_constraints.complete)
 
-    def assert_invalid(self, message, providers, *constraint_strs):
-        for provider in providers:
-            self.assert_error(
-                message, Constraints.from_strs, provider, constraint_strs)
-
-        if len(providers) != len(all_providers):
-            # Check it *is* valid for other providers
-            for provider in all_providers:
-                if provider in providers:
-                    continue
-                Constraints.from_strs(provider, constraint_strs)
+    def assert_invalid(self, message, *constraint_strs):
+        self.assert_error(
+            message, dummy_cs.parse, constraint_strs)
 
     def test_invalid_input(self):
         """Reject nonsense constraints"""
         self.assert_invalid(
             "Could not interpret 'BLAH' constraint: need more than 1 value to "
             "unpack",
-            all_providers, "BLAH")
+            "BLAH")
         self.assert_invalid(
             "Unknown constraint: 'foo'",
-            all_providers, "foo=", "bar=")
+            "foo=", "bar=")
 
     def test_invalid_constraints(self):
         """Reject nonsensical constraint values"""
         self.assert_invalid(
-            "Bad 'arch' constraint 'leg': unknown architecture", all_providers,
+            "Bad 'arch' constraint 'leg': unknown architecture",
             "arch=leg")
         self.assert_invalid(
-            "Bad 'cpu' constraint '-1': must be non-negative", all_providers,
+            "Bad 'cpu' constraint '-1': must be non-negative",
             "cpu=-1")
         self.assert_invalid(
             "Bad 'cpu' constraint 'fish': could not convert string to float: "
             "fish",
-            all_providers, "cpu=fish")
+            "cpu=fish")
         self.assert_invalid(
-            "Bad 'mem' constraint '-1': must be non-negative", all_providers,
+            "Bad 'mem' constraint '-1': must be non-negative",
             "mem=-1")
         self.assert_invalid(
             "Bad 'mem' constraint '4P': invalid literal for float(): 4P",
-            all_providers, "mem=4P")
-        self.assert_invalid(
-            "Bad 'ec2-zone' constraint 'Q': expected lowercase ascii char",
-            ["ec2"], "ec2-zone=Q")
+            "mem=4P")
 
     def test_hidden_constraints(self):
         """Reject attempts to explicitly specify computed constraints"""
         self.assert_invalid(
-            "Cannot set computed constraint: 'ubuntu-series'", all_providers,
+            "Cannot set computed constraint: 'ubuntu-series'",
             "ubuntu-series=cheesy")
         self.assert_invalid(
-            "Cannot set computed constraint: 'provider-type'", all_providers,
+            "Cannot set computed constraint: 'provider-type'",
             "provider-type=dummy")
 
-    def test_overlap_ec2(self):
-        """Overlapping ec2 constraints should be detected"""
-        self.assert_invalid(
-            "Ambiguous constraints: 'arch' overlaps with 'ec2-instance-type'",
-            ["ec2"], "ec2-instance-type=m1.small", "arch=i386")
-        self.assert_invalid(
-            "Ambiguous constraints: 'cpu' overlaps with 'ec2-instance-type'",
-            ["ec2"], "ec2-instance-type=m1.small", "cpu=1")
-        self.assert_invalid(
-            "Ambiguous constraints: 'ec2-instance-type' overlaps with 'mem'",
-            ["ec2"], "ec2-instance-type=m1.small", "mem=2G")
-
-    def test_overlap_orchestra(self):
-        """Overlapping orchestra constraints should be detected"""
-        self.assert_invalid(
-            "Ambiguous constraints: 'arch' overlaps with 'orchestra-name'",
-            ["orchestra"], "orchestra-name=herbert", "arch=i386")
-        self.assert_invalid(
-            "Ambiguous constraints: 'cpu' overlaps with 'orchestra-name'",
-            ["orchestra"], "orchestra-name=herbert", "cpu=1")
-        self.assert_invalid(
-            "Ambiguous constraints: 'mem' overlaps with 'orchestra-name'",
-            ["orchestra"], "orchestra-name=herbert", "mem=2G")
-        self.assert_invalid(
-            "Ambiguous constraints: 'orchestra-classes' overlaps with "
-            "'orchestra-name'",
-            ["orchestra"], "orchestra-name=herbert", "orchestra-classes=x,y")
-
 
 class ConstraintsUpdateTest(ConstraintsTestCase):
 
-    def assert_constraints(self, provider, strss, expected):
-        constraints = Constraints.from_strs(provider, strss[0])
+    def assert_constraints(self, strss, expected):
+        constraints = dummy_cs.parse(strss[0])
         for strs in strss[1:]:
-            constraints.update(Constraints.from_strs(provider, strs))
-        self.assert_roundtrip_equal(constraints, expected)
-
-    def assert_constraints_dummy(self, strss, expected):
+            constraints.update(dummy_cs.parse(strs))
         expected = dict(dummy_defaults, **expected)
-        self.assert_constraints("dummy", strss, expected)
+        self.assert_roundtrip_equal(dummy_cs, constraints, expected)
 
-    def test_constraints_dummy(self):
+    def test_constraints(self):
         """Sane constraints dicts are generated for unknown environments"""
-        self.assert_constraints_dummy([[]], {})
-        self.assert_constraints_dummy([["arch=arm"]], {"arch": "arm"})
-        self.assert_constraints_dummy([["cpu=0.1"]], {"cpu": 0.1})
-        self.assert_constraints_dummy([["mem=128"]], {"mem": 128})
-        self.assert_constraints_dummy(
+        self.assert_constraints([[]], {})
+        self.assert_constraints([["cpu=", "mem="]], {})
+        self.assert_constraints([["arch=arm"]], {"arch": "arm"})
+        self.assert_constraints([["cpu=0.1"]], {"cpu": 0.1})
+        self.assert_constraints([["mem=128"]], {"mem": 128})
+        self.assert_constraints([["cpu=0"]], {"cpu": 0})
+        self.assert_constraints([["mem=0"]], {"mem": 0})
+        self.assert_constraints(
             [["arch=amd64", "cpu=6", "mem=1.5G"]],
-            {"arch": "amd64", "cpu": 6, "mem": 1536,})
+            {"arch": "amd64", "cpu": 6, "mem": 1536})
 
     def test_overwriting_basic(self):
         """Later values shadow earlier values"""
-        self.assert_constraints_dummy(
+        self.assert_constraints(
             [["cpu=4", "mem=512"], ["arch=i386", "mem=1G"]],
             {"arch": "i386", "cpu": 4, "mem": 1024})
 
     def test_reset(self):
         """Empty string resets to juju default"""
-        self.assert_constraints_dummy(
+        self.assert_constraints(
             [["arch=arm", "cpu=4", "mem=1024"], ["arch=", "cpu=", "mem="]],
-            {"arch": None, "cpu": 1, "mem": 512})
-        self.assert_constraints_dummy(
+            {"arch": "amd64", "cpu": 1, "mem": 512})
+        self.assert_constraints(
             [["arch=", "cpu=", "mem="], ["arch=arm", "cpu=4", "mem=1024"]],
             {"arch": "arm", "cpu": 4, "mem": 1024})
 
-    def assert_constraints_ec2(self, strss, expected):
-        expected = dict(ec2_defaults, **expected)
-        self.assert_constraints("ec2", strss, expected)
-
-    def test_constraints_ec2(self):
-        """Sane constraints dicts are generated for ec2"""
-        self.assert_constraints_ec2([[]], {})
-        self.assert_constraints_ec2([["arch=arm"]], {"arch": "arm"})
-        self.assert_constraints_ec2([["cpu=128"]], {"cpu": 128})
-        self.assert_constraints_ec2([["mem=2G"]], {"mem": 2048})
-        self.assert_constraints_ec2([["ec2-zone=b"]], {"ec2-zone": "b"})
-        self.assert_constraints_ec2(
-            [["arch=amd64", "cpu=32", "mem=2G", "ec2-zone=b"]],
-            {"arch": "amd64", "cpu": 32, "mem": 2048, "ec2-zone": "b"})
-
-    def test_overwriting_ec2_instance_type(self):
-        """ec2-instance-type interacts correctly with arch, cpu, mem"""
-        self.assert_constraints_ec2(
-            [["ec2-instance-type=t1.micro"]],
-            {"ec2-instance-type": "t1.micro", "cpu": None, "mem": None})
-        self.assert_constraints_ec2(
-            [["arch=arm", "cpu=8"], ["ec2-instance-type=t1.micro"]],
-            {"ec2-instance-type": "t1.micro", "cpu": None, "mem": None})
-        self.assert_constraints_ec2(
-            [["ec2-instance-type=t1.micro"], ["arch=arm", "cpu=8"]],
-            {"ec2-instance-type": None, "arch": "arm", "cpu": 8, "mem": None})
-
-    def assert_constraints_orchestra(self, strss, expected):
-        expected = dict(orchestra_defaults, **expected)
-        self.assert_constraints("orchestra", strss, expected)
-
-    def test_constraints_orchestra(self):
-        """Sane constraints dicts are generated for orchestra"""
-        self.assert_constraints_orchestra([[]], {})
-        self.assert_constraints_orchestra([["arch=arm"]], {"arch": "arm"})
-        self.assert_constraints_orchestra([["cpu=128"]], {"cpu": 128})
-        self.assert_constraints_orchestra([["mem=0.25T"]], {"mem": 262144})
-        self.assert_constraints_orchestra(
-            [["orchestra-classes=x,y"]], {"orchestra-classes": ["x", "y"]})
-        self.assert_constraints_orchestra(
-            [["arch=i386", "cpu=2", "mem=768M", "orchestra-classes=a,b"]],
-            {"arch": "i386", "cpu": 2, "mem": 768,
-                "orchestra-classes": ["a", "b"]})
-
-    def test_overwriting_orchestra_name(self):
-        """orchestra-name interacts correctly with arch, cpu, mem"""
-        self.assert_constraints_orchestra(
-            [["orchestra-name=baggins"]],
-            {"orchestra-name": "baggins", "cpu": None, "mem": None})
-        self.assert_constraints_orchestra(
-            [["orchestra-name=baggins"], ["arch=arm"]],
-            {"orchestra-name": None, "arch": "arm", "cpu": None, "mem": None})
-        self.assert_constraints_orchestra(
-            [["arch=arm", "cpu=2"], ["orchestra-name=baggins"]],
-            {"orchestra-name": "baggins", "arch": None, "cpu": None,
-                "mem": None})
-
-    def test_overwriting_orchestra_classes(self):
-        """orchestra-classes interacts correctly with orchestra-name"""
-        self.assert_constraints_orchestra(
-            [["orchestra-name=baggins"], ["orchestra-classes=c,d", "cpu=2"]],
-            {"orchestra-classes": ["c", "d"], "cpu": 2, "mem": None})
-        self.assert_constraints_orchestra(
-            [["orchestra-classes=zz,top", "arch=amd64", "cpu=2"],
-                ["orchestra-name=baggins"]],
-            {"orchestra-name": "baggins", "orchestra-classes": None,
-                "cpu": None, "mem": None})
-
 
 class ConstraintsFulfilmentTest(ConstraintsTestCase):
 
-    def completed_constraints(self, provider="provider", series="series"):
-        return Constraints.from_strs(provider, []).with_series(series)
-
-    def assert_incomparable(self, c1, c2):
-        self.assert_error(
-            "Cannot compare incomplete constraints", c1.can_satisfy, c2)
-        self.assert_error(
-            "Cannot compare incomplete constraints", c2.can_satisfy, c1)
-
     def assert_match(self, c1, c2, expected):
         self.assertEquals(c1.can_satisfy(c2), expected)
         self.assertEquals(c2.can_satisfy(c1), expected)
 
     def test_fulfil_completeness(self):
-        """can_satisfy needs to be called on and with complete Constraints~s"""
-        c1 = Constraints({"provider-type": "a"})
-        c2 = Constraints({"provider-type": "a"})
-        self.assert_incomparable(c1, c2)
-        c3 = self.completed_constraints("a")
-        self.assert_incomparable(c1, c3)
-        c4 = self.completed_constraints("a")
-        self.assert_match(c3, c4, True)
+        """
+        can_satisfy needs to be called on and with complete Constraints~s to
+        have any chance of working.
+        """
+        good = Constraints(
+            dummy_cs, {"provider-type": "dummy", "ubuntu-series": "x"})
+        self.assert_match(good, good, True)
+        bad = [Constraints(dummy_cs, {}),
+               Constraints(dummy_cs, {"provider-type": "dummy"}),
+               Constraints(dummy_cs, {"ubuntu-series": "x"})]
+        for i, bad1 in enumerate(bad):
+            self.assert_match(bad1, good, False)
+            for bad2 in bad[i:]:
+                self.assert_match(bad1, bad2, False)
 
     def test_fulfil_matches(self):
+        other_cs = ConstraintSet("other")
+        other_cs.register_generics([])
+        other_constraints = other_cs.parse([])
         instances = (
-            Constraints({"provider-type": "a", "ubuntu-series": "x"}),
-            Constraints({"provider-type": "a", "ubuntu-series": "y"}),
-            Constraints({"provider-type": "b", "ubuntu-series": "x"}),
-            Constraints({"provider-type": "b", "ubuntu-series": "y"}))
+            dummy_constraints.with_series("x"),
+            dummy_constraints.with_series("y"),
+            other_constraints.with_series("x"),
+            other_constraints.with_series("y"))
 
         for i, c1 in enumerate(instances):
             self.assert_match(c1, c1, True)
@@ -272,94 +170,237 @@
                 self.assert_match(c1, c2, False)
 
     def assert_can_satisfy(
-            self, machine_strs, unit_strs, expected, provider="provider"):
-        machine = Constraints.from_strs(provider, machine_strs)
+            self, machine_strs, unit_strs, expected):
+        machine = dummy_cs.parse(machine_strs)
         machine = machine.with_series("shiny")
-        unit = Constraints.from_strs(provider, unit_strs)
+        unit = dummy_cs.parse(unit_strs)
         unit = unit.with_series("shiny")
         self.assertEquals(machine.can_satisfy(unit), expected)
 
-        if provider != "provider":
-            # Check that a different provider doesn't detect any problem,
-            # because it's ignoring all off-provider constraints.
-            machine = Constraints.from_strs("provider", machine_strs)
-            machine = machine.with_series("shiny")
-            unit = Constraints.from_strs("provider", unit_strs)
-            unit = unit.with_series("shiny")
-            self.assertEquals(machine.can_satisfy(unit), True)
-
-
     def test_can_satisfy(self):
         self.assert_can_satisfy([], [], True)
 
-        self.assert_can_satisfy(["arch=arm"], [], True)
+        self.assert_can_satisfy(["arch=arm"], [], False)
+        self.assert_can_satisfy(["arch=amd64"], [], True)
         self.assert_can_satisfy([], ["arch=arm"], False)
         self.assert_can_satisfy(["arch=i386"], ["arch=arm"], False)
         self.assert_can_satisfy(["arch=arm"], ["arch=amd64"], False)
         self.assert_can_satisfy(["arch=amd64"], ["arch=amd64"], True)
+        self.assert_can_satisfy(["arch=i386"], ["arch=any"], True)
+        self.assert_can_satisfy(["arch=arm"], ["arch=any"], True)
+        self.assert_can_satisfy(["arch=amd64"], ["arch=any"], True)
+        self.assert_can_satisfy(["arch=any"], ["arch=any"], True)
+        self.assert_can_satisfy(["arch=any"], ["arch=i386"], False)
+        self.assert_can_satisfy(["arch=any"], ["arch=amd64"], False)
+        self.assert_can_satisfy(["arch=any"], ["arch=arm"], False)
 
         self.assert_can_satisfy(["cpu=64"], [], True)
         self.assert_can_satisfy([], ["cpu=64"], False)
         self.assert_can_satisfy(["cpu=64"], ["cpu=32"], True)
         self.assert_can_satisfy(["cpu=32"], ["cpu=64"], False)
         self.assert_can_satisfy(["cpu=64"], ["cpu=64"], True)
+        self.assert_can_satisfy(["cpu=0.01"], ["cpu=any"], True)
+        self.assert_can_satisfy(["cpu=9999"], ["cpu=any"], True)
+        self.assert_can_satisfy(["cpu=any"], ["cpu=any"], True)
+        self.assert_can_satisfy(["cpu=any"], ["cpu=0.01"], False)
+        self.assert_can_satisfy(["cpu=any"], ["cpu=9999"], False)
 
         self.assert_can_satisfy(["mem=8G"], [], True)
         self.assert_can_satisfy([], ["mem=8G"], False)
         self.assert_can_satisfy(["mem=8G"], ["mem=4G"], True)
         self.assert_can_satisfy(["mem=4G"], ["mem=8G"], False)
         self.assert_can_satisfy(["mem=8G"], ["mem=8G"], True)
-
-        self.assert_can_satisfy(
-            # orchestra-name clears default cpu/mem values.
-            # This may be a problem.
-            ["orchestra-name=henry"], [], False, "orchestra")
-        self.assert_can_satisfy(
-            [], ["orchestra-name=henry"], False, "orchestra")
-        self.assert_can_satisfy(
-            ["orchestra-name=henry"], ["orchestra-name=jane"], False,
-            "orchestra")
-        self.assert_can_satisfy(
-            ["orchestra-name=jane"], ["orchestra-name=henry"], False,
-            "orchestra")
-        self.assert_can_satisfy(
-            ["orchestra-name=henry"], ["orchestra-name=henry"], True,
-            "orchestra")
-
-        self.assert_can_satisfy(
-            ["orchestra-classes=a,b"], [], True, "orchestra")
-        self.assert_can_satisfy(
-            [], ["orchestra-classes=a,b"], False, "orchestra")
-        self.assert_can_satisfy(
-            ["orchestra-classes=a,b"], ["orchestra-classes=a"], True,
-            "orchestra")
-        self.assert_can_satisfy(
-            ["orchestra-classes=a"], ["orchestra-classes=a,b"], False,
-            "orchestra")
-        self.assert_can_satisfy(
-            ["orchestra-classes=a,b"], ["orchestra-classes=a,b"], True,
-            "orchestra")
-        self.assert_can_satisfy(
-            ["orchestra-classes=a,b"], ["orchestra-classes=a,c"], False,
-            "orchestra")
-
-        self.assert_can_satisfy(["ec2-zone=a"], [], True, "ec2")
-        self.assert_can_satisfy([], ["ec2-zone=a"], False, "ec2")
-        self.assert_can_satisfy(["ec2-zone=a"], ["ec2-zone=b"], False, "ec2")
-        self.assert_can_satisfy(["ec2-zone=b"], ["ec2-zone=a"], False, "ec2")
-        self.assert_can_satisfy(["ec2-zone=a"], ["ec2-zone=a"], True, "ec2")
-
-        self.assert_can_satisfy(
-            # ec2-instance-type clears default cpu/mem values.
-            # This may be a problem.
-            ["ec2-instance-type=m1.small"], [], False, "ec2")
-        self.assert_can_satisfy([], ["ec2-instance-type=m1.small"], False, "ec2")
-        self.assert_can_satisfy(
-            ["ec2-instance-type=m1.large"], ["ec2-instance-type=m1.small"],
-            False, "ec2")
-        self.assert_can_satisfy(
-            ["ec2-instance-type=m1.small"], ["ec2-instance-type=m1.large"],
-            False, "ec2")
-        self.assert_can_satisfy(
-            ["ec2-instance-type=m1.small"], ["ec2-instance-type=m1.small"],
-            True, "ec2")
+        self.assert_can_satisfy(["mem=2M"], ["mem=any"], True)
+        self.assert_can_satisfy(["mem=256T"], ["mem=any"], True)
+        self.assert_can_satisfy(["mem=any"], ["mem=any"], True)
+        self.assert_can_satisfy(["mem=any"], ["mem=2M"], False)
+        self.assert_can_satisfy(["mem=any"], ["mem=256T"], False)
+
+
+class ConstraintSetTest(TestCase):
+
+    def allow_names(self, *names):
+        all_names = ["ubuntu-series", "provider-type"]
+        all_names.extend(names)
+        from juju.machine import constraints
+        self.patch(constraints, "ALL_NAMES", all_names)
+
+    def test_register_unknown_name(self):
+        e = self.assertRaises(
+            AssertionError, ConstraintSet("provider").register, "nonsense")
+        self.assertEquals(str(e), "please update ALL_NAMES")
+
+    def test_register_known_names(self):
+        self.allow_names("foo", "blob")
+        cs = ConstraintSet("provider")
+        cs.register("foo")
+        cs.register("blob")
+        c1 = cs.parse(["foo=bar"]).with_series("series")
+        self.assertEquals(c1["foo"], "bar")
+        self.assertEquals(c1["blob"], None)
+        c2 = cs.parse(["foo=bar"]).with_series("series")
+        self.assertTrue(c1.can_satisfy(c2))
+        self.assertTrue(c2.can_satisfy(c1))
+
+    def test_unregistered_name(self):
+        self.allow_names("foo", "bar", "baz")
+        cs = ConstraintSet("provider")
+        cs.register("bar")
+        output = self.capture_logging()
+        constraints = cs.parse(["foo=1", "bar=2", "baz=3"])
+        self.assertIn("ignored irrelevant 'foo' constraint", output.getvalue())
+        self.assertIn("ignored irrelevant 'baz' constraint", output.getvalue())
+        self.assertEquals(constraints["bar"], "2")
+
+    def test_register_invisible(self):
+        self.allow_names("foo")
+        cs = ConstraintSet("provider")
+        cs.register("foo", visible=False)
+        e = self.assertRaises(ConstraintError, cs.parse, ["foo=bar"])
+        self.assertEquals(str(e), "Cannot set computed constraint: 'foo'")
+
+    def test_register_comparer(self):
+        self.allow_names("foo")
+        cs = ConstraintSet("provider")
+        cs.register("foo", comparer=operator.ne)
+        c1 = cs.parse(["foo=bar"]).with_series("series")
+        c2 = cs.parse(["foo=bar"]).with_series("series")
+        self.assertFalse(c1.can_satisfy(c2))
+        self.assertFalse(c2.can_satisfy(c1))
+        c3 = cs.parse(["foo=baz"]).with_series("series")
+        self.assertTrue(c1.can_satisfy(c3))
+        self.assertTrue(c3.can_satisfy(c1))
+
+    def test_register_default_and_converter(self):
+        self.allow_names("foo")
+        cs = ConstraintSet("provider")
+        cs.register("foo", default="star", converter=lambda s: "death-" + s)
+        c1 = cs.parse([])
+        self.assertEquals(c1["foo"], "death-star")
+        c1 = cs.parse(["foo=clock"])
+        self.assertEquals(c1["foo"], "death-clock")
+
+    def test_convert_wraps_ValueError(self):
+        self.allow_names("foo", "bar")
+
+        def raiser(e):
+            raise e
+        cs = ConstraintSet("provider")
+        cs.register("foo", converter=lambda s: raiser(ValueError(s)))
+        cs.register("bar", converter=lambda s: raiser(KeyError(s)))
+        self.assertRaises(ConstraintError, cs.parse, ["foo=1"])
+        self.assertRaises(KeyError, cs.parse, ["bar=1"])
+
+    def test_register_conflicts(self):
+        self.allow_names("foo", "bar", "baz", "qux")
+        cs = ConstraintSet("provider")
+        cs.register("foo")
+        cs.register("bar")
+        cs.register("baz")
+        cs.register("qux")
+        cs.parse(["foo=1", "bar=2", "baz=3", "qux=4"])
+
+        def assert_ambiguous(strs):
+            e = self.assertRaises(ConstraintError, cs.parse, strs)
+            self.assertTrue(str(e).startswith("Ambiguous constraints"))
+
+        cs.register_conflicts(["foo"], ["bar", "baz", "qux"])
+        assert_ambiguous(["foo=1", "bar=2"])
+        assert_ambiguous(["foo=1", "baz=3"])
+        assert_ambiguous(["foo=1", "qux=4"])
+        cs.parse(["foo=1"])
+        cs.parse(["bar=2", "baz=3", "qux=4"])
+
+        cs.register_conflicts(["bar", "baz"], ["qux"])
+        assert_ambiguous(["bar=2", "qux=4"])
+        assert_ambiguous(["baz=3", "qux=4"])
+        cs.parse(["foo=1"])
+        cs.parse(["bar=2", "baz=3"])
+        cs.parse(["qux=4"])
+
+    def test_register_generics_no_instance_types(self):
+        cs = ConstraintSet("provider")
+        cs.register_generics([])
+        c1 = cs.parse([])
+        self.assertEquals(c1["arch"], "amd64")
+        self.assertEquals(c1["cpu"], 1.0)
+        self.assertEquals(c1["mem"], 512.0)
+        self.assertFalse("instance-type" in c1)
+
+        c2 = cs.parse(["arch=any", "cpu=0", "mem=8G"])
+        self.assertEquals(c2["arch"], None)
+        self.assertEquals(c2["cpu"], 0.0)
+        self.assertEquals(c2["mem"], 8192.0)
+        self.assertFalse("instance-type" in c2)
+
+    def test_register_generics_with_instance_types(self):
+        cs = ConstraintSet("provider")
+        cs.register_generics(["a1.big", "c7.peculiar"])
+        c1 = cs.parse([])
+        self.assertEquals(c1["arch"], "amd64")
+        self.assertEquals(c1["cpu"], 1.0)
+        self.assertEquals(c1["mem"], 512.0)
+        self.assertEquals(c1["instance-type"], None)
+
+        c2 = cs.parse(["arch=any", "cpu=0", "mem=8G"])
+        self.assertEquals(c2["arch"], None)
+        self.assertEquals(c2["cpu"], 0.0)
+        self.assertEquals(c2["mem"], 8192.0)
+        self.assertEquals(c2["instance-type"], None)
+
+        c3 = cs.parse(["instance-type=c7.peculiar", "arch=i386"])
+        self.assertEquals(c3["arch"], "i386")
+        self.assertEquals(c3["cpu"], None)
+        self.assertEquals(c3["mem"], None)
+        self.assertEquals(c3["instance-type"], "c7.peculiar")
+
+        def assert_ambiguous(strs):
+            e = self.assertRaises(ConstraintError, cs.parse, strs)
+            self.assertTrue(str(e).startswith("Ambiguous constraints"))
+
+        assert_ambiguous(["cpu=1", "instance-type=c7.peculiar"])
+        assert_ambiguous(["mem=1024", "instance-type=c7.peculiar"])
+
+        c4 = cs.parse([])
+        c4.update(c2)
+        self.assertEquals(c4["arch"], None)
+        self.assertEquals(c4["cpu"], 0.0)
+        self.assertEquals(c4["mem"], 8192.0)
+        self.assertEquals(c4["instance-type"], None)
+
+        c5 = cs.parse(["instance-type=a1.big"])
+        c5.update(cs.parse(["arch=i386"]))
+        self.assertEquals(c5["arch"], "i386")
+        self.assertEquals(c5["cpu"], None)
+        self.assertEquals(c5["mem"], None)
+        self.assertEquals(c5["instance-type"], "a1.big")
+
+        c6 = cs.parse(["instance-type=a1.big"])
+        c6.update(cs.parse(["cpu=20"]))
+        self.assertEquals(c6["arch"], "amd64")
+        self.assertEquals(c6["cpu"], 20.0)
+        self.assertEquals(c6["mem"], None)
+        self.assertEquals(c6["instance-type"], None)
+
+        c7 = cs.parse(["instance-type="])
+        self.assertEquals(c7["arch"], "amd64")
+        self.assertEquals(c7["cpu"], 1.0)
+        self.assertEquals(c7["mem"], 512.0)
+        self.assertEquals(c7["instance-type"], None)
+
+        c8 = cs.parse(["instance-type=any"])
+        self.assertEquals(c8["arch"], "amd64")
+        self.assertEquals(c8["cpu"], 1.0)
+        self.assertEquals(c8["mem"], 512.0)
+        self.assertEquals(c8["instance-type"], None)
+
+    def test_load_validates(self):
+        self.allow_names("foo")
+        cs = ConstraintSet("provider")
+
+        def blam(s):
+            raise ValueError(s)
+
+        cs.register("foo", converter=blam)
+        e = self.assertRaises(ConstraintError, cs.load, {"foo": "bar"})
+        self.assertEquals(str(e), "Bad 'foo' constraint 'bar': bar")

=== modified file 'juju/machine/unit.py'
--- juju/machine/unit.py	2012-02-21 12:14:11 +0000
+++ juju/machine/unit.py	2012-03-30 16:56:32 +0000
@@ -1,6 +1,5 @@
 import os
 import shutil
-import sys
 import logging
 
 import juju

=== modified file 'juju/providers/common/base.py'
--- juju/providers/common/base.py	2011-11-19 05:37:09 +0000
+++ juju/providers/common/base.py	2012-03-30 16:56:32 +0000
@@ -1,9 +1,10 @@
 import copy
 from operator import itemgetter
 
-from twisted.internet.defer import inlineCallbacks, returnValue
+from twisted.internet.defer import inlineCallbacks, returnValue, succeed
 
 from juju.environment.errors import EnvironmentsConfigError
+from juju.machine.constraints import ConstraintSet
 from juju.state.placement import UNASSIGNED_POLICY
 
 
@@ -30,10 +31,13 @@
 
     You may want to override the following methods, but you should be careful
     to call :class:`MachineProviderBase`'s implementation (or be very sure you
-    don't need to:
+    don't need to):
 
         * :meth:`__init__`
         * :meth:`get_serialization_data`
+        * :meth:`get_legacy_config_keys`
+        * :meth:`get_placement_policy`
+        * :meth:`get_constraint_set`
 
     You probably shouldn't override anything else.
     """
@@ -48,11 +52,16 @@
         self.environment_name = environment_name
         self.config = config
 
+    def get_constraint_set(self):
+        """Return the set of constraints that are valid for this provider."""
+        return succeed(ConstraintSet(self.provider_type))
+
+    def get_legacy_config_keys(self):
+        """Return any deprecated config keys that are set."""
+        return set() & set(self.config)
+
     def get_placement_policy(self):
-        """Get the unit placement policy for the provider.
-
-        :param preference: A user specified plcaement policy preference
-        """
+        """Get the unit placement policy for the provider."""
         return self.config.get("placement", UNASSIGNED_POLICY)
 
     def get_serialization_data(self):
@@ -151,9 +160,9 @@
         """
         return ZookeeperConnect(self).run(share=share)
 
-    def bootstrap(self):
+    def bootstrap(self, constraints):
         """Bootstrap an juju server in the provider."""
-        return Bootstrap(self).run()
+        return Bootstrap(self, constraints).run()
 
     def get_machine(self, instance_id):
         """Retrieve a provider machine by instance id.

=== modified file 'juju/providers/common/bootstrap.py'
--- juju/providers/common/bootstrap.py	2011-09-22 13:23:00 +0000
+++ juju/providers/common/bootstrap.py	2012-03-30 16:56:32 +0000
@@ -1,5 +1,7 @@
 from cStringIO import StringIO
 
+from twisted.internet.defer import inlineCallbacks, returnValue
+
 from juju.errors import EnvironmentNotFound, ProviderError
 
 from .utils import log
@@ -10,8 +12,9 @@
 class Bootstrap(object):
     """Generic bootstrap operation class."""
 
-    def __init__(self, provider):
+    def __init__(self, provider, constraints):
         self._provider = provider
+        self._constraints = constraints
 
     def run(self):
         """Get an existing zookeeper, or launch a new one.
@@ -47,6 +50,9 @@
             "Bootstrap aborted because file storage is not writable: %s"
             % str(failure.value))
 
+    @inlineCallbacks
     def _launch_machine(self, unused):
         log.debug("Launching juju bootstrap instance.")
-        return self._provider.start_machine({"machine-id": "0"}, master=True)
+        machines = yield self._provider.start_machine(
+            {"machine-id": "0", "constraints": self._constraints}, master=True)
+        returnValue(machines)

=== modified file 'juju/providers/common/cloudinit.py'
--- juju/providers/common/cloudinit.py	2012-02-21 19:28:28 +0000
+++ juju/providers/common/cloudinit.py	2012-03-30 16:56:32 +0000
@@ -1,4 +1,6 @@
+from base64 import b64encode
 from subprocess import Popen, PIPE
+from yaml import safe_dump
 
 from juju.errors import CloudInitError
 from juju.lib.upstart import UpstartService
@@ -29,14 +31,15 @@
     return scripts
 
 
-def _zookeeper_scripts(instance_id, secret, provider_type):
+def _zookeeper_scripts(instance_id, secret, constraints, provider_type):
     return [
         "juju-admin initialize"
         " --instance-id=%s"
         " --admin-identity=%s"
+        " --constraints-data=%s"
         " --provider-type=%s"
         % (instance_id, make_identity("admin:%s" % secret),
-           provider_type)]
+           b64encode(safe_dump(constraints.data)), provider_type)]
 
 
 def _machine_scripts(machine_id, zookeeper_hosts):
@@ -143,6 +146,7 @@
         self._zookeeper = False
         self._zookeeper_hosts = []
         self._zookeeper_secret = None
+        self._constraints = None
         self._origin, self._origin_url = get_default_origin()
 
     def add_ssh_key(self, key):
@@ -236,6 +240,13 @@
         """
         self._zookeeper_secret = secret
 
+    def set_constraints(self, constraints):
+        """Specify the initial machine's constraints.
+
+        You only need to set this if this machine will be a zookeeper instance.
+        """
+        self._constraints = constraints
+
     def render(self):
         """Get content for a cloud-init file with appropriate specifications.
 
@@ -265,6 +276,7 @@
         if self._zookeeper:
             require("_instance_id", "set_instance_id_accessor")
             require("_zookeeper_secret", "set_zookeeper_secret")
+            require("_constraints", "set_constraints")
         else:
             require("_zookeeper_hosts", "set_zookeeper_machines")
         if missing:
@@ -299,6 +311,7 @@
             scripts.extend(_zookeeper_scripts(
                 self._instance_id,
                 self._zookeeper_secret,
+                self._constraints,
                 self._provider_type))
         scripts.extend(_machine_scripts(
             self._machine_id, self._join_zookeeper_hosts()))

=== modified file 'juju/providers/common/launch.py'
--- juju/providers/common/launch.py	2011-09-30 04:52:20 +0000
+++ juju/providers/common/launch.py	2012-03-30 16:56:32 +0000
@@ -1,4 +1,6 @@
-from twisted.internet.defer import inlineCallbacks, returnValue
+from twisted.internet.defer import fail, inlineCallbacks, returnValue
+
+from juju.errors import ProviderError
 
 from .cloudinit import CloudInit
 from .utils import get_user_authorized_keys
@@ -24,10 +26,27 @@
     .. automethod:: _create_cloud_init
     """
 
-    def __init__(self, provider, master=False, constraints=None):
+    def __init__(self, provider, constraints, master=False):
         self._provider = provider
+        self._constraints = constraints
         self._master = master
-        self._constraints = constraints or {}
+
+    @classmethod
+    def launch(cls, provider, machine_data, master):
+        """Create and run a machine launch operation.
+
+        Exists for the convenience of the `MachineProvider` implementations
+        which actually use the "constraints" key in machine_data, which would
+        otherwise duplicate code.
+        """
+        if "machine-id" not in machine_data:
+            return fail(ProviderError(
+                "Cannot launch a machine without specifying a machine-id"))
+        if "constraints" not in machine_data:
+            return fail(ProviderError(
+                "Cannot launch a machine without specifying constraints"))
+        launcher = cls(provider, machine_data["constraints"], master)
+        return launcher.run(machine_data["machine-id"])
 
     @inlineCallbacks
     def run(self, machine_id):
@@ -88,6 +107,7 @@
         if self._master:
             cloud_init.enable_bootstrap()
             cloud_init.set_zookeeper_secret(config["admin-secret"])
+            cloud_init.set_constraints(self._constraints)
         return cloud_init
 
     def _on_new_zookeepers(self, machines):

=== modified file 'juju/providers/common/tests/data/cloud_init_bootstrap'
--- juju/providers/common/tests/data/cloud_init_bootstrap	2012-02-21 19:28:28 +0000
+++ juju/providers/common/tests/data/cloud_init_bootstrap	2012-03-30 16:56:32 +0000
@@ -6,8 +6,8 @@
 output: {all: '| tee -a /var/log/cloud-init-output.log'}
 packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
   default-jre-headless, zookeeper, zookeeperd, juju]
-runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
-    /var/log/juju, 'juju-admin initialize --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI=
+runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'juju-admin initialize
+    --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI= --constraints-data=e2NwdTogJzIwJywgcHJvdmlkZXItdHlwZTogZHVtbXksIHVidW50dS1zZXJpZXM6IGFzdG9uaXNoaW5nfQo=
     --provider-type=dummy', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
 
     description "Juju machine agent"

=== modified file 'juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers'
--- juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers	2012-02-21 19:28:28 +0000
+++ juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers	2012-03-30 16:56:32 +0000
@@ -6,8 +6,8 @@
 output: {all: '| tee -a /var/log/cloud-init-output.log'}
 packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
   default-jre-headless, zookeeper, zookeeperd, juju]
-runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
-    /var/log/juju, 'juju-admin initialize --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI=
+runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'juju-admin initialize
+    --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI= --constraints-data=e2NwdTogJzIwJywgcHJvdmlkZXItdHlwZTogZHVtbXksIHVidW50dS1zZXJpZXM6IGFzdG9uaXNoaW5nfQo=
     --provider-type=dummy', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
 
     description "Juju machine agent"

=== modified file 'juju/providers/common/tests/data/cloud_init_distro'
--- juju/providers/common/tests/data/cloud_init_distro	2012-02-21 19:28:28 +0000
+++ juju/providers/common/tests/data/cloud_init_distro	2012-03-30 16:56:32 +0000
@@ -4,9 +4,10 @@
 machine-data: {juju-provider-type: dummy, juju-zookeeper-hosts: 'cotswold:2181,longleat:2181',
   machine-id: passport}
 output: {all: '| tee -a /var/log/cloud-init-output.log'}
-packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper, juju]
-runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
-    /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf <<EOF
+packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
+  juju]
+runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf
+    <<EOF
 
     description "Juju machine agent"
 

=== modified file 'juju/providers/common/tests/data/cloud_init_ppa'
--- juju/providers/common/tests/data/cloud_init_ppa	2012-02-21 19:28:28 +0000
+++ juju/providers/common/tests/data/cloud_init_ppa	2012-03-30 16:56:32 +0000
@@ -6,9 +6,10 @@
 machine-data: {juju-provider-type: dummy, juju-zookeeper-hosts: 'cotswold:2181,longleat:2181',
   machine-id: passport}
 output: {all: '| tee -a /var/log/cloud-init-output.log'}
-packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper, juju]
-runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
-    /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf <<EOF
+packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
+  juju]
+runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf
+    <<EOF
 
     description "Juju machine agent"
 

=== modified file 'juju/providers/common/tests/test_base.py'
--- juju/providers/common/tests/test_base.py	2011-09-27 02:14:56 +0000
+++ juju/providers/common/tests/test_base.py	2012-03-30 16:56:32 +0000
@@ -63,6 +63,10 @@
         self.assertEqual(
             provider.get_placement_policy(), "local")
 
+    def test_get_legacy_config_keys(self):
+        provider = DummyProvider()
+        self.assertEqual(provider.get_legacy_config_keys(), set())
+
     def test_get_machine_error(self):
         provider = DummyProvider()
         provider.get_machines = self.mocker.mock()

=== modified file 'juju/providers/common/tests/test_bootstrap.py'
--- juju/providers/common/tests/test_bootstrap.py	2011-09-15 18:50:23 +0000
+++ juju/providers/common/tests/test_bootstrap.py	2012-03-30 16:56:32 +0000
@@ -1,10 +1,11 @@
 import logging
 import tempfile
 
-from twisted.internet.defer import fail, succeed
+from twisted.internet.defer import fail, succeed, inlineCallbacks
 
 from juju.errors import EnvironmentNotFound, ProviderError
 from juju.lib.testing import TestCase
+from juju.machine.tests.test_constraints import dummy_cs
 from juju.providers.common.base import MachineProviderBase
 from juju.providers.dummy import DummyMachine, FileStorage
 
@@ -27,7 +28,11 @@
 
 class DummyProvider(MachineProviderBase):
 
-    def __init__(self, file_storage, zookeeper):
+    provider_type = "dummy"
+    config = {"default-series": "splendid"}
+
+    def __init__(self, test, file_storage, zookeeper):
+        self._test = test
         self._file_storage = file_storage
         self._zookeeper = zookeeper
 
@@ -41,24 +46,34 @@
             return succeed([self._zookeeper])
         return fail(EnvironmentNotFound())
 
-    def start_machine(self, machine_id, master=False):
-        assert master is True
+    def start_machine(self, machine_data, master=False):
+        self._test.assertTrue(master)
+        self._test.assertEquals(machine_data["machine-id"], "0")
+        constraints = machine_data["constraints"]
+        self._test.assertEquals(constraints["provider-type"], "dummy")
+        self._test.assertEquals(constraints["ubuntu-series"], "splendid")
+        self._test.assertEquals(constraints["arch"], "arm")
         return [DummyMachine("i-keepzoos")]
 
 
 class BootstrapTest(TestCase):
 
+    @inlineCallbacks
+    def setUp(self):
+        yield super(BootstrapTest, self).setUp()
+        self.constraints = dummy_cs.parse(["arch=arm"]).with_series("splendid")
+
     def test_unknown_error(self):
-        provider = DummyProvider(None, SomeError())
-        d = provider.bootstrap()
+        provider = DummyProvider(self, None, SomeError())
+        d = provider.bootstrap(self.constraints)
         self.assertFailure(d, SomeError)
         return d
 
     def test_zookeeper_exists(self):
         log = self.capture_logging("juju.common", level=logging.DEBUG)
         provider = DummyProvider(
-            WorkingFileStorage(), DummyMachine("i-alreadykeepzoos"))
-        d = provider.bootstrap()
+            self, WorkingFileStorage(), DummyMachine("i-alreadykeepzoos"))
+        d = provider.bootstrap(self.constraints)
 
         def verify(machines):
             (machine,) = machines
@@ -73,8 +88,8 @@
         return d
 
     def test_bad_storage(self):
-        provider = DummyProvider(UnwritableFileStorage(), None)
-        d = provider.bootstrap()
+        provider = DummyProvider(self, UnwritableFileStorage(), None)
+        d = provider.bootstrap(self.constraints)
         self.assertFailure(d, ProviderError)
 
         def verify(error):
@@ -87,8 +102,8 @@
 
     def test_create_zookeeper(self):
         log = self.capture_logging("juju.common", level=logging.DEBUG)
-        provider = DummyProvider(WorkingFileStorage(), None)
-        d = provider.bootstrap()
+        provider = DummyProvider(self, WorkingFileStorage(), None)
+        d = provider.bootstrap(self.constraints)
 
         def verify(machines):
             (machine,) = machines

=== modified file 'juju/providers/common/tests/test_cloudinit.py'
--- juju/providers/common/tests/test_cloudinit.py	2012-02-22 09:23:16 +0000
+++ juju/providers/common/tests/test_cloudinit.py	2012-03-30 16:56:32 +0000
@@ -5,6 +5,7 @@
 
 from juju.errors import CloudInitError
 from juju.lib.testing import TestCase
+from juju.machine.tests.test_constraints import dummy_cs
 from juju.providers.common.cloudinit import (
     CloudInit, parse_juju_origin, get_default_origin)
 from juju.providers.dummy import DummyMachine
@@ -34,6 +35,8 @@
         cloud_init.set_provider_type("dummy")
         cloud_init.set_instance_id_accessor("token")
         cloud_init.set_zookeeper_secret("seekrit")
+        cloud_init.set_constraints(
+            dummy_cs.parse(["cpu=20"]).with_series("astonishing"))
         cloud_init.set_juju_source(distro=True)
         if with_zookeepers:
             cloud_init.set_zookeeper_machines([
@@ -64,7 +67,7 @@
             str(error),
             "Incomplete cloud-init: you need to call add_ssh_key, "
             "set_machine_id, set_provider_type, set_instance_id_accessor, "
-            "set_zookeeper_secret")
+            "set_zookeeper_secret, set_constraints")
 
     def test_source_validate(self):
         bad_choices = (

=== modified file 'juju/providers/common/tests/test_launch.py'
--- juju/providers/common/tests/test_launch.py	2011-09-19 23:33:37 +0000
+++ juju/providers/common/tests/test_launch.py	2012-03-30 16:56:32 +0000
@@ -1,6 +1,6 @@
 import tempfile
 
-from twisted.internet.defer import fail, succeed
+from twisted.internet.defer import fail, succeed, inlineCallbacks, returnValue
 
 from juju.errors import EnvironmentNotFound
 from juju.lib.testing import TestCase
@@ -9,10 +9,12 @@
 from juju.providers.dummy import DummyMachine, FileStorage
 
 
-def launch_machine(test, master, zookeeper):
+def get_classes(test, master, machine_id, zookeeper):
 
     class DummyProvider(MachineProviderBase):
 
+        provider_type = "dummy"
+
         def __init__(self):
             self.config = {"admin-secret": "BLAH"}
             self._file_storage = FileStorage(tempfile.mkdtemp())
@@ -27,54 +29,73 @@
 
     class DummyLaunchMachine(LaunchMachine):
 
-        def start_machine(self, machine_id, zookeepers):
-            test.assertEquals(machine_id, "1234")
+        def start_machine(self, actual_machine_id, zookeepers):
+            test.assertEquals(actual_machine_id, machine_id)
             test.assertEquals(zookeepers, filter(None, [zookeeper]))
             test.assertEquals(self._master, master)
-            test.assertEquals(self._constraints, {})
+            test.assertEquals(self._constraints, self.expect_constraints)
             return succeed([DummyMachine("i-malive")])
 
+    return DummyProvider, DummyLaunchMachine
+
+
+@inlineCallbacks
+def launch_machine(test, master, zookeeper):
+    DummyProvider, DummyLaunchMachine = get_classes(
+        test, master, "1234", zookeeper)
+
     provider = DummyProvider()
-    d = DummyLaunchMachine(provider, master).run("1234")
-    return provider, d
+    cs = yield provider.get_constraint_set()
+    constraints = cs.parse([])
+    launch = DummyLaunchMachine(provider, constraints, master)
+    launch.expect_constraints = constraints
+    machines = yield launch.run("1234")
+    returnValue((provider, machines))
 
 
 class LaunchMachineTest(TestCase):
 
+    @inlineCallbacks
     def assert_success(self, master, zookeeper):
-        provider, d = launch_machine(self, master, zookeeper)
-
-        def verify(machines):
-            (machine,) = machines
-            self.assertTrue(isinstance(machine, DummyMachine))
-            self.assertEquals(machine.instance_id, "i-malive")
-            return provider
-        d.addCallback(verify)
-        return d
+        provider, machines = yield launch_machine(self, master, zookeeper)
+        (machine,) = machines
+        self.assertTrue(isinstance(machine, DummyMachine))
+        self.assertEquals(machine.instance_id, "i-malive")
+        returnValue(provider)
 
     def test_start_nonzookeeper_no_zookeepers(self):
         """Starting a non-zookeeper without a zookeeper is an error"""
-        unused, d = launch_machine(self, False, None)
-        self.assertFailure(d, EnvironmentNotFound)
-        return d
+        return self.assertFailure(
+            launch_machine(self, False, None), EnvironmentNotFound)
 
+    @inlineCallbacks
     def test_start_zookeeper_no_zookeepers(self):
         """A new zookeeper should be recorded in provider state"""
-        d = self.assert_success(True, None)
-
-        def verify(provider):
-            provider_state = yield provider.load_state()
-            self.assertEquals(
-                provider_state, {"zookeeper-instances": ["i-malive"]})
-        d.addCallback(verify)
-        return d
-
+        provider = yield self.assert_success(True, None)
+        provider_state = yield provider.load_state()
+        self.assertEquals(
+            provider_state, {"zookeeper-instances": ["i-malive"]})
+
+    @inlineCallbacks
     def test_works_with_zookeeper(self):
         """Creating a non-zookeeper machine should not alter provider state"""
-        d = self.assert_success(False, DummyMachine("i-keepzoos"))
-
-        def verify(provider):
-            provider_state = yield provider.load_state()
-            self.assertEquals(provider_state, False)
-        d.addCallback(verify)
-        return d
+        provider = yield self.assert_success(False, DummyMachine("i-keepzoos"))
+        provider_state = yield provider.load_state()
+        self.assertEquals(provider_state, False)
+
+    @inlineCallbacks
+    def test_convenience_launch(self):
+        DummyProvider, DummyLaunchMachine = get_classes(
+            self, True, "999", None)
+
+        provider = DummyProvider()
+        cs = yield provider.get_constraint_set()
+        constraints = cs.parse(["arch=arm", "mem=1G"])
+        DummyLaunchMachine.expect_constraints = constraints
+        machine_data = {
+            "machine-id": "999", "constraints": constraints}
+        machines = yield DummyLaunchMachine.launch(
+            provider, machine_data, True)
+        (machine,) = machines
+        self.assertTrue(isinstance(machine, DummyMachine))
+        self.assertEquals(machine.instance_id, "i-malive")

=== modified file 'juju/providers/dummy.py'
--- juju/providers/dummy.py	2011-09-28 09:48:30 +0000
+++ juju/providers/dummy.py	2012-03-30 16:56:32 +0000
@@ -11,6 +11,7 @@
 
 
 from juju.machine import ProviderMachine
+from juju.machine.constraints import ConstraintSet
 from juju.state.placement import UNASSIGNED_POLICY
 from juju.providers.common.files import FileStorage
 
@@ -34,6 +35,9 @@
         self._state = None
         self._storage = None
 
+    def get_legacy_config_keys(self):
+        return set(("some-legacy-key",)) & set(self.config)
+
     def get_placement_policy(self):
         """Get the unit placement policy for the provider.
 
@@ -41,6 +45,11 @@
         """
         return self.config.get("placement", UNASSIGNED_POLICY)
 
+    def get_constraint_set(self):
+        cs = ConstraintSet(self.provider_type)
+        cs.register_generics([])
+        return succeed(cs)
+
     @property
     def provider_type(self):
         return "dummy"
@@ -91,7 +100,7 @@
                 return succeed(machine)
         return fail(MachinesNotFound([instance_id]))
 
-    def bootstrap(self):
+    def bootstrap(self, constraints):
         """
         Bootstrap juju on the machine provider.
         """

=== modified file 'juju/providers/ec2/__init__.py'
--- juju/providers/ec2/__init__.py	2011-09-19 17:17:00 +0000
+++ juju/providers/ec2/__init__.py	2012-03-30 16:56:32 +0000
@@ -1,7 +1,7 @@
 import os
 import re
 
-from twisted.internet.defer import fail, inlineCallbacks, returnValue
+from twisted.internet.defer import inlineCallbacks, returnValue
 
 from txaws.ec2.exception import EC2Error
 from txaws.service import AWSServiceRegion
@@ -16,7 +16,7 @@
 from .securitygroup import (
     open_provider_port, close_provider_port, get_provider_opened_ports,
     remove_security_groups, destroy_environment_security_group)
-from .utils import get_region_uri
+from .utils import convert_zone, get_region_uri, DEFAULT_REGION, INSTANCE_TYPES
 
 
 class MachineProvider(MachineProviderBase):
@@ -26,7 +26,7 @@
         super(MachineProvider, self).__init__(environment_name, config)
 
         if not config.get("ec2-uri"):
-            ec2_uri = get_region_uri(config.get("region", "us-east-1"))
+            ec2_uri = get_region_uri(config.get("region", DEFAULT_REGION))
         else:
             ec2_uri = config.get("ec2-uri")
 
@@ -42,6 +42,30 @@
     def provider_type(self):
         return "ec2"
 
+    @property
+    def using_amazon(self):
+        return "ec2-uri" not in self.config
+
+    @inlineCallbacks
+    def get_constraint_set(self):
+        """Return the set of constraints that are valid for this provider."""
+        cs = yield super(MachineProvider, self).get_constraint_set()
+        if self.using_amazon:
+            # Expose EC2 instance types/zones on AWS itelf, not private clouds.
+            cs.register_generics(INSTANCE_TYPES.keys())
+            cs.register("ec2-zone", converter=convert_zone)
+        returnValue(cs)
+
+    def get_legacy_config_keys(self):
+        """Return any deprecated config keys that are set"""
+        legacy = super(MachineProvider, self).get_legacy_config_keys()
+        if self.using_amazon:
+            # In the absence of a generic instance-type/image-id mechanism,
+            # these keys remain valid on private clouds.
+            amazon_legacy = set(("default-image-id", "default-instance-type"))
+            legacy.update(amazon_legacy.intersection(self.config))
+        return legacy
+
     def get_serialization_data(self):
         """Get provider configuration suitable for serialization.
 
@@ -67,12 +91,7 @@
             and run a provisioning agent, in addition to running a machine
             agent.
         """
-        if "machine-id" not in machine_data:
-            return fail(ProviderError(
-                "Cannot launch a machine without specifying a machine-id"))
-        machine_id = machine_data["machine-id"]
-        constraints = machine_data.get("constraints", {})
-        return EC2LaunchMachine(self, master, constraints).run(machine_id)
+        return EC2LaunchMachine.launch(self, machine_data, master)
 
     @inlineCallbacks
     def get_machines(self, instance_ids=()):

=== modified file 'juju/providers/ec2/launch.py'
--- juju/providers/ec2/launch.py	2011-09-19 20:38:45 +0000
+++ juju/providers/ec2/launch.py	2012-03-30 16:56:32 +0000
@@ -6,7 +6,7 @@
 from juju.providers.common.launch import LaunchMachine
 
 from .machine import machine_from_instance
-from .utils import get_image_id, log
+from .utils import get_machine_spec, log, DEFAULT_REGION
 
 
 class EC2LaunchMachine(LaunchMachine):
@@ -34,17 +34,21 @@
             "$(curl http://169.254.169.254/1.0/meta-data/instance-id)")
         user_data = cloud_init.render()
 
-        instance_type = self._provider.config.get(
-            "default-instance-type", "m1.small")
-        image_id = yield get_image_id(self._provider.config, self._constraints)
+        availability_zone = self._constraints["ec2-zone"]
+        if availability_zone is not None:
+            region = self._provider.config.get("region", DEFAULT_REGION)
+            availability_zone = region + availability_zone
+        spec = yield get_machine_spec(self._provider.config, self._constraints)
         security_groups = yield self._ensure_groups(machine_id)
 
+        log.debug("Launching with machine spec %s", spec)
         instances = yield self._provider.ec2.run_instances(
-            image_id=image_id,
-            instance_type=instance_type,
             min_count=1,
             max_count=1,
+            image_id=spec.image_id,
+            instance_type=spec.instance_type,
             security_groups=security_groups,
+            availability_zone=availability_zone,
             user_data=user_data)
 
         returnValue([machine_from_instance(i) for i in instances])

=== modified file 'juju/providers/ec2/tests/common.py'
--- juju/providers/ec2/tests/common.py	2011-09-29 05:35:04 +0000
+++ juju/providers/ec2/tests/common.py	2012-03-30 16:56:32 +0000
@@ -1,6 +1,6 @@
 from yaml import dump
 
-from twisted.internet.defer import fail, succeed
+from twisted.internet.defer import fail, succeed, inlineCallbacks, returnValue
 
 from txaws.s3.client import S3Client
 from txaws.s3.exception import S3Error
@@ -14,6 +14,13 @@
 
 MATCH_GROUP = MATCH(lambda x: x.startswith("juju-moon"))
 
+_constraints_provider = MachineProvider("", {})
+
+@inlineCallbacks
+def get_constraints(strs, series="splendid"):
+    cs = yield _constraints_provider.get_constraint_set()
+    returnValue(cs.parse(strs).with_series(series))
+
 
 class EC2TestMixin(object):
 
@@ -26,7 +33,8 @@
                 "admin-secret": "magic-beans",
                 "access-key": "0f62e973d5f8",
                 "secret-key": "3e5a7c653f59",
-                "control-bucket": self.env_name}
+                "control-bucket": self.env_name,
+                "default-series": "splendid"}
 
     def get_provider(self):
         """Return the ec2 machine provider.
@@ -81,7 +89,7 @@
 
 class EC2MachineLaunchMixin(object):
 
-    def _mock_launch_utils(self, ami_name="ami-default", **get_ami_kwargs):
+    def _mock_launch_utils(self, ami_name="ami-default", get_ami_args=()):
         get_public_key = self.mocker.replace(
             "juju.providers.common.utils.get_user_authorized_keys")
 
@@ -91,16 +99,12 @@
         get_public_key(MATCH(match_config))
         self.mocker.result("zebra")
 
-        if not get_ami_kwargs:
-            return
+        get_ami_args = get_ami_args or (
+            "splendid", "amd64", "us-east-1", False)
         get_ami = self.mocker.replace(
             "juju.providers.ec2.utils.get_current_ami")
-        get_ami(KWARGS)
-
-        def check_kwargs(**kwargs):
-            self.assertEquals(kwargs, get_ami_kwargs)
-            return succeed(ami_name)
-        self.mocker.call(check_kwargs)
+        get_ami(*get_ami_args)
+        self.mocker.result(succeed(ami_name))
 
     def _mock_create_group(self):
         group_name = "juju-%s" % self.env_name

=== modified file 'juju/providers/ec2/tests/data/bootstrap_cloud_init'
--- juju/providers/ec2/tests/data/bootstrap_cloud_init	2012-02-21 19:28:28 +0000
+++ juju/providers/ec2/tests/data/bootstrap_cloud_init	2012-03-30 16:56:32 +0000
@@ -5,10 +5,10 @@
 output: {all: '| tee -a /var/log/cloud-init-output.log'}
 packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
   default-jre-headless, zookeeper, zookeeperd, juju]
-runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
-    /var/log/juju, 'juju-admin initialize --instance-id=$(curl http://169.254.169.254/1.0/meta-data/instance-id)
-    --admin-identity=admin:JbJ6sDGV37EHzbG9FPvttk64cmg= --provider-type=ec2', 'cat
-    >> /etc/init/juju-machine-agent.conf <<EOF
+runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'juju-admin initialize
+    --instance-id=$(curl http://169.254.169.254/1.0/meta-data/instance-id) --admin-identity=admin:JbJ6sDGV37EHzbG9FPvttk64cmg=
+    --constraints-data=e2NwdTogbnVsbCwgaW5zdGFuY2UtdHlwZTogbTEuc21hbGwsIG1lbTogbnVsbCwgcHJvdmlkZXItdHlwZTogZWMyLCB1YnVudHUtc2VyaWVzOiBzcGxlbmRpZH0K
+    --provider-type=ec2', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
 
     description "Juju machine agent"
 

=== modified file 'juju/providers/ec2/tests/test_bootstrap.py'
--- juju/providers/ec2/tests/test_bootstrap.py	2011-09-30 04:52:20 +0000
+++ juju/providers/ec2/tests/test_bootstrap.py	2012-03-30 16:56:32 +0000
@@ -3,7 +3,7 @@
 
 import yaml
 
-from twisted.internet.defer import succeed
+from twisted.internet.defer import succeed, inlineCallbacks
 
 from txaws.ec2.model import SecurityGroup
 
@@ -11,7 +11,7 @@
 from juju.lib.testing import TestCase
 from juju.providers.ec2.machine import EC2ProviderMachine
 
-from .common import EC2TestMixin, EC2MachineLaunchMixin
+from .common import EC2TestMixin, EC2MachineLaunchMixin, get_constraints
 
 
 DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data")
@@ -50,8 +50,10 @@
             max_count=1,
             min_count=1,
             security_groups=["juju-moon", "juju-moon-0"],
+            availability_zone=None,
             user_data=MATCH(verify_user_data))
 
+    @inlineCallbacks
     def test_launch_bootstrap(self):
         """The provider bootstrap can launch a bootstrap/zookeeper machine."""
 
@@ -64,23 +66,20 @@
         self.mocker.result(succeed([]))
         self._mock_create_group()
         self._mock_create_machine_group(0)
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_launch()
         self.mocker.result(succeed([]))
         self._mock_save()
         self.mocker.replay()
 
         provider = self.get_provider()
-        deferred = provider.bootstrap()
-
-        def check_log(result):
-            log_text = log.getvalue()
-            self.assertIn("Launching juju bootstrap instance", log_text)
-            self.assertNotIn("previously bootstrapped", log_text)
-
-        deferred.addCallback(check_log)
-        return deferred
-
+        constraints = yield get_constraints(["instance-type=m1.small"])
+        yield provider.bootstrap(constraints)
+        log_text = log.getvalue()
+        self.assertIn("Launching juju bootstrap instance", log_text)
+        self.assertNotIn("previously bootstrapped", log_text)
+
+    @inlineCallbacks
     def test_launch_bootstrap_existing_provider_group(self):
         """
         When launching a bootstrap instance the provider will use an existing
@@ -94,15 +93,17 @@
         self.mocker.result(succeed([
             SecurityGroup("juju-%s" % self.env_name, "")]))
         self._mock_create_machine_group(0)
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_launch()
         self.mocker.result(succeed([]))
         self._mock_save()
         self.mocker.replay()
 
         provider = self.get_provider()
-        return provider.bootstrap()
+        constraints = yield get_constraints(["instance-type=m1.small"])
+        yield provider.bootstrap(constraints)
 
+    @inlineCallbacks
     def test_run_with_loaded_state(self):
         """
         If the provider bootstrap is run when there is already a running
@@ -116,21 +117,18 @@
         self.mocker.replay()
 
         log = self.capture_logging("juju.common")
-
-        def validate_result(result):
-            self.assertTrue(result)
-            machine = result.pop()
-            self.assertTrue(isinstance(machine, EC2ProviderMachine))
-            self.assertEqual(machine.instance_id, "i-foobar")
-            self.assertEquals(
-                log.getvalue(),
-                "juju environment previously bootstrapped.\n")
-
         provider = self.get_provider()
-        d = provider.bootstrap()
-        d.addCallback(validate_result)
-        return d
-
+        constraints = yield get_constraints(["instance-type=m1.small"])
+        machines = yield provider.bootstrap(constraints)
+
+        (machine,) = machines
+        self.assertTrue(isinstance(machine, EC2ProviderMachine))
+        self.assertEqual(machine.instance_id, "i-foobar")
+        self.assertEquals(
+            log.getvalue(),
+            "juju environment previously bootstrapped.\n")
+
+    @inlineCallbacks
     def test_run_with_launch(self):
         """
         The provider bootstrap will launch an instance when run if there
@@ -143,16 +141,14 @@
         self.mocker.result(succeed([
             SecurityGroup("juju-%s" % self.env_name, "")]))
         self._mock_create_machine_group(0)
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_launch()
         self.mocker.result(succeed([self.get_instance("i-foobar")]))
         self._mock_save()
         self.mocker.replay()
 
-        def validate_result(result):
-            (machine,) = result
-            self.assert_machine(machine, "i-foobar", "")
         provider = self.get_provider()
-        d = provider.bootstrap()
-        d.addCallback(validate_result)
-        return d
+        constraints = yield get_constraints(["instance-type=m1.small"])
+        machines = yield provider.bootstrap(constraints)
+        (machine,) = machines
+        self.assert_machine(machine, "i-foobar", "")

=== modified file 'juju/providers/ec2/tests/test_launch.py'
--- juju/providers/ec2/tests/test_launch.py	2011-09-28 05:22:36 +0000
+++ juju/providers/ec2/tests/test_launch.py	2012-03-30 16:56:32 +0000
@@ -13,15 +13,26 @@
 from juju.lib.testing import TestCase
 from juju.lib.mocker import MATCH
 
-from .common import EC2TestMixin, EC2MachineLaunchMixin
+from .common import EC2TestMixin, EC2MachineLaunchMixin, get_constraints
 
 DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data")
 
 
 class EC2MachineLaunchTest(EC2TestMixin, EC2MachineLaunchMixin, TestCase):
 
+    @inlineCallbacks
+    def setUp(self):
+        yield super(EC2MachineLaunchTest, self).setUp()
+        self.constraints = yield get_constraints([])
+        self.gen_constraints = yield get_constraints(["cpu=20", "mem=7168"])
+        self.gen_constraints = self.gen_constraints.with_series("dribbly")
+        self.ec2_constraints = yield get_constraints(
+            ["instance-type=cc2.8xlarge", "ec2-zone=b"])
+        self.ec2_constraints = self.ec2_constraints.with_series("vast")
+
     def _mock_launch(self, instance, expect_ami="ami-default",
                      expect_instance_type="m1.small",
+                     expect_availability_zone=None,
                      cloud_init="launch_cloud_init"):
 
         def verify_user_data(data):
@@ -37,6 +48,7 @@
             max_count=1,
             min_count=1,
             security_groups=["juju-moon", "juju-moon-1"],
+            availability_zone=expect_availability_zone,
             user_data=MATCH(verify_user_data))
 
         self.mocker.result(succeed([instance]))
@@ -62,7 +74,7 @@
         self.mocker.result(succeed([]))
         self._mock_create_group()
         self._mock_create_machine_group("1")
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_get_zookeeper_hosts()
         self._mock_launch(self.get_instance("i-foobar"))
         self.mocker.replay()
@@ -71,18 +83,28 @@
             (machine,) = result
             self.assert_machine(machine, "i-foobar", "")
         provider = self.get_provider()
-        d = provider.start_machine({"machine-id": "1"})
+        d = provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
         d.addCallback(verify_result)
         return d
 
     @inlineCallbacks
+    def test_provider_launch_requires_constraints(self):
+        self.mocker.replay()
+        provider = self.get_provider()
+        d = provider.start_machine({"machine-id": "1"})
+        e = yield self.assertFailure(d, ProviderError)
+        self.assertEquals(
+            str(e), "Cannot launch a machine without specifying constraints")
+
+    @inlineCallbacks
     def test_provider_launch_using_branch(self):
         """Can use a juju branch to launch a machine"""
         self.ec2.describe_security_groups()
         self.mocker.result(succeed([]))
         self._mock_create_group()
         self._mock_create_machine_group("1")
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_get_zookeeper_hosts()
         self._mock_launch(
             self.get_instance("i-foobar"),
@@ -91,7 +113,8 @@
 
         provider = self.get_provider()
         provider.config["juju-origin"] = "lp:~wizard/juju-juicebar"
-        machines = yield provider.start_machine({"machine-id": "1"})
+        machines = yield provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
         self.assert_machine(machines[0], "i-foobar", "")
 
     @inlineCallbacks
@@ -101,7 +124,7 @@
         self.mocker.result(succeed([]))
         self._mock_create_group()
         self._mock_create_machine_group("1")
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_get_zookeeper_hosts()
         self._mock_launch(
             self.get_instance("i-foobar"),
@@ -110,7 +133,8 @@
 
         provider = self.get_provider()
         provider.config["juju-origin"] = "ppa"
-        machines = yield provider.start_machine({"machine-id": "1"})
+        machines = yield provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
         self.assert_machine(machines[0], "i-foobar", "")
 
     @inlineCallbacks
@@ -120,7 +144,7 @@
         self.mocker.result(succeed([]))
         self._mock_create_group()
         self._mock_create_machine_group("1")
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_get_zookeeper_hosts()
         self._mock_launch(
             self.get_instance("i-foobar"),
@@ -129,7 +153,8 @@
 
         provider = self.get_provider()
         provider.config["juju-origin"] = "distro"
-        machines = yield provider.start_machine({"machine-id": "1"})
+        machines = yield provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
         self.assert_machine(machines[0], "i-foobar", "")
 
     @inlineCallbacks
@@ -141,17 +166,17 @@
         self.ec2.describe_security_groups()
         self.mocker.result(succeed([security_group]))
         self._mock_create_machine_group("1")
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_get_zookeeper_hosts()
         self._mock_launch(instance)
         self.mocker.replay()
 
         provider = self.get_provider()
-        provided_machines = yield provider.start_machine({"machine-id": "1"})
-        self.assertEqual(len(provided_machines), 1)
-        self.assertTrue(isinstance(provided_machines[0], EC2ProviderMachine))
-        self.assertEqual(
-            provided_machines[0].instance_id, instance.instance_id)
+        machines = yield provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
+        self.assertEqual(len(machines), 1)
+        self.assertTrue(isinstance(machines[0], EC2ProviderMachine))
+        self.assertEqual(machines[0].instance_id, instance.instance_id)
 
     @inlineCallbacks
     def test_provider_launch_existing_machine_security_group(self):
@@ -165,17 +190,17 @@
         self._mock_create_group()
         self._mock_delete_machine_group("1")  # delete existing sg
         self._mock_create_machine_group("1")  # then recreate
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_get_zookeeper_hosts()
         self._mock_launch(instance)
         self.mocker.replay()
 
         provider = self.get_provider()
-        provided_machines = yield provider.start_machine({"machine-id": "1"})
-        self.assertEqual(len(provided_machines), 1)
-        self.assertTrue(isinstance(provided_machines[0], EC2ProviderMachine))
-        self.assertEqual(
-            provided_machines[0].instance_id, instance.instance_id)
+        machines = yield provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
+        self.assertEqual(len(machines), 1)
+        self.assertTrue(isinstance(machines[0], EC2ProviderMachine))
+        self.assertEqual(machines[0].instance_id, instance.instance_id)
 
     @inlineCallbacks
     def test_provider_launch_existing_machine_security_group_is_active(self):
@@ -191,13 +216,14 @@
         self.mocker.result(succeed([machine_group]))
         self._mock_create_group()
         self._mock_delete_machine_group_was_deleted("1")  # sg is gone!
-        self._mock_launch_utils(region="us-east-1")
+        self._mock_launch_utils()
         self._mock_get_zookeeper_hosts()
         self.mocker.replay()
 
         provider = self.get_provider()
         ex = yield self.assertFailure(
-            provider.start_machine({"machine-id": "1"}),
+            provider.start_machine({
+                "machine-id": "1", "constraints": self.constraints}),
             ProviderInteractionError)
         self.assertEqual(
             str(ex),
@@ -216,7 +242,8 @@
         self.mocker.replay()
 
         provider = self.get_provider()
-        d = provider.start_machine({"machine-id": "1"})
+        d = provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
         self.assertFailure(d, EnvironmentNotFound)
         return d
 
@@ -231,65 +258,62 @@
         self.mocker.replay()
 
         provider = self.get_provider()
-        d = provider.start_machine({"machine-id": "1"})
+        d = provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
         self.assertFailure(d, EnvironmentNotFound)
         return d
 
-    def test_launch_options_known_instance_type(self):
-        self.ec2.describe_security_groups()
-        self.mocker.result(succeed([]))
-        self._mock_create_group()
-        self._mock_create_machine_group("1")
-        self._mock_launch_utils(region="us-east-1")
-        self._mock_get_zookeeper_hosts()
-        self._mock_launch(
-            self.get_instance("i-foobar"), expect_instance_type="m1.ginormous")
-        self.mocker.replay()
-
-        provider = self.get_provider()
-        provider.config["default-instance-type"] = "m1.ginormous"
-        return provider.start_machine({"machine-id": "1"})
-
-    def _mock_launch_with_ami_params(self, get_ami_kwargs, expect_ami=None):
-        expect_ami = expect_ami or "ami-default"
-        self.ec2.describe_security_groups()
-        self.mocker.result(succeed([]))
-        self._mock_create_group()
-        self._mock_create_machine_group("1")
-        self._mock_launch_utils(ami_name=expect_ami, **get_ami_kwargs)
-        self._mock_get_zookeeper_hosts()
-        self._mock_launch(self.get_instance("i-foobar"), expect_ami)
-
-    def test_launch_options_known_ami(self):
-        self._mock_launch_with_ami_params({}, expect_ami="ami-different")
-        self.mocker.replay()
-
-        provider = self.get_provider()
-        provider.config["default-image-id"] = "ami-different"
-        return provider.start_machine({"machine-id": "1"})
-
-    def test_launch_options_region(self):
-        self._mock_launch_with_ami_params({"region": "somewhere-else-1"})
+    def test_launch_options_from_config_region(self):
+        self.ec2.describe_security_groups()
+        self.mocker.result(succeed([]))
+        self._mock_create_group()
+        self._mock_create_machine_group("1")
+        self._mock_launch_utils(
+            ami_name="ami-regional",
+            get_ami_args=("splendid", "amd64", "somewhere-else-1", False))
+        self._mock_get_zookeeper_hosts()
+        self._mock_launch(self.get_instance("i-foobar"), "ami-regional")
         self.mocker.replay()
 
         provider = self.get_provider()
         provider.config["region"] = "somewhere-else-1"
-        return provider.start_machine({"machine-id": "1"})
-
-    def test_launch_options_custom_image_options(self):
-        self._mock_launch_with_ami_params({
-            "region": "us-east-1",
-            "ubuntu_release": "choleric",
-            "architecture": "quantum86",
-            "persistent_storage": "maybe",
-            "daily": "perhaps"})
-        self.mocker.replay()
-
-        provider = self.get_provider()
-        constraints = {
-            "ubuntu_release": "choleric",
-            "architecture": "quantum86",
-            "persistent_storage": "maybe",
-            "daily": "perhaps"}
-        return provider.start_machine({"machine-id": "1",
-                                       "constraints": constraints})
+        return provider.start_machine({
+            "machine-id": "1", "constraints": self.constraints})
+
+    def test_launch_options_ec2_constraints(self):
+        self.ec2.describe_security_groups()
+        self.mocker.result(succeed([]))
+        self._mock_create_group()
+        self._mock_create_machine_group("1")
+        self._mock_launch_utils(
+            ami_name="ami-fancy-cluster",
+            get_ami_args=("vast", "amd64", "us-east-1", True))
+        self._mock_get_zookeeper_hosts()
+        self._mock_launch(
+            self.get_instance("i-foobar"), "ami-fancy-cluster",
+            expect_instance_type="cc2.8xlarge",
+            expect_availability_zone="us-east-1b")
+        self.mocker.replay()
+
+        provider = self.get_provider()
+        return provider.start_machine({
+            "machine-id": "1",
+            "constraints": self.ec2_constraints})
+
+    def test_launch_options_generic_constraints(self):
+        self.ec2.describe_security_groups()
+        self.mocker.result(succeed([]))
+        self._mock_create_group()
+        self._mock_create_machine_group("1")
+        self._mock_launch_utils(
+            get_ami_args=("dribbly", "amd64", "us-east-1", False))
+        self._mock_get_zookeeper_hosts()
+        self._mock_launch(
+            self.get_instance("i-foobar"), "ami-default",
+            expect_instance_type="c1.xlarge")
+        self.mocker.replay()
+
+        provider = self.get_provider()
+        return provider.start_machine({
+            "machine-id": "1",
+            "constraints": self.gen_constraints})

=== modified file 'juju/providers/ec2/tests/test_provider.py'
--- juju/providers/ec2/tests/test_provider.py	2011-09-23 19:47:01 +0000
+++ juju/providers/ec2/tests/test_provider.py	2012-03-30 16:56:32 +0000
@@ -1,7 +1,10 @@
+from twisted.internet.defer import inlineCallbacks
+
+from juju.environment.errors import EnvironmentsConfigError
+from juju.errors import ConstraintError
 from juju.lib.testing import TestCase
 from juju.providers.ec2.files import FileStorage
 from juju.providers.ec2 import MachineProvider
-from juju.environment.errors import EnvironmentsConfigError
 
 from .common import EC2TestMixin
 
@@ -117,6 +120,91 @@
         serialized = provider.get_serialization_data()
         self.assertEqual(config, serialized)
 
+    def test_get_legacy_config_keys(self):
+        provider = MachineProvider(self.env_name, {
+            # Note: these keys *will* at some stage be considered legacy keys;
+            # they're included here to make sure the tests are updated when we
+            # make that change.
+            "default-series": "foo", "placement": "bar"})
+        self.assertEquals(provider.get_legacy_config_keys(), set())
+
+        # These keys are not valid on Amazon EC2...
+        provider.config.update({
+            "default-instance-type": "baz", "default-image-id": "qux"})
+        self.assertEquals(provider.get_legacy_config_keys(), set((
+            "default-instance-type", "default-image-id")))
+
+        # ...but they still are when using private clouds.
+        provider.config.update({"ec2-uri": "anything"})
+        self.assertEquals(provider.get_legacy_config_keys(), set())
+
+
+class ProviderConstraintsTestCase(TestCase):
+
+    def constraint_set(self):
+        provider = MachineProvider("some-ec2-env", {})
+        return provider.get_constraint_set()
+
+    @inlineCallbacks
+    def assert_invalid(self, msg, *strs):
+        cs = yield self.constraint_set()
+        e = self.assertRaises(ConstraintError, cs.parse, strs)
+        self.assertEquals(str(e), msg)
+
+    @inlineCallbacks
+    def test_constraints(self):
+        cs = yield self.constraint_set()
+        self.assertEquals(cs.parse([]), {
+            "provider-type": "ec2",
+            "ubuntu-series": None,
+            "instance-type": None,
+            "ec2-zone": None,
+            "arch": "amd64",
+            "cpu": 1.0,
+            "mem": 512.0})
+        self.assertEquals(cs.parse(["ec2-zone=X", "instance-type=m1.small"]), {
+            "provider-type": "ec2",
+            "ubuntu-series": None,
+            "instance-type": "m1.small",
+            "ec2-zone": "x",
+            "arch": "amd64",
+            "cpu": None,
+            "mem": None})
+
+        yield self.assert_invalid(
+            "Bad 'ec2-zone' constraint '7': expected single ascii letter",
+            "ec2-zone=7")
+        yield self.assert_invalid(
+            "Bad 'ec2-zone' constraint 'blob': expected single ascii letter",
+            "ec2-zone=blob")
+        yield self.assert_invalid(
+            "Bad 'instance-type' constraint 'qq1.moar': unknown instance type",
+            "instance-type=qq1.moar")
+        yield self.assert_invalid(
+            "Ambiguous constraints: 'cpu' overlaps with 'instance-type'",
+            "instance-type=m1.small", "cpu=1")
+        yield self.assert_invalid(
+            "Ambiguous constraints: 'instance-type' overlaps with 'mem'",
+            "instance-type=m1.small", "mem=2G")
+
+    @inlineCallbacks
+    def test_satisfy_zone_constraint(self):
+        cs = yield self.constraint_set()
+        a = cs.parse(["ec2-zone=a"]).with_series("series")
+        b = cs.parse(["ec2-zone=b"]).with_series("series")
+        self.assertTrue(a.can_satisfy(a))
+        self.assertTrue(b.can_satisfy(b))
+        self.assertFalse(a.can_satisfy(b))
+        self.assertFalse(b.can_satisfy(a))
+
+    @inlineCallbacks
+    def test_non_amazon_constraints(self):
+        provider = MachineProvider("some-non-ec2-env", {"ec2-uri": "blah"})
+        cs = yield provider.get_constraint_set()
+        self.assertEquals(cs.parse([]), {
+            "provider-type": "ec2",
+            "ubuntu-series": None})
+
 
 class FailCreateTest(TestCase):
 

=== modified file 'juju/providers/ec2/tests/test_utils.py'
--- juju/providers/ec2/tests/test_utils.py	2012-03-26 17:13:53 +0000
+++ juju/providers/ec2/tests/test_utils.py	2012-03-30 16:56:32 +0000
@@ -1,12 +1,16 @@
 import inspect
 import os
 
-from twisted.internet.defer import fail, succeed
+from twisted.internet.defer import fail, succeed, inlineCallbacks
 from twisted.web.error import Error
 
+from juju.errors import ProviderError
 from juju.lib.testing import TestCase
 from juju.providers import ec2
-from juju.providers.ec2.utils import get_current_ami, get_image_id
+from juju.providers.ec2.utils import (
+    get_current_ami, get_instance_type, get_machine_spec)
+
+from .common import get_constraints
 
 
 IMAGE_URI_TEMPLATE = "\
@@ -26,7 +30,7 @@
         page(IMAGE_URI_TEMPLATE % "nutty")
         self.mocker.result(fail(Error("404")))
         self.mocker.replay()
-        d = get_current_ami(ubuntu_release="nutty")
+        d = get_current_ami("nutty", "i386", "us-east-1", False)
         self.failUnlessFailure(d, LookupError)
         return d
 
@@ -39,7 +43,7 @@
         page(IMAGE_URI_TEMPLATE % "lucid")
         self.mocker.result(succeed(""))
         self.mocker.replay()
-        d = get_current_ami(ubuntu_release="lucid")
+        d = get_current_ami("lucid", "i386", "us-east-1", False)
         self.failUnlessFailure(d, LookupError)
         return d
 
@@ -51,12 +55,20 @@
             open(os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
 
         self.mocker.replay()
-        d = get_current_ami(ubuntu_release="lucid")
-
-        def verify_result(result):
-            self.assertEqual(result, "ami-714ba518")
-
-        d.addCallback(verify_result)
+        d = get_current_ami("lucid", "i386", "us-east-1", False)
+        d.addCallback(self.assertEquals, "ami-714ba518")
+        return d
+
+    def test_current_ami_by_arch(self):
+        """The current server machine image can be retrieved by arch."""
+        page = self.mocker.replace("twisted.web.client.getPage")
+        page(IMAGE_URI_TEMPLATE % "lucid")
+        self.mocker.result(
+            succeed(open(
+                os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
+        self.mocker.replay()
+        d = get_current_ami("lucid", "amd64", "us-east-1", False)
+        d.addCallback(self.assertEquals, "ami-4b4ba522")
         return d
 
     def test_current_ami_by_region(self):
@@ -67,75 +79,166 @@
             succeed(open(
                 os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
         self.mocker.replay()
-        d = get_current_ami(ubuntu_release="lucid", region="us-west-1")
-
-        def verify_result(result):
-            self.assertEqual(result, "ami-cb97c68e")
-
-        d.addCallback(verify_result)
-        return d
-
-    def test_current_ami_non_ebs(self):
-        """
-        The get_current_ami function accepts several filtering parameters
-        to guide image selection.
-        """
+        d = get_current_ami("lucid", "i386", "us-west-1", False)
+        d.addCallback(self.assertEquals, "ami-cb97c68e")
+        return d
+
+    def test_current_ami_with_virtualisation_info(self):
+        """The current server machine image can be retrieved by arch."""
+        page = self.mocker.replace("twisted.web.client.getPage")
+        page(IMAGE_URI_TEMPLATE % "natty")
+        self.mocker.result(
+            succeed(open(
+                os.path.join(IMAGE_DATA_DIR, "natty.txt")).read()))
+        self.mocker.replay()
+        d = get_current_ami("natty", "amd64", "us-east-1", True)
+        d.addCallback(self.assertEquals, "ami-1cad5275")
+        return d
+
+    def test_hvm_request_on_old_series(self):
         page = self.mocker.replace("twisted.web.client.getPage")
         page(IMAGE_URI_TEMPLATE % "lucid")
-        self.mocker.result(succeed(
-            open(os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
+        self.mocker.result(
+            succeed(open(
+                os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
         self.mocker.replay()
-        d = get_current_ami(ubuntu_release="lucid", persistent_storage=False)
-
-        def verify_result(result):
-            self.assertEqual(result, "ami-2d4aa444")
-
-        d.addCallback(verify_result)
+        d = get_current_ami("lucid", "amd64", "us-east-1", True)
+        self.failUnlessFailure(d, LookupError)
         return d
 
 
 class GetImageIdTest(TestCase):
 
-    def test_default_image_id(self):
-        d = get_image_id({"default-image-id": "ami-burble"}, {})
-        d.addCallback(self.assertEquals, "ami-burble")
-        return d
-
-    def test_no_constraints(self):
+    @inlineCallbacks
+    def assert_image_id(self, config, constraints, series, arch, region, hvm,
+                        instance_type):
         get_current_ami_m = self.mocker.replace(get_current_ami)
-        get_current_ami_m(region="us-east-1")
+        get_current_ami_m(series, arch, region, hvm)
         self.mocker.result(succeed("ami-giggle"))
         self.mocker.replay()
 
-        d = get_image_id({}, {})
-        d.addCallback(self.assertEquals, "ami-giggle")
-        return d
-
-    def test_default_series(self):
-        get_current_ami_m = self.mocker.replace(get_current_ami)
-        get_current_ami_m(region="us-east-1", ubuntu_release="puissant")
-        self.mocker.result(succeed("ami-pickle"))
-        self.mocker.replay()
-
-        d = get_image_id({"default-series": "puissant"}, {})
-        d.addCallback(self.assertEquals, "ami-pickle")
-        return d
-
-    def test_uses_constraints(self):
-        get_current_ami_m = self.mocker.replace(get_current_ami)
-        get_current_ami_m(ubuntu_release="serendipitous", architecture="x512",
-                          daily=False, persistent_storage=True,
-                          region="blah-north-6")
-        self.mocker.result(succeed("ami-tinkle"))
-        self.mocker.replay()
-
-        constraints = {
-            "architecture": "x512",
-            "ubuntu_release": "serendipitous",
-            "persistent_storage": True,
-            "daily": False}
-        d = get_image_id(
-            {"region": "blah-north-6", "default-series": "overridden"},
-            constraints)
-        d.addCallback(self.assertEquals, "ami-tinkle")
-        return d
+        spec = yield get_machine_spec(config, constraints)
+        self.assertEquals(spec.image_id, "ami-giggle")
+        self.assertEquals(spec.instance_type, instance_type)
+
+    @inlineCallbacks
+    def test_empty_config(self):
+        constraints = yield get_constraints(["arch=i386"])
+        yield self.assert_image_id(
+            {}, constraints,
+            "splendid", "i386", "us-east-1", False,
+            "m1.small")
+
+    @inlineCallbacks
+    def test_series_from_config(self):
+        config = {"default-series": "puissant"}
+        constraints = yield get_constraints(["arch=i386"], None)
+        yield self.assert_image_id(
+            config, constraints,
+            "puissant", "i386", "us-east-1", False,
+            "m1.small")
+
+    @inlineCallbacks
+    def test_arch_from_instance_constraint(self):
+        constraints = yield get_constraints([
+            "instance-type=m1.large", "arch=any"])
+        yield self.assert_image_id(
+            {}, constraints,
+            "splendid", "amd64", "us-east-1", False,
+            "m1.large")
+
+    @inlineCallbacks
+    def test_arch_from_nothing(self):
+        constraints = yield get_constraints([
+            "arch=any", "cpu=any", "mem=any", "instance-type=any"])
+        yield self.assert_image_id(