Merge lp:~bcsaller/pyjuju/subordinate-control-status into lp:pyjuju

[Benjamin Saller]

juju/control should be aware of subordinates

Includes support for add-unit, deploy, status, remove-unit

https://codereview.appspot.com/5970068/

[Benjamin Saller (bcsaller)]

Reviewers: mp+100489_code.launchpad.net,

Message:
Please take a look.

Description:
juju/control should be aware of subordinates

Includes support for add-unit, deploy, status, remove-unit

https://code.launchpad.net/~bcsaller/juju/subordinate-control-status/+merge/100489

(do not edit description out of merge proposal)

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

Affected files:
   A [revision details]
   M juju/control/add_unit.py
   M juju/control/deploy.py
   M juju/control/remove_unit.py
   M juju/control/status.py
   M juju/control/tests/test_add_unit.py
   M juju/control/tests/test_deploy.py
   M juju/control/tests/test_remove_unit.py
   M juju/control/tests/test_status.py
   M juju/state/tests/test_charm.py
   M juju/unit/tests/test_lifecycle.py

[Benjamin Saller (bcsaller)]

Please take a look.

https://codereview.appspot.com/5970068/

[lp:~bcsaller/pyjuju/subordinate-control-status]

523. By Benjamin Saller on 2012-04-02

better comments

[Kapil Thangavelu (hazmat)]

This looks good. The refactoring of status isn't complete though.. it
needs some more docs, this area of the codebase is frequently touched,
and it needs more introduction to what the responsibility of the various
methods are, esp. given their use of shared instance state variables in
a functional style.

https://codereview.appspot.com/5970068/diff/2002/juju/control/status.py
File juju/control/status.py (right):

https://codereview.appspot.com/5970068/diff/2002/juju/control/status.py#newcode136
juju/control/status.py:136: s = StatusCommand(client, provider, log)
it shouldn't exist if its only purpose is for existing tests.. i'd just
update the tests to the new api.. that's part of the refactoring, else
its just dead code.

https://codereview.appspot.com/5970068/diff/2002/juju/control/status.py#newcode155
juju/control/status.py:155: self.service_manager =
ServiceStateManager(client)
these where documented in a self referential way post the diff, but
saying 'service_name' to 'state' isn't very clear, if its referring to
the actual state object (unlikely), or what structure the dictionary
termed state has.

https://codereview.appspot.com/5970068/diff/2002/juju/control/status.py#newcode252
juju/control/status.py:252: def _process_units(self, service, relations,
rel_svc_map):
this should have some docs, what are the params

https://codereview.appspot.com/5970068/diff/2002/juju/control/status.py#newcode271
juju/control/status.py:271: u = self.unit_data[unit.unit_name] = dict()
this method could use some documentation, what are the params

https://codereview.appspot.com/5970068/diff/2002/juju/control/status.py#newcode307
juju/control/status.py:307: relation_data =
self.service_data[service.service_name]["relations"]
please document the return value.

https://codereview.appspot.com/5970068/diff/2002/juju/control/status.py#newcode339
juju/control/status.py:339: relation_data =
self.service_data[service.service_name]["relations"]
please document what the method is doing..

ie. inspects all the relations of a service and...?

https://codereview.appspot.com/5970068/

[Kapil Thangavelu (hazmat)]

https://codereview.appspot.com/5970068/diff/2002/juju/control/tests/test_status.py
File juju/control/tests/test_status.py (right):

https://codereview.appspot.com/5970068/diff/2002/juju/control/tests/test_status.py#newcode788
juju/control/tests/test_status.py:788: state = yield
self.build_topology()
this method is a crutch, its creating way more stuff than what is
actually tested for. its better to simplify and model an api for
creation of whats needed, instead of relying on a megamethod to build
world every test.

i'd like to see a test here of removing a primary unit with a
subordinate attached, as that broke status on my previous usage of this
feature.

https://codereview.appspot.com/5970068/

[lp:~bcsaller/pyjuju/subordinate-control-status]

524. By Benjamin Saller on 2012-04-04

move status changes to proper branch, added docs, moved collect method to test module

[Kapil Thangavelu (hazmat)]

Latest changes look good, time to merge.

[lp:~bcsaller/pyjuju/subordinate-control-status]

525. By Benjamin Saller on 2012-04-05

wip

526. By Benjamin Saller on 2012-04-05

handle case where principal unit is removed

=== modified file 'juju/control/add_unit.py'
--- juju/control/add_unit.py	2012-03-29 13:40:45 +0000
+++ juju/control/add_unit.py	2012-04-05 21:24:20 +0000
@@ -4,6 +4,7 @@
 
 from juju.control import legacy
 from juju.control.utils import get_environment, sync_environment_state
+from juju.errors import JujuError
 from juju.state.placement import place_unit
 from juju.state.service import ServiceStateManager
 
@@ -51,6 +52,10 @@
 
         service_manager = ServiceStateManager(client)
         service_state = yield service_manager.get_service_state(service_name)
+        if (yield service_state.is_subordinate()):
+            raise JujuError("Subordinate services acquire units from "
+                            "their principal service.")
+
         for i in range(num_units):
             unit_state = yield service_state.add_unit_state()
             yield place_unit(client, placement_policy, unit_state)

=== modified file 'juju/control/deploy.py'
--- juju/control/deploy.py	2012-03-29 13:40:45 +0000
+++ juju/control/deploy.py	2012-04-05 21:24:20 +0000
@@ -37,7 +37,7 @@
     sub_parser.add_argument(
         "--repository",
         help="Directory for charm lookup and retrieval",
-        default=os.environ.get('JUJU_REPOSITORY'),
+        default=os.environ.get("JUJU_REPOSITORY"),
         type=expand_path)
 
     sub_parser.add_argument(
@@ -170,9 +170,13 @@
         yield state.write()
 
         # Create desired number of service units
-        for i in xrange(num_units):
-            unit_state = yield service_state.add_unit_state()
-            yield place_unit(client, placement_policy, unit_state)
+        if (yield service_state.is_subordinate()):
+            log.info("Subordinate %r awaiting relationship "
+                     "to principal for deployment.", service_name)
+        else:
+            for i in xrange(num_units):
+                unit_state = yield service_state.add_unit_state()
+                yield place_unit(client, placement_policy, unit_state)
 
         # Check if we have any peer relations to establish
         if charm.metadata.peers:

=== modified file 'juju/control/remove_unit.py'
--- juju/control/remove_unit.py	2011-11-29 22:50:38 +0000
+++ juju/control/remove_unit.py	2012-04-05 21:24:20 +0000
@@ -2,6 +2,7 @@
 
 from twisted.internet.defer import inlineCallbacks
 
+from juju.errors import JujuError
 from juju.state.service import ServiceStateManager, parse_service_name
 from juju.control.utils import get_environment
 
@@ -39,6 +40,10 @@
             service_name = parse_service_name(unit_name)
             service_state = yield service_manager.get_service_state(
                 service_name)
+            if (yield service_state.is_subordinate()):
+                raise JujuError("Subordinate services acquire units from "
+                                "their principal service.")
+
             unit_state = yield service_state.get_unit_state(unit_name)
             yield service_state.remove_unit_state(unit_state)
             log.info("Unit %r removed from service %r",

=== modified file 'juju/control/status.py'
--- juju/control/status.py	2012-03-29 02:50:29 +0000
+++ juju/control/status.py	2012-04-05 21:24:20 +0000
@@ -7,12 +7,11 @@
 from twisted.internet.defer import inlineCallbacks, returnValue
 import yaml
 
-from juju.errors import  ProviderError
 from juju.environment.errors import EnvironmentsConfigError
 from juju.state.errors import UnitRelationStateNotFound
 from juju.state.charm import CharmStateManager
 from juju.state.machine import MachineStateManager
-from juju.state.service import ServiceStateManager
+from juju.state.service import ServiceStateManager, parse_service_name
 from juju.state.relation import RelationStateManager
 from juju.unit.workflow import WorkflowStateClient
 
@@ -96,7 +95,9 @@
     client = yield provider.connect()
     try:
         # Collect status information
-        state = yield collect(scope, provider, client, log)
+        command = StatusCommand(client, provider, log)
+        state = yield command(scope)
+        #state = yield collect(scope, provider, client, log)
     finally:
         yield client.close()
     # Render
@@ -125,60 +126,222 @@
     return (services, units)
 
 
-@inlineCallbacks
-def collect(scope, machine_provider, client, log):
-    """Extract status information into nested dicts for rendering.
-
-       `scope`: an optional list of name specifiers. Globbing based
-       wildcards supported. Defaults to all units, services and
-       relations.
-
-       `machine_provider`: machine provider for the environment
-
-       `client`: ZK client connection
-
-       `log`: a Python stdlib logger.
-    """
-    service_manager = ServiceStateManager(client)
-    relation_manager = RelationStateManager(client)
-    machine_manager = MachineStateManager(client)
-    charm_manager = CharmStateManager(client)
-
-    service_data = {}
-    machine_data = {}
-    state = dict(services=service_data, machines=machine_data)
-
-    seen_machines = set()
-    filter_services, filter_units = digest_scope(scope)
-
-    services = yield service_manager.get_all_service_states()
-    for service in services:
-        if len(filter_services):
-            found = False
-            for filter_service in filter_services:
-                if fnmatch(service.service_name, filter_service):
-                    found = True
-                    break
-            if not found:
-                continue
-
-        unit_data = {}
+class StatusCommand(object):
+    def __init__(self, client, provider, log):
+        """
+        Callable status command object.
+
+        `client`: ZK client connection
+        `provider`: machine provider for the environment
+        `log`: a Python stdlib logger.
+
+        """
+        self.client = client
+        self.provider = provider
+        self.log = log
+
+        self.service_manager = ServiceStateManager(client)
+        self.relation_manager = RelationStateManager(client)
+        self.machine_manager = MachineStateManager(client)
+        self.charm_manager = CharmStateManager(client)
+        self._reset()
+
+    def _reset(self, scope=None):
+        # init per-run state
+        # self.state is assembled by the various process methods
+        # intermediate access to state is made more convenient
+        # using these references to its internals.
+        self.service_data = {}  # service name: service info
+        self.machine_data = {}  # machine id: machine state
+        self.unit_data = {}  # unit_name :unit_info
+
+        # used in collecting subordinate (which are added to state in a two
+        # phase pass)
+        self.subordinates = {}  # service : set(principal service names)
+
+        self.state = dict(services=self.service_data,
+                     machines=self.machine_data)
+
+        # Filtering info
+        self.seen_machines = set()
+        self.filter_services, self.filter_units = digest_scope(scope)
+
+    @inlineCallbacks
+    def __call__(self, scope=None):
+        """Extract status information into nested dicts for rendering.
+
+        `scope`: an optional list of name specifiers. Globbing based wildcards
+        supported. Defaults to all units, services and relations.
+
+        """
+        self._reset(scope)
+
+        # Pass 1 Gather Data (including principals and subordinates)
+        # this builds unit info  and container relationships
+        # which is assembled in pass 2 below
+        yield self._process_services()
+
+        # Pass 2: Nest information according to principal/subordinates
+        # rules
+        self._process_subordinates()
+
+        yield self._process_machines()
+
+        returnValue(self.state)
+
+    @inlineCallbacks
+    def _process_services(self):
+        """
+        For each service gather the following information::
+
+          <service name>:
+            charm: <charm name>
+            exposed: <expose boolean>
+            relations:
+                 <relation info -- see _process_relations>
+            units:
+                 <unit info -- see _process_units>
+        """
+        services = yield self.service_manager.get_all_service_states()
+        for service in services:
+            if len(self.filter_services):
+                found = False
+                for filter_service in self.filter_services:
+                    if fnmatch(service.service_name, filter_service):
+                        found = True
+                        break
+                if not found:
+                    continue
+            yield self._process_service(service)
+
+    @inlineCallbacks
+    def _process_service(self, service):
+        """
+        Gather the service info (described in _process_services).
+
+        `service`: ServiceState instance
+        """
+
         relation_data = {}
+        service_data = self.service_data
 
         charm_id = yield service.get_charm_id()
-        charm = yield charm_manager.get_charm_state(charm_id)
-
-        service_data[service.service_name] = dict(units=unit_data,
-                                                  charm=charm.id,
-                                                  relations=relation_data)
-        exposed = yield service.get_exposed_flag()
-        if exposed:
-            service_data[service.service_name].update(exposed=exposed)
-
+        charm = yield self.charm_manager.get_charm_state(charm_id)
+
+        service_data[service.service_name] = (
+            dict(units={},
+                 charm=charm.id,
+                 relations=relation_data))
+
+        if (yield service.is_subordinate()):
+            service_data[service.service_name]["subordinate"] = True
+
+        yield self._process_expose(service)
+
+        relations, rel_svc_map = yield self._process_relation_map(
+            service)
+
+        unit_matched = yield self._process_units(service,
+                                                 relations,
+                                                 rel_svc_map)
+
+        # after filtering units check if any matched or remove the
+        # service from the output
+        if self.filter_units and not unit_matched:
+            del service_data[service.service_name]
+            return
+
+        yield self._process_relations(service, relations, rel_svc_map)
+
+    @inlineCallbacks
+    def _process_units(self, service, relations, rel_svc_map):
+        """
+        Gather unit information for a service::
+
+            <unit name>:
+                agent-state: <started|pendding|etc>
+                machine: <machine id>
+                open-ports: ["port/protocol", ...]
+                public-address: <public dns name or ip>
+                subordinates:
+                     <optional nested units of subordinate services>
+
+
+        `service`: ServiceState intance
+        `relations`: list of ServiceRelationState instance for this service
+        `rel_svc_map`: maps relation internal ids to the remote endpoint
+                       service name. This references the name of the remote
+                       endpoint and so is generated per service.
+        """
         units = yield service.get_all_unit_states()
         unit_matched = False
 
-        relations = yield relation_manager.get_relations_for_service(service)
+        for unit in units:
+            if len(self.filter_units):
+                found = False
+                for filter_unit in self.filter_units:
+                    if fnmatch(unit.unit_name, filter_unit):
+                        found = True
+                        break
+                if not found:
+                    continue
+            yield self._process_unit(service, unit, relations, rel_svc_map)
+            unit_matched = True
+        returnValue(unit_matched)
+
+    @inlineCallbacks
+    def _process_unit(self, service, unit, relations, rel_svc_map):
+        """ Generate unit info for a single unit of a single service.
+
+        `unit`: ServiceUnitState
+        see `_process_units` for an explanation of other arguments.
+
+        """
+        u = self.unit_data[unit.unit_name] = dict()
+        container = yield unit.get_container()
+
+        if container:
+            u["container"] = container.unit_name
+            self.subordinates.setdefault(unit.service_name,
+                                    set()).add(container.service_name)
+
+        machine_id = yield unit.get_assigned_machine_id()
+        u["machine"] = machine_id
+        unit_workflow_client = WorkflowStateClient(self.client, unit)
+        unit_state = yield unit_workflow_client.get_state()
+        if not unit_state:
+            u["agent-state"] = "pending"
+        else:
+            unit_connected = yield unit.has_agent()
+            u["agent-state"] = unit_state.replace("_", "-") \
+                               if unit_connected else "down"
+
+        exposed = self.service_data[service.service_name].get("exposed")
+        if exposed:
+            open_ports = yield unit.get_open_ports()
+            u["open-ports"] = ["{port}/{proto}".format(**port_info)
+                               for port_info in open_ports]
+
+        u["public-address"] = yield unit.get_public_address()
+
+        # indicate we should include information about this
+        # machine later
+        self.seen_machines.add(machine_id)
+
+        # collect info on each relation for the service unit
+        yield self._process_unit_relations(service, unit,
+                                           relations, rel_svc_map)
+
+    @inlineCallbacks
+    def _process_relation_map(self, service):
+        """Generate a mapping from a services relations to the service name of
+        the remote endpoints.
+
+        returns: ([ServiceRelationState, ...], mapping)
+        """
+        relation_data = self.service_data[service.service_name]["relations"]
+        relation_mgr = self.relation_manager
+        relations = yield relation_mgr.get_relations_for_service(service)
         rel_svc_map = {}
 
         for relation in relations:
@@ -199,107 +362,182 @@
                                  "than 2 endpoints")
 
             rel_service = rel_services[0]
+            relation_data.setdefault(relation.relation_name, set()).add(
+                rel_service.service_name)
+            rel_svc_map[relation.internal_relation_id] = (
+                 rel_service.service_name)
+
+        returnValue((relations, rel_svc_map))
+
+    @inlineCallbacks
+    def _process_relations(self, service, relations, rel_svc_map):
+        """Generate relation information for a given service
+
+        Each service with relations will have a relations dict
+        nested under it with one or more relations described::
+
+           relations:
+              <relation name>:
+              - <remote service name>
+
+        """
+        relation_data = self.service_data[service.service_name]["relations"]
+
+        for relation in relations:
+            rel_services = yield relation.get_service_states()
+
+            # A single related service implies a peer relation. More
+            # imply a bi-directional provides/requires relationship.
+            # In the later case we omit the local side of the relation
+            # when reporting.
+            if len(rel_services) > 1:
+                # Filter out self from multi-service relations.
+                rel_services = [
+                    rsn for rsn in rel_services if rsn.service_name !=
+                    service.service_name]
+
+            if len(rel_services) > 1:
+                raise ValueError("Unexpected relationship with more "
+                                 "than 2 endpoints")
+
+            rel_service = rel_services[0]
             relation_data.setdefault(
-                relation.relation_name, set()).add(rel_service.service_name)
-            rel_svc_map[relation.internal_relation_id] = \
-                 rel_service.service_name
+                relation.relation_name, set()).add(
+                    rel_service.service_name)
+            rel_svc_map[relation.internal_relation_id] = (
+                rel_service.service_name)
 
         # Normalize the sets back to lists
         for r in relation_data:
-            relation_data[r] = list(relation_data[r])
-
-        for unit in units:
-            if len(filter_units):
-                found = False
-                for filter_unit in filter_units:
-                    if fnmatch(unit.unit_name, filter_unit):
-                        found = True
-                        break
-                if not found:
-                    continue
-
-            u = unit_data[unit.unit_name] = dict()
-            machine_id = yield unit.get_assigned_machine_id()
-            u["machine"] = machine_id
-            unit_workflow_client = WorkflowStateClient(client, unit)
-            unit_state = yield unit_workflow_client.get_state()
-            if not unit_state:
-                u["agent-state"] = "pending"
+            relation_data[r] = sorted(relation_data[r])
+
+    @inlineCallbacks
+    def _process_unit_relations(self, service, unit, relations, rel_svc_map):
+        """Collect UnitRelationState information per relation and per unit.
+
+        Includes information under each unit for its relations including
+        its relation state and information about any possible errors.
+
+        see `_process_relations` for argument information
+        """
+        u = self.unit_data[unit.unit_name]
+        relation_errors = {}
+
+        for relation in relations:
+            try:
+                relation_unit = yield relation.get_unit_state(unit)
+            except UnitRelationStateNotFound:
+                # This exception will occur when relations are
+                # established between services without service
+                # units, and therefore never have any
+                # corresponding service relation units.
+                # UPDATE: common with subordinate services, and
+                # some testing scenarios.
+                continue
+            relation_workflow_client = WorkflowStateClient(
+                self.client, relation_unit)
+            workflow_state = yield relation_workflow_client.get_state()
+
+            rel_svc_name = rel_svc_map.get(relation.internal_relation_id)
+            if rel_svc_name and workflow_state not in ("up", None):
+                relation_errors.setdefault(
+                    relation.relation_name, set()).add(rel_svc_name)
+
+        if relation_errors:
+            # Normalize sets and store.
+            u["relation-errors"] = dict(
+                [(r, sorted(relation_errors[r])) for r in relation_errors])
+
+    def _process_subordinates(self):
+        """Properly nest subordinate units under their principal service's
+        unit nodes. Services and units are generated in one pass, then
+        iterated by this method to structure the output data to reflect
+        actual unit containment.
+
+        Subordinate units will include the follow::
+           subordinate: true
+            subordinate-to:
+            - <principal service names>
+
+        Principal services that have subordinates will include::
+
+            subordinates:
+              <subordinate unit name>:
+                agent-state: <agent state>
+        """
+        service_data = self.service_data
+
+        for unit_name, u in self.unit_data.iteritems():
+            container = u.get("container")
+            if container:
+                d = self.unit_data[container].setdefault("subordinates", {})
+                d[unit_name] = u
+
+                # remove keys that don't appear in output or come from container
+                for key in ("container", "machine", "public-address"):
+                    u.pop(key, None)
             else:
-                unit_connected = yield unit.has_agent()
-                u["agent-state"] = unit_state.replace("_", "-") \
-                                   if unit_connected else "down"
-            if exposed:
-                open_ports = yield unit.get_open_ports()
-                u["open-ports"] = ["{port}/{proto}".format(**port_info)
-                                   for port_info in open_ports]
-
-            u["public-address"] = yield unit.get_public_address()
-
-            # indicate we should include information about this
-            # machine later
-            seen_machines.add(machine_id)
-            unit_matched = True
-
-            # collect info on each relation for the service unit
-            relation_errors = {}
-            for relation in relations:
-                try:
-                    relation_unit = yield relation.get_unit_state(unit)
-                except UnitRelationStateNotFound:
-                    # This exception will occur when relations are
-                    # established between services without service
-                    # units, and therefore never have any
-                    # corresponding service relation units.
-                    # UPDATE: common with subordinate services, and
-                    # some testing scenarios.
-                    continue
-                relation_workflow_client = WorkflowStateClient(
-                    client, relation_unit)
-                workflow_state = yield relation_workflow_client.get_state()
-
-                rel_svc_name = rel_svc_map.get(relation.internal_relation_id)
-                if rel_svc_name and workflow_state not in ("up", None):
-                    relation_errors.setdefault(
-                        relation.relation_name, set()).add(rel_svc_name)
-
-            if relation_errors:
-                # Normalize sets and store.
-                u["relation-errors"] = dict(
-                    [(r, list(relation_errors[r])) for r in relation_errors])
-
-        # after filtering units check if any matched or remove the
-        # service from the output
-        if filter_units and not unit_matched:
-            del service_data[service.service_name]
-            continue
-
-    machines = yield machine_manager.get_all_machine_states()
-    for machine_state in machines:
-        if (filter_services or filter_units) and \
-                machine_state.id not in seen_machines:
-            continue
-
+                service_name = parse_service_name(unit_name)
+                service_data[service_name]["units"][unit_name] = u
+
+        for sub_service, principal_services in self.subordinates.iteritems():
+            service_data[sub_service]["subordinate-to"] = sorted(principal_services)
+            service_data[sub_service].pop("units", None)
+
+    @inlineCallbacks
+    def _process_expose(self, service):
+        """Indicate if a service is exposed or not."""
+        exposed = yield service.get_exposed_flag()
+        if exposed:
+            self.service_data[service.service_name].update(exposed=exposed)
+        returnValue(exposed)
+
+    @inlineCallbacks
+    def _process_machines(self):
+        """Gather machine information.
+
+        machines:
+          <machine id>:
+            agent-state: <agent state>
+            dns-name: <dns name>
+            instance-id: <provider specific instance id>
+            instance-state: <instance state>
+        """
+
+        machines = yield self.machine_manager.get_all_machine_states()
+        for machine_state in machines:
+            if (self.filter_services or self.filter_units) and \
+                    machine_state.id not in self.seen_machines:
+                continue
+            yield self._process_machine(machine_state)
+
+    @inlineCallbacks
+    def _process_machine(self, machine_state):
+        """
+        `machine_state`: MachineState instance
+        """
         instance_id = yield machine_state.get_instance_id()
         m = {"instance-id": instance_id \
              if instance_id is not None else "pending"}
         if instance_id is not None:
             try:
-                pm = yield machine_provider.get_machine(instance_id)
+                pm = yield self.provider.get_machine(instance_id)
                 m["dns-name"] = pm.dns_name
                 m["instance-state"] = pm.state
                 if (yield machine_state.has_agent()):
                     # if the agent's connected, we're fine
                     m["agent-state"] = "running"
                 else:
-                    units = (yield machine_state.get_all_service_unit_states())
+                    units = (
+                        yield machine_state.get_all_service_unit_states())
                     for unit in units:
                         unit_workflow_client = WorkflowStateClient(
-                            client, unit)
+                            self.client, unit)
                         if (yield unit_workflow_client.get_state()):
-                            # for unit to have a state, its agent must have
-                            # run, which implies the machine agent must have
-                            # been running correctly at some point in the past
+                            # for unit to have a state, its agent must
+                            # have run, which implies the machine agent
+                            # must have been running correctly at some
+                            # point in the past
                             m["agent-state"] = "down"
                             break
                     else:
@@ -307,13 +545,11 @@
                         m["agent-state"] = "not-started"
             except ProviderError:
                 # The provider doesn't have machine information
-                log.error(
+                self.log.error(
                     "Machine provider information missing: machine %s" % (
                         machine_state.id))
 
-        machine_data[machine_state.id] = m
-
-    returnValue(state)
+        self.machine_data[machine_state.id] = m
 
 
 def render_yaml(data, filelike, environment):
@@ -356,6 +592,15 @@
         "shape": "box",
         "style": "filled",
         },
+
+    "subunit": {
+        "color": "#c9c9c9",
+        "fontcolor": "#ffffff",
+        "shape": "box",
+        "style": "filled",
+        "rank": "same"
+        },
+
     "relation": {
         "dir": "none"}
     }
@@ -364,9 +609,10 @@
 def safe_dot_label(name):
     """Convert a name to a label safe for use in DOT.
 
-    Works around an issue where service names like wiki-db will
-    produce DOT items with names like cluster_wiki-db where the
-    trailing '-' invalidates the name.
+    Works around an issue where service names like wiki-db will produce DOT
+    items with names like cluster_wiki-db where the trailing '-' invalidates
+    the name.
+
     """
     return name.replace("-", "_")
 
@@ -399,34 +645,54 @@
                            **style["service"])
         cluster.add_node(snode)
 
-        for unit_name, unit in service["units"].iteritems():
-            un = pydot.Node(safe_dot_label(unit_name),
-                            label="<%s<br/><i>%s</i>>" % (
-                                unit_name,
-                                unit.get("public-address")),
-                            **style["unit"])
-            cluster.add_node(un)
+        for unit_name, unit in service.get("units", {}).iteritems():
+            subordinates = unit.get("subordinates")
+            if subordinates:
+                container = pydot.Subgraph()
+                un = pydot.Node(safe_dot_label(unit_name),
+                                    label="<%s<br/><i>%s</i>>" % (
+                                        unit_name,
+                                        unit.get("public-address")),
+                                    **style["unit"])
+                container.add_node(un)
+                for sub in subordinates:
+                    s = pydot.Node(safe_dot_label(sub),
+                                   label="<%s<br/>>" % (sub),
+                                   **style["subunit"])
+                    container.add_node(s)
+                    container.add_edge(pydot.Edge(un, s, **style["relation"]))
+                cluster.add_subgraph(container)
+            else:
+                un = pydot.Node(safe_dot_label(unit_name),
+                                label="<%s<br/><i>%s</i>>" % (
+                                    unit_name,
+                                    unit.get("public-address")),
+                                **style["unit"])
+                cluster.add_node(un)
 
             cluster.add_edge(pydot.Edge(snode, un))
 
         dot.add_subgraph(cluster)
 
         # now map the relationships
-        for kind, relations in service["relations"].iteritems():
-            for relation in relations:
-                src = safe_dot_label(relation)
+        for kind, relation in service["relations"].iteritems():
+            if not isinstance(relation, list):
+                relation = (relation,)
+            for rel in relation:
+                src = safe_dot_label(rel)
                 dest = safe_dot_label(service_name)
-                descriptor = tuple(sorted((src, dest)))
+                descriptor = ":".join(tuple(sorted((src, dest))))
+                kind = safe_dot_label("%s/%s" % (descriptor, kind))
                 if descriptor not in seen_relations:
                     seen_relations.add(descriptor)
                     dot.add_edge(pydot.Edge(
-                        src,
-                        dest,
-                        label=kind,
-                        **style["relation"]
-                    ))
+                            src,
+                            dest,
+                            label=kind,
+                            **style["relation"]
+                        ))
 
-    if format == 'dot':
+    if format == "dot":
         filelike.write(dot.to_string())
     else:
         filelike.write(dot.create(format=format))

=== modified file 'juju/control/tests/test_add_unit.py'
--- juju/control/tests/test_add_unit.py	2012-03-29 13:40:45 +0000
+++ juju/control/tests/test_add_unit.py	2012-04-05 21:24:20 +0000
@@ -97,6 +97,19 @@
             "Service 'volcano' was not found", self.stderr.getvalue())
 
     @inlineCallbacks
+    def test_add_unit_subordinate_service(self):
+        yield self.add_service_from_charm("logging")
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        main(["add-unit", "logging"])
+        yield finished
+        self.assertIn(
+            "Subordinate services acquire units from "
+            "their principal service.",
+            self.stderr.getvalue())
+
+    @inlineCallbacks
     def test_add_unit_reuses_machines(self):
         """Verify that if machines are not in use, add-unit uses them."""
         # add machine to wordpress, then destroy and reallocate later
@@ -107,6 +120,7 @@
         wordpress_machine_state = yield self.add_machine_state()
         yield wordpress_unit_state.assign_to_machine(wordpress_machine_state)
         yield wordpress_unit_state.unassign_from_machine()
+
         finished = self.setup_cli_reactor()
         self.setup_exit(0)
         self.mocker.replay()

=== modified file 'juju/control/tests/test_deploy.py'
--- juju/control/tests/test_deploy.py	2012-03-29 03:20:51 +0000
+++ juju/control/tests/test_deploy.py	2012-04-05 21:24:20 +0000
@@ -506,6 +506,33 @@
         self.assertEqual(machine_id, 0)
 
     @inlineCallbacks
+
+    def test_deploy_informs_with_subordinate(self):
+        """Verify subordinate charm doesn't deploy.
+
+        And that it properly notifies the user.
+        """
+        log = self.capture_logging()
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+
+        # missing config file
+        main(["deploy",
+            "--repository", self.unbundled_repo_path, "local:logging"])
+        yield finished
+        self.assertIn(
+            "Subordinate 'logging' awaiting relationship to "
+            "principal for deployment.\n",
+            log.getvalue())
+
+        # and verify no units assigned to service
+        service_state = yield self.service_state_manager.get_service_state("logging")
+        self.assertEqual(service_state.service_name, "logging")
+
+        units = yield service_state.get_unit_names()
+        self.assertEqual(units, [])
+
     def test_deploy_legacy_keys_in_legacy_env(self):
         yield self.client.delete("/constraints")
 

=== modified file 'juju/control/tests/test_remove_unit.py'
--- juju/control/tests/test_remove_unit.py	2012-03-27 22:46:44 +0000
+++ juju/control/tests/test_remove_unit.py	2012-04-05 21:24:20 +0000
@@ -139,6 +139,18 @@
             "Service 'volcano' was not found", self.stderr.getvalue())
 
     @inlineCallbacks
+    def test_remove_unit_with_subordinate(self):
+        yield self.add_service_from_charm("logging")
+        finished = self.setup_cli_reactor()
+        self.setup_exit(0)
+        self.mocker.replay()
+        main(["remove-unit", "logging/0"])
+        yield finished
+        self.assertIn(
+            "Subordinate services acquire units from their principal service.",
+            self.stderr.getvalue())
+
+    @inlineCallbacks
     def test_remove_unit_bad_parse(self):
         """Verify that a bad service unit name results in an appropriate error.
         """

=== modified file 'juju/control/tests/test_status.py'
--- juju/control/tests/test_status.py	2012-03-30 10:13:09 +0000
+++ juju/control/tests/test_status.py	2012-04-05 21:24:20 +0000
@@ -33,6 +33,17 @@
     fp.close()
 
 
+@inlineCallbacks
+def collect(scope, provider, client, log):
+    """Collect and return status info as dict"""
+    # provided for backwards compatibility with
+    # original API
+    # used only in testing
+    s = status.StatusCommand(client, provider, log)
+    state = yield s(scope)
+    returnValue(state)
+
+
 class StatusTestBase(ServiceStateManagerTestBase, ControlToolTest):
 
     # Status tests setup a large tree every time, make allowances for it.
@@ -64,8 +75,7 @@
     @inlineCallbacks
     def add_relation_unit_states(self, relation_state, unit_states, states):
         for unit_state, state in zip(unit_states, states):
-            relation_unit_state = yield relation_state.add_unit_state(
-                unit_state)
+            relation_unit_state = yield relation_state.add_unit_state(unit_state)
             workflow_client = ZookeeperWorkflowState(
                 self.client, relation_unit_state)
             with (yield workflow_client.lock()):
@@ -76,6 +86,7 @@
             self,
             source_endpoint, source_units, source_states,
             dest_endpoint, dest_units, dest_states):
+
         relation_state, service_relation_states = \
             yield self.relation_state_manager.add_relation_state(
             *[source_endpoint, dest_endpoint])
@@ -86,11 +97,17 @@
             dest_relation_state, dest_units, dest_states)
 
     @inlineCallbacks
-    def add_unit(self, service, machine, with_agent=lambda _: True):
-        unit = yield service.add_unit_state()
-        yield unit.assign_to_machine(machine)
+    def add_unit(self, service, machine, with_agent=lambda _: True,
+                 units=None, container=None):
+        unit = yield service.add_unit_state(container=container)
+        self.assertTrue(machine or container)
+        if machine is not None:
+            yield unit.assign_to_machine(machine)
         if with_agent(unit.unit_name):
             yield unit.connect_agent()
+        if units is not None:
+            units.setdefault(service.service_name, []).append(unit)
+
         returnValue(unit)
 
     @inlineCallbacks
@@ -155,15 +172,19 @@
                 if fnmatch(name, pattern):
                     return False
             return True
-        wpu = yield self.add_unit(wordpress, m1, with_unit)
-        myu1 = yield self.add_unit(mysql, m2, with_unit)
-        myu2 = yield self.add_unit(mysql, m3, with_unit)
-        vu1 = yield self.add_unit(varnish, m4, with_unit)
-        vu2 = yield self.add_unit(varnish, m5, with_unit)
-        mc1 = yield self.add_unit(memcache, m6, with_unit)
-        mc2 = yield self.add_unit(memcache, m7, with_unit)
-
-         # add unit states to services and assign to machines
+
+
+        units = {}
+        wpu = yield self.add_unit(wordpress, m1, with_unit, units)
+        myu1 = yield self.add_unit(mysql, m2, with_unit, units)
+        myu2 = yield self.add_unit(mysql, m3, with_unit, units)
+        vu1 = yield self.add_unit(varnish, m4, with_unit, units)
+        vu2 = yield self.add_unit(varnish, m5, with_unit, units)
+        mc1 = yield self.add_unit(memcache, m6, with_unit, units)
+        mc2 = yield self.add_unit(memcache, m7, with_unit, units)
+        state["units"] = units
+
+        # add unit states to services and assign to machines
         # Set the lifecycle state and open ports, if any, for each unit state.
         yield self.set_unit_state(wpu, "started", [(80, "tcp"), (443, "tcp")])
         yield self.set_unit_state(myu1, "started")
@@ -250,7 +271,7 @@
             yield riak_u1_workflow.set_state("up")
         yield peer_rel.add_unit_state(riak_u2)
 
-        state = yield status.collect(
+        state = yield collect(
             ["riak"], self.provider, self.client, None)
         self.assertEqual(
             state["services"]["riak"],
@@ -295,15 +316,15 @@
             mysql_ep, [mysql_1], ["up"],
             teamblog_db_ep, [teamblog_1], ["up"])
 
-        state = yield status.collect(None, self.provider, self.client, None)
-        self.assertEqual(
-            state['services']['mysql']['units']['mysql/0'],
-            {'agent-state': 'pending',
-             'machine': 0,
-             'public-address': None})
-        self.assertEqual(
-            state['services']['mysql']['relations'],
-            {'db': ['myblog', 'teamblog']})
+        state = yield collect(None, self.provider, self.client, None)
+        self.assertEqual(
+            state["services"]["mysql"]["units"]["mysql/0"],
+            {"agent-state": "pending",
+             "machine": 0,
+             "public-address": None})
+        self.assertEqual(
+            state["services"]["mysql"]["relations"],
+            {"db": ["myblog", "teamblog"]})
 
     @inlineCallbacks
     def test_service_with_multiple_rels_to_same_endpoint(self):
@@ -330,18 +351,18 @@
             mysql_ep, [mysql_1], ["down"],
             read_db_ep, [myblog_1], ["up"])
 
-        state = yield status.collect(None, self.provider, self.client, None)
+        state = yield collect(None, self.provider, self.client, None)
         # Even though there are two relations to this service we
         # collapse to one the additional displays are redundant.
         self.assertEqual(
-            state['services']['mysql']['relations'],
-            {'db': ['myblog']})
+            state["services"]["mysql"]["relations"],
+            {"db": ["myblog"]})
         self.assertEqual(
-            state['services']['mysql']['units']['mysql/0'],
-            {'agent-state': 'pending',
-             'machine': 0,
-             'relation-errors': {'db': ['myblog']},
-             'public-address': None})
+            state["services"]["mysql"]["units"]["mysql/0"],
+            {"agent-state": "pending",
+             "machine": 0,
+             "relation-errors": {"db": ["myblog"]},
+             "public-address": None})
 
     @inlineCallbacks
     def test_collect(self):
@@ -359,7 +380,7 @@
         yield agent.start()
 
         # collect everything
-        state = yield status.collect(None, self.provider, self.client, None)
+        state = yield collect(None, self.provider, self.client, None)
         services = state["services"]
         self.assertIn("wordpress", services)
         self.assertIn("varnish", services)
@@ -404,7 +425,7 @@
         self.assertEqual(
             services["wordpress"],
             {"charm": "local:series/wordpress-3",
-             "relations":  {
+             "relations": {
                     "cache": ["memcache"],
                     "db": ["mysql"],
                     "proxy": ["varnish"]},
@@ -436,7 +457,7 @@
         yield self.build_topology()
 
         # collect by service name
-        state = yield status.collect(
+        state = yield collect(
             ["wordpress"], self.provider, self.client, None)
         # Validate that only the expected service is present
         # in the state
@@ -444,13 +465,13 @@
         self.assertEqual(state["services"].keys(), ["wordpress"])
 
         # collect by unit name
-        state = yield status.collect(["*/0"], self.provider, self.client, None)
+        state = yield collect(["*/0"], self.provider, self.client, None)
         self.assertEqual(set(state["machines"].keys()), set([0, 1, 3, 5]))
         self.assertEqual(set(state["services"].keys()),
                          set(["memcache", "varnish", "mysql", "wordpress"]))
 
         # collect by unit name
-        state = yield status.collect(["*/1"], self.provider, self.client, None)
+        state = yield collect(["*/1"], self.provider, self.client, None)
         self.assertEqual(set(state["machines"].keys()), set([2, 4, 6]))
 
         # verify that only the proper units and services are present
@@ -489,13 +510,13 @@
                             }}}})
 
         # filter a missing service
-        state = yield status.collect(
+        state = yield collect(
             ["cluehammer"], self.provider, self.client, None)
         self.assertEqual(set(state["machines"].keys()), set([]))
         self.assertEqual(set(state["services"].keys()), set([]))
 
         # filter a missing unit
-        state = yield status.collect(["*/7"], self.provider, self.client, None)
+        state = yield collect(["*/7"], self.provider, self.client, None)
         self.assertEqual(set(state["machines"].keys()), set([]))
         self.assertEqual(set(state["services"].keys()), set([]))
 
@@ -512,7 +533,7 @@
         yield unit.unassign_from_machine()
         yield unit.set_public_address(None)
         # test that the machine is in state information w/o assignment
-        state = yield status.collect(None, self.provider, self.client, None)
+        state = yield collect(None, self.provider, self.client, None)
         # verify that the unassigned machine appears in the state
         self.assertEqual(state["machines"][machine_id],
                          {"dns-name": "steamcloud-1.com",
@@ -544,7 +565,7 @@
         yield wordpress.remove_unit_state(unit)
 
         # test that wordpress has no assigned service units
-        state = yield status.collect(None, self.provider, self.client, None)
+        state = yield collect(None, self.provider, self.client, None)
         self.assertEqual(
             state["services"]["wordpress"],
             {"charm": "local:series/wordpress-3",
@@ -576,7 +597,7 @@
         yield wpu.assign_to_machine(m8)
 
         # test that we identify we don't have machine state
-        state = yield status.collect(
+        state = yield collect(
             None, self.provider, self.client, logging.getLogger())
         self.assertEqual(state["machines"][7]["instance-id"],
                          "pending")
@@ -715,13 +736,16 @@
         self.assertIn("mysql -> wordpress", result)
 
         # assert that properties were applied to a relationship
-        self.assertIn("wordpress -> varnish  [dir=none, label=proxy]",
+        self.assertIn("wordpress -> varnish  [dir=none, "
+                      "label=\"varnish:wordpress/proxy\"]",
                       result)
 
         # verify that the renderer picked up the DNS name of the
         # machines (and they are associated with the proper machine)
         self.assertIn(
-            '"mysql/0" [color="#DD4814", fontcolor="#ffffff", shape=box, style=filled, label=<mysql/0<br/><i>mysql-0.example.com</i>>]',
+            '"mysql/0" [color="#DD4814", fontcolor="#ffffff", '
+            "shape=box, style=filled, label=<mysql/0<br/><i>mysql-0."
+            "example.com</i>>]",
             result)
         self.assertIn(
             '"mysql/1" [color="#DD4814", fontcolor="#ffffff", shape=box, style=filled, label=<mysql/1<br/><i>mysql-1.example.com</i>>]',
@@ -771,3 +795,100 @@
 
         # look for a hint the process completed.
         self.assertIn("</svg>", self.output.getvalue())
+
+    @inlineCallbacks
+    def test_subordinate_status_output(self):
+        state = yield self.build_topology()
+        # supplement status with additional subordinates
+        # add logging to mysql and wordpress
+        logging = yield self.add_service_from_charm("logging")
+
+        mysql_ep = RelationEndpoint("mysql", "client-server",
+                                    "juju-info", "server")
+        wordpress_db_ep = RelationEndpoint("wordpress", "client-server",
+                                           "juju-info", "server")
+        logging_ep = RelationEndpoint("logging", "client-server",
+                                      "juju-info", "client", "container")
+
+        my_log_rel, my_log_services = (
+            yield self.relation_state_manager.add_relation_state(
+                mysql_ep, logging_ep))
+        wp_log_rel, wp_log_services = (
+            yield self.relation_state_manager.add_relation_state(
+            wordpress_db_ep, logging_ep))
+
+        units = state["units"]
+        log_units = units.setdefault("logging", {})
+        wp1 = iter(units["wordpress"]).next()
+        mu1, mu2 = list(units["mysql"])
+
+        yield self.add_unit(logging, None, container=mu1, units=log_units)
+        yield self.add_unit(logging, None, container=wp1, units=log_units)
+        yield self.add_unit(logging, None, container=mu2, units=log_units)
+
+        self.mock_environment()
+        self.mocker.replay()
+
+        yield status.status(self.environment, [],
+                            status.render_yaml, self.output, None)
+
+        state = yaml.load(self.output.getvalue())
+
+        # verify our changes
+        log_state = state["services"]["logging"]
+
+        self.assertEqual(set(log_state["relations"]["juju-info"]),
+                         set(["mysql", "wordpress"]))
+        self.assertEqual(set(log_state["subordinate-to"]),
+                         set(["mysql", "wordpress"]))
+
+        wp_state = state["services"]["wordpress"]
+        self.assertEqual(wp_state["relations"]["juju-info"], ["logging"])
+        wp_subs = wp_state["units"]["wordpress/0"]["subordinates"]
+        logging_sub = wp_subs["logging/1"]
+        # this assertion verifies that we don't see keys we don't
+        # expect as well
+        self.assertEqual(logging_sub, {"agent-state": "pending"})
+
+    @inlineCallbacks
+    def test_subordinate_status_output_no_container(self):
+        state = yield self.build_topology()
+        # supplement status with additional subordinates
+        # add logging to mysql and wordpress
+        logging = yield self.add_service_from_charm("logging")
+
+        mysql_ep = RelationEndpoint("mysql", "client-server",
+                                    "juju-info", "server")
+        wordpress_db_ep = RelationEndpoint("wordpress", "client-server",
+                                           "juju-info", "server")
+        logging_ep = RelationEndpoint("logging", "client-server",
+                                      "juju-info", "client", "container")
+
+        my_log_rel, my_log_services = (
+            yield self.relation_state_manager.add_relation_state(
+                mysql_ep, logging_ep))
+        wp_log_rel, wp_log_services = (
+            yield self.relation_state_manager.add_relation_state(
+            wordpress_db_ep, logging_ep))
+
+        units = state["units"]
+        log_units = units.setdefault("logging", {})
+        wp1 = iter(units["wordpress"]).next()
+        mu1, mu2 = list(units["mysql"])
+
+        yield self.add_unit(logging, None, container=mu1, units=log_units)
+        yield self.add_unit(logging, None, container=wp1, units=log_units)
+        yield self.add_unit(logging, None, container=mu2, units=log_units)
+
+        # remove mysql/0
+        yield state["services"]["mysql"].remove_unit_state(mu1)
+
+        self.mock_environment()
+        self.mocker.replay()
+
+        yield status.status(self.environment, [],
+                            status.render_yaml, self.output, None)
+
+        output = yaml.load(self.output.getvalue())
+        self.assertNotIn(mu1.unit_name, output["services"]["mysql"]["units"])
+        self.assertIn(mu2.unit_name, output["services"]["mysql"]["units"])

=== modified file 'juju/state/service.py'
--- juju/state/service.py	2012-03-30 10:13:09 +0000
+++ juju/state/service.py	2012-04-05 21:24:20 +0000
@@ -23,6 +23,7 @@
 from juju.state.charm import CharmStateManager
 from juju.state.relation import ServiceRelationState, RelationStateManager
 from juju.state.machine import _public_machine_id, MachineState
+from juju.state.topology import InternalTopologyError
 from juju.state.utils import (
     remove_tree, dict_merge, YAMLState, YAMLStateNodeMixin)
 
@@ -866,7 +867,12 @@
 
         """
         topology = yield self._read_topology()
-        container_info = topology.get_service_unit_container(self.internal_id)
+        try:
+            container_info = topology.get_service_unit_container(
+                self.internal_id)
+        except InternalTopologyError:
+            returnValue(None)
+
         if container_info is None:
             returnValue(None)
 

=== modified file 'juju/state/tests/test_charm.py'
--- juju/state/tests/test_charm.py	2012-03-16 10:11:36 +0000
+++ juju/state/tests/test_charm.py	2012-04-05 21:24:20 +0000
@@ -1,17 +1,19 @@
+import os
+import shutil
+
 import yaml
 
 from twisted.internet.defer import inlineCallbacks
 
 from juju.charm.directory import CharmDirectory
 from juju.charm.tests import local_charm_id
+from juju.charm.tests.test_directory import sample_directory
 from juju.charm.tests.test_repository import unbundled_repository
+
 from juju.state.charm import CharmStateManager
 from juju.state.errors import CharmStateNotFound
 from juju.state.tests.common import StateTestBase
 
-import os
-import shutil
-
 
 class CharmStateManagerTest(StateTestBase):
 
@@ -107,6 +109,20 @@
             "local:series/dummy-1")
         metadata = yield charm_state.get_metadata()
         self.assertEquals(metadata.name, "dummy")
+        self.assertFalse(metadata.is_subordinate)
+        self.assertFalse(charm_state.is_subordinate())
+
+    @inlineCallbacks
+    def test_charm_state_is_subordinate(self):
+        log_dir = os.path.join(os.path.dirname(sample_directory), "logging")
+        charm = CharmDirectory(log_dir)
+        yield self.charm_state_manager.add_charm_state(
+            "local:series/logging-1", charm, "")
+        charm_state = yield self.charm_state_manager.get_charm_state(
+            "local:series/logging-1")
+
+        self.assertTrue(charm_state.is_subordinate)
+
 
     @inlineCallbacks
     def test_charm_state_config_options(self):

=== modified file 'juju/state/tests/test_service.py'
--- juju/state/tests/test_service.py	2012-03-30 10:13:09 +0000
+++ juju/state/tests/test_service.py	2012-04-05 21:24:20 +0000
@@ -11,2880 +11,2921 @@
 from juju.charm.tests import local_charm_id
 from juju.charm.tests.test_metadata import test_repository_path
 from juju.machine.tests.test_constraints import (
-    dummy_constraints, dummy_cs, series_constraints)
+        dummy_constraints, dummy_cs, series_constraints)
 from juju.lib.pick import pick_attr
 from juju.state.charm import CharmStateManager
 from juju.charm.tests.test_repository import unbundled_repository
 from juju.state.endpoint import RelationEndpoint
 from juju.state.service import (
-    ServiceStateManager, NO_HOOKS, RETRY_HOOKS, parse_service_name)
+        ServiceStateManager, NO_HOOKS, RETRY_HOOKS, parse_service_name)
 from juju.state.machine import MachineStateManager
 from juju.state.relation import RelationStateManager
 from juju.state.utils import YAMLState
 from juju.state.errors import (
-    StateChanged, ServiceStateNotFound, ServiceUnitStateNotFound,
-    ServiceUnitStateMachineAlreadyAssigned, ServiceStateNameInUse,
-    BadDescriptor, BadServiceStateName, ServiceUnitDebugAlreadyEnabled,
-    MachineStateNotFound, NoUnusedMachines, ServiceUnitResolvedAlreadyEnabled,
-    ServiceUnitRelationResolvedAlreadyEnabled, StopWatcher,
-    ServiceUnitUpgradeAlreadyEnabled)
+        StateChanged, ServiceStateNotFound, ServiceUnitStateNotFound,
+        ServiceUnitStateMachineAlreadyAssigned, ServiceStateNameInUse,
+        BadDescriptor, BadServiceStateName, ServiceUnitDebugAlreadyEnabled,
+        MachineStateNotFound, NoUnusedMachines, ServiceUnitResolvedAlreadyEnabled,
+        ServiceUnitRelationResolvedAlreadyEnabled, StopWatcher,
+        ServiceUnitUpgradeAlreadyEnabled)
 
 from juju.state.tests.common import StateTestBase
 
 
 class ServiceStateManagerTestBase(StateTestBase):
 
-    @inlineCallbacks
-    def setUp(self):
-        yield super(ServiceStateManagerTestBase, self).setUp()
-        yield self.push_default_config()
-        self.charm_state_manager = CharmStateManager(self.client)
-        self.service_state_manager = ServiceStateManager(self.client)
-        self.machine_state_manager = MachineStateManager(self.client)
-        self.charm_state = yield self.charm_state_manager.add_charm_state(
-            local_charm_id(self.charm), self.charm, "")
-        self.relation_state_manager = RelationStateManager(self.client)
-
-    @inlineCallbacks
-    def add_service(self, name):
-        service_state = yield self.service_state_manager.add_service_state(
-            name, self.charm_state, dummy_constraints)
-        returnValue(service_state)
-
-    @inlineCallbacks
-    def add_service_from_charm(
-            self, service_name, charm_id=None, constraints=None,
-            charm_dir=None, charm_name=None):
-        """Add a service from a charm.
-        """
-        if not charm_id and charm_dir is None:
-            charm_name = charm_name or service_name
-            charm_dir = CharmDirectory(os.path.join(
-                test_repository_path, "series", charm_name))
-        if charm_id is None:
-            charm_state = yield self.charm_state_manager.add_charm_state(
-                local_charm_id(charm_dir), charm_dir, "")
-        else:
-            charm_state = yield self.charm_state_manager.get_charm_state(
-                charm_id)
-        service_state = yield self.service_state_manager.add_service_state(
-            service_name, charm_state, constraints or dummy_constraints)
-        returnValue(service_state)
-
-    @inlineCallbacks
-    def get_subordinate_charm(self):
-        """Return charm state for a subordinate charm.
-
-        Many tests rely on adding relationships to a proper subordinate.
-        This return the charm state of a testing subordinate charm.
-        """
-        unbundled_repo_path = self.makeDir()
-        os.rmdir(unbundled_repo_path)
-        shutil.copytree(unbundled_repository, unbundled_repo_path)
-
-        sub_charm = CharmDirectory(
-            os.path.join(unbundled_repo_path, "series", "logging"))
-        self.charm_state_manager.add_charm_state("local:series/logging-1",
-                                                  sub_charm, "")
-        logging_charm_state = yield self.charm_state_manager.get_charm_state(
-            "local:series/logging-1")
-        returnValue(logging_charm_state)
-
-    @inlineCallbacks
-    def add_relation(self, relation_type, relation_scope, *services):
-        endpoints = []
-        for service_meta in services:
-            service_state, relation_name, relation_role = service_meta
-            endpoints.append(RelationEndpoint(
-                service_state.service_name,
-                relation_type,
-                relation_name,
-                relation_role,
-                relation_scope))
-        relation_state = yield self.relation_state_manager.add_relation_state(
-            *endpoints)
-        returnValue(relation_state[0])
-
-    @inlineCallbacks
-    def remove_service(self, internal_service_id):
-        topology = yield self.get_topology()
-        topology.remove_service(internal_service_id)
-        yield self.set_topology(topology)
-
-    @inlineCallbacks
-    def remove_service_unit(self, internal_service_id, internal_unit_id):
-        topology = yield self.get_topology()
-        topology.remove_service_unit(internal_service_id, internal_unit_id)
-        yield self.set_topology(topology)
-
-    def add_machine_state(self, constraints=None):
-        return self.machine_state_manager.add_machine_state(
-            constraints or series_constraints)
-
-    @inlineCallbacks
-    def assert_machine_states(self, present, absent):
-        """Assert that machine IDs are either `present` or `absent` in topo."""
-        for machine_id in present:
-            self.assertTrue(
-                (yield self.machine_state_manager.get_machine_state(
-                        machine_id)))
-        for machine_id in absent:
-            ex = yield self.assertFailure(
-                self.machine_state_manager.get_machine_state(machine_id),
-                MachineStateNotFound)
-            self.assertEqual(ex.machine_id, machine_id)
-
-    @inlineCallbacks
-    def assert_machine_assignments(self, service_name, machine_ids):
-        """Assert that `service_name` is deployed on `machine_ids`."""
-        topology = yield self.get_topology()
-        service_id = topology.find_service_with_name(service_name)
-        assigned_machine_ids = [
-            topology.get_service_unit_machine(service_id, unit_id)
-            for unit_id in topology.get_service_units(service_id)]
-        internal_machine_ids = []
-        for machine_id in machine_ids:
-            if machine_id is None:
-                # corresponds to get_service_unit_machine API in this case
-                internal_machine_ids.append(None)
-            else:
-                internal_machine_ids.append("machine-%010d" % machine_id)
-        self.assertEqual(
-            set(assigned_machine_ids), set(internal_machine_ids))
-
-    @inlineCallbacks
-    def get_unit_state(self):
-        """Simple test helper to get a unit state."""
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        returnValue(unit_state)
+        @inlineCallbacks
+        def setUp(self):
+                yield super(ServiceStateManagerTestBase, self).setUp()
+                yield self.push_default_config()
+                self.charm_state_manager = CharmStateManager(self.client)
+                self.service_state_manager = ServiceStateManager(self.client)
+                self.machine_state_manager = MachineStateManager(self.client)
+                self.charm_state = yield self.charm_state_manager.add_charm_state(
+                        local_charm_id(self.charm), self.charm, "")
+                self.relation_state_manager = RelationStateManager(self.client)
+
+        @inlineCallbacks
+        def add_service(self, name):
+                service_state = yield self.service_state_manager.add_service_state(
+                        name, self.charm_state, dummy_constraints)
+                returnValue(service_state)
+
+        @inlineCallbacks
+        def add_service_from_charm(
+                        self, service_name, charm_id=None, constraints=None,
+                        charm_dir=None, charm_name=None):
+                """Add a service from a charm.
+                """
+                if not charm_id and charm_dir is None:
+                        charm_name = charm_name or service_name
+                        charm_dir = CharmDirectory(os.path.join(
+                                test_repository_path, "series", charm_name))
+                if charm_id is None:
+                        charm_state = yield self.charm_state_manager.add_charm_state(
+                                local_charm_id(charm_dir), charm_dir, "")
+                else:
+                        charm_state = yield self.charm_state_manager.get_charm_state(
+                                charm_id)
+                service_state = yield self.service_state_manager.add_service_state(
+                        service_name, charm_state, constraints or dummy_constraints)
+                returnValue(service_state)
+
+        @inlineCallbacks
+        def get_subordinate_charm(self):
+                """Return charm state for a subordinate charm.
+
+                Many tests rely on adding relationships to a proper subordinate.
+                This return the charm state of a testing subordinate charm.
+                """
+                unbundled_repo_path = self.makeDir()
+                os.rmdir(unbundled_repo_path)
+                shutil.copytree(unbundled_repository, unbundled_repo_path)
+
+                sub_charm = CharmDirectory(
+                        os.path.join(unbundled_repo_path, "series", "logging"))
+                self.charm_state_manager.add_charm_state("local:series/logging-1",
+                                                                                                  sub_charm, "")
+                logging_charm_state = yield self.charm_state_manager.get_charm_state(
+                        "local:series/logging-1")
+                returnValue(logging_charm_state)
+
+        @inlineCallbacks
+        def add_relation(self, relation_type, relation_scope, *services):
+                endpoints = []
+                for service_meta in services:
+                        service_state, relation_name, relation_role = service_meta
+                        endpoints.append(RelationEndpoint(
+                                service_state.service_name,
+                                relation_type,
+                                relation_name,
+                                relation_role,
+                                relation_scope))
+                relation_state = yield self.relation_state_manager.add_relation_state(
+                        *endpoints)
+                returnValue(relation_state[0])
+
+        @inlineCallbacks
+        def remove_service(self, internal_service_id):
+                topology = yield self.get_topology()
+                topology.remove_service(internal_service_id)
+                yield self.set_topology(topology)
+
+        @inlineCallbacks
+        def remove_service_unit(self, internal_service_id, internal_unit_id):
+                topology = yield self.get_topology()
+                topology.remove_service_unit(internal_service_id, internal_unit_id)
+                yield self.set_topology(topology)
+
+        def add_machine_state(self, constraints=None):
+                return self.machine_state_manager.add_machine_state(
+                        constraints or series_constraints)
+
+        @inlineCallbacks
+        def assert_machine_states(self, present, absent):
+                """Assert that machine IDs are either `present` or `absent` in topo."""
+                for machine_id in present:
+                        self.assertTrue(
+                                (yield self.machine_state_manager.get_machine_state(
+                                                machine_id)))
+                for machine_id in absent:
+                        ex = yield self.assertFailure(
+                                self.machine_state_manager.get_machine_state(machine_id),
+                                MachineStateNotFound)
+                        self.assertEqual(ex.machine_id, machine_id)
+
+        @inlineCallbacks
+        def assert_machine_assignments(self, service_name, machine_ids):
+                """Assert that `service_name` is deployed on `machine_ids`."""
+                topology = yield self.get_topology()
+                service_id = topology.find_service_with_name(service_name)
+                assigned_machine_ids = [
+                        topology.get_service_unit_machine(service_id, unit_id)
+                        for unit_id in topology.get_service_units(service_id)]
+                internal_machine_ids = []
+                for machine_id in machine_ids:
+                        if machine_id is None:
+                                # corresponds to get_service_unit_machine API in this case
+                                internal_machine_ids.append(None)
+                        else:
+                                internal_machine_ids.append("machine-%010d" % machine_id)
+                self.assertEqual(
+                        set(assigned_machine_ids), set(internal_machine_ids))
+
+        @inlineCallbacks
+        def get_unit_state(self):
+                """Simple test helper to get a unit state."""
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                unit_state = yield service_state.add_unit_state()
+                returnValue(unit_state)
 
 
 class ServiceStateManagerTest(ServiceStateManagerTestBase):
 
-    @inlineCallbacks
-    def test_add_service(self):
-        """
-        Adding a service state should register it in zookeeper,
-        including the requested charm id.
-        """
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-        children = yield self.client.get_children("/services")
-
-        self.assertEquals(sorted(children),
-                          ["service-0000000000", "service-0000000001"])
-
-        content, stat = yield self.client.get("/services/service-0000000000")
-        details = yaml.load(content)
-        self.assertTrue(details)
-        self.assertEquals(details.get("charm"), "local:series/dummy-1")
-        self.assertFalse(isinstance(details.get("charm"), unicode))
-        self.assertEquals(details.get("constraints"), series_constraints.data)
-
-        topology = yield self.get_topology()
-        self.assertEquals(topology.find_service_with_name("wordpress"),
-                          "service-0000000000")
-        self.assertEquals(topology.find_service_with_name("mysql"),
-                          "service-0000000001")
-
-    @inlineCallbacks
-    def test_add_service_with_duplicated_name(self):
-        """
-        If a service is added with a duplicated name, a meaningful
-        error should be raised.
-        """
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-
-        try:
-            yield self.service_state_manager.add_service_state(
-                "wordpress", self.charm_state, dummy_constraints)
-        except ServiceStateNameInUse, e:
-            self.assertEquals(e.service_name, "wordpress")
-        else:
-            self.fail("Error not raised")
-
-    @inlineCallbacks
-    def test_get_service_and_check_attributes(self):
-        """
-        Getting a service state should be possible, and the service
-        state identification should be available through its
-        attributes.
-        """
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        self.assertEquals(service_state.service_name, "wordpress")
-        self.assertEquals(service_state.internal_id, "service-0000000000")
-
-    @inlineCallbacks
-    def test_get_service_not_found(self):
-        """
-        Getting a service state which is not available should errback
-        a meaningful error.
-        """
-        try:
-            yield self.service_state_manager.get_service_state("wordpress")
-        except ServiceStateNotFound, e:
-            self.assertEquals(e.service_name, "wordpress")
-        else:
-            self.fail("Error not raised")
-
-    def test_get_unit_state(self):
-        """A unit state can be retrieved by name from the service manager."""
-        self.assertFailure(self.service_state_manager.get_unit_state(
-            "wordpress/1"), ServiceStateNotFound)
-
-        self.assertFailure(self.service_state_manager.get_unit_state(
-            "wordpress1"), ServiceUnitStateNotFound)
-
-        wordpress_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-
-        self.assertFailure(self.service_state_manager.get_unit_state(
-            "wordpress/1"), ServiceUnitStateNotFound)
-
-        wordpress_unit = wordpress_state.add_unit_state()
-
-        unit_state = yield self.service_state_manager.get_unit_state(
-                "wordpress/1")
-
-        self.assertEqual(unit_state.internal_id, wordpress_unit.internal_id)
-
-    @inlineCallbacks
-    def test_get_service_charm_id(self):
-        """
-        The service state should make its respective charm id available.
-        """
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        charm_id = yield service_state.get_charm_id()
-        self.assertEquals(charm_id, "local:series/dummy-1")
-
-    @inlineCallbacks
-    def test_set_service_charm_id(self):
-        """
-        The service state should allow its charm id to be set.
-        """
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        yield service_state.set_charm_id("local:series/dummy-2")
-        charm_id = yield service_state.get_charm_id()
-        self.assertEquals(charm_id, "local:series/dummy-2")
-
-    @inlineCallbacks
-    def test_get_service_constraints(self):
-        """The service state should make constraints available"""
-        initial_constraints = dummy_cs.parse(["cpu=256", "arch=amd64"])
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, initial_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        constraints = yield service_state.get_constraints()
-        self.assertEquals(
-            constraints, initial_constraints.with_series("series"))
-
-    @inlineCallbacks
-    def test_get_service_constraints_inherits(self):
-        """The service constraints should be combined with the environment's"""
-        yield self.push_env_constraints("arch=arm", "cpu=32")
-        service_constraints = dummy_cs.parse(["cpu=256"])
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, service_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        constraints = yield service_state.get_constraints()
-        expected_base = dummy_cs.parse(["arch=arm", "cpu=256"])
-        self.assertEquals(constraints, expected_base.with_series("series"))
-
-    @inlineCallbacks
-    def test_get_missing_service_constraints(self):
-        """
-        Nodes created before the constraints mechanism was added should have
-        empty constraints.
-        """
-        yield self.client.delete("/constraints")
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        path = "/services/" + service_state.internal_id
-        node = YAMLState(self.client, path)
-        yield node.read()
-        del node["constraints"]
-        yield node.write()
-        constraints = yield service_state.get_constraints()
-        self.assertEquals(constraints.data, {})
-
-    @inlineCallbacks
-    def test_get_missing_unit_constraints(self):
-        """
-        Nodes created before the constraints mechanism was added should have
-        empty constraints.
-        """
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        unit_state = yield service_state.add_unit_state()
-        path = "/units/" + unit_state.internal_id
-        node = YAMLState(self.client, path)
-        yield node.read()
-        del node["constraints"]
-        yield node.write()
-        constraints = yield unit_state.get_constraints()
-        self.assertEquals(constraints.data, {})
-
-    @inlineCallbacks
-    def test_set_service_constraints(self):
-        """The service state should make constraints available for change"""
-        initial_constraints = dummy_cs.parse(["cpu=256", "arch=amd64"])
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, initial_constraints)
-        service_state = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        new_constraints = dummy_cs.parse(["mem=2G", "arch=arm"])
-        yield service_state.set_constraints(new_constraints)
-        retrieved_constraints = yield service_state.get_constraints()
-        self.assertEquals(
-            retrieved_constraints, new_constraints.with_series("series"))
-
-    @inlineCallbacks
-    def test_remove_service_state(self):
-        """
-        A service state can be removed along with its relations, units,
-        and zookeeper state.
-        """
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-
-        relation_state = yield self.add_relation(
-            "rel-type2", "global", [service_state, "app", "server"])
-
-        unit_state = yield service_state.add_unit_state()
-        machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        yield unit_state.assign_to_machine(machine_state)
-
-        yield self.service_state_manager.remove_service_state(service_state)
-
-        topology = yield self.get_topology()
-        self.assertFalse(topology.has_relation(relation_state.internal_id))
-        self.assertFalse(topology.has_service(service_state.internal_id))
-        self.assertFalse(
-            topology.get_service_units_in_machine(machine_state.internal_id))
-
-        exists = yield self.client.exists(
-            "/services/%s" % service_state.internal_id)
-        self.assertFalse(exists)
-
-    @inlineCallbacks
-    def test_add_service_unit_and_check_attributes(self):
-        """
-        A service state should enable adding a new service unit
-        under it, and again the unit should offer attributes allowing
-        its identification.
-        """
-        service_state0 = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state1 = yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-
-        unit_state0 = yield service_state0.add_unit_state()
-        unit_state1 = yield service_state1.add_unit_state()
-        unit_state2 = yield service_state0.add_unit_state()
-        unit_state3 = yield service_state1.add_unit_state()
-
-        children = yield self.client.get_children("/units")
-        self.assertEquals(sorted(children),
-                          ["unit-0000000000", "unit-0000000001",
-                           "unit-0000000002", "unit-0000000003"])
-
-        self.assertEquals(unit_state0.service_name, "wordpress")
-        self.assertEquals(unit_state0.internal_id, "unit-0000000000")
-        self.assertEquals(unit_state0.unit_name, "wordpress/0")
-
-        self.assertEquals(unit_state1.service_name, "mysql")
-        self.assertEquals(unit_state1.internal_id, "unit-0000000001")
-        self.assertEquals(unit_state1.unit_name, "mysql/0")
-
-        self.assertEquals(unit_state2.service_name, "wordpress")
-        self.assertEquals(unit_state2.internal_id, "unit-0000000002")
-        self.assertEquals(unit_state2.unit_name, "wordpress/1")
-
-        self.assertEquals(unit_state3.service_name, "mysql")
-        self.assertEquals(unit_state3.internal_id, "unit-0000000003")
-        self.assertEquals(unit_state3.unit_name, "mysql/1")
-
-        topology = yield self.get_topology()
-
-        self.assertTrue(
-            topology.has_service_unit("service-0000000000",
-                                      "unit-0000000000"))
-        self.assertTrue(
-            topology.has_service_unit("service-0000000001",
-                                      "unit-0000000001"))
-        self.assertTrue(
-            topology.has_service_unit("service-0000000000",
-                                      "unit-0000000002"))
-        self.assertTrue(
-            topology.has_service_unit("service-0000000001",
-                                      "unit-0000000003"))
-
-    def get_presence_path(
-        self, relation_state, relation_role, unit_state, container=None):
-        container = container.internal_id if container else None
-        presence_path = "/".join(filter(None, [
-            "/relations",
-            relation_state.internal_id,
-            container,
-            relation_role,
-            unit_state.internal_id]))
-        return presence_path
-
-    @inlineCallbacks
-    def test_add_service_unit_with_container(self):
-        """
-        Validate adding units with containers specified and recovering that.
-        """
-        mysql_ep = RelationEndpoint("mysql", "juju-info", "juju-info",
-                                    "server", "global")
-        logging_ep = RelationEndpoint("logging", "juju-info", "juju-info",
-                                      "client", "container")
-
-        logging_charm_state = yield self.get_subordinate_charm()
-        self.assertTrue(logging_charm_state.is_subordinate())
-        log_state = yield self.service_state_manager.add_service_state(
-            "logging", logging_charm_state, dummy_constraints)
-        mysql_state = yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-
-        relation_state, service_states = (yield
-            self.relation_state_manager.add_relation_state(
-                mysql_ep, logging_ep))
-
-        unit_state1 = yield mysql_state.add_unit_state()
-        unit_state0 = yield log_state.add_unit_state(container=unit_state1)
-
-        unit_state3 = yield mysql_state.add_unit_state()
-        unit_state2 = yield log_state.add_unit_state(container=unit_state3)
-
-        self.assertEquals((yield unit_state1.get_container()), None)
-        self.assertEquals((yield unit_state0.get_container()), unit_state1)
-        self.assertEquals((yield unit_state2.get_container()), unit_state3)
-        self.assertEquals((yield unit_state3.get_container()), None)
-
-        for unit_state in (unit_state1, unit_state3):
-            yield unit_state.set_private_address(
-                "%s.example.com" % (
-                    unit_state.unit_name.replace("/", "-")))
-
-        # construct the proper relation state
-        mystate = pick_attr(service_states, relation_role="server")
-        logstate = pick_attr(service_states, relation_role="client")
-        yield logstate.add_unit_state(unit_state0)
-        yield logstate.add_unit_state(unit_state2)
-
-        yield mystate.add_unit_state(unit_state1)
-        yield mystate.add_unit_state(unit_state3)
-
-        @inlineCallbacks
-        def verify_container(relation_state, service_relation_state,
-                             unit_state, container):
-            presence_path = self.get_presence_path(
-                relation_state,
-                service_relation_state.relation_role,
-                unit_state,
-                container)
-
-            content, stat = yield self.client.get(presence_path)
-            self.assertTrue(stat)
-            self.assertEqual(content, '')
-            # verify the node data on the relation role nodes
-            role_path = os.path.dirname(presence_path)
-            # role path
-            content, stat = yield self.client.get(role_path)
-            self.assertTrue(stat)
-            node_info = yaml.load(content)
-
-            self.assertEqual(
-                node_info["name"],
-                service_relation_state.relation_name)
-            self.assertEqual(
-                node_info["role"],
-                service_relation_state.relation_role)
-
-            settings_path = os.path.dirname(
-                os.path.dirname(presence_path)) + "/settings/" + \
-                    unit_state.internal_id
-            content, stat = yield self.client.get(settings_path)
-            self.assertTrue(stat)
-            settings_info = yaml.load(content)
-
-            # Verify that private address was set
-            # we verify the content elsewhere
-            self.assertTrue(settings_info["private-address"])
-
-        # verify all the units are constructed as expected
-        # first the client roles with another container
-        yield verify_container(relation_state, logstate,
-                               unit_state0, unit_state1)
-
-        yield verify_container(relation_state, logstate,
-                               unit_state2, unit_state3)
-
-        # and now the principals (which are their own relation containers)
-        yield verify_container(relation_state, logstate,
-                               unit_state0, unit_state1)
-
-        yield verify_container(relation_state, mystate,
-                               unit_state1, unit_state1)
-
-    @inlineCallbacks
-    def test_add_service_unit_with_changing_state(self):
-        """
-        When adding a service unit, there's a chance that the
-        service will go away mid-way through.  Rather than blowing
-        up randomly, a nice error should be raised.
-        """
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-
-        yield self.remove_service(service_state.internal_id)
-
-        d = service_state.add_unit_state()
-        yield self.assertFailure(d, StateChanged)
-
-    @inlineCallbacks
-    def test_get_unit_names(self):
-        """A service's units names are retrievable."""
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-
-        expected_names = []
-        for i in range(3):
-            unit_state = yield service_state.add_unit_state()
-            expected_names.append(unit_state.unit_name)
-
-        unit_names = yield service_state.get_unit_names()
-        self.assertEqual(unit_names, expected_names)
-
-    @inlineCallbacks
-    def test_remove_service_unit(self):
-        """Removing a service unit removes all state associated.
-        """
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-
-        unit_state = yield service_state.add_unit_state()
-
-        # Assign to a machine
-        machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        yield unit_state.assign_to_machine(machine_state)
-        # Connect a unit agent
-        yield unit_state.connect_agent()
-
-        # Now try and destroy it.
-        yield service_state.remove_unit_state(unit_state)
-
-        # Verify destruction.
-        topology = yield self.get_topology()
-        self.assertTrue(topology.has_service(service_state.internal_id))
-        self.assertFalse(
-            topology.has_service_unit(
-                service_state.internal_id, unit_state.internal_id))
-
-        exists = yield self.client.exists("/units/%s" % unit_state.internal_id)
-        self.assertFalse(exists)
-
-    def test_remove_service_unit_nonexistant(self):
-        """Removing a non existant service unit, is fine."""
-
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        yield service_state.remove_unit_state(unit_state)
-        yield service_state.remove_unit_state(unit_state)
-
-    @inlineCallbacks
-    def test_get_all_service_states(self):
-        services = yield self.service_state_manager.get_all_service_states()
-        self.assertFalse(services)
-
-        yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        services = yield self.service_state_manager.get_all_service_states()
-        self.assertEquals(len(services), 1)
-
-        yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-        services = yield self.service_state_manager.get_all_service_states()
-        self.assertEquals(len(services), 2)
-
-    @inlineCallbacks
-    def test_get_service_unit(self):
-        """
-        Getting back service units should be possible using the
-        user-oriented id.
-        """
-        service_state0 = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state1 = yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-
-        yield service_state0.add_unit_state()
-        yield service_state1.add_unit_state()
-        yield service_state0.add_unit_state()
-        yield service_state1.add_unit_state()
-
-        unit_state0 = yield service_state0.get_unit_state("wordpress/0")
-        unit_state1 = yield service_state1.get_unit_state("mysql/0")
-        unit_state2 = yield service_state0.get_unit_state("wordpress/1")
-        unit_state3 = yield service_state1.get_unit_state("mysql/1")
-
-        self.assertEquals(unit_state0.internal_id, "unit-0000000000")
-        self.assertEquals(unit_state1.internal_id, "unit-0000000001")
-        self.assertEquals(unit_state2.internal_id, "unit-0000000002")
-        self.assertEquals(unit_state3.internal_id, "unit-0000000003")
-
-        self.assertEquals(unit_state0.unit_name, "wordpress/0")
-        self.assertEquals(unit_state1.unit_name, "mysql/0")
-        self.assertEquals(unit_state2.unit_name, "wordpress/1")
-        self.assertEquals(unit_state3.unit_name, "mysql/1")
-
-    @inlineCallbacks
-    def test_get_all_unit_states(self):
-        service_state0 = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state1 = yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-
-        yield service_state0.add_unit_state()
-        yield service_state1.add_unit_state()
-        yield service_state0.add_unit_state()
-        yield service_state1.add_unit_state()
-
-        unit_state0 = yield service_state0.get_unit_state("wordpress/0")
-        unit_state1 = yield service_state1.get_unit_state("mysql/0")
-        unit_state2 = yield service_state0.get_unit_state("wordpress/1")
-        unit_state3 = yield service_state1.get_unit_state("mysql/1")
-
-        wordpress_units = yield service_state0.get_all_unit_states()
-        self.assertEquals(
-            set(wordpress_units), set((unit_state0, unit_state2)))
-
-        mysql_units = yield service_state1.get_all_unit_states()
-        self.assertEquals(set(mysql_units), set((unit_state1, unit_state3)))
-
-    @inlineCallbacks
-    def test_get_all_unit_states_with_changing_state(self):
-        """
-        When getting the service unit states, there's a chance that
-        the service will go away mid-way through.  Rather than blowing
-        up randomly, a nice error should be raised.
-        """
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        yield service_state.add_unit_state()
-        unit_state = (yield service_state.get_all_unit_states())[0]
-        self.assertEqual(unit_state.unit_name, "wordpress/0")
-        yield self.remove_service(service_state.internal_id)
-        yield self.assertFailure(
-            service_state.get_all_unit_states(), StateChanged)
-
-    @inlineCallbacks
-    def test_set_functions(self):
-        wordpress = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        mysql = yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-
-        s1 = yield self.service_state_manager.get_service_state(
-            "wordpress")
-        s2 = yield self.service_state_manager.get_service_state(
-            "mysql")
-        self.assertEquals(hash(s1), hash(wordpress))
-        self.assertEquals(hash(s2), hash(mysql))
-
-        self.assertNotEqual(s1, object())
-        self.assertNotEqual(s1, s2)
-
-        self.assertEquals(s1, wordpress)
-        self.assertEquals(s2, mysql)
-
-        us0 = yield wordpress.add_unit_state()
-        us1 = yield wordpress.add_unit_state()
-
-        unit_state0 = yield wordpress.get_unit_state("wordpress/0")
-        unit_state1 = yield wordpress.get_unit_state("wordpress/1")
-
-        self.assertEquals(us0, unit_state0)
-        self.assertEquals(us1, unit_state1)
-        self.assertEquals(hash(us1), hash(unit_state1))
-
-        self.assertNotEqual(us0, object())
-        self.assertNotEqual(us0, us1)
-
-    @inlineCallbacks
-    def test_get_service_unit_not_found(self):
-        """
-        Attempting to retrieve a non-existent service unit should
-        result in an errback.
-        """
-        service_state0 = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state1 = yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-
-        # Add some state in a different service to make it a little
-        # bit more prone to breaking in case of errors.
-        yield service_state1.add_unit_state()
-
-        try:
-            yield service_state0.get_unit_state("wordpress/0")
-        except ServiceUnitStateNotFound, e:
-            self.assertEquals(e.unit_name, "wordpress/0")
-        else:
-            self.fail("Error not raised")
-
-    @inlineCallbacks
-    def test_get_set_public_address(self):
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        self.assertEqual((yield unit_state.get_public_address()), None)
-        yield unit_state.set_public_address("example.foobar.com")
-        yield self.assertEqual(
-            (yield unit_state.get_public_address()),
-             "example.foobar.com")
-
-    @inlineCallbacks
-    def test_get_set_private_address(self):
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        self.assertEqual((yield unit_state.get_private_address()), None)
-        yield unit_state.set_private_address("example.local")
-        yield self.assertEqual(
-            (yield unit_state.get_private_address()),
-             "example.local")
-
-    @inlineCallbacks
-    def test_get_service_unit_with_changing_state(self):
-        """
-        If a service is removed during operation, get_service_unit()
-        should raise a nice error.
-        """
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-
-        yield self.remove_service(service_state.internal_id)
-
-        d = service_state.get_unit_state("wordpress/0")
-        yield self.assertFailure(d, StateChanged)
-
-    @inlineCallbacks
-    def test_get_service_unit_with_bad_service_name(self):
-        """
-        Service unit names contain a service name embedded into
-        them.  The service name requested when calling get_unit_state()
-        must match that of the object being used.
-        """
-        service_state0 = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        service_state1 = yield self.service_state_manager.add_service_state(
-            "mysql", self.charm_state, dummy_constraints)
-
-        # Add some state in a different service to make it a little
-        # bit more prone to breaking in case of errors.
-        yield service_state1.add_unit_state()
-
-        try:
-            yield service_state0.get_unit_state("mysql/0")
-        except BadServiceStateName, e:
-            self.assertEquals(e.expected_name, "wordpress")
-            self.assertEquals(e.obtained_name, "mysql")
-        else:
-            self.fail("Error not raised")
-
-    @inlineCallbacks
-    def test_assign_unit_to_machine(self):
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-
-        yield unit_state.assign_to_machine(machine_state)
-
-        topology = yield self.get_topology()
-
-        self.assertEquals(
-            topology.get_service_unit_machine(service_state.internal_id,
-                                              unit_state.internal_id),
-            machine_state.internal_id)
-
-    @inlineCallbacks
-    def test_assign_unit_to_machine_with_changing_state(self):
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-
-        yield self.remove_service_unit(service_state.internal_id,
-                                       unit_state.internal_id)
-
-        d = unit_state.assign_to_machine(machine_state)
-        yield self.assertFailure(d, StateChanged)
-
-        yield self.remove_service(service_state.internal_id)
-
-        d = unit_state.assign_to_machine(machine_state)
-        yield self.assertFailure(d, StateChanged)
-
-    @inlineCallbacks
-    def test_unassign_unit_from_machine(self):
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-
-        yield unit_state.assign_to_machine(machine_state)
-        yield unit_state.unassign_from_machine()
-
-        topology = yield self.get_topology()
-
-        self.assertEquals(
-            topology.get_service_unit_machine(service_state.internal_id,
-                                              unit_state.internal_id),
-            None)
-
-    @inlineCallbacks
-    def test_get_set_clear_resolved(self):
-        """The a unit can be set to resolved to mark a future transition, with
-        an optional retry flag."""
-
-        unit_state = yield self.get_unit_state()
-
-        self.assertIdentical((yield unit_state.get_resolved()), None)
-        yield unit_state.set_resolved(NO_HOOKS)
-
-        yield self.assertFailure(
-            unit_state.set_resolved(NO_HOOKS),
-            ServiceUnitResolvedAlreadyEnabled)
-        yield self.assertEqual(
-
-                (yield unit_state.get_resolved()), {"retry": NO_HOOKS})
-
-        yield unit_state.clear_resolved()
-        self.assertIdentical((yield unit_state.get_resolved()), None)
-        yield unit_state.clear_resolved()
-
-        yield self.assertFailure(unit_state.set_resolved(None), ValueError)
-
-    @inlineCallbacks
-    def test_watch_resolved(self):
-        """A unit resolved watch can be instituted on a permanent basis."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-
-        unit_state.watch_resolved(callback)
-        yield unit_state.set_resolved(RETRY_HOOKS)
-        yield unit_state.clear_resolved()
-        yield unit_state.set_resolved(NO_HOOKS)
-
-        yield self.poke_zk()
-
-        self.assertEqual(len(results), 4)
-        self.assertIdentical(results.pop(0), False)
-        self.assertEqual(results.pop(0).type_name, "created")
-        self.assertEqual(results.pop(0).type_name, "deleted")
-        self.assertEqual(results.pop(0).type_name, "created")
-
-        self.assertEqual(
-            (yield unit_state.get_resolved()),
-            {"retry": NO_HOOKS})
-
-    @inlineCallbacks
-    def test_watch_resolved_processes_current_state(self):
-        """The watch method processes the current state before returning."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        @inlineCallbacks
-        def callback(value):
-            results.append((yield unit_state.get_resolved()))
-
-        yield unit_state.watch_resolved(callback)
-        self.assertTrue(results)
-
-    @inlineCallbacks
-    def test_stop_watch_resolved(self):
-        """A unit resolved watch can be instituted on a permanent basis.
-
-        However the callback can raise StopWatcher at anytime to stop the watch
-        """
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-            if len(results) == 1:
-                raise StopWatcher()
-            if len(results) == 3:
-                raise StopWatcher()
-
-        unit_state.watch_resolved(callback)
-        yield unit_state.set_resolved(RETRY_HOOKS)
-        yield unit_state.clear_resolved()
-        yield self.poke_zk()
-
-        unit_state.watch_resolved(callback)
-        yield unit_state.set_resolved(NO_HOOKS)
-        yield unit_state.clear_resolved()
-
-        yield self.poke_zk()
-
-        self.assertEqual(len(results), 3)
-        self.assertIdentical(results.pop(0), False)
-        self.assertIdentical(results.pop(0), False)
-        self.assertEqual(results.pop(0).type_name, "created")
-
-        self.assertEqual(
-            (yield unit_state.get_resolved()), None)
-
-    @inlineCallbacks
-    def test_get_set_clear_relation_resolved(self):
-        """The a unit's realtions can be set to resolved to mark a
-        future transition, with an optional retry flag."""
-
-        unit_state = yield self.get_unit_state()
-
-        self.assertIdentical((yield unit_state.get_relation_resolved()), None)
-        yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
-
-        # Trying to set a conflicting raises an error
-        yield self.assertFailure(
-            unit_state.set_relation_resolved({"0": NO_HOOKS}),
-            ServiceUnitRelationResolvedAlreadyEnabled)
-
-        # Doing the same thing is fine
-        yield unit_state.set_relation_resolved({"0": RETRY_HOOKS}),
-
-        # Its fine to put in new values
-        yield unit_state.set_relation_resolved({"21": RETRY_HOOKS})
-        yield self.assertEqual(
-            (yield unit_state.get_relation_resolved()),
-            {"0": RETRY_HOOKS, "21": RETRY_HOOKS})
-
-        yield unit_state.clear_relation_resolved()
-        self.assertIdentical((yield unit_state.get_relation_resolved()), None)
-        yield unit_state.clear_relation_resolved()
-
-        yield self.assertFailure(
-            unit_state.set_relation_resolved(True), ValueError)
-        yield self.assertFailure(
-            unit_state.set_relation_resolved(None), ValueError)
-
-    @inlineCallbacks
-    def test_watch_relation_resolved(self):
-        """A unit resolved watch can be instituted on a permanent basis."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-
-        unit_state.watch_relation_resolved(callback)
-        yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
-        yield unit_state.clear_relation_resolved()
-        yield unit_state.set_relation_resolved({"0": NO_HOOKS})
-
-        yield self.poke_zk()
-
-        self.assertEqual(len(results), 4)
-        self.assertIdentical(results.pop(0), False)
-        self.assertEqual(results.pop(0).type_name, "created")
-        self.assertEqual(results.pop(0).type_name, "deleted")
-        self.assertEqual(results.pop(0).type_name, "created")
-
-        self.assertEqual(
-            (yield unit_state.get_relation_resolved()),
-            {"0": NO_HOOKS})
-
-    @inlineCallbacks
-    def test_watch_relation_resolved_processes_current_state(self):
-        """The watch method returns only after processing the current state."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        @inlineCallbacks
-        def callback(value):
-            results.append((yield unit_state.get_relation_resolved()))
-        yield unit_state.watch_relation_resolved(callback)
-        self.assertTrue(results)
-
-    @inlineCallbacks
-    def test_stop_watch_relation_resolved(self):
-        """A unit resolved watch can be instituted on a permanent basis."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-
-            if len(results) == 1:
-                raise StopWatcher()
-
-            if len(results) == 3:
-                raise StopWatcher()
-
-        unit_state.watch_relation_resolved(callback)
-        yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
-        yield unit_state.clear_relation_resolved()
-        yield self.poke_zk()
-        self.assertEqual(len(results), 1)
-
-        unit_state.watch_relation_resolved(callback)
-        yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
-        yield unit_state.clear_relation_resolved()
-        yield self.poke_zk()
-        self.assertEqual(len(results), 3)
-        self.assertIdentical(results.pop(0), False)
-        self.assertIdentical(results.pop(0), False)
-        self.assertEqual(results.pop(0).type_name, "created")
-
-        self.assertEqual(
-            (yield unit_state.get_relation_resolved()), None)
-
-    @inlineCallbacks
-    def test_watch_resolved_slow_callback(self):
-        """A slow watch callback is still invoked serially."""
-        unit_state = yield self.get_unit_state()
-
-        callbacks = [Deferred() for i in range(5)]
-        results = []
-        contents = []
-
-        @inlineCallbacks
-        def watch(value):
-            results.append(value)
-            yield callbacks[len(results) - 1]
-            contents.append((yield unit_state.get_resolved()))
-
-        callbacks[0].callback(True)
-        yield unit_state.watch_resolved(watch)
-
-        # These get collapsed into a single event
-        yield unit_state.set_resolved(RETRY_HOOKS)
-        yield unit_state.clear_resolved()
-        yield self.poke_zk()
-
-        # Verify the callback hasn't completed
-        self.assertEqual(len(results), 2)
-        self.assertEqual(len(contents), 1)
-
-        # Let it finish
-        callbacks[1].callback(True)
-        yield self.poke_zk()
-
-        # Verify result counts
-        self.assertEqual(len(results), 3)
-        self.assertEqual(len(contents), 2)
-
-        # Verify result values. Even though we have created event, the
-        # setting retrieved shows the hook is not enabled.
-        self.assertEqual(results[-1].type_name, "deleted")
-        self.assertEqual(contents[-1], None)
-
-        yield unit_state.set_resolved(NO_HOOKS)
-        callbacks[2].callback(True)
-        yield self.poke_zk()
-
-        self.assertEqual(len(results), 4)
-        self.assertEqual(contents[-1], {"retry": NO_HOOKS})
-
-        # Clear out any pending activity.
-        yield self.poke_zk()
-
-    @inlineCallbacks
-    def test_watch_relation_resolved_slow_callback(self):
-        """A slow watch callback is still invoked serially."""
-        unit_state = yield self.get_unit_state()
-
-        callbacks = [Deferred() for i in range(5)]
-        results = []
-        contents = []
-
-        @inlineCallbacks
-        def watch(value):
-            results.append(value)
-            yield callbacks[len(results) - 1]
-            contents.append((yield unit_state.get_relation_resolved()))
-
-        callbacks[0].callback(True)
-        yield unit_state.watch_relation_resolved(watch)
-
-        # These get collapsed into a single event
-        yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
-        yield unit_state.clear_relation_resolved()
-        yield self.poke_zk()
-
-        # Verify the callback hasn't completed
-        self.assertEqual(len(results), 2)
-        self.assertEqual(len(contents), 1)
-
-        # Let it finish
-        callbacks[1].callback(True)
-        yield self.poke_zk()
-
-        # Verify result counts
-        self.assertEqual(len(results), 3)
-        self.assertEqual(len(contents), 2)
-
-        # Verify result values. Even though we have created event, the
-        # setting retrieved shows the hook is not enabled.
-        self.assertEqual(results[-1].type_name, "deleted")
-        self.assertEqual(contents[-1], None)
-
-        yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
-        callbacks[2].callback(True)
-        yield self.poke_zk()
-
-        self.assertEqual(len(results), 4)
-        self.assertEqual(contents[-1], {"0": RETRY_HOOKS})
-
-        # Clear out any pending activity.
-        yield self.poke_zk()
-
-    @inlineCallbacks
-    def test_set_and_clear_upgrade_flag(self):
-        """An upgrade flag can be set on a unit."""
-
-        # Defaults to false
-        unit_state = yield self.get_unit_state()
-        upgrade_flag = yield unit_state.get_upgrade_flag()
-        self.assertEqual(upgrade_flag, False)
-
-        # Can be set
-        yield unit_state.set_upgrade_flag()
-        upgrade_flag = yield unit_state.get_upgrade_flag()
-        self.assertEqual(upgrade_flag, {'force': False})
-
-        # Attempting to set multiple times is an error if the values
-        # differ.
-        yield self.assertFailure(
-            unit_state.set_upgrade_flag(force=True),
-            ServiceUnitUpgradeAlreadyEnabled)
-        self.assertEqual(upgrade_flag, {'force': False})
-
-        # Can be cleared
-        yield unit_state.clear_upgrade_flag()
-        upgrade_flag = yield unit_state.get_upgrade_flag()
-        self.assertEqual(upgrade_flag, False)
-
-        # Can be cleared multiple times
-        yield unit_state.clear_upgrade_flag()
-        upgrade_flag = yield unit_state.get_upgrade_flag()
-        self.assertEqual(upgrade_flag, False)
-
-        # A empty node present is not problematic
-        yield self.client.create(unit_state._upgrade_flag_path, "")
-        upgrade_flag = yield unit_state.get_upgrade_flag()
-        self.assertEqual(upgrade_flag, False)
-
-        yield unit_state.set_upgrade_flag(force=True)
-        upgrade_flag = yield unit_state.get_upgrade_flag()
-        self.assertEqual(upgrade_flag, {"force": True})
-
-    @inlineCallbacks
-    def test_watch_upgrade_flag_once(self):
-        """An upgrade watch can be set to notified of presence and changes."""
-        unit_state = yield self.get_unit_state()
-        yield unit_state.set_upgrade_flag()
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-
-        unit_state.watch_upgrade_flag(callback, permanent=False)
-        yield unit_state.clear_upgrade_flag()
-        yield unit_state.set_upgrade_flag(force=True)
-        yield self.sleep(0.1)
-        yield self.poke_zk()
-        self.assertEqual(len(results), 2)
-        self.assertIdentical(results.pop(0), True)
-        self.assertIdentical(results.pop().type_name, "deleted")
-
-        self.assertEqual(
-            (yield unit_state.get_upgrade_flag()),
-            {'force': True})
-
-    @inlineCallbacks
-    def test_watch_upgrade_processes_current_state(self):
-        unit_state = yield self.get_unit_state()
-        results = []
-
-        @inlineCallbacks
-        def callback(value):
-            results.append((yield unit_state.get_upgrade_flag()))
-
-        yield unit_state.watch_upgrade_flag(callback)
-        self.assertTrue(results)
-
-    @inlineCallbacks
-    def test_watch_upgrade_flag_permanent(self):
-        """An upgrade watch can be instituted on a permanent basis."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-
-        yield unit_state.watch_upgrade_flag(callback)
-        self.assertTrue(results)
-        yield unit_state.set_upgrade_flag()
-        yield unit_state.clear_upgrade_flag()
-        yield unit_state.set_upgrade_flag()
-
-        yield self.poke_zk()
-
-        self.assertEqual(len(results), 4)
-        self.assertIdentical(results.pop(0), False)
-        self.assertIdentical(results.pop(0).type_name, "created")
-        self.assertIdentical(results.pop(0).type_name, "deleted")
-        self.assertIdentical(results.pop(0).type_name, "created")
-
-        self.assertEqual(
-            (yield unit_state.get_upgrade_flag()),
-            {'force': False})
-
-    @inlineCallbacks
-    def test_watch_upgrade_flag_waits_on_slow_callbacks(self):
-        """A slow watch callback is still invoked serially."""
-        unit_state = yield self.get_unit_state()
-
-        callbacks = [Deferred() for i in range(5)]
-        results = []
-        contents = []
-
-        @inlineCallbacks
-        def watch(value):
-            results.append(value)
-            yield callbacks[len(results) - 1]
-            contents.append((yield unit_state.get_upgrade_flag()))
-
-        yield callbacks[0].callback(True)
-        yield unit_state.watch_upgrade_flag(watch)
-
-        # These get collapsed into a single event
-        yield unit_state.set_upgrade_flag()
-        yield unit_state.clear_upgrade_flag()
-        yield self.poke_zk()
-
-        # Verify the callback hasn't completed
-        self.assertEqual(len(results), 2)
-        self.assertEqual(len(contents), 1)
-
-        # Let it finish
-        callbacks[1].callback(True)
-        yield self.poke_zk()
-
-        # Verify result counts
-        self.assertEqual(len(results), 3)
-        self.assertEqual(len(contents), 2)
-
-        # Verify result values. Even though we have created event, the
-        # setting retrieved shows the hook is not enabled.
-        self.assertEqual(results[-1].type_name, "deleted")
-        self.assertEqual(contents[-1], False)
-
-        yield unit_state.set_upgrade_flag()
-        yield self.poke_zk()
-
-        # Verify the callback hasn't completed
-        self.assertEqual(len(contents), 2)
-
-        callbacks[2].callback(True)
-        yield self.poke_zk()
-
-        # Verify values.
-        self.assertEqual(len(contents), 3)
-        self.assertEqual(results[-1].type_name, "created")
-        self.assertEqual(contents[-1], {'force': False})
-
-        # Clear out any pending activity.
-        yield self.poke_zk()
-
-    @inlineCallbacks
-    def test_enable_debug_hook(self):
-        """Unit hook debugging can be enabled on the unit state."""
-        unit_state = yield self.get_unit_state()
-        enabled = yield unit_state.enable_hook_debug(["*"])
-        self.assertIdentical(enabled, True)
-        content, stat = yield self.client.get(
-            "/units/%s/debug" % unit_state.internal_id)
-        data = yaml.load(content)
-        self.assertEqual(data, {"debug_hooks": ["*"]})
-
-    @inlineCallbacks
-    def test_enable_debug_multiple_named_hooks(self):
-        """Unit hook debugging can be enabled for multiple hooks."""
-        unit_state = yield self.get_unit_state()
-        enabled = yield unit_state.enable_hook_debug(
-            ["db-relation-broken", "db-relation-changed"])
-
-        self.assertIdentical(enabled, True)
-        content, stat = yield self.client.get(
-            "/units/%s/debug" % unit_state.internal_id)
-        data = yaml.load(content)
-        self.assertEqual(
-            data,
-            {"debug_hooks": ["db-relation-broken", "db-relation-changed"]})
-
-    @inlineCallbacks
-    def test_enable_debug_all_and_named_is_error(self):
-        """Unit hook debugging can be enabled for multiple hooks,
-        but only if they are all named hooks."""
-        unit_state = yield self.get_unit_state()
-
-        error = yield self.assertFailure(
-            unit_state.enable_hook_debug(["*", "db-relation-changed"]),
-            ValueError)
-        self.assertEquals(
-            str(error),
-            "Ambigious to debug all hooks and named hooks "
-            "['*', 'db-relation-changed']")
-
-    @inlineCallbacks
-    def test_enable_debug_requires_sequence(self):
-        """The enable hook debug only accepts a sequences of names.
-        """
-        unit_state = yield self.get_unit_state()
-
-        error = yield self.assertFailure(
-            unit_state.enable_hook_debug(None),
-            AssertionError)
-        self.assertEquals(str(error), "Hook names must be a list: got None")
-
-    @inlineCallbacks
-    def test_enable_named_debug_hook(self):
-        """Unit hook debugging can be enabled on for a named hook."""
-        unit_state = yield self.get_unit_state()
-        enabled = yield unit_state.enable_hook_debug(
-            ["db-relation-changed"])
-        self.assertIdentical(enabled, True)
-        content, stat = yield self.client.get(
-            "/units/%s/debug" % unit_state.internal_id)
-        data = yaml.load(content)
-        self.assertEqual(data, {"debug_hooks": ["db-relation-changed"]})
-
-    @inlineCallbacks
-    def test_enable_debug_hook_pre_existing(self):
-        """Attempting to enable debug on a unit state already being debugged
-        raises an exception.
-        """
-        unit_state = yield self.get_unit_state()
-        yield unit_state.enable_hook_debug(["*"])
-        error = yield self.assertFailure(unit_state.enable_hook_debug(["*"]),
-                                         ServiceUnitDebugAlreadyEnabled)
-        self.assertEquals(
-            str(error), "Service unit 'wordpress/0' is already in debug mode.")
-
-    @inlineCallbacks
-    def test_enable_debug_hook_lifetime(self):
-        """A debug hook setting is only active for the lifetime of the client
-        that created it.
-        """
-        unit_state = yield self.get_unit_state()
-        yield unit_state.enable_hook_debug(["*"])
-        exists = yield self.client.exists(
-            "/units/%s/debug" % unit_state.internal_id)
-        self.assertTrue(exists)
-        yield self.client.close()
-        self.client = self.get_zookeeper_client()
-        yield self.client.connect()
-        exists = yield self.client.exists(
-            "/units/%s/debug" % unit_state.internal_id)
-        self.assertFalse(exists)
-
-    @inlineCallbacks
-    def test_watch_debug_hook_once(self):
-        """A watch can be set to notified of presence and changes."""
-        unit_state = yield self.get_unit_state()
-        yield unit_state.enable_hook_debug(["*"])
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-
-        yield unit_state.watch_hook_debug(callback, permanent=False)
-        yield unit_state.clear_hook_debug()
-        yield unit_state.enable_hook_debug(["*"])
-        yield self.poke_zk()
-        self.assertEqual(len(results), 2)
-        self.assertIdentical(results.pop(0), True)
-        self.assertIdentical(results.pop().type_name, "deleted")
-
-        self.assertEqual(
-            (yield unit_state.get_hook_debug()),
-            {"debug_hooks": ["*"]})
-
-    @inlineCallbacks
-    def test_watch_debug_hook_processes_current_state(self):
-        """A hook debug watch can be instituted on a permanent basis."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        @inlineCallbacks
-        def callback(value):
-            results.append((yield unit_state.get_hook_debug()))
-
-        yield unit_state.watch_hook_debug(callback)
-        self.assertTrue(results)
-
-    @inlineCallbacks
-    def test_watch_debug_hook_permanent(self):
-        """A hook debug watch can be instituted on a permanent basis."""
-        unit_state = yield self.get_unit_state()
-
-        results = []
-
-        def callback(value):
-            results.append(value)
-
-        yield unit_state.watch_hook_debug(callback)
-        yield unit_state.enable_hook_debug(["*"])
-        yield unit_state.clear_hook_debug()
-        yield unit_state.enable_hook_debug(["*"])
-
-        yield self.poke_zk()
-
-        self.assertEqual(len(results), 4)
-        self.assertIdentical(results.pop(0), False)
-        self.assertIdentical(results.pop(0).type_name, "created")
-        self.assertIdentical(results.pop(0).type_name, "deleted")
-        self.assertIdentical(results.pop(0).type_name, "created")
-
-        self.assertEqual(
-            (yield unit_state.get_hook_debug()),
-            {"debug_hooks": ["*"]})
-
-    @inlineCallbacks
-    def test_watch_debug_hook_waits_on_slow_callbacks(self):
-        """A slow watch callback is still invoked serially."""
-
-        unit_state = yield self.get_unit_state()
-
-        callbacks = [Deferred() for i in range(5)]
-        results = []
-        contents = []
-
-        @inlineCallbacks
-        def watch(value):
-            results.append(value)
-            yield callbacks[len(results) - 1]
-            contents.append((yield unit_state.get_hook_debug()))
-
-        callbacks[0].callback(True)  # Finish the current state processing
-        yield unit_state.watch_hook_debug(watch)
-
-        # These get collapsed into a single event
-        yield unit_state.enable_hook_debug(["*"])
-        yield unit_state.clear_hook_debug()
-        yield self.poke_zk()
-
-        # Verify the callback hasn't completed
-        self.assertEqual(len(results), 2)
-        self.assertEqual(len(contents), 1)
-
-        # Let it finish
-        callbacks[1].callback(True)
-        yield self.poke_zk()
-
-        # Verify result counts
-        self.assertEqual(len(results), 3)
-        self.assertEqual(len(contents), 2)
-
-        # Verify result values. Even though we have created event, the
-        # setting retrieved shows the hook is not enabled.
-        self.assertEqual(results[-1].type_name, "deleted")
-        self.assertEqual(contents[-1], None)
-
-        yield unit_state.enable_hook_debug(["*"])
-        yield self.poke_zk()
-
-        # Verify the callback hasn't completed
-        self.assertEqual(len(contents), 2)
-
-        callbacks[2].callback(True)
-        yield self.poke_zk()
-
-        # Verify values.
-        self.assertEqual(len(contents), 3)
-        self.assertEqual(results[-1].type_name, "created")
-        self.assertEqual(contents[-1], {"debug_hooks": ["*"]})
-
-        # Clear out any pending activity.
-        yield self.poke_zk()
-
-    @inlineCallbacks
-    def test_service_unit_agent(self):
-        """A service unit state has an associated unit agent."""
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        exists_d, watch_d = unit_state.watch_agent()
-        exists = yield exists_d
-        self.assertFalse(exists)
-        yield unit_state.connect_agent()
-        event = yield watch_d
-        self.assertEqual(event.type_name, "created")
-        self.assertEqual(event.path,
-                         "/units/%s/agent" % unit_state.internal_id)
-
-    @inlineCallbacks
-    def test_get_charm_id(self):
-        """A service unit knows its charm id"""
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        unit_charm = yield unit_state.get_charm_id()
-        service_charm = yield service_state.get_charm_id()
-        self.assertTrue(
-            (self.charm_state.id == unit_charm == service_charm))
-
-    @inlineCallbacks
-    def test_set_charm_id(self):
-        """A service unit charm can be set and is validated when set."""
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        yield self.assertFailure(
-            unit_state.set_charm_id("abc"), CharmURLError)
-        yield self.assertFailure(
-            unit_state.set_charm_id("abc:foobar-a"), CharmURLError)
-        yield self.assertFailure(
-            unit_state.set_charm_id(None), CharmURLError)
-        charm_id = "local:series/name-1"
-        yield unit_state.set_charm_id(charm_id)
-        value = yield unit_state.get_charm_id()
-        self.assertEqual(charm_id, value)
-
-    @inlineCallbacks
-    def test_add_unit_state_combines_constraints(self):
-        """Constraints are inherited both from juju defaults and service"""
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state,
-            dummy_cs.parse(["arch=arm", "mem=1G"]))
-        unit_state = yield service_state.add_unit_state()
-        constraints = yield unit_state.get_constraints()
-        expected = {
-            "arch": "arm", "cpu": 1, "mem": 1024,
-            "provider-type": "dummy", "ubuntu-series": "series"}
-        self.assertEquals(constraints, expected)
-
-    @inlineCallbacks
-    def test_unassign_unit_from_machine_without_being_assigned(self):
-        """
-        When unassigning a machine from a unit, it is possible that
-        the machine has not been previously assigned, or that it
-        was assigned but the state changed beneath us.  In either
-        case, the end state is the intended state, so we simply
-        move forward without any errors here, to avoid having to
-        handle the extra complexity of dealing with the concurrency
-        problems.
-        """
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-
-        yield unit_state.unassign_from_machine()
-
-        topology = yield self.get_topology()
-        self.assertEquals(
-            topology.get_service_unit_machine(service_state.internal_id,
-                                              unit_state.internal_id),
-            None)
-
-        machine_id = yield unit_state.get_assigned_machine_id()
-        self.assertEqual(machine_id, None)
-
-    @inlineCallbacks
-    def test_assign_unit_to_machine_again_fails(self):
-        """
-        Trying to assign a machine to an already assigned unit
-        should fail, unless we're assigning to precisely the same
-        machine, in which case it's no big deal.
-        """
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-        machine_state0 = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        machine_state1 = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-
-        yield unit_state.assign_to_machine(machine_state0)
-
-        # Assigning again to the same machine is a NOOP, so nothing
-        # terrible should happen if we let it go through.
-        yield unit_state.assign_to_machine(machine_state0)
-
-        try:
-            yield unit_state.assign_to_machine(machine_state1)
-        except ServiceUnitStateMachineAlreadyAssigned, e:
-            self.assertEquals(e.unit_name, "wordpress/0")
-        else:
-            self.fail("Error not raised")
-
-        machine_id = yield unit_state.get_assigned_machine_id()
-        self.assertEqual(machine_id, 0)
-
-    @inlineCallbacks
-    def test_unassign_unit_from_machine_with_changing_state(self):
-        service_state = yield self.service_state_manager.add_service_state(
-            "wordpress", self.charm_state, dummy_constraints)
-        unit_state = yield service_state.add_unit_state()
-
-        yield self.remove_service_unit(service_state.internal_id,
-                                       unit_state.internal_id)
-
-        d = unit_state.unassign_from_machine()
-        yield self.assertFailure(d, StateChanged)
-
-        d = unit_state.get_assigned_machine_id()
-        yield self.assertFailure(d, StateChanged)
-
-        yield self.remove_service(service_state.internal_id)
-
-        d = unit_state.unassign_from_machine()
-        yield self.assertFailure(d, StateChanged)
-
-        d = unit_state.get_assigned_machine_id()
-        yield self.assertFailure(d, StateChanged)
-
-    @inlineCallbacks
-    def test_assign_unit_to_unused_machine(self):
-        """Verify that unused machines can be assigned to when their machine
-        constraints match the service unit's."""
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        mysql_service_state = yield self.add_service_from_charm("mysql")
-        mysql_unit_state = yield mysql_service_state.add_unit_state()
-        mysql_machine_state = yield \
-            self.machine_state_manager.add_machine_state(series_constraints)
-        yield mysql_unit_state.assign_to_machine(mysql_machine_state)
-        yield self.service_state_manager.remove_service_state(
-            mysql_service_state)
-        wordpress_service_state = yield self.add_service_from_charm(
-            "wordpress")
-        wordpress_unit_state = yield wordpress_service_state.add_unit_state()
-        yield wordpress_unit_state.assign_to_unused_machine()
-        self.assertEqual(
-            (yield self.get_topology()).get_machines(),
-            ["machine-0000000000", "machine-0000000001"])
-        yield self.assert_machine_assignments("wordpress", [1])
-
-    @inlineCallbacks
-    def test_assign_unit_to_unused_machine_bad_constraints(self):
-        """Verify that unused machines do not get allocated service units with
-        non-matching constraints."""
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        mysql_service_state = yield self.add_service_from_charm("mysql")
-        mysql_unit_state = yield mysql_service_state.add_unit_state()
-        mysql_machine_state = yield \
-            self.machine_state_manager.add_machine_state(
-                series_constraints)
-        yield mysql_unit_state.assign_to_machine(mysql_machine_state)
-        yield self.service_state_manager.remove_service_state(
-            mysql_service_state)
-        other_constraints = dummy_cs.parse(["arch=arm"])
-        wordpress_service_state = yield self.add_service_from_charm(
-            "wordpress", constraints=other_constraints.with_series("series"))
-        wordpress_unit_state = yield wordpress_service_state.add_unit_state()
-        yield self.assertFailure(
-            wordpress_unit_state.assign_to_unused_machine(),
-            NoUnusedMachines)
-        self.assertEqual(
-            (yield self.get_topology()).get_machines(),
-            ["machine-0000000000", "machine-0000000001"])
-        yield self.assert_machine_assignments("wordpress", [None])
-
-    @inlineCallbacks
-    def test_assign_unit_to_unused_machine_with_changing_state_service(self):
-        """Verify `StateChanged` raised if service is manipulated during reuse.
-        """
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        mysql_service_state = yield self.add_service_from_charm("mysql")
-        mysql_unit_state = yield mysql_service_state.add_unit_state()
-        mysql_machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        yield mysql_unit_state.assign_to_machine(mysql_machine_state)
-        yield self.service_state_manager.remove_service_state(
-            mysql_service_state)
-        wordpress_service_state = yield self.add_service_from_charm(
-            "wordpress")
-        wordpress_unit_state = yield wordpress_service_state.add_unit_state()
-        yield self.remove_service(wordpress_service_state.internal_id)
-        yield self.assertFailure(
-            wordpress_unit_state.assign_to_unused_machine(), StateChanged)
-
-    @inlineCallbacks
-    def test_assign_unit_to_unused_machine_with_changing_state_service_unit(self):
-        "Verify `StateChanged` raised if unit is manipulated during reuse."""
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        mysql_service_state = yield self.add_service_from_charm("mysql")
-        mysql_unit_state = yield mysql_service_state.add_unit_state()
-        mysql_machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        yield mysql_unit_state.assign_to_machine(mysql_machine_state)
-        yield self.service_state_manager.remove_service_state(
-            mysql_service_state)
-        wordpress_service_state = yield self.add_service_from_charm(
-            "wordpress")
-        wordpress_unit_state = yield wordpress_service_state.add_unit_state()
-        yield self.remove_service_unit(
-            wordpress_service_state.internal_id,
-            wordpress_unit_state.internal_id)
-        yield self.assertFailure(
-            wordpress_unit_state.assign_to_unused_machine(), StateChanged)
-
-    @inlineCallbacks
-    def test_assign_unit_to_unused_machine_only_machine_zero(self):
-        """Verify when the only available machine is machine 0"""
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        wordpress_service_state = yield self.add_service_from_charm(
-            "wordpress")
-        wordpress_unit_state = yield wordpress_service_state.add_unit_state()
-        yield self.assertFailure(
-            wordpress_unit_state.assign_to_unused_machine(),
-            NoUnusedMachines)
-
-    @inlineCallbacks
-    def test_assign_unit_to_unused_machine_none_available(self):
-        """Verify when there are no unused machines"""
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        mysql_service_state = yield self.add_service_from_charm("mysql")
-        mysql_unit_state = yield mysql_service_state.add_unit_state()
-        mysql_machine_state = yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-        yield mysql_unit_state.assign_to_machine(mysql_machine_state)
-        yield self.assert_machine_assignments("mysql", [1])
-        wordpress_service_state = yield self.add_service_from_charm(
-            "wordpress")
-        wordpress_unit_state = yield wordpress_service_state.add_unit_state()
-        yield self.assertFailure(
-            wordpress_unit_state.assign_to_unused_machine(),
-            NoUnusedMachines)
-
-    @inlineCallbacks
-    def test_watch_relations_processes_current_state(self):
-        """
-        The watch method returns only after processing initial state.
-
-        Note the callback is only invoked if there are changes
-        requiring processing.
-        """
-        service_state = yield self.add_service("wordpress")
-        yield self.add_relation(
-            "rel-type", "global", [service_state, "name", "role"])
-
-        results = []
-
-        def callback(*args):
-            results.append(True)
-
-        yield service_state.watch_relation_states(callback)
-        self.assertTrue(results)
-
-    @inlineCallbacks
-    def test_watch_relations_when_being_created(self):
-        """
-        We can watch relations before we have any.
-        """
-        service_state = yield self.add_service("wordpress")
-
-        wait_callback = [Deferred() for i in range(5)]
-        calls = []
-
-        def watch_relations(old_relations, new_relations):
-            calls.append((old_relations, new_relations))
-            wait_callback[len(calls) - 1].callback(True)
-
-        # Start watching
-        service_state.watch_relation_states(watch_relations)
-
-        # Callback is still untouched
-        self.assertEquals(calls, [])
-
-        # add a service relation and wait for the callback
-        relation_state = yield self.add_relation(
-            "rel-type", "global", [service_state, "name", "role"])
-        yield wait_callback[1]
-
-        # verify the result
-        self.assertEquals(len(calls), 2)
-        old_relations, new_relations = calls[1]
-        self.assertFalse(old_relations)
-        self.assertEquals(new_relations[0].relation_role, "role")
-
-        # add a new relation with the service assigned to it.
-        relation_state2 = yield self.add_relation(
-            "rel-type2", "global", [service_state, "app", "server"])
-        yield wait_callback[2]
-
-        self.assertEquals(len(calls), 3)
-        old_relations, new_relations = calls[2]
-        self.assertEquals([r.internal_relation_id for r in old_relations],
-                          [relation_state.internal_id])
-        self.assertEquals([r.internal_relation_id for r in new_relations],
-                          [relation_state.internal_id,
-                           relation_state2.internal_id])
-
-    @inlineCallbacks
-    def test_watch_relations_may_defer(self):
-        """
-        The watch relations callback may return a deferred so that
-        it performs some its logic asynchronously. In this case, it must
-        not be called a second time before its postponed logic is finished
-        completely.
-        """
-        wait_callback = [Deferred() for i in range(5)]
-        finish_callback = [Deferred() for i in range(5)]
-
-        calls = []
-
-        def watch_relations(old_relations, new_relations):
-            calls.append((old_relations, new_relations))
-            wait_callback[len(calls) - 1].callback(True)
-            return finish_callback[len(calls) - 1]
-
-        service_state = yield self.add_service("s-1")
-        service_state.watch_relation_states(watch_relations)
-
-        # Shouldn't have any callbacks yet.
-        self.assertEquals(calls, [])
-
-        # Assign to a relation.
-        yield self.add_relation("rel-type", "global",
-                                (service_state, "name", "role"))
-
-        # Hold off until callback is started.
-        yield wait_callback[0]
-
-        # Assign to another relation.
-        yield self.add_relation("rel-type", "global",
-                          (service_state, "name2", "role"))
-
-        # Give a chance for something bad to happen.
-        yield self.sleep(0.3)
-
-        # Ensure we still have a single call.
-        self.assertEquals(len(calls), 1)
-
-        # Allow the first call to be completed, and wait on the
-        # next one.
-        finish_callback[0].callback(None)
-        yield wait_callback[1]
-        finish_callback[1].callback(None)
-
-        # We should have the second change now.
-        self.assertEquals(len(calls), 2)
-
-    @inlineCallbacks
-    def test_get_relation_endpoints_service_name(self):
-        """Test getting endpoints with descriptor ``<service name>``"""
-        yield self.add_service_from_charm("wordpress")
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-            "wordpress")),
-            [RelationEndpoint("wordpress", "varnish", "cache", "client"),
-            RelationEndpoint("wordpress", "mysql", "db", "client"),
-            RelationEndpoint("wordpress", "http", "url", "server"),
-            RelationEndpoint("wordpress", "juju-info", "juju-info", "server")])
-        yield self.add_service_from_charm("riak")
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-            "riak")),
-            [RelationEndpoint("riak", "http", "admin", "server"),
-            RelationEndpoint("riak", "http", "endpoint", "server"),
-            RelationEndpoint("riak", "riak", "ring", "peer"),
-            RelationEndpoint("riak", "juju-info", "juju-info", "server")])
-
-    @inlineCallbacks
-    def test_get_relation_endpoints_service_name_relation_name(self):
-        """Test getting endpoints with ``<service name:relation name>``"""
-        yield self.add_service_from_charm("wordpress")
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-            "wordpress:url")),
-            [RelationEndpoint("wordpress", "http", "url", "server"),
-            RelationEndpoint("wordpress", "juju-info", "juju-info", "server")])
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-            "wordpress:db")),
-            [RelationEndpoint("wordpress", "mysql", "db", "client"),
-            RelationEndpoint("wordpress", "juju-info", "juju-info", "server")])
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-            "wordpress:cache")),
-            [RelationEndpoint("wordpress", "varnish", "cache", "client"),
-            RelationEndpoint("wordpress", "juju-info", "juju-info", "server")])
-        yield self.add_service_from_charm("riak")
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-            "riak:ring")),
-            [RelationEndpoint("riak", "riak", "ring", "peer"),
-            RelationEndpoint("riak", "juju-info", "juju-info", "server")])
-
-    @inlineCallbacks
-    def test_descriptor_for_services_without_charms(self):
-        """Test with services that have no corresponding charms defined"""
-        yield self.add_service("nocharm")
-        # verify we get the implicit interface
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-                "nocharm")),
-                [RelationEndpoint("nocharm",
-                "juju-info", "juju-info", "server")])
-
-        self.assertEqual(
-            (yield self.service_state_manager.get_relation_endpoints(
-                "nocharm:nonsense")),
-                [RelationEndpoint("nocharm",
-                "juju-info", "juju-info", "server")])
-
-    @inlineCallbacks
-    def test_descriptor_for_missing_service(self):
-        """Test with a service that is not in the topology"""
-        yield self.assertFailure(
-            self.service_state_manager.get_relation_endpoints(
-                "notadded"),
-            ServiceStateNotFound)
-
-    @inlineCallbacks
-    def test_bad_descriptors(self):
-        """Test that the descriptors meet the minimum naming standards"""
-        yield self.assertFailure(
-            self.service_state_manager.get_relation_endpoints("a:b:c"),
-            BadDescriptor)
-        yield self.assertFailure(
-            self.service_state_manager.get_relation_endpoints(""),
-            BadDescriptor)
-
-    @inlineCallbacks
-    def test_join_descriptors_service_name(self):
-        """Test descriptor of the form ``<service name>`"""
-        yield self.add_service_from_charm("wordpress")
-        yield self.add_service_from_charm("mysql")
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "wordpress", "mysql")),
-            [(RelationEndpoint("wordpress", "mysql", "db", "client"),
-              RelationEndpoint("mysql", "mysql", "server", "server"))])
-        # symmetric - note the pair has rotated
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "mysql", "wordpress")),
-            [(RelationEndpoint("mysql", "mysql", "server", "server"),
-              RelationEndpoint("wordpress", "mysql", "db", "client"))])
-        yield self.add_service_from_charm("varnish")
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "wordpress", "varnish")),
-            [(RelationEndpoint("wordpress", "varnish", "cache", "client"),
-              RelationEndpoint("varnish", "varnish", "webcache", "server"))])
-
-    @inlineCallbacks
-    def test_join_descriptors_service_name_relation_name(self):
-        """Test joining descriptors ``<service name:relation name>``"""
-        yield self.add_service_from_charm("wordpress")
-        yield self.add_service_from_charm("mysql")
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "wordpress:db", "mysql")),
-            [(RelationEndpoint("wordpress", "mysql", "db", "client"),
-              RelationEndpoint("mysql", "mysql", "server", "server"))])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "mysql:server", "wordpress")),
-            [(RelationEndpoint("mysql", "mysql", "server", "server"),
-              RelationEndpoint("wordpress", "mysql", "db", "client"))])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "mysql:server", "wordpress:db")),
-            [(RelationEndpoint("mysql", "mysql", "server", "server"),
-              RelationEndpoint("wordpress", "mysql", "db", "client"))])
-
-        yield self.add_service_from_charm("varnish")
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "wordpress:cache", "varnish")),
-            [(RelationEndpoint("wordpress", "varnish", "cache", "client"),
-              RelationEndpoint("varnish", "varnish", "webcache", "server"))])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "wordpress:cache", "varnish:webcache")),
-            [(RelationEndpoint("wordpress", "varnish", "cache", "client"),
-              RelationEndpoint("varnish", "varnish", "webcache", "server"))])
-
-    @inlineCallbacks
-    def test_join_peer_descriptors(self):
-        """Test joining of peer relation descriptors"""
-        yield self.add_service_from_charm("riak")
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "riak", "riak")),
-            [(RelationEndpoint("riak", "riak", "ring", "peer"),
-              RelationEndpoint("riak", "riak", "ring", "peer"))])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "riak:ring", "riak")),
-            [(RelationEndpoint("riak", "riak", "ring", "peer"),
-              RelationEndpoint("riak", "riak", "ring", "peer"))])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "riak:ring", "riak:ring")),
-            [(RelationEndpoint("riak", "riak", "ring", "peer"),
-              RelationEndpoint("riak", "riak", "ring", "peer"))])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "riak:no-ring", "riak:ring")),
-            [])
-
-    @inlineCallbacks
-    def test_join_descriptors_no_common_relation(self):
-        """Test joining of descriptors that do not share a relation"""
-        yield self.add_service_from_charm("mysql")
-        yield self.add_service_from_charm("riak")
-        yield self.add_service_from_charm("wordpress")
-        yield self.add_service_from_charm("varnish")
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "mysql", "riak")),
-            [])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "mysql:server", "riak:ring")),
-            [])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "varnish", "mysql")),
-            [])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "riak:ring", "riak:admin")),
-            [])
-        self.assertEqual(
-            (yield self.service_state_manager.join_descriptors(
-                "riak", "wordpress")),
-            [])
-
-    @inlineCallbacks
-    def test_join_descriptors_no_service_state(self):
-        """Test joining of nonexistent services"""
-        yield self.add_service_from_charm("wordpress")
-        yield self.assertFailure(
-            self.service_state_manager.join_descriptors("wordpress", "nosuch"),
-            ServiceStateNotFound)
-        yield self.assertFailure(
-            self.service_state_manager.join_descriptors("notyet", "nosuch"),
-            ServiceStateNotFound)
-
-    @inlineCallbacks
-    def test_watch_services_initial_callback(self):
-        """Watch service processes initial state before returning.
-
-        Note the callback is only executed if there is some meaningful state
-        change.
-        """
-        results = []
-
-        def callback(*args):
-            results.append(True)
-
-        yield self.service_state_manager.watch_service_states(callback)
-        yield self.add_service("wordpress")
-        yield self.poke_zk()
-        self.assertTrue(results)
-
-    @inlineCallbacks
-    def test_watch_services_when_being_created(self):
-        """
-        It should be possible to start watching services even
-        before they are created.  In this case, the callback will
-        be made when it's actually introduced.
-        """
-        wait_callback = [Deferred() for i in range(10)]
-
-        calls = []
-
-        def watch_services(old_services, new_services):
-            calls.append((old_services, new_services))
-            wait_callback[len(calls) - 1].callback(True)
-
-        # Start watching.
-        self.service_state_manager.watch_service_states(watch_services)
-
-        # Callback is still untouched.
-        self.assertEquals(calls, [])
-
-        # Add a service, and wait for callback.
-        yield self.add_service("wordpress")
-        yield wait_callback[0]
-
-        # The first callback must have been fired, and it must have None
-        # as the first argument because that's the first service seen.
-        self.assertEquals(len(calls), 1)
-        old_services, new_services = calls[0]
-        self.assertEquals(old_services, set())
-        self.assertEquals(new_services, set(["wordpress"]))
-
-        # Add a service again.
-        yield self.add_service("mysql")
-        yield wait_callback[1]
-
-        # Now the watch callback must have been fired with two
-        # different service sets.  The old one, and the new one.
-        self.assertEquals(len(calls), 2)
-        old_services, new_services = calls[1]
-        self.assertEquals(old_services, set(["wordpress"]))
-        self.assertEquals(new_services, set(["mysql", "wordpress"]))
-
-    @inlineCallbacks
-    def test_watch_services_may_defer(self):
-        """
-        The watch services callback may return a deferred so that it
-        performs some of its logic asynchronously. In this case, it
-        must not be called a second time before its postponed logic
-        is finished completely.
-        """
-        wait_callback = [Deferred() for i in range(10)]
-        finish_callback = [Deferred() for i in range(10)]
-
-        calls = []
-
-        def watch_services(old_services, new_services):
-            calls.append((old_services, new_services))
-            wait_callback[len(calls) - 1].callback(True)
-            return finish_callback[len(calls) - 1]
-
-        # Start watching.
-        self.service_state_manager.watch_service_states(watch_services)
-
-        # Create the service.
-        yield self.add_service("wordpress")
-
-        # Hold off until callback is started.
-        yield wait_callback[0]
-
-        # Add another service.
-        yield self.add_service("mysql")
-
-        # Ensure we still have a single call.
-        self.assertEquals(len(calls), 1)
-
-        # Allow the first call to be completed, and wait on the
-        # next one.
-        finish_callback[0].callback(None)
-        yield wait_callback[1]
-        finish_callback[1].callback(None)
-
-        # We should have the second change now.
-        self.assertEquals(len(calls), 2)
-        old_services, new_services = calls[1]
-        self.assertEquals(old_services, set(["wordpress"]))
-        self.assertEquals(new_services, set(["mysql", "wordpress"]))
-
-    @inlineCallbacks
-    def test_watch_services_with_changing_topology(self):
-        """
-        If the topology changes in an unrelated way, the services
-        watch callback should not be called with two equal
-        arguments.
-        """
-        wait_callback = [Deferred() for i in range(10)]
-
-        calls = []
-
-        def watch_services(old_services, new_services):
-            calls.append((old_services, new_services))
-            wait_callback[len(calls) - 1].callback(True)
-
-        # Start watching.
-        self.service_state_manager.watch_service_states(watch_services)
-
-        # Callback is still untouched.
-        self.assertEquals(calls, [])
-
-        # Add a service, and wait for callback.
-        yield self.add_service("wordpress")
-        yield wait_callback[0]
-
-        # Now change the topology in an unrelated way.
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-
-        # Add a service again.
-        yield self.add_service("mysql")
-        yield wait_callback[1]
-
-        # But it *shouldn't* have happened.
-        self.assertEquals(len(calls), 2)
-
-    @inlineCallbacks
-    def test_watch_service_units_initial_callback(self):
-        """Watch service unit processes initial state before returning.
-
-        Note the callback is only executed if there is some meaningful state
-        change.
-        """
-        results = []
-
-        def callback(*args):
-            results.append(True)
-
-        service_state = yield self.add_service("wordpress")
-        yield service_state.watch_service_unit_states(callback)
-        yield service_state.add_unit_state()
-        yield self.poke_zk()
-        self.assertTrue(results)
-
-    @inlineCallbacks
-    def test_watch_service_units_when_being_created(self):
-        """
-        It should be possible to start watching service units even
-        before they are created.  In this case, the callback will be
-        made when it's actually introduced.
-        """
-        wait_callback = [Deferred() for i in range(10)]
-
-        calls = []
-
-        def watch_service_units(old_service_units, new_service_units):
-            calls.append((old_service_units, new_service_units))
-            wait_callback[len(calls) - 1].callback(True)
-
-        # Start watching.
-        service_state = yield self.add_service("wordpress")
-        service_state.watch_service_unit_states(watch_service_units)
-
-        # Callback is still untouched.
-        self.assertEquals(calls, [])
-
-        # Add a service unit, and wait for callback.
-        yield service_state.add_unit_state()
-
-        yield wait_callback[0]
-
-        # The first callback must have been fired, and it must have None
-        # as the first argument because that's the first service seen.
-        self.assertEquals(len(calls), 1)
-        old_service_units, new_service_units = calls[0]
-        self.assertEquals(old_service_units, set())
-        self.assertEquals(new_service_units, set(["wordpress/0"]))
-
-        # Add another service unit.
-        yield service_state.add_unit_state()
-        yield wait_callback[1]
-
-        # Now the watch callback must have been fired with two
-        # different service sets.  The old one, and the new one.
-        self.assertEquals(len(calls), 2)
-        old_service_units, new_service_units = calls[1]
-        self.assertEquals(old_service_units, set(["wordpress/0"]))
-        self.assertEquals(new_service_units, set(["wordpress/0", "wordpress/1"]))
-
-    @inlineCallbacks
-    def test_watch_service_units_may_defer(self):
-        """
-        The watch service units callback may return a deferred so that
-        it performs some of its logic asynchronously.  In this case,
-        it must not be called a second time before its postponed logic
-        is finished completely.
-        """
-        wait_callback = [Deferred() for i in range(10)]
-        finish_callback = [Deferred() for i in range(10)]
-
-        calls = []
-
-        def watch_service_units(old_service_units, new_service_units):
-            calls.append((old_service_units, new_service_units))
-            wait_callback[len(calls) - 1].callback(True)
-            return finish_callback[len(calls) - 1]
-
-        # Start watching.
-        service_state = yield self.add_service("wordpress")
-        service_state.watch_service_unit_states(watch_service_units)
-
-        # Create the service unit.
-        yield service_state.add_unit_state()
-
-        # Hold off until callback is started.
-        yield wait_callback[0]
-
-        # Add another service unit.
-        yield service_state.add_unit_state()
-
-        # Ensure we still have a single call.
-        self.assertEquals(len(calls), 1)
-
-        # Allow the first call to be completed, and wait on the
-        # next one.
-        finish_callback[0].callback(None)
-        yield wait_callback[1]
-        finish_callback[1].callback(None)
-
-        # We should have the second change now.
-        self.assertEquals(len(calls), 2)
-        old_service_units, new_service_units = calls[1]
-        self.assertEquals(old_service_units, set(["wordpress/0"]))
-        self.assertEquals(
-            new_service_units, set(["wordpress/0", "wordpress/1"]))
-
-    @inlineCallbacks
-    def test_watch_service_units_with_changing_topology(self):
-        """
-        If the topology changes in an unrelated way, the services
-        watch callback should not be called with two equal
-        arguments.
-        """
-        wait_callback = [Deferred() for i in range(10)]
-
-        calls = []
-
-        def watch_service_units(old_service_units, new_service_units):
-            calls.append((old_service_units, new_service_units))
-            wait_callback[len(calls) - 1].callback(True)
-
-        # Start watching.
-        service_state = yield self.add_service("wordpress")
-        service_state.watch_service_unit_states(watch_service_units)
-
-        # Callback is still untouched.
-        self.assertEquals(calls, [])
-
-        # Add a service, and wait for callback.
-        yield service_state.add_unit_state()
-        yield wait_callback[0]
-
-        # Now change the topology in an unrelated way.
-        yield self.machine_state_manager.add_machine_state(
-            series_constraints)
-
-        # Add a service again.
-        yield service_state.add_unit_state()
-        yield wait_callback[1]
-
-        # But it *shouldn't* have happened.
-        self.assertEquals(len(calls), 2)
-
-    @inlineCallbacks
-    def test_service_config_get_set(self):
-        """Validate that we can set and get service config options."""
-        wordpress = yield self.add_service_from_charm("wordpress")
-
-        # attempt to get the initialized service state
-        config = yield wordpress.get_config()
-
-        # the initial state is empty
-        self.assertEqual(config, {"blog-title": "My Title"})
-
-        # behaves as a normal dict
-        self.assertRaises(KeyError, config.__getitem__, "missing")
-
-        # various ways to set state
-        config.update(dict(alpha="beta", one="two"))
-        config["another"] = "value"
-
-        # write the values
-        yield config.write()
-
-        # we should be able to read the config and see the same values
-        # (in this case it would be the cached object)
-        config2 = yield wordpress.get_config()
-        self.assertEqual(config2, {"alpha": "beta",
-                                   "one": "two",
-                                   "another": "value",
-                                   "blog-title": "My Title"})
-
-        # now set a non-string value and recover it
-        config2["number"] = 1
-        config2["one"] = None
-        yield config2.write()
-
-        yield config.read()
-        self.assertEquals(config["number"], 1)
-        self.assertEquals(config["one"], None)
-
-    @inlineCallbacks
-    def test_service_config_get_returns_new(self):
-        """Validate that we can set and get service config options."""
-        wordpress = yield self.add_service_from_charm("wordpress")
-
-        # attempt to get the initialized service state
-        config = yield wordpress.get_config()
-        config.update({"foo": "bar"})
-        # Defaults come through
-        self.assertEqual(config, {"foo": "bar", "blog-title": "My Title"})
-
-        config2 = yield wordpress.get_config()
-        self.assertEqual(config2, {"blog-title": "My Title"})
-
-        yield config.write()
-        self.assertEqual(config, {"foo": "bar", "blog-title": "My Title"})
-
-        # Config2 is still empty (a different YAML State), with charm defaults.
-        self.assertEqual(config2, {"blog-title": "My Title"})
-
-        yield config2.read()
-        self.assertEqual(config, {"foo": "bar", "blog-title": "My Title"})
-
-        # The default was never written to storage.
-        data, stat = yield self.client.get(
-            "/services/%s/config" % wordpress.internal_id)
-        self.assertEqual(yaml.load(data), {"foo": "bar"})
-
-    @inlineCallbacks
-    def test_get_charm_state(self):
-        wordpress = yield self.add_service_from_charm("wordpress")
-        charm = yield wordpress.get_charm_state()
-
-        self.assertEqual(charm.name, "wordpress")
-        metadata = yield charm.get_metadata()
-        self.assertEqual(metadata.summary, "Blog engine")
+        @inlineCallbacks
+        def test_add_service(self):
+                """
+                Adding a service state should register it in zookeeper,
+                including the requested charm id.
+                """
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+                children = yield self.client.get_children("/services")
+
+                self.assertEquals(sorted(children),
+                                                  ["service-0000000000", "service-0000000001"])
+
+                content, stat = yield self.client.get("/services/service-0000000000")
+                details = yaml.load(content)
+                self.assertTrue(details)
+                self.assertEquals(details.get("charm"), "local:series/dummy-1")
+                self.assertFalse(isinstance(details.get("charm"), unicode))
+                self.assertEquals(details.get("constraints"), series_constraints.data)
+
+                topology = yield self.get_topology()
+                self.assertEquals(topology.find_service_with_name("wordpress"),
+                                                  "service-0000000000")
+                self.assertEquals(topology.find_service_with_name("mysql"),
+                                                  "service-0000000001")
+
+        @inlineCallbacks
+        def test_add_service_with_duplicated_name(self):
+                """
+                If a service is added with a duplicated name, a meaningful
+                error should be raised.
+                """
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+
+                try:
+                        yield self.service_state_manager.add_service_state(
+                                "wordpress", self.charm_state, dummy_constraints)
+                except ServiceStateNameInUse, e:
+                        self.assertEquals(e.service_name, "wordpress")
+                else:
+                        self.fail("Error not raised")
+
+        @inlineCallbacks
+        def test_get_service_and_check_attributes(self):
+                """
+                Getting a service state should be possible, and the service
+                state identification should be available through its
+                attributes.
+                """
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                self.assertEquals(service_state.service_name, "wordpress")
+                self.assertEquals(service_state.internal_id, "service-0000000000")
+
+        @inlineCallbacks
+        def test_get_service_not_found(self):
+                """
+                Getting a service state which is not available should errback
+                a meaningful error.
+                """
+                try:
+                        yield self.service_state_manager.get_service_state("wordpress")
+                except ServiceStateNotFound, e:
+                        self.assertEquals(e.service_name, "wordpress")
+                else:
+                        self.fail("Error not raised")
+
+        def test_get_unit_state(self):
+                """A unit state can be retrieved by name from the service manager."""
+                self.assertFailure(self.service_state_manager.get_unit_state(
+                        "wordpress/1"), ServiceStateNotFound)
+
+                self.assertFailure(self.service_state_manager.get_unit_state(
+                        "wordpress1"), ServiceUnitStateNotFound)
+
+                wordpress_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+
+                self.assertFailure(self.service_state_manager.get_unit_state(
+                        "wordpress/1"), ServiceUnitStateNotFound)
+
+                wordpress_unit = wordpress_state.add_unit_state()
+
+                unit_state = yield self.service_state_manager.get_unit_state(
+                                "wordpress/1")
+
+                self.assertEqual(unit_state.internal_id, wordpress_unit.internal_id)
+
+        @inlineCallbacks
+        def test_get_service_charm_id(self):
+                """
+                The service state should make its respective charm id available.
+                """
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                charm_id = yield service_state.get_charm_id()
+                self.assertEquals(charm_id, "local:series/dummy-1")
+
+        @inlineCallbacks
+        def test_set_service_charm_id(self):
+                """
+                The service state should allow its charm id to be set.
+                """
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                yield service_state.set_charm_id("local:series/dummy-2")
+                charm_id = yield service_state.get_charm_id()
+                self.assertEquals(charm_id, "local:series/dummy-2")
+
+        @inlineCallbacks
+        def test_get_service_constraints(self):
+                """The service state should make constraints available"""
+                initial_constraints = dummy_cs.parse(["cpu=256", "arch=amd64"])
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, initial_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                constraints = yield service_state.get_constraints()
+                self.assertEquals(
+                        constraints, initial_constraints.with_series("series"))
+
+        @inlineCallbacks
+        def test_get_service_constraints_inherits(self):
+                """The service constraints should be combined with the environment's"""
+                yield self.push_env_constraints("arch=arm", "cpu=32")
+                service_constraints = dummy_cs.parse(["cpu=256"])
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, service_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                constraints = yield service_state.get_constraints()
+                expected_base = dummy_cs.parse(["arch=arm", "cpu=256"])
+                self.assertEquals(constraints, expected_base.with_series("series"))
+
+        @inlineCallbacks
+        def test_get_missing_service_constraints(self):
+                """
+                Nodes created before the constraints mechanism was added should have
+                empty constraints.
+                """
+                yield self.client.delete("/constraints")
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                path = "/services/" + service_state.internal_id
+                node = YAMLState(self.client, path)
+                yield node.read()
+                del node["constraints"]
+                yield node.write()
+                constraints = yield service_state.get_constraints()
+                self.assertEquals(constraints.data, {})
+
+        @inlineCallbacks
+        def test_get_missing_unit_constraints(self):
+                """
+                Nodes created before the constraints mechanism was added should have
+                empty constraints.
+                """
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                unit_state = yield service_state.add_unit_state()
+                path = "/units/" + unit_state.internal_id
+                node = YAMLState(self.client, path)
+                yield node.read()
+                del node["constraints"]
+                yield node.write()
+                constraints = yield unit_state.get_constraints()
+                self.assertEquals(constraints.data, {})
+
+        @inlineCallbacks
+        def test_set_service_constraints(self):
+                """The service state should make constraints available for change"""
+                initial_constraints = dummy_cs.parse(["cpu=256", "arch=amd64"])
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, initial_constraints)
+                service_state = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                new_constraints = dummy_cs.parse(["mem=2G", "arch=arm"])
+                yield service_state.set_constraints(new_constraints)
+                retrieved_constraints = yield service_state.get_constraints()
+                self.assertEquals(
+                        retrieved_constraints, new_constraints.with_series("series"))
+
+        @inlineCallbacks
+        def test_remove_service_state(self):
+                """
+                A service state can be removed along with its relations, units,
+                and zookeeper state.
+                """
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+
+                relation_state = yield self.add_relation(
+                        "rel-type2", "global", [service_state, "app", "server"])
+
+                unit_state = yield service_state.add_unit_state()
+                machine_state = yield self.machine_state_manager.add_machine_state(
+                        series_constraints)
+                yield unit_state.assign_to_machine(machine_state)
+
+                yield self.service_state_manager.remove_service_state(service_state)
+
+                topology = yield self.get_topology()
+                self.assertFalse(topology.has_relation(relation_state.internal_id))
+                self.assertFalse(topology.has_service(service_state.internal_id))
+                self.assertFalse(
+                        topology.get_service_units_in_machine(machine_state.internal_id))
+
+                exists = yield self.client.exists(
+                        "/services/%s" % service_state.internal_id)
+                self.assertFalse(exists)
+
+        @inlineCallbacks
+        def test_add_service_unit_and_check_attributes(self):
+                """
+                A service state should enable adding a new service unit
+                under it, and again the unit should offer attributes allowing
+                its identification.
+                """
+                service_state0 = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state1 = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                unit_state0 = yield service_state0.add_unit_state()
+                unit_state1 = yield service_state1.add_unit_state()
+                unit_state2 = yield service_state0.add_unit_state()
+                unit_state3 = yield service_state1.add_unit_state()
+
+                children = yield self.client.get_children("/units")
+                self.assertEquals(sorted(children),
+                                                  ["unit-0000000000", "unit-0000000001",
+                                                   "unit-0000000002", "unit-0000000003"])
+
+                self.assertEquals(unit_state0.service_name, "wordpress")
+                self.assertEquals(unit_state0.internal_id, "unit-0000000000")
+                self.assertEquals(unit_state0.unit_name, "wordpress/0")
+
+                self.assertEquals(unit_state1.service_name, "mysql")
+                self.assertEquals(unit_state1.internal_id, "unit-0000000001")
+                self.assertEquals(unit_state1.unit_name, "mysql/0")
+
+                self.assertEquals(unit_state2.service_name, "wordpress")
+                self.assertEquals(unit_state2.internal_id, "unit-0000000002")
+                self.assertEquals(unit_state2.unit_name, "wordpress/1")
+
+                self.assertEquals(unit_state3.service_name, "mysql")
+                self.assertEquals(unit_state3.internal_id, "unit-0000000003")
+                self.assertEquals(unit_state3.unit_name, "mysql/1")
+
+                topology = yield self.get_topology()
+
+                self.assertTrue(
+                        topology.has_service_unit("service-0000000000",
+                                                                          "unit-0000000000"))
+                self.assertTrue(
+                        topology.has_service_unit("service-0000000001",
+                                                                          "unit-0000000001"))
+                self.assertTrue(
+                        topology.has_service_unit("service-0000000000",
+                                                                          "unit-0000000002"))
+                self.assertTrue(
+                        topology.has_service_unit("service-0000000001",
+                                                                          "unit-0000000003"))
+
+        def get_presence_path(
+                self, relation_state, relation_role, unit_state, container=None):
+                container = container.internal_id if container else None
+                presence_path = "/".join(filter(None, [
+                        "/relations",
+                        relation_state.internal_id,
+                        container,
+                        relation_role,
+                        unit_state.internal_id]))
+                return presence_path
+
+        @inlineCallbacks
+        def test_add_service_unit_with_container(self):
+                """
+                Validate adding units with containers specified and recovering that.
+                """
+                mysql_ep = RelationEndpoint("mysql", "juju-info", "juju-info",
+                                                                        "server", "global")
+                logging_ep = RelationEndpoint("logging", "juju-info", "juju-info",
+                                                                          "client", "container")
+
+                logging_charm_state = yield self.get_subordinate_charm()
+                self.assertTrue(logging_charm_state.is_subordinate())
+                log_state = yield self.service_state_manager.add_service_state(
+                        "logging", logging_charm_state, dummy_constraints)
+                mysql_state = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                relation_state, service_states = (yield
+                        self.relation_state_manager.add_relation_state(
+                                mysql_ep, logging_ep))
+
+                unit_state1 = yield mysql_state.add_unit_state()
+                unit_state0 = yield log_state.add_unit_state(container=unit_state1)
+
+                unit_state3 = yield mysql_state.add_unit_state()
+                unit_state2 = yield log_state.add_unit_state(container=unit_state3)
+
+                self.assertEquals((yield unit_state1.get_container()), None)
+                self.assertEquals((yield unit_state0.get_container()), unit_state1)
+                self.assertEquals((yield unit_state2.get_container()), unit_state3)
+                self.assertEquals((yield unit_state3.get_container()), None)
+
+                for unit_state in (unit_state1, unit_state3):
+                        yield unit_state.set_private_address(
+                                "%s.example.com" % (
+                                        unit_state.unit_name.replace("/", "-")))
+
+                # construct the proper relation state
+                mystate = pick_attr(service_states, relation_role="server")
+                logstate = pick_attr(service_states, relation_role="client")
+                yield logstate.add_unit_state(unit_state0)
+                yield logstate.add_unit_state(unit_state2)
+
+                yield mystate.add_unit_state(unit_state1)
+                yield mystate.add_unit_state(unit_state3)
+
+                @inlineCallbacks
+                def verify_container(relation_state, service_relation_state,
+                                                         unit_state, container):
+                        presence_path = self.get_presence_path(
+                                relation_state,
+                                service_relation_state.relation_role,
+                                unit_state,
+                                container)
+
+                        content, stat = yield self.client.get(presence_path)
+                        self.assertTrue(stat)
+                        self.assertEqual(content, '')
+                        # verify the node data on the relation role nodes
+                        role_path = os.path.dirname(presence_path)
+                        # role path
+                        content, stat = yield self.client.get(role_path)
+                        self.assertTrue(stat)
+                        node_info = yaml.load(content)
+
+                        self.assertEqual(
+                                node_info["name"],
+                                service_relation_state.relation_name)
+                        self.assertEqual(
+                                node_info["role"],
+                                service_relation_state.relation_role)
+
+                        settings_path = os.path.dirname(
+                                os.path.dirname(presence_path)) + "/settings/" + \
+                                        unit_state.internal_id
+                        content, stat = yield self.client.get(settings_path)
+                        self.assertTrue(stat)
+                        settings_info = yaml.load(content)
+
+                        # Verify that private address was set
+                        # we verify the content elsewhere
+                        self.assertTrue(settings_info["private-address"])
+
+                # verify all the units are constructed as expected
+                # first the client roles with another container
+                yield verify_container(relation_state, logstate,
+                                                           unit_state0, unit_state1)
+
+                yield verify_container(relation_state, logstate,
+                                                           unit_state2, unit_state3)
+
+                # and now the principals (which are their own relation containers)
+                yield verify_container(relation_state, logstate,
+                                                           unit_state0, unit_state1)
+
+                yield verify_container(relation_state, mystate,
+                                                           unit_state1, unit_state1)
+
+        @inlineCallbacks
+        def test_get_container_no_principal(self):
+                """Get container should handle no principal."""
+                mysql_ep = RelationEndpoint("mysql", "juju-info", "juju-info",
+                                                                        "server", "global")
+                logging_ep = RelationEndpoint("logging", "juju-info", "juju-info",
+                                                                          "client", "container")
+
+                logging_charm_state = yield self.get_subordinate_charm()
+                self.assertTrue(logging_charm_state.is_subordinate())
+                log_state = yield self.service_state_manager.add_service_state(
+                        "logging", logging_charm_state, dummy_constraints)
+                mysql_state = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                relation_state, service_states = (yield
+                        self.relation_state_manager.add_relation_state(
+                                mysql_ep, logging_ep))
+
+                unit_state1 = yield mysql_state.add_unit_state()
+                unit_state0 = yield log_state.add_unit_state(container=unit_state1)
+
+                unit_state3 = yield mysql_state.add_unit_state()
+                unit_state2 = yield log_state.add_unit_state(container=unit_state3)
+
+                self.assertEquals((yield unit_state1.get_container()), None)
+                self.assertEquals((yield unit_state0.get_container()), unit_state1)
+                self.assertEquals((yield unit_state2.get_container()), unit_state3)
+                self.assertEquals((yield unit_state3.get_container()), None)
+
+                # now remove a principal node and test again
+
+                yield mysql_state.remove_unit_state(unit_state1)
+                container = yield unit_state0.get_container()
+                self.assertEquals(container, None)
+
+                # the other pair is still fine
+                self.assertEquals((yield unit_state2.get_container()), unit_state3)
+                self.assertEquals((yield unit_state3.get_container()), None)
+
+
+        @inlineCallbacks
+        def test_add_service_unit_with_changing_state(self):
+                """
+                When adding a service unit, there's a chance that the
+                service will go away mid-way through.  Rather than blowing
+                up randomly, a nice error should be raised.
+                """
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+
+                yield self.remove_service(service_state.internal_id)
+
+                d = service_state.add_unit_state()
+                yield self.assertFailure(d, StateChanged)
+
+        @inlineCallbacks
+        def test_get_unit_names(self):
+                """A service's units names are retrievable."""
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+
+                expected_names = []
+                for i in range(3):
+                        unit_state = yield service_state.add_unit_state()
+                        expected_names.append(unit_state.unit_name)
+
+                unit_names = yield service_state.get_unit_names()
+                self.assertEqual(unit_names, expected_names)
+
+        @inlineCallbacks
+        def test_remove_service_unit(self):
+                """Removing a service unit removes all state associated.
+                """
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+
+                unit_state = yield service_state.add_unit_state()
+
+                # Assign to a machine
+                machine_state = yield self.machine_state_manager.add_machine_state(
+                        series_constraints)
+                yield unit_state.assign_to_machine(machine_state)
+                # Connect a unit agent
+                yield unit_state.connect_agent()
+
+                # Now try and destroy it.
+                yield service_state.remove_unit_state(unit_state)
+
+                # Verify destruction.
+                topology = yield self.get_topology()
+                self.assertTrue(topology.has_service(service_state.internal_id))
+                self.assertFalse(
+                        topology.has_service_unit(
+                                service_state.internal_id, unit_state.internal_id))
+
+                exists = yield self.client.exists("/units/%s" % unit_state.internal_id)
+                self.assertFalse(exists)
+
+        def test_remove_service_unit_nonexistant(self):
+                """Removing a non existant service unit, is fine."""
+
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                unit_state = yield service_state.add_unit_state()
+                yield service_state.remove_unit_state(unit_state)
+                yield service_state.remove_unit_state(unit_state)
+
+        @inlineCallbacks
+        def test_get_all_service_states(self):
+                services = yield self.service_state_manager.get_all_service_states()
+                self.assertFalse(services)
+
+                yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                services = yield self.service_state_manager.get_all_service_states()
+                self.assertEquals(len(services), 1)
+
+                yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+                services = yield self.service_state_manager.get_all_service_states()
+                self.assertEquals(len(services), 2)
+
+        @inlineCallbacks
+        def test_get_service_unit(self):
+                """
+                Getting back service units should be possible using the
+                user-oriented id.
+                """
+                service_state0 = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state1 = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                yield service_state0.add_unit_state()
+                yield service_state1.add_unit_state()
+                yield service_state0.add_unit_state()
+                yield service_state1.add_unit_state()
+
+                unit_state0 = yield service_state0.get_unit_state("wordpress/0")
+                unit_state1 = yield service_state1.get_unit_state("mysql/0")
+                unit_state2 = yield service_state0.get_unit_state("wordpress/1")
+                unit_state3 = yield service_state1.get_unit_state("mysql/1")
+
+                self.assertEquals(unit_state0.internal_id, "unit-0000000000")
+                self.assertEquals(unit_state1.internal_id, "unit-0000000001")
+                self.assertEquals(unit_state2.internal_id, "unit-0000000002")
+                self.assertEquals(unit_state3.internal_id, "unit-0000000003")
+
+                self.assertEquals(unit_state0.unit_name, "wordpress/0")
+                self.assertEquals(unit_state1.unit_name, "mysql/0")
+                self.assertEquals(unit_state2.unit_name, "wordpress/1")
+                self.assertEquals(unit_state3.unit_name, "mysql/1")
+
+        @inlineCallbacks
+        def test_get_all_unit_states(self):
+                service_state0 = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state1 = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                yield service_state0.add_unit_state()
+                yield service_state1.add_unit_state()
+                yield service_state0.add_unit_state()
+                yield service_state1.add_unit_state()
+
+                unit_state0 = yield service_state0.get_unit_state("wordpress/0")
+                unit_state1 = yield service_state1.get_unit_state("mysql/0")
+                unit_state2 = yield service_state0.get_unit_state("wordpress/1")
+                unit_state3 = yield service_state1.get_unit_state("mysql/1")
+
+                wordpress_units = yield service_state0.get_all_unit_states()
+                self.assertEquals(
+                        set(wordpress_units), set((unit_state0, unit_state2)))
+
+                mysql_units = yield service_state1.get_all_unit_states()
+                self.assertEquals(set(mysql_units), set((unit_state1, unit_state3)))
+
+        @inlineCallbacks
+        def test_get_all_unit_states_with_changing_state(self):
+                """
+                When getting the service unit states, there's a chance that
+                the service will go away mid-way through.  Rather than blowing
+                up randomly, a nice error should be raised.
+                """
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                yield service_state.add_unit_state()
+                unit_state = (yield service_state.get_all_unit_states())[0]
+                self.assertEqual(unit_state.unit_name, "wordpress/0")
+                yield self.remove_service(service_state.internal_id)
+                yield self.assertFailure(
+                        service_state.get_all_unit_states(), StateChanged)
+
+        @inlineCallbacks
+        def test_set_functions(self):
+                wordpress = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                mysql = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                s1 = yield self.service_state_manager.get_service_state(
+                        "wordpress")
+                s2 = yield self.service_state_manager.get_service_state(
+                        "mysql")
+                self.assertEquals(hash(s1), hash(wordpress))
+                self.assertEquals(hash(s2), hash(mysql))
+
+                self.assertNotEqual(s1, object())
+                self.assertNotEqual(s1, s2)
+
+                self.assertEquals(s1, wordpress)
+                self.assertEquals(s2, mysql)
+
+                us0 = yield wordpress.add_unit_state()
+                us1 = yield wordpress.add_unit_state()
+
+                unit_state0 = yield wordpress.get_unit_state("wordpress/0")
+                unit_state1 = yield wordpress.get_unit_state("wordpress/1")
+
+                self.assertEquals(us0, unit_state0)
+                self.assertEquals(us1, unit_state1)
+                self.assertEquals(hash(us1), hash(unit_state1))
+
+                self.assertNotEqual(us0, object())
+                self.assertNotEqual(us0, us1)
+
+        @inlineCallbacks
+        def test_get_service_unit_not_found(self):
+                """
+                Attempting to retrieve a non-existent service unit should
+                result in an errback.
+                """
+                service_state0 = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state1 = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                # Add some state in a different service to make it a little
+                # bit more prone to breaking in case of errors.
+                yield service_state1.add_unit_state()
+
+                try:
+                        yield service_state0.get_unit_state("wordpress/0")
+                except ServiceUnitStateNotFound, e:
+                        self.assertEquals(e.unit_name, "wordpress/0")
+                else:
+                        self.fail("Error not raised")
+
+        @inlineCallbacks
+        def test_get_set_public_address(self):
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                unit_state = yield service_state.add_unit_state()
+                self.assertEqual((yield unit_state.get_public_address()), None)
+                yield unit_state.set_public_address("example.foobar.com")
+                yield self.assertEqual(
+                        (yield unit_state.get_public_address()),
+                         "example.foobar.com")
+
+        @inlineCallbacks
+        def test_get_set_private_address(self):
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                unit_state = yield service_state.add_unit_state()
+                self.assertEqual((yield unit_state.get_private_address()), None)
+                yield unit_state.set_private_address("example.local")
+                yield self.assertEqual(
+                        (yield unit_state.get_private_address()),
+                         "example.local")
+
+        @inlineCallbacks
+        def test_get_service_unit_with_changing_state(self):
+                """
+                If a service is removed during operation, get_service_unit()
+                should raise a nice error.
+                """
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+
+                yield self.remove_service(service_state.internal_id)
+
+                d = service_state.get_unit_state("wordpress/0")
+                yield self.assertFailure(d, StateChanged)
+
+        @inlineCallbacks
+        def test_get_service_unit_with_bad_service_name(self):
+                """
+                Service unit names contain a service name embedded into
+                them.  The service name requested when calling get_unit_state()
+                must match that of the object being used.
+                """
+                service_state0 = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                service_state1 = yield self.service_state_manager.add_service_state(
+                        "mysql", self.charm_state, dummy_constraints)
+
+                # Add some state in a different service to make it a little
+                # bit more prone to breaking in case of errors.
+                yield service_state1.add_unit_state()
+
+                try:
+                        yield service_state0.get_unit_state("mysql/0")
+                except BadServiceStateName, e:
+                        self.assertEquals(e.expected_name, "wordpress")
+                        self.assertEquals(e.obtained_name, "mysql")
+                else:
+                        self.fail("Error not raised")
+
+        @inlineCallbacks
+        def test_assign_unit_to_machine(self):
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                unit_state = yield service_state.add_unit_state()
+                machine_state = yield self.machine_state_manager.add_machine_state(
+                        series_constraints)
+
+                yield unit_state.assign_to_machine(machine_state)
+
+                topology = yield self.get_topology()
+
+                self.assertEquals(
+                        topology.get_service_unit_machine(service_state.internal_id,
+                                                                                          unit_state.internal_id),
+                        machine_state.internal_id)
+
+        @inlineCallbacks
+        def test_assign_unit_to_machine_with_changing_state(self):
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                unit_state = yield service_state.add_unit_state()
+                machine_state = yield self.machine_state_manager.add_machine_state(
+                        series_constraints)
+
+                yield self.remove_service_unit(service_state.internal_id,
+                                                                           unit_state.internal_id)
+
+                d = unit_state.assign_to_machine(machine_state)
+                yield self.assertFailure(d, StateChanged)
+
+                yield self.remove_service(service_state.internal_id)
+
+                d = unit_state.assign_to_machine(machine_state)
+                yield self.assertFailure(d, StateChanged)
+
+        @inlineCallbacks
+        def test_unassign_unit_from_machine(self):
+                service_state = yield self.service_state_manager.add_service_state(
+                        "wordpress", self.charm_state, dummy_constraints)
+                unit_state = yield service_state.add_unit_state()
+                machine_state = yield self.machine_state_manager.add_machine_state(
+                        series_constraints)
+
+                yield unit_state.assign_to_machine(machine_state)
+                yield unit_state.unassign_from_machine()
+
+                topology = yield self.get_topology()
+
+                self.assertEquals(
+                        topology.get_service_unit_machine(service_state.internal_id,
+                                                                                          unit_state.internal_id),
+                        None)
+
+        @inlineCallbacks
+        def test_get_set_clear_resolved(self):
+                """The a unit can be set to resolved to mark a future transition, with
+                an optional retry flag."""
+
+                unit_state = yield self.get_unit_state()
+
+                self.assertIdentical((yield unit_state.get_resolved()), None)
+                yield unit_state.set_resolved(NO_HOOKS)
+
+                yield self.assertFailure(
+                        unit_state.set_resolved(NO_HOOKS),
+                        ServiceUnitResolvedAlreadyEnabled)
+                yield self.assertEqual(
+
+                                (yield unit_state.get_resolved()), {"retry": NO_HOOKS})
+
+                yield unit_state.clear_resolved()
+                self.assertIdentical((yield unit_state.get_resolved()), None)
+                yield unit_state.clear_resolved()
+
+                yield self.assertFailure(unit_state.set_resolved(None), ValueError)
+
+        @inlineCallbacks
+        def test_watch_resolved(self):
+                """A unit resolved watch can be instituted on a permanent basis."""
+                unit_state = yield self.get_unit_state()
+
+                results = []
+
+                def callback(value):
+                        results.append(value)
+
+                unit_state.watch_resolved(callback)
+                yield unit_state.set_resolved(RETRY_HOOKS)
+                yield unit_state.clear_resolved()
+                yield unit_state.set_resolved(NO_HOOKS)
+
+                yield self.poke_zk()
+
+                self.assertEqual(len(results), 4)
+                self.assertIdentical(results.pop(0), False)
+                self.assertEqual(results.pop(0).type_name, "created")
+                self.assertEqual(results.pop(0).type_name, "deleted")
+                self.assertEqual(results.pop(0).type_name, "created")
+
+                self.assertEqual(
+                        (yield unit_state.get_resolved()),
+                        {"retry": NO_HOOKS})
+
+        @inlineCallbacks
+        def test_watch_resolved_processes_current_state(self):
+                """The watch method processes the current state before returning."""
+                unit_state = yield self.get_unit_state()
+
+                results = []
+
+                @inlineCallbacks
+                def callback(value):
+                        results.append((yield unit_state.get_resolved()))
+
+                yield unit_state.watch_resolved(callback)
+                self.assertTrue(results)
+
+        @inlineCallbacks
+        def test_stop_watch_resolved(self):
+                """A unit resolved watch can be instituted on a permanent basis.
+
+                However the callback can raise StopWatcher at anytime to stop the watch
+                """
+                unit_state = yield self.get_unit_state()
+
+                results = []
+
+                def callback(value):
+                        results.append(value)
+                        if len(results) == 1:
+                                raise StopWatcher()
+                        if len(results) == 3:
+                                raise StopWatcher()
+
+                unit_state.watch_resolved(callback)
+                yield unit_state.set_resolved(RETRY_HOOKS)
+                yield unit_state.clear_resolved()
+                yield self.poke_zk()
+
+                unit_state.watch_resolved(callback)
+                yield unit_state.set_resolved(NO_HOOKS)
+                yield unit_state.clear_resolved()
+
+                yield self.poke_zk()
+
+                self.assertEqual(len(results), 3)
+                self.assertIdentical(results.pop(0), False)
+                self.assertIdentical(results.pop(0), False)
+                self.assertEqual(results.pop(0).type_name, "created")
+
+                self.assertEqual(
+                        (yield unit_state.get_resolved()), None)
+
+        @inlineCallbacks
+        def test_get_set_clear_relation_resolved(self):
+                """The a unit's realtions can be set to resolved to mark a
+                future transition, with an optional retry flag."""
+
+                unit_state = yield self.get_unit_state()
+
+                self.assertIdentical((yield unit_state.get_relation_resolved()), None)
+                yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
+
+                # Trying to set a conflicting raises an error
+                yield self.assertFailure(
+                        unit_state.set_relation_resolved({"0": NO_HOOKS}),
+                        ServiceUnitRelationResolvedAlreadyEnabled)
+
+                # Doing the same thing is fine
+                yield unit_state.set_relation_resolved({"0": RETRY_HOOKS}),
+
+                # Its fine to put in new values
+                yield unit_state.set_relation_resolved({"21": RETRY_HOOKS})
+                yield self.assertEqual(
+                        (yield unit_state.get_relation_resolved()),
+                        {"0": RETRY_HOOKS, "21": RETRY_HOOKS})
+
+                yield unit_state.clear_relation_resolved()
+                self.assertIdentical((yield unit_state.get_relation_resolved()), None)
+                yield unit_state.clear_relation_resolved()
+
+                yield self.assertFailure(
+                        unit_state.set_relation_resolved(True), ValueError)
+                yield self.assertFailure(
+                        unit_state.set_relation_resolved(None), ValueError)
+
+        @inlineCallbacks
+        def test_watch_relation_resolved(self):
+                """A unit resolved watch can be instituted on a permanent basis."""
+                unit_state = yield self.get_unit_state()
+
+                results = []
+
+                def callback(value):
+                        results.append(value)
+
+                unit_state.watch_relation_resolved(callback)
+                yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
+                yield unit_state.clear_relation_resolved()
+                yield unit_state.set_relation_resolved({"0": NO_HOOKS})
+
+                yield self.poke_zk()
+
+                self.assertEqual(len(results), 4)
+                self.assertIdentical(results.pop(0), False)
+                self.assertEqual(results.pop(0).type_name, "created")
+                self.assertEqual(results.pop(0).type_name, "deleted")
+                self.assertEqual(results.pop(0).type_name, "created")
+
+                self.assertEqual(
+                        (yield unit_state.get_relation_resolved()),
+                        {"0": NO_HOOKS})
+
+        @inlineCallbacks
+        def test_watch_relation_resolved_processes_current_state(self):
+                """The watch method returns only after processing the current state."""
+                unit_state = yield self.get_unit_state()
+
+                results = []
+
+                @inlineCallbacks
+                def callback(value):
+                        results.append((yield unit_state.get_relation_resolved()))
+                yield unit_state.watch_relation_resolved(callback)
+                self.assertTrue(results)
+
+        @inlineCallbacks
+        def test_stop_watch_relation_resolved(self):
+                """A unit resolved watch can be instituted on a permanent basis."""
+                unit_state = yield self.get_unit_state()
+
+                results = []
+
+                def callback(value):
+                        results.append(value)
+
+                        if len(results) == 1:
+                                raise StopWatcher()
+
+                        if len(results) == 3:
+                                raise StopWatcher()
+
+                unit_state.watch_relation_resolved(callback)
+                yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
+                yield unit_state.clear_relation_resolved()
+                yield self.poke_zk()
+                self.assertEqual(len(results), 1)
+
+                unit_state.watch_relation_resolved(callback)
+                yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
+                yield unit_state.clear_relation_resolved()
+                yield self.poke_zk()
+                self.assertEqual(len(results), 3)
+                self.assertIdentical(results.pop(0), False)
+                self.assertIdentical(results.pop(0), False)
+                self.assertEqual(results.pop(0).type_name, "created")
+
+                self.assertEqual(
+                        (yield unit_state.get_relation_resolved()), None)
+
+        @inlineCallbacks
+        def test_watch_resolved_slow_callback(self):
+                """A slow watch callback is still invoked serially."""
+                unit_state = yield self.get_unit_state()
+
+                callbacks = [Deferred() for i in range(5)]
+                results = []
+                contents = []
+
+                @inlineCallbacks
+                def watch(value):
+                        results.append(value)
+                        yield callbacks[len(results) - 1]
+                        contents.append((yield unit_state.get_resolved()))
+
+                callbacks[0].callback(True)
+                yield unit_state.watch_resolved(watch)
+
+                # These get collapsed into a single event
+                yield unit_state.set_resolved(RETRY_HOOKS)
+                yield unit_state.clear_resolved()
+                yield self.poke_zk()
+
+                # Verify the callback hasn't completed
+                self.assertEqual(len(results), 2)
+                self.assertEqual(len(contents), 1)
+
+                # Let it finish
+                callbacks[1].callback(True)
+                yield self.poke_zk()
+
+                # Verify result counts
+                self.assertEqual(len(results), 3)
+                self.assertEqual(len(contents), 2)
+
+                # Verify result values. Even though we have created event, the
+                # setting retrieved shows the hook is not enabled.
+                self.assertEqual(results[-1].type_name, "deleted")
+                self.assertEqual(contents[-1], None)
+
+                yield unit_state.set_resolved(NO_HOOKS)
+                callbacks[2].callback(True)
+                yield self.poke_zk()
+
+                self.assertEqual(len(results), 4)
+                self.assertEqual(contents[-1], {"retry": NO_HOOKS})
+
+                # Clear out any pending activity.
+                yield self.poke_zk()
+
+        @inlineCallbacks
+        def test_watch_relation_resolved_slow_callback(self):
+                """A slow watch callback is still invoked serially."""
+                unit_state = yield self.get_unit_state()
+
+                callbacks = [Deferred() for i in range(5)]
+                results = []
+                contents = []
+
+                @inlineCallbacks
+                def watch(value):
+                        results.append(value)
+                        yield callbacks[len(results) - 1]
+                        contents.append((yield unit_state.get_relation_resolved()))
+
+                callbacks[0].callback(True)
+                yield unit_state.watch_relation_resolved(watch)
+
+                # These get collapsed into a single event
+                yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
+                yield unit_state.clear_relation_resolved()
+                yield self.poke_zk()
+
+                # Verify the callback hasn't completed
+                self.assertEqual(len(results), 2)
+                self.assertEqual(len(contents), 1)
+
+                # Let it finish
+                callbacks[1].callback(True)
+                yield self.poke_zk()
+
+                # Verify result counts
+                self.assertEqual(len(results), 3)
+                self.assertEqual(len(contents), 2)
+
+                # Verify result values. Even though we have created event, the
+                # setting retrieved shows the hook is not enabled.
+                self.assertEqual(results[-1].type_name, "deleted")
+                self.assertEqual(contents[-1], None)
+
+                yield unit_state.set_relation_resolved({"0": RETRY_HOOKS})
+                callbacks[2].callback(True)
+                yield self.poke_zk()
+
+                self.assertEqual(len(results), 4)
+                self.assertEqual(contents[-1], {"0": RETRY_HOOKS})
+
+                # Clear out any pending activity.
+                yield self.poke_zk()
+
+        @inlineCallbacks
+        def test_set_and_clear_upgrade_flag(self):
+                """An upgrade flag can be set on a unit."""
+
+                # Defaults to false
+                unit_state = yield self.get_unit_state()
+                upgrade_flag = yield unit_state.get_upgrade_flag()
+                self.assertEqual(upgrade_flag, False)
+
+                # Can be set
+                yield unit_state.set_upgrade_flag()
+                upgrade_flag = yield unit_state.get_upgrade_flag()
+                self.assertEqual(upgrade_flag, {'force': False})
+
+                # Attempting to set multiple times is an error if the values
+                # differ.
+                yield self.assertFailure(
+                        unit_state.set_upgrade_flag(force=True),
+                        ServiceUnitUpgradeAlreadyEnabled)
+                self.assertEqual(upgrade_flag, {'force': False})
+
+                # Can be cleared
+                yield unit_state.clear_upgrade_flag()
+                upgrade_flag = yield unit_state.get_upgrade_flag()
+                self.assertEqual(upgrade_flag, False)
+
+                # Can be cleared multiple times
+                yield unit_state.clear_upgrade_flag()
+                upgrade_flag = yield unit_state.get_upgrade_flag()
+                self.assertEqual(upgrade_flag, False)
+
+                # A empty node present is not problematic
+                yield self.client.create(unit_state._upgrade_flag_path, "")
+                upgrade_flag = yield unit_state.get_upgrade_flag()
+                self.assertEqual(upgrade_flag, False)
+
+                yield unit_state.set_upgrade_flag(force=True)
+                upgrade_flag = yield unit_state.get_upgrade_flag()
+                self.assertEqual(upgrade_flag, {"force": True})
+
+        @inlineCallbacks
+        def test_watch_upgrade_flag_once(self):
+                """An upgrade watch can be set to notified of presence and changes."""
+                unit_state = yield self.get_unit_state()
+                yield unit_state.set_upgrade_flag()
+
+                results = []
+