Merge lp:~bcsaller/pyjuju/ensemble-status into lp:pyjuju

[Benjamin Saller]

This is being pushed for a sanity check. I think its generally fine, but lacks the addition of machine instance/dns level data that makes using the status information useful. Feedback welcome.

[Gustavo Niemeyer (niemeyer)]

A few initial comments:

[1]

+import pydot

I suggest making the dependency on this optional, by importing it inside the
specific method which depends on it and erroring out with a nice message in
case it's missing.

[2]

+ topology = yield service_manager._read_topology()

This is a private method, and the raw topology information has been private
so far. I'm not sure if we should simply expose it, or if we should instead
use the public API which already exists. Either way, let's not poke the
internals like this on the final merge.

Let's talk about it live to figure a good approach.

[3]

100 + # pretend to use an api rather than topology._state
101 + # directly

Let's talk about [2] before spending time with this, but the topology has
a proper interface. That's poking the internals of the internals. The
internals of the Topology, including the format of its dictionary, should
not be used anywhere else besides its own implementation. Its interface
gives access to everything stored in there, with proper namings and
conventions.

[4]

70 + """
71 + Output status information about a deployment.
72 + """
(...)
129 + """ walk the topology state looking for all the interesting names
130 + (as defined in filters) returning the state mapping with only the

Please use the agreed convention for comments.

144 + # walk state collecting names
145 + # collect services and units
(...)
166 + #now take the list of valid names and paths and pluck them from
167 + #the source data

Also proper capitalized/spaced comments on these.

review: Needs Fixing

[Gustavo Niemeyer (niemeyer)]

Btw, in terms of poking at internals, this might be useful feedback:

http://blog.labix.org/2009/05/15/class-member-access-control-enforcement-vs-convention
http://blog.labix.org/2010/11/09/interfaces-and-the-design-of-software

[lp:~bcsaller/pyjuju/ensemble-status]

118. By Benjamin Saller on 2011-01-12

cleaned up dot rendering with clusters, added more complex topography

119. By Benjamin Saller on 2011-01-19

changes to support iteration over state managers

120. By Benjamin Saller on 2011-01-20

checkpoint status work

still issues with machine assignment and relation endpoint reporting

121. By Benjamin Saller on 2011-01-22

Basic Dot rendering vs higher level api

122. By Benjamin Saller on 2011-01-22

Merged state-changes into status-api.

123. By Benjamin Saller on 2011-01-22

more robust testing topology

124. By Benjamin Saller on 2011-01-24

moving some inspection methods into the state managers
removing non-passing tests to show current state of pipeline

[Benjamin Saller (bcsaller)]

This stage represents a number of changes from the previous phase.

The higher level state API is used and InternalTopology isn't touched. The tests create a topology through the higher level API as well.

A number of changes will be forthcoming. I expect to simplify the collect phase of the status command by making the state objects themselves able to gather information. I intend to change the rendering phase to also take the environment so that things like environment name can be included in the output.

The reason for wanting to change the collection phase mainly deals with the need to filter which elements make it into the result set based on which command line arguments are passed.

The current filtering model is a bit ugly for doing things like

#ensemble status memcache

where this might be a service

#ensemble status wordpress/1

and this is a unit.

review: Needs Resubmitting

[Gustavo Niemeyer (niemeyer)]

Thanks Ben, this implementation is going into a much better direction,
and doesn't feel too far from getting in.

Please address the following issues, without tweaking the branch further,
so that we can get this merged. You can follow with further changes in
a separate branch.

[1]

+ def get_services(self):
+ """Get all the services associated with a given relation.
+ """

s/get_services/get_all_service_states/, as per the existing convention (see
method immediately above). We could call it get_service_states, but the
_all will make it more distinguishable when reading the code.

These new methods feel good.

[2]

+ for service in topology.get_relation_services(
+ self.internal_relation_id):
+ service_name = topology.get_service_name(service)

Stylistic minor: the indentation after the for confuses the
line continuation with the block content. An extra indent
in will avoid this.

I'm actually wondering if we should stop using the 80 columns rule.
I've been using larger terminals and am pretty happy with the
readability benefits so far. Let's talk about this in our standup.

[3]

+ service_manager = ServiceStateManager(self._client)

Creating these objects internally under each method is starting to
feel wrong. Don't worry about this in your branch, but let's add
that as a topic for discussion in the near future.

[4]

+ def get_endpoints(self):
+ """Return a list of RelationEndpoints associated with this relation."""
+ from ensemble.state.service import ServiceStateManager
+ service_manager = ServiceStateManager(self.client)
+ endpoints = yield service_manager.get_relation_endpoints(self.service_name)

If the method is called get_relation_endpoints under service_manager, it feels
like a good idea to call it get_relation_endpoints here as well.

Again, these helpers feel good. Just the fact we're creating managers everywhere
feels like a bad idea, but again, not a problem to be handled in your branch.

[5]

+ @inlineCallbacks
+ def get_machines(self):
+ topology = yield self._read_topology()
+ machines = []
+ for machine_id in topology.get_machines():
+ # ugh, string manipulation
+ machine_id = int(machine_id[-10:])

s/get_machines/get_all_machine_states/, aligned with the function immediately above.

Also, there's an _internal_id_to_id() function there.

Since that kind of issue is recurring a bit, a general advice is to observe
the surroundings of what is being touched to see how problems are currently
solved. This is valid for algorithms, code style, method names, etc.
Consistency is very important to make a large code base tolerable.

[6]

     @inlineCallbacks
+ def get_units(self):
+ """Return a list of ServiceUnitState instances associated with

s/get_units/get_all_unit_states/

[7]

+ def as_dict(self):
+ instance_id = yield self.get_instance_id()

Those serialization methods should be inside the status command implementation
itself. It doesn't feel like they're useful anywhere else, and the content of
these dictionaries is tightly related to the usage inside the command.

You ca...

review: Needs Fixing

[Kapil Thangavelu (hazmat)]

Looks very nice.

[1]
pep8isms
control/status.py

line 81: help="An optional filename to output the result to",
line over 80

line 124: EnvironmentsConfigError undefined

line 233: two blank lines before func

line 354: extra blank line at the end of the file

[2]
    renderer = getattr(globals(), "render_%s" % options.format, render_json)

I'm not a big fan of grabbing things of globals, it feels a bit
implicit. It would be nice to toss the renderers into a class,
dictionary, or instance as namespace, and then just use getattr
against the namespace.

[3]
def encode_state(o):

Its not entirely clear what this is doing, or why it would get a
deferred instead of an object. it would be nice to have doc strings,
and in general its better to spell out variable names, then use
abbreviations.

[4]
import pydot

python-pydot probably should get added to the debian/control as dep, or at least a suggestion.

[5]

machine.py line 81: machine_id = int(machine_id[-10:])
there's an _internal_id_to_id function in the same module that should be used for this.

[6]
relation.py line 264: get_services

it doesn't feel right to have a method to return all the services
associated to a servicerelationstate, as its effectivly returning
itself as well. The relation stuff feels a bit unwieldy in this
respect, but it would be nice to have this sort of method on the
relation state manager. i'm not entirely sure what that should like
though.

[7] unrelated and for the future enhancement of status in a separate
branch, but i just added code to expose at least the machine provider
dns names on the provider machines, as well an accessor api to get
them individual (in addition to the existing bulk api).

[lp:~bcsaller/pyjuju/ensemble-status]

125. By Benjamin Saller on 2011-01-25

pass environment to render methods, used in dot to title graph

126. By Benjamin Saller on 2011-01-27

uniform api for state object iteration for services and machines.

127. By Benjamin Saller on 2011-01-27

use _internal_id_to_id for machine id conversion
tests for get_all_unit_states
more method pattern renames

128. By Benjamin Saller on 2011-01-27

ignore pdb history file

129. By Benjamin Saller on 2011-01-27

test set membership functions

130. By Benjamin Saller on 2011-01-28

remove unused method

131. By Benjamin Saller on 2011-01-31

relation iteration

132. By Benjamin Saller on 2011-01-31

checkpoint node based mark/sweep status code

133. By Benjamin Saller on 2011-01-31

nodes work with nested paths and mark/sweep algorithm for filtering, checkpoint before changing the status state construction to use Nodes

[Benjamin Saller (bcsaller)]

> [1]
>
> +    def get_services(self):
> +        """Get all the services associated with a given relation.
> +        """
>
> s/get_services/get_all_service_states/, as per the existing convention (see
> method immediately above). We could call it get_service_states, but the
> _all will make it more distinguishable when reading the code.
>
> These new methods feel good.
>

Renamed many methods in this style.

> [2]
>
> +        for service in topology.get_relation_services(
> +            self.internal_relation_id):
> +            service_name = topology.get_service_name(service)
>
> Stylistic minor: the indentation after the for confuses the
> line continuation with the block content. An extra indent
> in will avoid this.
>
> I'm actually wondering if we should stop using the 80 columns rule.
> I've been using larger terminals and am pretty happy with the
> readability benefits so far. Let's talk about this in our standup.
>

Many developers consider this important from a sense of tradition I
think. I think that setting a guideline is a good idea but the age of
small fixed terminals ended a long time ago.

For pep8 adding
 --ignore E501

(or adding E501) to the ignore comma delimited list will mask that error.

> [3]
>
> +        service_manager = ServiceStateManager(self._client)
>
> Creating these objects internally under each method is starting to
> feel wrong.  Don't worry about this in your branch, but let's add
> that as a topic for discussion in the near future.
>

agreed, maybe a facade over the whole thing? something that can
translate from elements in the conceptual graph to other connected
objects. it could hold reference to all the managers. Our tests
usually need to keep handles to more than one state manager to do
anything useful so this might make sense moving forward.

> [4]
>
> +    def get_endpoints(self):
> +        """Return a list of RelationEndpoints associated with this relation."""
> +        from ensemble.state.service import ServiceStateManager
> +        service_manager = ServiceStateManager(self.client)
> +        endpoints = yield service_manager.get_relation_endpoints(self.service_name)
>
> If the method is called get_relation_endpoints under service_manager, it feels
> like a good idea to call it get_relation_endpoints here as well.
>
> Again, these helpers feel good. Just the fact we're creating managers everywhere
> feels like a bad idea, but again, not a problem to be handled in your branch.
>

changed and test added. Though in this case its arguable that
'_relation_' is implied given 'self'.

> [5]
>
> +    @inlineCallbacks
> +    def get_machines(self):
> +        topology = yield self._read_topology()
> +        machines = []
> +        for machine_id in topology.get_machines():
> +            # ugh, string manipulation
> +            machine_id = int(machine_id[-10:])
>
> s/get_machines/get_all_machine_states/, aligned with the function immediately above.
>
> Also, there's an _internal_id_to_id() function there.
>
> Since that kind of issue is recurring a bit, a general advice is to observe
> the surroundings of what is being touched to see how problems are currently
> solved.  This is valid for algor...

[lp:~bcsaller/pyjuju/ensemble-status]

134. By Benjamin Saller on 2011-01-31

removed deprecated as_dict methods from state objects

135. By Benjamin Saller on 2011-01-31

json rendering works for the pure data state
removed yaml output, doesn't make sense in this context
state diagrams 95% back to rendering on the correct data, next patch should fix the relationships (again)
prune some dead code

[Benjamin Saller (bcsaller)]

On Wed, Jan 26, 2011 at 9:23 PM, Kapil Thangavelu
<email address hidden> wrote:
>
> Looks very nice.
>
> [1]
> pep8isms
> control/status.py
>
> line 81: help="An optional filename to output the result to",
> line over 80
>
> line 124: EnvironmentsConfigError undefined
>
> line 233: two blank lines before func
>
> line 354: extra blank line at the end of the file
>
>

Fixed 81/124

> [2]
>    renderer = getattr(globals(), "render_%s" % options.format, render_json)
>
> I'm not a big fan of grabbing things of globals, it feels a bit
> implicit. It would be nice to toss the renderers into a class,
> dictionary, or instance as namespace, and then just use getattr
> against the namespace.
>

added registry

> [3]
> def encode_state(o):
>
> Its not entirely clear what this is doing, or why it would get a
> deferred instead of an object.  it would be nice to have doc strings,
> and in general its better to spell out variable names, then use
> abbreviations.
>

removed

> [4]
> import pydot
>
> python-pydot probably should get added to the debian/control as dep, or at least a suggestion.

added as optional

>
> [5]
>
> machine.py line 81: machine_id = int(machine_id[-10:])
> there's an _internal_id_to_id function in the same module that should be used for this.
>

corrected
>
> [6]
> relation.py line 264: get_services
>
> it doesn't feel right to have a method to return all the services
> associated to a servicerelationstate, as its effectivly returning
> itself as well. The relation stuff feels a bit unwieldy in this
> respect, but it would be nice to have this sort of method on the
> relation state manager. i'm not entirely sure what that should like
> though.
>

yeah, this is still an issue where I am with the branch now too (even
though the underlying code has changed a bit), my next step might be
to refactor this more.

> [7] unrelated and for the future enhancement of status in a separate
> branch, but i just added code to expose at least the machine provider
> dns names on the provider machines, as well an accessor api to get
> them individual (in addition to the existing bulk api).

I'll need this, great.
> --
> https://code.launchpad.net/~bcsaller/ensemble/ensemble-status/+merge/45897
> You are the owner of lp:~bcsaller/ensemble/ensemble-status.
>

[Gustavo Niemeyer (niemeyer)]

The branch is still at revision 124, from the 24th. Can you please push the changes?

[lp:~bcsaller/pyjuju/ensemble-status]

136. By Benjamin Saller on 2011-01-31

remove yaml renderer, added renderers registry

[Gustavo Niemeyer (niemeyer)]

As discussed over the phone, this will be split in multiple smaller branches.

Unmerged revisions

136. By Benjamin Saller on 2011-01-31

remove yaml renderer, added renderers registry

135. By Benjamin Saller on 2011-01-31

json rendering works for the pure data state
removed yaml output, doesn't make sense in this context
state diagrams 95% back to rendering on the correct data, next patch should fix the relationships (again)
prune some dead code

134. By Benjamin Saller on 2011-01-31

removed deprecated as_dict methods from state objects

133. By Benjamin Saller on 2011-01-31

nodes work with nested paths and mark/sweep algorithm for filtering, checkpoint before changing the status state construction to use Nodes

132. By Benjamin Saller on 2011-01-31

checkpoint node based mark/sweep status code

131. By Benjamin Saller on 2011-01-31

relation iteration

130. By Benjamin Saller on 2011-01-28

remove unused method

129. By Benjamin Saller on 2011-01-27

test set membership functions

128. By Benjamin Saller on 2011-01-27

ignore pdb history file

127. By Benjamin Saller on 2011-01-27

use _internal_id_to_id for machine id conversion
tests for get_all_unit_states
more method pattern renames

=== modified file '.bzrignore'
--- .bzrignore	2010-11-18 05:29:38 +0000
+++ .bzrignore	2011-02-01 15:32:39 +0000
@@ -2,3 +2,4 @@
 /_trial_temp
 /tags
 zookeeper.log
+.pdb-pyhist

=== modified file 'ensemble/control/__init__.py'
--- ensemble/control/__init__.py	2011-01-31 22:58:29 +0000
+++ ensemble/control/__init__.py	2011-02-01 15:32:39 +0000
@@ -11,7 +11,11 @@
 import destroy_service
 import remove_relation
 import shutdown
+<<<<<<< TREE
 import ssh
+=======
+import status
+>>>>>>> MERGE-SOURCE
 
 import initialize
 
@@ -19,10 +23,15 @@
     add_relation,
     deploy,
     bootstrap,
+<<<<<<< TREE
     destroy_service,
     remove_relation,
     ssh,
     shutdown]
+=======
+    shutdown,
+    status]
+>>>>>>> MERGE-SOURCE
 
 
 ADMIN_SUBCOMMANDS = [

=== added file 'ensemble/control/status.py'
--- ensemble/control/status.py	1970-01-01 00:00:00 +0000
+++ ensemble/control/status.py	2011-02-01 15:32:39 +0000
@@ -0,0 +1,496 @@
+import argparse
+import json
+import fnmatch
+import sys
+
+from twisted.internet.defer import (Deferred,
+                                    inlineCallbacks,
+                                    returnValue)
+
+from ensemble.environment.errors import EnvironmentsConfigError
+from ensemble.state.service import ServiceStateManager
+from ensemble.state.machine import MachineStateManager
+from ensemble.state.relation import RelationStateManager
+
+_marker = object()
+
+renderers = {}
+
+# suppliment information passed to
+# the DOT methods, expands as kwargs for the
+# indicated data type
+DEFAULT_STYLE = {
+    "service_container": {
+        "bgcolor": "#dedede",
+        },
+    "service": {
+        "color": "#772953",
+        "shape": "component",
+        "style": "filled",
+        "fontcolor": "#ffffff",
+        },
+    "unit": {
+        "color": "#DD4814",
+        "fontcolor": "#ffffff",
+        "shape": "box",
+        "style": "filled",
+        },
+    "relation": {},
+    }
+
+
+def configure_subparser(subparsers):
+    sub_parser = subparsers.add_parser("status", help=command.__doc__)
+
+    sub_parser.add_argument(
+        "--environment", "-e",
+        help="Environment to status.")
+
+    sub_parser.add_argument("--output",
+                            help="An optional filename to output "
+                            "the result to",
+                            type=argparse.FileType("w"),
+                            default=sys.stdout)
+
+    sub_parser.add_argument("--format",
+                            help="Select an output format",
+                            default="json"
+                           )
+
+    sub_parser.add_argument("--watch", "-w",
+                            action="store_true",
+                            help="""Interval in seconds to return
+                            status updates""")
+
+    sub_parser.add_argument("scope",
+                            nargs="+",
+                            help="""scope of status request""")
+
+    return sub_parser
+
+
+def command(options):
+    """
+    Output status information about a deployment.
+    """
+    environment = options.environments.get(options.environment)
+    if environment is None and options.environment:
+        raise EnvironmentsConfigError(
+            "Invalid environment %r" % options.environment)
+    elif environment is None:
+        environment = options.environments.get_default()
+
+    renderer = renderers.get("render_%s" % options.format)
+    if renderer is None:
+        raise SystemExit("Unsupported render format %s" % (
+                options.format))
+
+    return status(environment, options.scope, renderer, options.output)
+
+
+@inlineCallbacks
+def status(environment, scope, renderer, output):
+    """Collect and render status information about a given
+    environment.
+    """
+    provider = environment.get_machine_provider()
+    client = yield provider.connect()
+
+    # watch topology change, any change can trigger
+    # a new collection/render cycle
+    #if options.watch:
+    #    pass
+    # Collect status information
+    state = yield collect(environment, scope)
+    # Render
+    renderer(state, output, environment)
+    yield client.close()
+
+
+class Node(dict):
+    """
+    Represents a graph node. Behaves as a dict with an explicit (and
+    optional) parent reference. When using a visitor pattern this has
+    helper methods for supporting mark/seen annotations
+    """
+
+    def __init__(self, name="", parent=None, **kwargs):
+        self.parent = parent
+        self["name"] = name
+        self.update(kwargs)
+
+        # vistor assistance
+        self._marked = False
+        if parent:
+            parent.add_child_node(self)
+
+    def __hash__(self):
+        return hash(self.name)
+
+    def __eq__(self, other):
+        return self.path == other.path
+
+    @property
+    def name(self):
+        return self["name"]
+
+    @property
+    def path(self):
+        path = []
+        obj = self
+        while obj:
+            path.insert(0, obj.name)
+            obj = obj.parent
+        if path and not path[0]:
+            path.pop(0)
+        return path
+
+    @property
+    def pathname(self):
+        return ".".join(self.path)
+
+    def __contains__(self, key):
+        try:
+            self.__getitem__(key)
+        except KeyError:
+            return False
+        return True
+
+    def __getitem__(self, key):
+        """Support '.' delimited nested node paths as arguments to
+        dict access"""
+        if "." not in key:
+            return super(Node, self).__getitem__(key)
+
+        path = key.split(".")
+        ob = self
+        for p in path:
+            # each element of the path must be a node
+            # either return it or create it accordingly
+            ob = ob.get(p, _marker)
+            if ob is _marker:
+                raise KeyError(key)
+
+        return ob
+    __getattr__ = __getitem__
+
+    def __setitem__(self, key, value):
+        """Support dict styled sets with '.' delimited path support
+        where using '.' will nest child nodes automatically
+        """
+        if "." not in key:
+            # This is a plain set, value shouldn't be a node
+            # if trying to set a child directly call add_child_node
+            super(Node, self).__setitem__(key, value)
+            return
+
+        if not isinstance(value, Node):
+            raise ValueError("""Nested paths only allow setting Node children""")
+        # Its a nested path
+        path = key.split(".")
+        ob = self
+        for p in path:
+            # each element of the path must be a node
+            # either return it or create it accordingly
+            ob = ob.setdefault(p, Node(p, parent=ob))
+
+        # then on the last element add the final node
+        ob.add_child_node(value)
+
+    @property
+    def is_marked(self):
+        return self._marked is True
+
+    def add_child_node(self, other):
+        super(Node, self).__setitem__(other.name, other)
+        other.parent = self
+
+    def mark(self, value=True):
+        """Mark a node as seen, its value should be included in the
+        output set.
+        """
+        self._marked = value
+
+    def mark_parents(self):
+        """A convenience method to mark all the ancestors of a node."""
+        ob = self
+        while ob:
+            ob.mark()
+            ob = ob.parent
+
+    def mark_children(self):
+        """A convenience method to recursively mark all children of a
+        node"""
+        for node in self.iternodes(True):
+            node.mark()
+
+    def filter(self, patterns):
+        """
+        Return a new node tree containing only those nodes that match
+        a pattern in patterns (and the children of any such nodes).
+
+        `patterns`: list or string of fnmatch style descriptors to be
+        compared to node names.
+        """
+        result = Node()
+        nodes = list(self.iternodes(True))
+        nodes = sorted(nodes, key=lambda x: x.name)
+
+        # reset the tree (very non-concurrent)
+        [n.mark(False) for n in nodes]
+
+        for node in nodes:
+            if filter_name(node.name, patterns):
+                # mark this node and its parents
+                # and its children
+                node.mark_parents()
+                node.mark_children()
+
+        # now walk the tree
+        for node in nodes:
+            if node.is_marked:
+                result[node.pathname] = node
+
+        return result
+
+    def iternodes(self, recurse=False):
+        """Iterator method yielding back only Node instances among
+        children. The output can optionally include the nodes of those
+        children as well.
+
+        """
+        for value in self.itervalues():
+            if isinstance(value, Node):
+                yield value
+                if recurse:
+                    for v in value.iternodes(recurse=recurse):
+                        yield v
+
+
+@inlineCallbacks
+def collect(environment, scopes):
+    """Collect the objects which will be rendered for status information
+    keyword arguments:
+
+       `environment`: ensemble environment
+
+       `scope`: an optional list of name specifiers. Globbing based
+       wildcards supported. Defaults to all units, services and
+       relations.
+    """
+    provider = environment.get_machine_provider()
+    client = yield provider.connect()
+
+    service_manager = ServiceStateManager(client)
+    machine_manager = MachineStateManager(client)
+    relation_manager = RelationStateManager(client)
+
+    # status the runtime environment
+    # build a graph of nested dicts from services down to relations
+    # with the machines and the units mapped under them
+    # then process this tree as a graph annotating each node when the
+    # following is observed
+    #   if a nodes name matches the scope all its children are marked
+    #   if a nodes name matches its parents are marked
+    # at the end of this process unmarked nodes are removed from the
+    # data. This is then passed to the renderer.
+
+    # this produces a (manager, element_name, category) tuple which is added to
+    # the components list
+    components = []
+    state = Node()
+
+    # for (category, manager) in (("services", service_manager),
+    #                             ("machines", machine_manager),
+    #                             ("relation", relation_manager)):
+    #     names = yield manager.keys()
+    #     for name in names:
+    #         components.append((manager, name, category))
+
+    # # ask each manager for the object by name including its
+    # for (manager, name, category) in components:
+    #     instance = yield manager.get(name)
+    #     data = None
+    #     # create the data dicts expected by the render phase
+    #     if manager is service_manager:
+    #         # serialize instance
+    #         # add relations
+    #         data = serialize(instance)
+    #         relations ={}
+    #         relation_states = yield relation_manager.get_relations_for_service(instance)
+    #         for relation_state in relation_states:
+    #             relations[relation_state.internal_relation_id] = serialize(relation_state)
+
+    #         data["relations"] = relations
+
+
+    #     elif manager is machine_manager:
+    #         pass
+    #     elif manager is relation_manager:
+    #         pass
+
+    #     if data:
+    #         state.setdefault(category, list()).append(data)
+
+    services = yield service_manager.values()
+    for service in services:
+        s = Node(service.service_name, state)
+        # and serialize data from the service into n
+        s["service_name"] = service.service_name
+        units = yield service.get_all_unit_states()
+        us = Node("units", s)
+        for unit in units:
+            u = Node(unit.unit_name, us)
+            u["unit_name"] = unit.unit_name
+            machine = yield unit.get_machine()
+            machine_name = yield machine.get_instance_id()
+            u["machine_name"] = machine_name
+            m = Node(machine_name, u)
+
+        relations = yield relation_manager.get_relations_for_service(service)
+        rs = Node("relations", s)
+        for relation in relations:
+            r = Node(relation.internal_relation_id, rs)
+            r["relation_role"] = relation.relation_role
+            rel_services = yield relation.get_service_states()
+            r.setdefault("services", []).append(
+                [s.service_name for s in rel_services])
+
+    state = state.filter(scopes)
+    print state
+    returnValue(state)
+
+
+def filter_name(name, patterns):
+    """Returns boolean if name is in patterns.
+
+    `name`: a string
+    `patterns`: either a string or a list of strings containing either
+                direct matching specfications or glob based wildcards
+    """
+
+    if not patterns:
+        return True
+
+    if isinstance(patterns, basestring):
+        patterns = [patterns]
+
+    for pattern in patterns:
+        if fnmatch.fnmatch(name, pattern):
+            return True
+    return False
+
+
+def jsonify(data, filelike, pretty=True, **kwargs):
+    args = dict(skipkeys=True)
+    args.update(kwargs)
+    if pretty:
+        args["sort_keys"] = True
+        args["indent"] = 4
+    return json.dump(data, filelike, **args)
+
+
+def render_json(data, filelike, environment):
+    jsonify(data, filelike)
+renderers["json"] = render_json
+
+def dot_method(format):
+    """
+    Pydot supports many output formats. Support many common ones with
+    a function template.
+    """
+    try:
+        import pydot
+    except ImportError:
+        raise SystemExit("""You need to install the pydot """
+                         """library to support DOT visualizations""")
+
+    def render_dot(data, filelike, environment, style=DEFAULT_STYLE):
+        dot = pydot.Dot(
+            graph_name=environment.name,
+            simplify=True,
+            )
+        # first create a cluster for each service
+        for service in data.iternodes():
+            cluster = pydot.Cluster(
+                service.service_name,
+                shape="component",
+                label="%s service" % (service.service_name),
+                **style["service_container"])
+
+            snode = pydot.Node(service.service_name,
+                               label="<%s>" % (service.service_name,),
+                               **style["service"])
+            cluster.add_node(snode)
+
+            for unit in service.units.iternodes():
+                machine_name = unit.machine_name
+                un = pydot.Node(unit.unit_name,
+                                label="<%s<br/><i>%s</i>>" % (unit.unit_name,
+                                                              machine_name),
+                                **style["unit"])
+                cluster.add_node(un)
+
+                cluster.add_edge(pydot.Edge(snode, un))
+
+            dot.add_subgraph(cluster)
+
+            # now map the relationships
+            for relation in service.relations.iternodes():
+                kind = relation.relation_role
+                dirtype = None
+                if len(relation.services) == 2:
+                    src, dest = relation.services
+                    if kind == "peer":
+                        dirtype = "both"
+                    elif kind == "client":
+                        # only draw one side of
+                        # client-server relationships
+                        dirtype = "forward"
+
+                    if dirtype:
+                        dot.add_edge(pydot.Edge(
+                                src.service_name,
+                                dest.service_name,
+                                #constraint=False,
+                                dirType=dirtype,
+                                label=kind,
+                                **style["relation"]
+                            ))
+
+        filelike.write(dot.create(format=format))
+
+    renderers[format] = render_dot
+    return render_dot
+
+render_dot = dot_method("dot")
+render_svg = dot_method("svg")
+render_png = dot_method("png")
+
+
+def render_human(data, filelike, environment):
+    """human readable output version of the status"""
+    # first create a cluster for each service
+    for name, service in data["services"].items():
+        print >>filelike, "%s: %s/%s" % (name,
+                                         service["name"],
+                                         service["sequence"]
+                                        )
+        for unit in service["units"]:
+            print >>filelike, "    %s" % (unit)
+
+    # now map the relationships
+    for name, (kind, services) in data["relations"].items():
+        src, dest = services.keys()
+        if kind == "peer":
+            dirType = "<->"
+
+        elif kind == "client-server":
+            # determin the client and the server
+            dirType = "->"
+            if services[src]["role"] != "server":
+                src, dest = dest, src
+        print >>filelike, "%s %s %s" % (
+            src, dirType, dest)
+
+

=== added file 'ensemble/control/tests/test_status.py'
--- ensemble/control/tests/test_status.py	1970-01-01 00:00:00 +0000
+++ ensemble/control/tests/test_status.py	2011-02-01 15:32:39 +0000
@@ -0,0 +1,275 @@
+from StringIO import StringIO
+import json
+import yaml
+
+from twisted.internet.defer import inlineCallbacks
+
+from .common import ControlToolTest
+from ensemble.control import status
+from ensemble.state.tests.test_service import ServiceStateManagerTestBase
+
+
+class StatusTest(ServiceStateManagerTestBase, ControlToolTest):
+
+    @inlineCallbacks
+    def setUp(self):
+        yield ServiceStateManagerTestBase.setUp(self)
+        yield ControlToolTest.setUp(self)
+
+        self.capture_logging()
+        config = {
+            "ensemble": "environments",
+            "environments": {
+                "firstenv": {
+                    "type": "dummy",
+                    "admin-secret": "homer"}}}
+        self.write_config(yaml.dump(config))
+        self.config.load()
+        self.output = StringIO()
+
+    @inlineCallbacks
+    def build_topology(self, base=None):
+        # build out the topology using the state managers
+        m1 = yield self.machine_state_manager.add_machine_state()
+        m2 = yield self.machine_state_manager.add_machine_state()
+        m3 = yield self.machine_state_manager.add_machine_state()
+        m4 = yield self.machine_state_manager.add_machine_state()
+        m5 = yield self.machine_state_manager.add_machine_state()
+        m6 = yield self.machine_state_manager.add_machine_state()
+        m7 = yield self.machine_state_manager.add_machine_state()
+
+        yield m1.set_instance_id("alpha")
+        yield m2.set_instance_id("beta")
+        yield m3.set_instance_id("cappa")
+        yield m4.set_instance_id("delta")
+        yield m5.set_instance_id("gamma")
+        yield m6.set_instance_id("mc1")
+        yield m7.set_instance_id("mc2")
+
+        wordpress = yield self.add_service_from_formula("wordpress")
+        mysql = yield self.add_service_from_formula("mysql")
+        varnish = yield self.add_service_from_formula("varnish")
+        # w/o additional metadata
+        memcache = yield self.add_service("memcache")
+
+        yield self.add_relation("client-server",
+                                (wordpress, "app", "client"),
+                                (mysql, "db", "server"))
+
+        yield self.add_relation("client-server",
+                                (varnish, "proxy", "client"),
+                                (wordpress, "app", "server"))
+
+        yield self.add_relation("client-server",
+                                (memcache, "cache", "server"),
+                                (wordpress, "app", "client"))
+
+        wpu = yield wordpress.add_unit_state()
+        yield wpu.assign_to_machine(m1)
+
+        myu = yield mysql.add_unit_state()
+        myu2 = yield mysql.add_unit_state()
+        yield myu.assign_to_machine(m2)
+        yield myu2.assign_to_machine(m3)
+
+        vu1 = yield varnish.add_unit_state()
+        vu2 = yield varnish.add_unit_state()
+        yield vu1.assign_to_machine(m4)
+        yield vu2.assign_to_machine(m5)
+
+        mc1 = yield memcache.add_unit_state()
+        mc2 = yield memcache.add_unit_state()
+        yield mc1.assign_to_machine(m6)
+        yield mc2.assign_to_machine(m7)
+
+    def test_filter_name(self):
+        # patterns is string
+        self.assertTrue(status.filter_name("alpha/1", "*/1"))
+        self.assertTrue(status.filter_name("alpha/1", "alpha*"))
+        self.assertFalse(status.filter_name("alpha/1", "beta*"))
+
+        # patterns is a list
+        self.assertTrue(status.filter_name("alpha/1", ["*/1"]))
+        self.assertTrue(status.filter_name("alpha/1", ["alpha*"]))
+        self.assertFalse(status.filter_name("alpha/1", ["beta*"]))
+
+        # patterns is a list of more than one
+        #   (where the first element matches)
+        self.assertTrue(status.filter_name("alpha/1", ["*/1", "beta"]))
+        self.assertTrue(status.filter_name("alpha/1", ["alpha*", "beta"]))
+        self.assertFalse(status.filter_name("alpha/1", ["beta*", "gamma"]))
+        #   (and where only the second matches)
+        self.assertTrue(status.filter_name("alpha/1", ["beta", "*/1"]))
+        self.assertTrue(status.filter_name("alpha/1", ["beta", "alpha*"]))
+        self.assertFalse(status.filter_name("alpha/1", ["gamma", "beta*"]))
+
+    @inlineCallbacks
+    def test_render_json(self):
+        environment = self.config.get("firstenv")
+        yield self.build_topology()
+
+        yield status.status(environment, [],
+                            status.render_json, self.output)
+
+    # @inlineCallbacks
+    # def test_render_human(self):
+    #     environment = self.config.get("firstenv")
+    #     yield self.build_topology()
+
+    #     yield status.status(self.config, environment, [],
+    #                         status.render_human, self.output)
+    #     print self.output.getvalue()
+    #     #self.assertIn("service-0000000000: mysql/1", self.output.getvalue())
+
+    # @inlineCallbacks
+    # def test_render_dot(self):
+    #     environment = self.config.get("firstenv")
+    #     yield self.build_topology()
+
+    #     yield status.status(self.config, environment, [],
+    #                         status.render_human, self.output)
+    #     print self.output.getvalue()
+    #     # verify various expected clauses (without caring about things
+    #     # like spatial positioning
+    #     self.assertIn("mysql -> wordpress", result)
+    #     self.assertIn('mysql -> "unit-0000000000"', result)
+    #     self.assertIn('wordpress -> "unit-0000000001"', result)
+
+    @inlineCallbacks
+    def test_status_base_topology(self):
+        # set up machine name mocks to map back to machines these
+        # names should be output in the status information
+        environment = self.config.get("firstenv")
+        yield self.build_topology()
+
+        yield status.status(environment, [],
+                            status.render_svg, self.output)
+        fp = open("/tmp/ens.svg", "w")
+        fp.write(self.output.getvalue())
+        fp.close()
+
+        self.output = StringIO()
+        yield status.status(environment, [],
+                            status.render_dot, self.output)
+        fp = open("/tmp/ens.dot", "w")
+        fp.write(self.output.getvalue())
+        fp.close()
+
+    def test_node_basics(self):
+        Node = status.Node
+
+        wp = Node("wordpress")
+        wp["service_id"] = "service-0000000000"
+
+        self.assertEqual(wp["name"], "wordpress")
+        self.assertEqual(wp.name, "wordpress")
+        self.assertEqual(wp["service_id"], "service-0000000000")
+        self.assertEqual(wp.parent, None)
+
+        m1 = Node("machine1", wp)
+        self.assertEqual(m1.parent, wp)
+        self.assertEqual(m1.path, ["wordpress", "machine1"])
+
+    def build_simple_node_tree(self):
+        Node = status.Node
+        root = Node()
+        wp = Node("wordpress", root)
+        wp0 = Node("wordpress/0", wp)
+        wp1 = Node("wordpress/1", wp)
+        Node("machine1", wp0)
+        Node("machine2", wp1)
+
+        my = Node("mysql", root)
+        my0 = Node("mysql/0", my)
+        my1 = Node("mysql/1", my)
+        Node("machine3", my0)
+        Node("machine4", my1)
+        return root
+
+    def test_node_mark(self):
+        root = self.build_simple_node_tree()
+        wp0 = root["wordpress.wordpress/0"]
+
+        wp0.mark_parents()
+        self.assertTrue(root.is_marked)
+        self.assertTrue(root["wordpress"].is_marked)
+        self.assertTrue(wp0.is_marked)
+
+        self.assertFalse(root["mysql"].is_marked)
+        self.assertFalse(wp0["machine1"].is_marked)
+
+        # now mark the children
+        wp0.mark_children()
+        self.assertTrue(wp0["machine1"].is_marked)
+
+    def test_node_nested_paths(self):
+        # test with missing path
+        root = self.build_simple_node_tree()
+
+        # literal value
+        try:
+            root["alpha.beta"] = "literal"
+        except ValueError:
+            pass
+        else:
+            self.fail("""Literal value with nested path key in node didn't fail properly""")
+
+        # node child
+        another = status.Node("another")
+        root["alpha.beta"] = another
+
+        alpha = root["alpha"]
+        self.assertInstance(alpha, status.Node)
+        self.assertEqual(alpha.parent, root)
+
+        beta = alpha["beta"]
+        self.assertEqual(beta.pathname, "alpha.beta")
+
+        # test path base dict access
+        self.assertEqual(another, root["alpha.beta.another"])
+
+        # get a literal with a path
+        another["foo"] = "bar"
+        self.assertEqual(another["foo"], "bar")
+        self.assertEqual(root["alpha.beta.another.foo"], "bar")
+
+        self.assertTrue("alpha.beta" in root)
+
+    def test_node_iteration(self):
+        root = self.build_simple_node_tree()
+        nodes = set(root.iternodes())
+        names = set(n.pathname for n in nodes)
+        self.assertEqual(names, set(("wordpress", "mysql")))
+
+        # and with recursion
+        nodes = set(root.iternodes(True))
+        names = set(n.pathname for n in nodes)
+        self.assertEqual(names,
+                         set(["mysql",
+                              "mysql.mysql/0",
+                              "mysql.mysql/0.machine3",
+                              "mysql.mysql/1",
+                              "mysql.mysql/1.machine4",
+                              "wordpress",
+                              "wordpress.wordpress/0",
+                              "wordpress.wordpress/0.machine1",
+                              "wordpress.wordpress/1",
+                              "wordpress.wordpress/1.machine2"]))
+
+    def test_node_mark_sweep(self):
+        root = self.build_simple_node_tree()
+        # now attempt to mark/sweep with a name based filter
+        result = root.filter("wordpress")
+        self.assertIn("wordpress", result)
+        self.assertFalse("mysql" in result)
+
+        # now try a lower level filter
+        result = root.filter("wordpress/1")
+        # the top level expectations are the same but because we
+        # matched a name at the middle layer of the graph we wouldn't
+        # have recursively marked down from wordpress and don't expect
+        # to find wordpress/0 in the result
+        self.assertIn("wordpress", result)
+        self.assertFalse("mysql" in result)
+
+

=== modified file 'ensemble/providers/dummy.py'
--- ensemble/providers/dummy.py	2011-01-26 23:51:42 +0000
+++ ensemble/providers/dummy.py	2011-02-01 15:32:39 +0000
@@ -37,8 +37,13 @@
         if not "machine-id" in machine_data:
             return fail(ProviderError(
                 "Machine state `machine-id` required in machine_data"))
+<<<<<<< TREE
         dns_name = machine_data.get("dns-name")
         machine = DummyMachine(len(self._machines), dns_name)
+=======
+        machine = DummyMachine(len(self._machines))
+        machine.machine_data = machine_data
+>>>>>>> MERGE-SOURCE
         self._machines.append(machine)
         return succeed([machine])
 

=== modified file 'ensemble/state/base.py'
--- ensemble/state/base.py	2010-12-07 01:26:01 +0000
+++ ensemble/state/base.py	2011-02-01 15:32:39 +0000
@@ -124,3 +124,53 @@
                 return
             self._old_topology = new_topology
             watch.addCallback(self.__topology_changed, watch_topology_function)
+
+    # Common Iteration API methods
+    #     These depend on the subclasses defining
+    # state_accessor and state_iter shown below
+    @inlineCallbacks
+    def keys(self):
+        """Iterate the top level objects of this manager returning ids
+        that can be passed to the get() method.
+        """
+        keys = yield self.state_iter()
+        returnValue(keys)
+
+    @inlineCallbacks
+    def values(self):
+        """Iterate the top level objects of this manager.
+        """
+        result = []
+        keys = yield self.keys()
+        for key in keys:
+            state = yield self.get(key)
+            result.append(state)
+
+        returnValue(result)
+
+    @inlineCallbacks
+    def items(self):
+        """Iterate the top level objects of a this manager returning
+        (id, instance) tuples.
+        """
+        result = []
+        keys = yield self.keys()
+        for key in keys:
+            state = yield self.get(key)
+            result.append((key, state))
+        returnValue(result)
+
+    @inlineCallbacks
+    def get(self, key):
+        """
+        Return the state object for this manager
+        """
+        state = yield self.state_accessor(key)
+        returnValue(state)
+
+    # These define a simple way to bind existing methods to a common
+    # API shared by state managers
+    # accessor for state by key
+    state_accessor = None
+    # iterator over state instances by name
+    state_iter = None

=== modified file 'ensemble/state/machine.py'
--- ensemble/state/machine.py	2011-01-31 22:57:52 +0000
+++ ensemble/state/machine.py	2011-02-01 15:32:39 +0000
@@ -76,6 +76,30 @@
         machine_state = MachineState(self._client, internal_id)
         returnValue(machine_state)
 
+    @inlineCallbacks
+    def get_all_machine_states(self):
+        topology = yield self._read_topology()
+        machines = []
+        for machine_id in topology.get_machines():
+            # ugh, string manipulation
+            machine_id = _internal_id_to_id(machine_id)
+            machine = yield self.get_machine_state(machine_id)
+            machines.append(machine)
+        returnValue(machines)
+
+    @inlineCallbacks
+    def get_all_machine_names(self):
+        topology = yield self._read_topology()
+        machines = []
+        for machine_id in topology.get_machines():
+            # ugh, string manipulation
+            machine_id = int(machine_id[-10:])
+            machines.append(machine_id)
+        returnValue(machines)
+
+    state_accessor = get_machine_state
+    state_iter = get_all_machine_names
+
     def watch_machine_states(self, callback):
         """Observe changes in the known machines through the watch function.
 
@@ -113,6 +137,14 @@
         super(MachineState, self).__init__(client)
         self._internal_id = internal_id
 
+    def __hash__(self):
+        return hash(self.id)
+
+    def __eq__(self, other):
+        if not isinstance(other, MachineState):
+            return False
+        return self.id == other.id
+
     @property
     def id(self):
         """High-level id built using the sequence as an int."""

=== modified file 'ensemble/state/relation.py'
--- ensemble/state/relation.py	2011-01-31 16:13:10 +0000
+++ ensemble/state/relation.py	2011-02-01 15:32:39 +0000
@@ -137,6 +137,15 @@
         yield self._retry_topology_change(remove_relation)
 
     @inlineCallbacks
+    def get_relation_state(self, relation_id):
+        """Return a RelationState for a given id or None"""
+        topology = yield self._read_topology()
+        relation = None
+        if topology.has_relation(relation_id):
+            relation = RelationState(self._client, relation_id)
+        returnValue(relation)
+
+    @inlineCallbacks
     def get_relations_for_service(self, service_state):
         """Get the relations associated to the service.
         """
@@ -153,6 +162,7 @@
                     **service_info))
         returnValue(relations)
 
+<<<<<<< TREE
     @inlineCallbacks
     def get_relation_state(self, *endpoints):
         """Return `relation_state` connecting the endpoints.
@@ -165,6 +175,19 @@
             raise RelationStateNotFound()
         returnValue(RelationState(self._client, internal_id))
 
+=======
+    @inlineCallbacks
+    def get_all_relation_names(self):
+        """
+        Return the names of the
+        """
+        topology = yield self._read_topology()
+        returnValue(topology.get_all_relation_names())
+
+    state_iter = get_all_relation_names
+    state_accessor = get_relation_state
+
+>>>>>>> MERGE-SOURCE
 
 class RelationState(StateBase):
     """Represents a connection between one or more services.
@@ -284,6 +307,21 @@
                 unit_state.internal_id,
                 self._relation_id))
 
+    @inlineCallbacks
+    def get_service_states(self):
+        """Get all the services associated with a given relation.
+        """
+        from ensemble.state.service import ServiceStateManager
+        service_manager = ServiceStateManager(self._client)
+        services = []
+        topology = yield service_manager._read_topology()
+        for service in topology.get_relation_services(
+            self.internal_relation_id):
+            service_name = topology.get_service_name(service)
+            service = yield service_manager.get_service_state(service_name)
+            services.append(service)
+        returnValue(services)
+
 
 class UnitRelationState(StateBase):
     """A service unit's relation state.

=== modified file 'ensemble/state/service.py'
--- ensemble/state/service.py	2011-01-31 22:57:52 +0000
+++ ensemble/state/service.py	2011-02-01 15:32:39 +0000
@@ -94,6 +94,7 @@
         returnValue(ServiceState(self._client, internal_id, service_name))
 
     @inlineCallbacks
+<<<<<<< TREE
     def get_unit_state(self, unit_name):
         """Returns the unit state with the given name.
 
@@ -109,6 +110,34 @@
         returnValue(unit_state)
 
     @inlineCallbacks
+=======
+    def get_all_service_states(self):
+        """
+        Yield a ServiceState for each service in the environment.
+        """
+        topology = yield self._read_topology()
+        services = []
+        for service_id in topology.get_services():
+            service_name = topology.get_service_name(service_id)
+            service = yield self.get_service_state(service_name)
+            services.append(service)
+        returnValue(services)
+
+    @inlineCallbacks
+    def get_all_service_names(self):
+        topology = yield self._read_topology()
+        names = []
+        for service_id in topology.get_services():
+            service_name = topology.get_service_name(service_id)
+            names.append(service_name)
+        returnValue(names)
+
+    # support the common dict access API
+    state_iter = get_all_service_names
+    state_accessor = get_service_state
+
+    @inlineCallbacks
+>>>>>>> MERGE-SOURCE
     def get_relation_endpoints(self, descriptor):
         """Get all relation endpoints for `descriptor`.
 
@@ -180,6 +209,19 @@
         self._internal_id = internal_id
         self._service_name = service_name
 
+    def __hash__(self):
+        return hash(self.internal_id)
+
+    def __eq__(self, other):
+        if not isinstance(other, ServiceState):
+            return False
+        return self.internal_id == other.internal_id
+
+    def __repr__(self):
+        return "<%s %s>" % (
+            self.__class__.__name__,
+            self.internal_id)
+
     @property
     def service_name(self):
         """Name of the service represented by this state.
@@ -232,6 +274,7 @@
                                      internal_unit_id))
 
     @inlineCallbacks
+<<<<<<< TREE
     def get_unit_names(self):
         topology = yield self._read_topology()
         if not topology.has_service(self._internal_id):
@@ -269,6 +312,24 @@
             self._client, "/units/%s" % service_unit.internal_id)
 
     @inlineCallbacks
+=======
+    def get_all_unit_states(self):
+        """Return a list of ServiceUnitState instances associated with
+        this service.
+        """
+        topology = yield self._read_topology()
+        units = []
+
+        for unit_id in topology.get_service_units(self._internal_id):
+            unit_name = topology.get_service_unit_name(self._internal_id,
+                                                       unit_id)
+            unit = yield self.get_unit_state(unit_name)
+            units.append(unit)
+
+        returnValue(units)
+
+    @inlineCallbacks
+>>>>>>> MERGE-SOURCE
     def get_unit_state(self, unit_name):
         """Return service unit state with the given unit name.
 
@@ -338,6 +399,16 @@
 
         self._watch_topology(watch_topology)
 
+    @inlineCallbacks
+    def get_relations(self):
+        """Return a list ServiceRelationState objects for the
+        relations of this service.
+        """
+        from ensemble.state.relation import RelationStateManager
+        relation_manager = RelationStateManager(self.client)
+        relations = yield relation_manager.get_relations_for_service(self)
+        returnValue(relations)
+
 
 def _to_service_relation_state(client, service_id, assigned_relations):
     """Helper method to construct a list of service relation states.
@@ -373,6 +444,25 @@
         self._unit_sequence = unit_sequence
         self._internal_id = internal_id
 
+    def __hash__(self):
+        return hash(self.unit_name)
+
+    def __eq__(self, other):
+        if not isinstance(other, ServiceUnitState):
+            return False
+        return self.unit_name == other.unit_name
+
+    def __repr__(self):
+        return "<%s %s>" % (self.__class__.__name__,
+                            self.unit_name)
+
+    @inlineCallbacks
+    def as_dict(self):
+        returnValue(
+            dict(service_name=self.service_name,
+                 unit_name=self.unit_name,
+                 type="ServiceUnit"))
+
     @property
     def service_name(self):
         """Service name for the service from this unit."""
@@ -392,6 +482,7 @@
         """Get the zookeeper path for the service unit agent."""
         return "/units/%s/agent" % self._internal_id
 
+<<<<<<< TREE
     @inlineCallbacks
     def get_assigned_machine_id(self):
         """ Get the assigned machine id or None if the unit is not assigned.
@@ -403,6 +494,23 @@
             machine_id = _public_machine_id(machine_id)
         returnValue(machine_id)
 
+=======
+    @inlineCallbacks
+    def get_machine(self):
+        """Return the MachineState for the machine assignment of this
+        unit."""
+        from ensemble.state.machine import MachineStateManager
+        machine_state_manager = MachineStateManager(self._client)
+        topology = yield self._read_topology()
+        machine_id = topology.get_service_unit_machine(
+            self._internal_service_id,
+            self.internal_id)
+        machine_state = yield machine_state_manager.get_machine_state(
+            int(machine_id[-10:]))
+        returnValue(machine_state)
+
+
+>>>>>>> MERGE-SOURCE
     def assign_to_machine(self, machine_state):
         """Assign this service unit to the given machine.
         """

=== modified file 'ensemble/state/tests/test_machine.py'
--- ensemble/state/tests/test_machine.py	2011-01-20 18:13:50 +0000
+++ ensemble/state/tests/test_machine.py	2011-02-01 15:32:39 +0000
@@ -111,6 +111,56 @@
             self.fail("Error not raised")
 
     @inlineCallbacks
+    def test_get_all_machine_states(self):
+        machines = yield self.machine_state_manager.get_all_machine_states()
+        self.assertFalse(machines)
+
+        yield self.machine_state_manager.add_machine_state()
+        machines = yield self.machine_state_manager.get_all_machine_states()
+        self.assertEquals(len(machines), 1)
+
+        yield self.machine_state_manager.add_machine_state()
+        machines = yield self.machine_state_manager.get_all_machine_states()
+        self.assertEquals(len(machines), 2)
+
+    @inlineCallbacks
+    def test_state_iter(self):
+        wordpress = yield self.service_state_manager.add_service_state("wordpress", self.formula_state)
+        yield self.service_state_manager.add_service_state("mysql", self.formula_state)
+
+        m1 = yield self.machine_state_manager.add_machine_state()
+        m2 = yield self.machine_state_manager.add_machine_state()
+
+        mu1 = yield wordpress.add_unit_state()
+        mu2 = yield wordpress.add_unit_state()
+        yield mu1.assign_to_machine(m1)
+        yield mu2.assign_to_machine(m2)
+
+        keys = yield self.machine_state_manager.keys()
+        values = yield self.machine_state_manager.values()
+        items = yield self.machine_state_manager.items()
+        # this exploits that subsequent calls to key() should yield
+        # the same result ordering for the same data and that this
+        # method is used to power values and items
+        self.assertEqual(zip(keys, values), items)
+
+    @inlineCallbacks
+    def test_set_functions(self):
+        m1 = yield self.machine_state_manager.add_machine_state()
+        m2 = yield self.machine_state_manager.add_machine_state()
+
+        m3 = yield self.machine_state_manager.get_machine_state(0)
+        m4 = yield self.machine_state_manager.get_machine_state(1)
+
+        self.assertEquals(hash(m1), hash(m3))
+        self.assertEquals(hash(m2), hash(m4))
+        self.assertNotIdentical(hash(m1), hash(m2))
+        self.assertEquals(m1, m3)
+        self.assertEquals(m2, m4)
+
+
+
+    @inlineCallbacks
     def test_set_and_get_instance_id(self):
         """
         Each provider must have its own notion of an id for machines it offers.

=== modified file 'ensemble/state/tests/test_relation.py'
--- ensemble/state/tests/test_relation.py	2011-01-31 16:13:10 +0000
+++ ensemble/state/tests/test_relation.py	2011-02-01 15:32:39 +0000
@@ -702,6 +702,13 @@
             self.service1_relation.get_unit_state(unit_state),
             UnitRelationStateNotFound)
 
+    @inlineCallbacks
+    def test_get_all_service_states(self):
+        services = yield self.service1_relation.get_service_states()
+        self.assertEqual(set(services),
+                         set((self.service_state1,
+                              self.service_state2)))
+
 
 class UnitRelationStateTest(RelationTestBase):
 

=== modified file 'ensemble/state/tests/test_service.py'
--- ensemble/state/tests/test_service.py	2011-01-31 22:22:29 +0000
+++ ensemble/state/tests/test_service.py	2011-02-01 15:32:39 +0000
@@ -277,6 +277,7 @@
         yield self.assertFailure(d, StateChanged)
 
     @inlineCallbacks
+<<<<<<< TREE
     def test_get_unit_names(self):
         """A service's units names are retrievable."""
         service_state = yield self.service_state_manager.add_service_state(
@@ -328,6 +329,36 @@
         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)
+
+        service_state0 = yield self.service_state_manager.add_service_state(
+            "wordpress", self.formula_state)
+        services = yield self.service_state_manager.get_all_service_states()
+        self.assertEquals(len(services), 1)
+
+        service_state1 = yield self.service_state_manager.add_service_state(
+            "mysql", self.formula_state)
+        services = yield self.service_state_manager.get_all_service_states()
+        self.assertEquals(len(services), 2)
+
+    @inlineCallbacks
+    def test_state_iter(self):
+        yield self.service_state_manager.add_service_state("wordpress", self.formula_state)
+        yield self.service_state_manager.add_service_state("mysql", self.formula_state)
+
+        keys = yield self.service_state_manager.keys()
+        values = yield self.service_state_manager.values()
+        items = yield self.service_state_manager.items()
+        # this exploits that subsequent calls to key() should yield
+        # the same result ordering for the same data and that this
+        # method is used to power values and items
+        self.assertEqual(zip(keys, values), items)
+
+    @inlineCallbacks
+>>>>>>> MERGE-SOURCE
     def test_get_service_unit(self):
         """
         Getting back service units should be possible using the
@@ -359,6 +390,56 @@
         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.formula_state)
+        service_state1 = yield self.service_state_manager.add_service_state(
+            "mysql", self.formula_state)
+
+        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_set_functions(self):
+        wordpress = yield self.service_state_manager.add_service_state(
+            "wordpress", self.formula_state)
+        mysql = yield self.service_state_manager.add_service_state(
+            "mysql", self.formula_state)
+
+        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.assertNotIdentical(hash(s1), hash(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))
+
+    @inlineCallbacks
     def test_get_service_unit_not_found(self):
         """
         Attempting to retrieve a non-existent service unit should

=== modified file 'ensemble/state/topology.py'
--- ensemble/state/topology.py	2011-01-26 19:50:07 +0000
+++ ensemble/state/topology.py	2011-02-01 15:32:39 +0000
@@ -294,6 +294,12 @@
         """
         return relation_id in self._state.get("relations", self._nil_dict)
 
+    def get_all_relation_names(self):
+        """Returns a list of relation_id that can be passed to other
+        get_relation methods.
+        """
+        return self._state.get("relations", self._nil_dict).keys()
+
     def get_relation_services(self, relation_id):
         """Get all the services associated to the relation.
         """