Merge lp:~therve/pyjuju/rapi-uuid into lp:pyjuju

[Thomas Herve]

The branch merges the changes from trunk including the new environment UUID, and expose that UUID in the first API message.

Unmerged revisions

624. By Thomas Herve on 2013-01-17

Add env uuid to the API

623. By Thomas Herve on 2013-01-17

Merge from trunk

622. By Kapil Thangavelu on 2013-01-10

Merged rapi-annotation into rapi-rollup.

621. By Kapil Thangavelu on 2012-12-20

Merged rapi-annotation into rapi-rollup.

620. By Kapil Thangavelu on 2012-12-18

merge tls for ws

619. By Kapil Thangavelu on 2012-12-17

merge rapi-login

618. By Kapil Thangavelu on 2012-11-07

Merged export-import into rapi-rollup.

617. By Kapil Thangavelu on 2012-10-20

add openstack export

616. By Kapil Thangavelu on 2012-10-20

Merged svc-change-units into export-import.

615. By Kapil Thangavelu on 2012-10-16

Merged svc-change-units into export-import.

=== added file 'improv.py'
--- improv.py	1970-01-01 00:00:00 +0000
+++ improv.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,463 @@
+#!/usr/bin/which python
+#
+# Launch a juju api server with some sample data.
+#
+#
+# author: kapilt
+"""
+
+TODO:
+
+  Subordinate service unit handling.
+
+    - data generator on new relation or new unit
+    - check scope of relation if subordinate, add sub units
+    - on new unit, check service relations for sub and add sub unit
+    - on removed unit, check service relations for sub and remove sub unit.
+"""
+
+import argparse
+import json
+import logging
+import os
+import random
+import shutil
+import tempfile
+import yaml
+import zookeeper
+
+from twisted.internet.defer import Deferred, inlineCallbacks, succeed
+from twisted.internet import reactor
+
+from juju.agents.api import APIEndpointAgent, keys_directory
+from juju.charm.publisher import CharmPublisher
+from juju.charm.repository import (
+    CharmURL, RemoteCharmRepository, CS_STORE_URL)
+
+from juju.environment.config import EnvironmentsConfig
+from juju.errors import JujuError
+from juju.state.environment import EnvironmentStateManager
+
+from juju.machine.constraints import ConstraintSet
+from juju.providers.dummy import MachineProvider, DummyMachine
+from juju.providers.common.files import FileStorage
+
+from juju.state.base import StateBase
+from juju.state.endpoint import RelationEndpoint
+from juju.state.errors import StopWatcher
+from juju.state.initialize import StateHierarchy
+from juju.state.machine import MachineStateManager
+from juju.state.placement import _unassigned_placement
+from juju.state.relation import RelationStateManager
+from juju.state.security import Principal
+from juju.state.service import ServiceStateManager
+from juju.state.utils import get_open_port, YAMLState
+from juju.tests.common import zookeeper_test_context
+
+
+
+from txzookeeper.managed import ManagedClient
+
+log = logging.getLogger("jitsu.scale")
+
+
+JUJU_ENV_CONF = """
+environments:
+  dervish:
+    type: dummy
+    default-series: precise
+"""
+
+
+class TempDir(object):
+
+    def __enter__(self):
+        self.temp_dir = tempfile.mkdtemp()
+        return self.temp_dir
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        if os.path.exists(self.temp_dir):
+            shutil.rmtree(self.temp_dir)
+
+
+class Machine(DummyMachine):
+
+    def __init__(self, instance_id, dns_name, private_dns, state):
+        self.instance_id = instance_id
+        self.dns_name = dns_name
+        self.private_dns_name = private_dns
+        self.state = state
+
+
+class MachineProvider(MachineProvider):
+
+    def start_machine(self, machine_data, master=False):
+        """Start a machine in the provider."""
+
+        machine = Machine(
+            machine_data['machine_id'],
+            machine_data['dns_name'],
+            machine_data['priv_dns_name'],
+            machine_data['state']
+            )
+        self._machines.append(machine)
+        return succeed([machine])
+
+
+class DataGenerator(StateBase):
+
+    # weighted
+    unit_states = (
+        'pending', 'installed', 'install_error',
+        'started', 'started', 'started', 'started',
+        'start_error', 'stopped', 'stop_error')
+
+    # weighted / 80% success
+    relation_states = ('up', 'up', 'up', 'down', 'down')
+
+    # weighted / 90% running
+    machine_agent_states = (
+        'pending', 'running', 'running', 'running')
+
+    machine_states = (
+        'running', 'pending', 'terminated', 'stopped')
+
+    def __init__(self, client, provider):
+        super(DataGenerator, self).__init__(client)
+        self.address_block = "192.168.%s.%s"
+        self.provider = provider
+        self.addresses = set()
+        self.seen = set()
+        self.running = False
+        self.finished = Deferred()
+
+    @inlineCallbacks
+    def init_service_unit(self, topo, service_id, unit_id, unit_name):
+
+        relations = topo.get_relations_for_service(service_id)
+
+        # Topology doesn't store subordinate status, this is a best
+        # approximation, technically a subordinate can be the server.
+        is_sub = bool(
+            [r for r in relations if r['scope'] == 'container' \
+             and r['service']['role'] == 'client'])
+
+        # Find the machine for the unit.
+        if is_sub:
+            container_id = topo.get_service_unit_principal(unit_id)
+            assert container_id, "no container for subordinate %s" % unit_name
+            container_svc_id = topo.get_service_unit_service(container_id)
+            machine_id = topo.get_service_unit_machine(
+                container_svc_id, container_id)
+        else:
+            machine_id = topo.get_service_unit_machine(service_id, unit_id)
+
+        log.debug("Processing new unit %s:%s (sub: %s) on machine %s" % (
+            unit_name, unit_id, is_sub, machine_id))
+
+        # If the unit's machine is pending, bail.
+        if machine_id is None:
+            return
+
+        machine = yield self.provider.get_machine(machine_id)
+        if machine.state == 'pending':
+            return
+
+        self.seen.add(unit_id)
+
+        # TODO for subs check principal is running.
+        state = random.choice(self.unit_states)
+        if state == 'pending':
+            return
+
+        node = YAMLState(self._client, "/units/%s" % unit_id)
+        yield node.read()
+
+        unit_address = self._new_address()
+
+        w = {unit_name: yaml.safe_dump(
+            {'state': state, 'state_variables': {}})}
+
+        for r in relations:
+            # simulate the unit's relation state enough for status.
+            # TODO: subordinate relation state
+            if r['scope'] == 'container':
+                continue
+            alive_path = "/relations/%s/%s/%s" % (
+                r['relation_id'], r['service']['role'], unit_id)
+            yield self._client.create(alive_path)
+
+            w[r['relation_id']] = yaml.safe_dump({
+                'state': random.choice(self.relation_states),
+                'state_variables': {}})
+
+        d = {'public-address': unit_address,
+             'private-address': unit_address,
+             'workflow_state': w}
+
+        node.update(d)
+
+        try:
+            yield self._client.create("/units/%s/agent" % unit_id, "")
+        except zookeeper.NodeExistsException:
+            log.debug("Unit: %s already has agent.." % unit_id)
+            pass
+
+        yield node.write()
+        n, s = yield self._client.get("/units/%s" % unit_id)
+
+    @inlineCallbacks
+    def init_machine(self, mid):
+        maddr = self._new_address()
+        md = {'machine_id': mid, 'priv_dns_name': maddr,
+              'state': 'running', 'dns_name': maddr}
+        yield self.provider.start_machine(md)
+        node = YAMLState(self._client, "/machines/%s" % mid)
+        yield node.read()
+        node['provider-machine-id'] = mid
+        yield node.write()
+        if md['state'] == 'running':
+            yield self._client.create("/machines/%s/agent" % mid, "")
+
+    def _new_address(self):
+        while 1:
+            addr = self.address_block % (
+                random.randint(1, 256), random.randint(1, 256))
+            if addr in self.addresses:
+                continue
+            self.addresses.add(addr)
+            return addr
+
+    @inlineCallbacks
+    def process(self, old, new):
+        """
+        """
+        log.info("DataGen processing topology delta")
+        if not self.running:
+            self.finished.callback(True)
+            raise StopWatcher()
+
+        # Process new and removed machines.
+        cur_machines = set(new.get_machines())
+        if old is None:
+            old_machines = set()
+        else:
+            old_machines = set(old.get_machines())
+
+        for m in (cur_machines - old_machines):
+            #log.info("Adding machine %s" % m)
+            yield self.init_machine(m)
+
+        removed = list(old_machines - cur_machines)
+        p_machines = yield self.provider.get_machines(removed)
+        yield self.provider.shutdown_machines(p_machines)
+
+        # Process new units.
+        cur_services = set(new.get_services())
+        cur_units = set()
+        for s in cur_services:
+            get_unit_name = lambda uid: (
+                s, uid, new.get_service_unit_name(s, uid))
+            cur_units.update(
+                map(get_unit_name, new.get_service_units(s)))
+
+        for su in cur_units:
+            if su[1] in self.seen:
+                continue
+            #log.info("Adding unit %s" % (su,))
+            yield self.init_service_unit(new, *su)
+
+        self.count += 1
+
+    def start(self):
+        assert not self.running
+        self.running = True
+        self.count = 0
+        self.finished = Deferred()
+        return self._watch_topology(self.process)
+
+    def stop(self):
+        if not self.running:
+            return
+        self.running = False
+        return self.finished
+
+
+@inlineCallbacks
+def load(client, data):
+    """load up an environment export (based on jitsu import)
+    """
+    # Get state managers
+    services = ServiceStateManager(client)
+    relations = RelationStateManager(client)
+    machines = MachineStateManager(client)
+
+    # Resolve charms from charm store
+    store = RemoteCharmRepository(CS_STORE_URL)
+    charms = []
+    for s in data['services']:
+        curl = CharmURL.infer(s['charm'], "precise")
+        if s['charm'].startswith('local:'):
+            raise JujuError("Local charm not supported")
+        else:
+            assert s['charm'].startswith('cs:')
+            charm = yield store.find(curl)
+            charms.append((s['charm'], charm))
+
+    # Upload charms to the environment
+    with TempDir() as temp_dir:
+        storage = FileStorage(temp_dir)
+        publisher = CharmPublisher(client, storage)
+        seen = set()
+        for cid, c in charms:
+            if cid in seen:
+                continue
+            seen.add(cid)
+            log.info("Publishing charm %s", cid)
+            yield publisher.add_charm(
+                str(CharmURL.infer(cid, "precise")),
+                c)
+        charm_states = yield publisher.publish()
+
+    # Index by url
+    charm_map = dict([(ci[0], cs) for ci, cs in zip(charms, charm_states)])
+    constraint_set = ConstraintSet("dummy")
+    constraint_set.register_generics([])
+
+    # Create services
+    for s in data['services']:
+        log.info("Creating service %s %s", s['name'], charm_map[s['charm']].id)
+        constraints = constraint_set.load(s['constraints'])
+        svc = yield services.add_service_state(
+            s['name'],
+            charm_map[s['charm']],
+            constraints)
+        config = yield svc.get_config()
+        config.update(s['config'])
+        yield config.write()
+
+        # Create units
+        log.info("Creating units %d", s['unit_count'])
+        for i in range(s['unit_count']):
+            unit = yield svc.add_unit_state()
+            yield _unassigned_placement(client, machines, unit)
+
+    # Add relations
+    for r in data['relations']:
+        if len(r) == 1:
+            eps = [RelationEndpoint(*r[0])]
+        else:
+            eps = [RelationEndpoint(*r[0]), RelationEndpoint(*r[1])]
+        log.info("Adding relation %s" % (
+            " ".join(map(
+                lambda r: "%s:%s %s" % (
+                    r.service_name, r.relation_name, r.relation_role),
+                eps))))
+        yield relations.add_relation_state(*eps)
+
+
+@inlineCallbacks
+def initialize(
+        api_port, api_secure, api_keys, zk_port, export_data, agent_dir):
+
+    # Setup the state hierarchy.
+    client = yield ManagedClient("localhost:%s" % zk_port).connect()
+    principal = Principal("admin", "admin")
+    constraints = {'arch': 'amd64', 'cpu': 1,
+                   'ubuntu-series': 'precise', 'provider-type': 'dummy'}
+    log.info("Initializing state")
+    state = StateHierarchy(
+        client, principal.get_token(), "0", constraints, "dummy")
+    yield state.initialize()
+
+    # Initialize the environment config state.
+    config = EnvironmentsConfig()
+    config.parse(JUJU_ENV_CONF)
+    env = EnvironmentStateManager(client)
+    yield env.set_config_state(config, "dervish")
+
+    provider = MachineProvider("dervish", config.get_default())
+
+    # Attach the client
+    yield principal.attach(client)
+
+    # Load the tree
+    yield load(client, export_data)
+
+    # Hook up the runtime data simulator
+    #   Generates appropriate state for units, and machines.
+    generator = DataGenerator(client, provider)
+    yield generator.start()
+
+    # Start the api agent
+    agent = APIEndpointAgent()
+    agent.configure({
+        "zookeeper_servers": "localhost:%s" % zk_port,
+        "logfile": "-",
+        "juju_directory": agent_dir,
+        "port": api_port,
+        "secure": api_secure,
+        "keys": api_keys,
+        "loglevel": "DEBUG",
+        "session_file": os.path.join(agent_dir, "session.yml")
+        })
+    log.info("Starting api agent..")
+    yield agent.startService()
+
+
+@inlineCallbacks
+def run_one(func, *args, **kw):
+    try:
+        yield func(*args, **kw)
+    except:
+        import traceback
+        traceback.print_exc()
+        reactor.stop()
+
+
+def get_parser():
+    parser = argparse.ArgumentParser(
+        description="Start an api server with data")
+    parser.add_argument("-p", "--port", default=8081, type=int,
+                        help="Port to use")
+    parser.add_argument("-s", "--secure", action='store_true',
+                        help="Enable secure websockets")
+    parser.add_argument("-k", "--keys", type=keys_directory, metavar='PATH',
+                        help="Path to juju.key and juju.crt, used by secure "
+                             "websockets in place of the default ones")
+    parser.add_argument("-f", "--file", required=True,
+                        type=argparse.FileType('r'),
+                        help="Environment json export")
+
+    return parser
+
+
+def main():
+    parser = get_parser()
+    options = parser.parse_args()
+    log_options = {
+        "level": logging.DEBUG,
+        "format": "%(asctime)s %(name)s:%(levelname)s %(message)s"}
+
+    logging.basicConfig(**log_options)
+    zookeeper.set_debug_level(0)
+    export_data = json.loads(options.file.read())
+    zk_port = get_open_port()
+
+
+    if not "ZOOKEEPER_PATH" in os.environ:
+        if not os.path.exists('/etc/zookeeper/conf'):
+            raise ValueError("ZK not found")
+        os.environ['ZOOKEEPER_PATH'] = "system"
+
+    with TempDir() as agent_dir:
+        with zookeeper_test_context(os.environ['ZOOKEEPER_PATH'], zk_port):
+            reactor.callWhenRunning(
+                run_one, initialize,
+                options.port, options.secure, options.keys,
+                zk_port, export_data, agent_dir)
+            reactor.run()
+
+if __name__ == '__main__':
+    main()
+

=== added file 'juju/agents/api.py'
--- juju/agents/api.py	1970-01-01 00:00:00 +0000
+++ juju/agents/api.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,159 @@
+"""
+API endpoint agent.
+"""
+import argparse
+import os
+import logging
+
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.agents.base import BaseAgent
+from juju.environment.config import EnvironmentsConfig
+from juju.errors import JujuError
+from juju.lib.websockets import WebSocketsResource
+from juju.rapi.transport.ws import WebSocketAPIFactory
+from juju.state.auth import make_ace
+
+from twisted.internet import ssl
+from twisted.web.static import Data
+from twisted.web.server import Site
+from zookeeper import NoNodeException
+
+log = logging.getLogger("juju.agents.api")
+KEYS_DEFAULT_PATH = os.path.abspath(
+    os.path.join(os.path.dirname(__file__), 'keys'))
+
+
+def keys_directory(argument):
+    """Validate the path argument and return *(private key, certificate)*."""
+    path = os.path.abspath(os.path.expanduser(argument))
+    if os.path.isdir(path):
+        key = os.path.join(path, 'juju.key')
+        cert = os.path.join(path, 'juju.crt')
+        if os.path.isfile(key) and os.path.isfile(cert):
+            # The order is significant here. These paths will be passed to
+            # ``twisted.internet.ssl.DefaultOpenSSLContextFactory``.
+            return key, cert
+        msg = 'cannot find the juju.key and juju.crt files in %r' % argument
+        raise argparse.ArgumentTypeError(msg)
+    msg = '%r: no such directory' % argument
+    raise argparse.ArgumentTypeError(msg)
+
+
+class APIEndpointAgent(BaseAgent):
+
+    name = "juju-api"
+
+    @inlineCallbacks
+    def start(self):
+        log.info("Starting api server")
+
+        self.environment = yield self.configure_environment()
+        self.provider = yield self._get_provider()
+        env_uuid = yield self.global_settings_state.get_environment_id()
+        log.debug("Received environment data.")
+        root = Data("Juju API Server\n", "text/plain")
+        self.ws_factory = WebSocketAPIFactory(
+            self.config['zookeeper_servers'], self.provider, env_uuid)
+        yield self.ws_factory.startFactory()
+
+        root.putChild('ws', WebSocketsResource(self.ws_factory))
+
+        from twisted.internet import reactor
+
+        port = int(self.config.get('port', 80))
+        site = Site(root)
+        if self.config.get('secure'):
+            keys = self.config['keys'] or keys_directory(KEYS_DEFAULT_PATH)
+            context_factory = ssl.DefaultOpenSSLContextFactory(*keys)
+            self.api_socket = reactor.listenSSL(port, site, context_factory)
+            log.info("Secure websocket active")
+        else:
+            self.api_socket = reactor.listenTCP(port, site)
+            log.info("Websocket active")
+
+    def stop(self):
+        if self.api_socket:
+            self.ws_factory.stopFactory()
+            self.api_socket.stopListening()
+            self.api_socket = None
+
+    def _get_provider(self):
+        return self.environment.get_machine_provider()
+
+    # TODO Refactory into common for provisioning agent
+    @inlineCallbacks
+    def configure_environment(self):
+        """The provisioning agent configure its environment on start or change.
+
+        The environment contains the configuration th agent needs to interact
+        with its machine provider, in order to do its work. This configuration
+        data is deployed lazily over an encrypted connection upon first usage.
+
+        The agent waits for this data to exist before completing its startup.
+        """
+        try:
+            get_d, watch_d = self.client.get_and_watch("/environment")
+            environment_data, stat = yield get_d
+        except NoNodeException:
+            # Wait till the environment node appears. play twisted gymnastics
+            exists_d, watch_d = self.client.exists_and_watch("/environment")
+            stat = yield exists_d
+            if stat:
+                environment = yield self.configure_environment()
+            else:
+                watch_d.addCallback(
+                    lambda result: self.configure_environment())
+            if not stat:
+                environment = yield watch_d
+            returnValue(environment)
+
+        # Lazy initialize login nodes if not present.
+        yield self._initialize_login()
+
+        config = EnvironmentsConfig()
+        config.parse(environment_data)
+        returnValue(config.get_default())
+
+    @inlineCallbacks
+    def _initialize_login(self):
+        children = yield self.client.get_children("/")
+        if "login" in children:
+            return
+
+        acls, stat = yield self.client.get_acl("/initialized")
+        admin_acl = None
+
+        for a in acls:
+            if a['id'].startswith('admin'):
+                admin_acl = a
+                break
+
+        yield self.client.create(
+            "/login", acls=[make_ace(admin_acl['id'], all=True)])
+
+    def configure(self, options):
+        super(APIEndpointAgent, self).configure(options)
+        if not options.get("port"):
+            msg = ("--port must be provided in the command line")
+            raise JujuError(msg)
+        if options.get("keys") and not options.get("secure"):
+            msg = ("in addition to providing keys, a secure connection must "
+                   "be explicitly enabled using --secure")
+            raise JujuError(msg)
+        self.api_socket = None
+
+    @classmethod
+    def setup_options(cls, parser):
+        super(APIEndpointAgent, cls).setup_options(parser)
+        port = os.environ.get("JUJU_API_PORT", "")
+        default_port = port.isdigit() and int(port) or 80
+        parser.add_argument(
+            "--port", default=default_port, type=int)
+        parser.add_argument("--secure", action='store_true')
+        parser.add_argument("--keys", default=os.getenv('JUJU_API_KEYS'),
+                            type=keys_directory, metavar='PATH')
+        return parser
+
+if __name__ == '__main__':
+    APIEndpointAgent.run()

=== added directory 'juju/agents/keys'
=== added file 'juju/agents/keys/juju.crt'
--- juju/agents/keys/juju.crt	1970-01-01 00:00:00 +0000
+++ juju/agents/keys/juju.crt	2013-01-17 11:02:31 +0000
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDFjCCAf4CCQDVditilj3gADANBgkqhkiG9w0BAQUFADBNMQswCQYDVQQGEwJV
+SzEWMBQGA1UECAwNR3JlYXQgQnJpdGFpbjEXMBUGA1UECgwOQ2Fub25pY2FsIEx0
+ZC4xDTALBgNVBAMMBEp1anUwHhcNMTIxMDI0MTEwODExWhcNMjIxMDIyMTEwODEx
+WjBNMQswCQYDVQQGEwJVSzEWMBQGA1UECAwNR3JlYXQgQnJpdGFpbjEXMBUGA1UE
+CgwOQ2Fub25pY2FsIEx0ZC4xDTALBgNVBAMMBEp1anUwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQC06CPCvKhkehtxrJ8aVI+M2SoPT1XAJWxe6pOLRkAu
+laD6QlE7krsu3ERFnOQnMMwH38zFKEszBWuNSbff2DSPR3SXH+mFg8XNjzg4d04P
+hObvAUAa3M/h5kUnJpZ4TrU8eYWGE/sW5AGRmw6lIL6mBP5uYgF0/wJv3Wsa53NC
+khztRSvmiDFO52f2OVx5mUU8LkpuTrwc0Z4UL76lqRGFOUizDL/SCdbX273GH63J
+4Qt/ex3kYLyOVtbmVJRXLXoVDVFTU6VzhW4LaN1ql+OpvntY7NHCXu+2+v/VJKyY
+9vFHY1AFF6xhSAvOtGPwreZkCj1nDJIq/NroCs35EPwlAgMBAAEwDQYJKoZIhvcN
+AQEFBQADggEBAJ2a1ZeArxwI6qGp5NjpD3JBElG0Oe0xKqQNM27eWzsjq3vzWrhg
+wtqZZdmUWbnbj/cw5GUxZY6DB56D8HPgjFecyVoC1ffY5RU5QNZndw7C74C5Rty9
+3Rc8m0IB3z6obEHk+0yW4w2kk7g/T49uHpumfc39zYSHMBsQISXdTvulx0ualbwq
+nmDIC96alu2mL7wyvSWzNbqOhIJR45uznqADeBEWSVVjYVG6DW41Ss/dr0XHRQKh
+5kBzaC8TlN9lauOVqJv+kr9FlrLus0vnouYbxFn1Cjf4PPGzqk7zQBDKOty0pBkc
+3NUUa63qxDE7DIw5Knk45cvsOba9nTaLnBU=
+-----END CERTIFICATE-----

=== added file 'juju/agents/keys/juju.key'
--- juju/agents/keys/juju.key	1970-01-01 00:00:00 +0000
+++ juju/agents/keys/juju.key	2013-01-17 11:02:31 +0000
@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEowIBAAKCAQEAtOgjwryoZHobcayfGlSPjNkqD09VwCVsXuqTi0ZALpWg+kJR
+O5K7LtxERZzkJzDMB9/MxShLMwVrjUm339g0j0d0lx/phYPFzY84OHdOD4Tm7wFA
+GtzP4eZFJyaWeE61PHmFhhP7FuQBkZsOpSC+pgT+bmIBdP8Cb91rGudzQpIc7UUr
+5ogxTudn9jlceZlFPC5Kbk68HNGeFC++pakRhTlIswy/0gnW19u9xh+tyeELf3sd
+5GC8jlbW5lSUVy16FQ1RU1Olc4VuC2jdapfjqb57WOzRwl7vtvr/1SSsmPbxR2NQ
+BResYUgLzrRj8K3mZAo9ZwySKvza6ArN+RD8JQIDAQABAoIBADKfXxpoNmrfbHyT
+xHXWwdC1GDruhV1eW4P3+k+X2e/vOPuuwRJ9jdmgE46zR3jcA8wUSTXGf7yIQL9p
+qIV/9708TpjXej49UIWkFSRf5j0bgI/S9sBNl/JrwGAjQSnrRHXmv4F0Z+fQ58t5
+61Az6IWGkjgLPsMhdOoeuJDvwWYYCjTKAGxa9SHxHjqPg4uWk5Ndc+vvnoxhGgkm
+6b183JR6zc80r6F9xJyXOvP8RSHG/CC/O9I7St004EsQjXlFUUtZTQlgawnrZv20
+0YPwTExHyB4aj9gXDVEykdoku2X+7nytCRKzxXTJshLO3uiLSOsrX43hWX0tCiK7
++foX8yECgYEA51WO3gifcmIrckcQbcJXzyL0zFrOs3VahXCh7zN9E21hgnGLaj0Y
+Q8bkSJGKzCWVHUoIkqaFgCuj6PGj6rpLYtkJ8HqTWxEwUrCa6chkv43oY3h1vRjP
+XqmPy+Arvz3ypPgWuu+E3fd+uDvJp5o9wp6F+PXxacV75IBDIQFtMx0CgYEAyDIg
+ktImbNv6wqOz8Bw/7GsmxN9XLpwNJzV4sP6/bhHuxn44qhM6YoZTKblt58TujtQX
+D3/snSiXBJIci/AR1nQw76exFUOhNt30efCKxjz5gKSj1cQ5fN0e/5JT4OhZrjZD
+RmY0Za6+TO+p1796r7/RM3a4FVWuM0j/hFhA1qkCgYEAnzoXtSIwRXXmu6jIWRP8
+hplj78jNH162KMTm4RMKkzWleTiYIk7dBcG/XWe4Jl3z7g4IKpCtsRPYpTy1e5ow
+y1/iZICqLnN9VF00s5d4KRUPEHBYcgjCq0CAtm6dDewguIX+dzrntDRnJ34XheI3
+gl7EjiESwp/ob9YM3onx1M0CgYBCYOyQAgIfoijZFLJ68ML5PuYR7QPZPoDV+VLV
+TQJoGqYTRpK/QbTgKi207fjVGmUHEqe6ye3Ihkbcix3QAH/JnakELZP3uv7fVGTV
+cb5x0JHh57UzEecF0cOPdhM9xYzGyNMxqn3BIVmT5Ptpv+GMGIvjBoAvAsPJ2XBv
+j1ugUQKBgFDooiQAvqjJFJbnsRuYUirf1J//PR76BAu5dt+0573VgRkJ+OULOe4b
+mJs9Hi5XHCgPP4lmltz9EFsgcD1cFp0KFuadltYkB3Hp4uJZtUDC/pWT5myn9gv0
+aIOJKuRux7yhcavIazgLDIo/ko14Sp7pnpBFh70ruRNbTuSYBIS/
+-----END RSA PRIVATE KEY-----

=== modified file 'juju/charm/repository.py'
--- juju/charm/repository.py	2012-08-23 23:57:09 +0000
+++ juju/charm/repository.py	2013-01-17 11:02:31 +0000
@@ -129,7 +129,10 @@
             self.url_base, urllib.quote(charm_id))
         try:
             host = urlparse.urlparse(url).hostname
-            all_info = json.loads((yield getPage(url, contextFactory=VerifyingContextFactory(host))))
+            all_info = json.loads(
+                (yield getPage(
+                    url,
+                    contextFactory=VerifyingContextFactory(host))))
             charm_info = all_info[charm_id]
             for warning in charm_info.get("warnings", []):
                 log.warning("%s: %s", charm_id, warning)
@@ -152,7 +155,8 @@
         downloading_path = f.name
         host = urlparse.urlparse(url).hostname
         try:
-            yield downloadPage(url, downloading_path, contextFactory=VerifyingContextFactory(host))
+            yield downloadPage(url, downloading_path,
+                               contextFactory=VerifyingContextFactory(host))
         except Error:
             raise CharmNotFound(self.url_base, charm_url)
         os.rename(downloading_path, cache_path)

=== modified file 'juju/charm/tests/test_metadata.py'
--- juju/charm/tests/test_metadata.py	2012-09-14 15:33:33 +0000
+++ juju/charm/tests/test_metadata.py	2013-01-17 11:02:31 +0000
@@ -222,22 +222,27 @@
     def test_provide_implicit_relation(self):
         """Verify providing a juju-* reserved relation errors"""
         with self.change_sample() as data:
-            data["provides"] = {"juju-foo": {"interface": "juju-magic", "scope": "container"}}
+            data["provides"] = {"juju-foo": {
+                "interface": "juju-magic",
+                "scope": "container"}}
 
         # verify relation level error
         error = self.assertRaises(MetaDataError,
                                   self.metadata.parse, self.sample)
-        self.assertIn("Charm dummy attempting to provide relation in implicit relation namespace: juju-foo",
+        self.assertIn(("Charm dummy attempting to provide relation "
+                      "in implicit relation namespace: juju-foo"),
                       str(error))
 
         # verify interface level error
         with self.change_sample() as data:
-            data["provides"] = {"foo-rel": {"interface": "juju-magic", "scope": "container"}}
+            data["provides"] = {"foo-rel": {
+                "interface": "juju-magic", "scope": "container"}}
 
         error = self.assertRaises(MetaDataError,
                                   self.metadata.parse, self.sample)
         self.assertIn(
-            "Charm dummy attempting to provide interface in implicit namespace: juju-magic (relation: foo-rel)",
+            ("Charm dummy attempting to provide interface "
+            "in implicit namespace: juju-magic (relation: foo-rel)"),
             str(error))
 
     def test_format(self):

=== added file 'juju/lib/constants.py'
--- juju/lib/constants.py	1970-01-01 00:00:00 +0000
+++ juju/lib/constants.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,359 @@
+# -*- test-case-name: twisted.python.test.test_constants -*-
+# Copyright (c) Twisted Matrix Laboratories.
+# See LICENSE for details.
+# License: MIT
+# See MIT http://opensource.org/licenses/mit-license.php for details.
+"""
+Symbolic constant support, including collections and constants with text,
+numeric, and bit flag values.
+"""
+
+__all__ = [
+    'NamedConstant', 'ValueConstant', 'FlagConstant',
+    'Names', 'Values', 'Flags']
+
+from itertools import count
+from operator import and_, or_, xor
+
+_unspecified = object()
+_constantOrder = count().next
+
+
+class _Constant(object):
+    """
+    @ivar _index: A C{int} allocated from a shared counter in order to keep
+        track of the order in which L{_Constant}s are instantiated.
+
+    @ivar name: A C{str} giving the name of this constant; only set once the
+        constant is initialized by L{_ConstantsContainer}.
+
+    @ivar _container: The L{_ConstantsContainer} subclass this constant belongs
+        to; only set once the constant is initialized by that subclass.
+    """
+    def __init__(self):
+        self._index = _constantOrder()
+
+    def __get__(self, oself, cls):
+        """
+        Ensure this constant has been initialized before returning it.
+        """
+        cls._initializeEnumerants()
+        return self
+
+    def __repr__(self):
+        """
+        Return text identifying both which constant this is and which
+        collection it belongs to.
+        """
+        return "<%s=%s>" % (self._container.__name__, self.name)
+
+    def _realize(self, container, name, value):
+        """
+        Complete the initialization of this L{_Constant}.
+
+        @param container: The L{_ConstantsContainer} subclass this constant is
+            part of.
+
+        @param name: The name of this constant in its container.
+
+        @param value: The value of this constant; not used, as named constants
+            have no value apart from their identity.
+        """
+        self._container = container
+        self.name = name
+
+
+class _EnumerantsInitializer(object):
+    """
+    L{_EnumerantsInitializer} is a descriptor used to initialize a
+    cache of objects representing named constants for a particular
+    L{_ConstantsContainer} subclass.
+    """
+    def __get__(self, oself, cls):
+        """
+        Trigger the initialization of the enumerants cache on C{cls} and then
+        return it.
+        """
+        cls._initializeEnumerants()
+        return cls._enumerants
+
+
+class _ConstantsContainer(object):
+    """
+    L{_ConstantsContainer} is a class with attributes used as symbolic
+    constants.  It is up to subclasses to specify what kind of constants are
+    allowed.
+
+    @cvar _constantType: Specified by a L{_ConstantsContainer} subclass to
+        specify the type of constants allowed by that subclass.
+
+    @cvar _enumerantsInitialized: A C{bool} tracking whether C{_enumerants} has
+        been initialized yet or not.
+
+    @cvar _enumerants: A C{dict} mapping the names of constants (eg
+        L{NamedConstant} instances) found in the class definition to those
+        instances.  This is initialized via the L{_EnumerantsInitializer}
+        descriptor the first time it is accessed.
+    """
+    _constantType = None
+
+    _enumerantsInitialized = False
+    _enumerants = _EnumerantsInitializer()
+
+    def __new__(cls):
+        """
+        Classes representing constants containers are not intended to be
+        instantiated.
+
+        The class object itself is used directly.
+        """
+        raise TypeError("%s may not be instantiated." % (cls.__name__,))
+
+    def _initializeEnumerants(cls):
+        """
+        Find all of the L{NamedConstant} instances in the definition of C{cls},
+        initialize them with constant values, and build a mapping from their
+        names to them to attach to C{cls}.
+        """
+        if not cls._enumerantsInitialized:
+            constants = []
+            for (name, descriptor) in cls.__dict__.iteritems():
+                if isinstance(descriptor, cls._constantType):
+                    constants.append((descriptor._index, name, descriptor))
+            enumerants = {}
+            constants.sort()
+            for (index, enumerant, descriptor) in constants:
+                value = cls._constantFactory(enumerant, descriptor)
+                descriptor._realize(cls, enumerant, value)
+                enumerants[enumerant] = descriptor
+            # Replace the _enumerants descriptor with the result so
+            # future access will go directly to the values.  The
+            # _enumerantsInitialized flag is still necessary because
+            # NamedConstant.__get__ may also call this method.
+            cls._enumerants = enumerants
+            cls._enumerantsInitialized = True
+    _initializeEnumerants = classmethod(_initializeEnumerants)
+
+    def _constantFactory(cls, name, descriptor):
+        """
+        Construct the value for a new constant to add to this container.
+
+        @param name: The name of the constant to create.
+
+        @return: L{NamedConstant} instances have no value apart from identity,
+            so return a meaningless dummy value.
+        """
+        return _unspecified
+    _constantFactory = classmethod(_constantFactory)
+
+    def lookupByName(cls, name):
+        """
+        Retrieve a constant by its name or raise a C{ValueError} if there is no
+        constant associated with that name.
+
+        @param name: A C{str} giving the name of one of the constants
+            defined by C{cls}.
+
+        @raise ValueError: If C{name} is not the name of one of the constants
+            defined by C{cls}.
+
+        @return: The L{NamedConstant} associated with C{name}.
+        """
+        if name in cls._enumerants:
+            return getattr(cls, name)
+        raise ValueError(name)
+    lookupByName = classmethod(lookupByName)
+
+    def iterconstants(cls):
+        """
+        Iteration over a L{Names} subclass results in all of the constants it
+        contains.
+
+        @return: an iterator the elements of which are the L{NamedConstant}
+            instances defined in the body of this L{Names} subclass.
+        """
+        constants = cls._enumerants.values()
+        constants.sort(key=lambda descriptor: descriptor._index)
+        return iter(constants)
+    iterconstants = classmethod(iterconstants)
+
+
+class NamedConstant(_Constant):
+    """
+    L{NamedConstant} defines an attribute to be a named constant within a
+    collection defined by a L{Names} subclass.
+
+    L{NamedConstant} is only for use in the definition of L{Names}
+    subclasses.  Do not instantiate L{NamedConstant} elsewhere and do not
+    subclass it.
+    """
+
+
+class Names(_ConstantsContainer):
+    """
+    A L{Names} subclass contains constants which differ only in their names and
+    identities.
+    """
+    _constantType = NamedConstant
+
+
+class ValueConstant(_Constant):
+    """
+    L{ValueConstant} defines an attribute to be a named constant within a
+    collection defined by a L{Values} subclass.
+
+    L{ValueConstant} is only for use in the definition of L{Values} subclasses.
+    Do not instantiate L{ValueConstant} elsewhere and do not subclass it.
+    """
+    def __init__(self, value):
+        _Constant.__init__(self)
+        self.value = value
+
+
+class Values(_ConstantsContainer):
+    """
+    A L{Values} subclass contains constants which are associated with arbitrary
+    values.
+    """
+    _constantType = ValueConstant
+
+    def lookupByValue(cls, value):
+        """
+        Retrieve a constant by its value or raise a C{ValueError} if
+        there is no constant associated with that value.
+
+        @param value: The value of one of the constants defined by C{cls}.
+
+        @raise ValueError: If C{value} is not the value of one of the constants
+            defined by C{cls}.
+
+        @return: The L{ValueConstant} associated with C{value}.
+        """
+        for constant in cls.iterconstants():
+            if constant.value == value:
+                return constant
+        raise ValueError(value)
+    lookupByValue = classmethod(lookupByValue)
+
+
+def _flagOp(op, left, right):
+    """
+    Implement a binary operator for a L{FlagConstant} instance.
+
+    @param op: A two-argument callable implementing the binary operation.  For
+        example, C{operator.or_}.
+
+    @param left: The left-hand L{FlagConstant} instance.
+    @param right: The right-hand L{FlagConstant} instance.
+
+    @return: A new L{FlagConstant} instance representing the result of the
+        operation.
+    """
+    value = op(left.value, right.value)
+    names = op(left.names, right.names)
+    result = FlagConstant()
+    result._realize(left._container, names, value)
+    return result
+
+
+class FlagConstant(_Constant):
+    """
+    L{FlagConstant} defines an attribute to be a flag constant within a
+    collection defined by a L{Flags} subclass.
+
+    L{FlagConstant} is only for use in the definition of L{Flags} subclasses.
+    Do not instantiate L{FlagConstant} elsewhere and do not subclass it.
+    """
+    def __init__(self, value=_unspecified):
+        _Constant.__init__(self)
+        self.value = value
+
+    def _realize(self, container, names, value):
+        """
+        Complete the initialization of this L{FlagConstant}.
+
+        This implementation differs from other C{_realize} implementations in
+        that a L{FlagConstant} may have several names which apply to it, due to
+        flags being combined with various operators.
+
+        @param container: The L{Flags} subclass this constant is part of.
+
+        @param names: When a single-flag value is being initialized, a
+            C{str} giving the name of that flag.  This is the case
+            which happens when a L{Flags} subclass is being
+            initialized and L{FlagConstant} instances from its body
+            are being realized.  Otherwise, a C{set} of C{str} giving
+            names of all the flags set on this L{FlagConstant}
+            instance.  This is the case when two flags are combined
+            using C{|}, for example.
+        """
+        if isinstance(names, str):
+            name = names
+            names = set([names])
+        elif len(names) == 1:
+            (name,) = names
+        else:
+            name = "{" + ",".join(sorted(names)) + "}"
+        _Constant._realize(self, container, name, value)
+        self.value = value
+        self.names = names
+
+    def __or__(self, other):
+        """
+        Define C{|} on two L{FlagConstant} instances to create a new
+        L{FlagConstant} instance with all flags set in either instance set.
+        """
+        return _flagOp(or_, self, other)
+
+    def __and__(self, other):
+        """
+        Define C{&} on two L{FlagConstant} instances to create a new
+        L{FlagConstant} instance with only flags set in both instances set.
+        """
+        return _flagOp(and_, self, other)
+
+    def __xor__(self, other):
+        """
+        Define C{^} on two L{FlagConstant} instances to create a new
+        L{FlagConstant} instance with only flags set on exactly one instance
+        set.
+        """
+        return _flagOp(xor, self, other)
+
+
+    def __invert__(self):
+        """
+        Define C{~} on a L{FlagConstant} instance to create a new
+        L{FlagConstant} instance with all flags not set on this instance set.
+        """
+        result = FlagConstant()
+        result._realize(self._container, set(), 0)
+        for flag in self._container.iterconstants():
+            if flag.value & self.value == 0:
+                result |= flag
+        return result
+
+
+class Flags(Values):
+    """
+    A L{Flags} subclass contains constants which can be combined using the
+    common bitwise operators (C{|}, C{&}, etc) similar to a I{bitvector} from a
+    language like C.
+    """
+    _constantType = FlagConstant
+
+    _value = 1
+
+    def _constantFactory(cls, name, descriptor):
+        """
+        For L{FlagConstant} instances with no explicitly defined value, assign
+        the next power of two as its value.
+        """
+        if descriptor.value is _unspecified:
+            value = cls._value
+            cls._value <<= 1
+        else:
+            value = descriptor.value
+            cls._value = value << 1
+        return value
+    _constantFactory = classmethod(_constantFactory)

=== modified file 'juju/lib/serializer.py'
--- juju/lib/serializer.py	2012-09-14 15:33:33 +0000
+++ juju/lib/serializer.py	2013-01-17 11:02:31 +0000
@@ -2,20 +2,22 @@
 from yaml import dump as _dump
 from yaml import load as _load
 
+
 def dump(value):
     return _dump(value, Dumper=CSafeDumper)
 
 yaml_dump = dump
 
+
 def load(value):
     return _load(value, Loader=CSafeLoader)
 
 yaml_load = load
 
+
 def yaml_mark_with_path(path, mark):
     # yaml c ext, cant be modded, convert to capture path
     return Mark(
         path, mark.index,
         mark.line, mark.column,
         mark.buffer, mark.pointer)
-

=== modified file 'juju/lib/service.py'
--- juju/lib/service.py	2012-10-05 16:05:39 +0000
+++ juju/lib/service.py	2013-01-17 11:02:31 +0000
@@ -1,4 +1,4 @@
-from twisted.internet.defer import inlineCallbacks
+from twisted.internet.defer import inlineCallbacks, Deferred
 from twisted.internet.threads import deferToThread
 
 from juju.errors import ServiceError
@@ -9,20 +9,31 @@
 
 def _check_call(args, env=None, output_path=None):
     if not output_path:
-        output_path = os.devnull
-
-    with open(output_path, "a") as f:
+        f = open(os.devnull, "a")
+    else:
+        check_path = os.path.exists(output_path) and output_path \
+                     or os.path.dirname(output_path)
+        if os.access(check_path, os.W_OK):
+            f = open(output_path, "a")
+        else:
+            raise ValueError(
+                "Output path inaccessible %s" % output_path)
+    try:
         return subprocess.check_call(
             args,
             stdout=f.fileno(), stderr=f.fileno(),
             env=env)
+    finally:
+        f.close()
 
 
 def _cat(filename, use_sudo=False):
     args = ("cat", filename)
     if use_sudo and not os.access(filename, os.R_OK):
         args = ("sudo",) + args
-
+    elif os.path.exists(filename):
+        with open(filename) as fh:
+            return (0, fh.read())
     p = subprocess.Popen(
         args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
     stdout_data, _ = p.communicate()
@@ -37,28 +48,17 @@
     specifies the location of the pid file that is used to track this service.
 
     """
-    def __init__(self, name, pidfile, use_sudo=False):
+    def __init__(self, name, pidfile, output_path, use_sudo=False):
         self._name = name
         self._use_sudo = use_sudo
         self._description = None
         self._environ = None
         self._command = None
         self._daemon = True
-        self._output_path = None
-
+        self.output_path = output_path
         self._pid_path = pidfile
         self._pid = None
 
-    @property
-    def output_path(self):
-        if self._output_path is not None:
-            return self._output_path
-        return "/tmp/%s.output" % self._name
-
-    @output_path.setter
-    def output_path(self, path):
-        self._output_path = path
-
     def set_description(self, description):
         self._description = description
 
@@ -70,6 +70,9 @@
             environ[k] = str(v)
         self._environ = environ
 
+    def set_output_path(self, output_path):
+        self._output_path = output_path
+
     def set_command(self, command):
         if self._daemon:
             if "--pidfile" not in command:
@@ -77,13 +80,12 @@
             else:
                 # pid file is in command (consume it for get_pid)
                 idx = command.index("--pidfile")
-                self._pid_path = command[idx+1]
-
+                self._pid_path = command[idx + 1]
         self._command = command
 
     @inlineCallbacks
     def _trash_output(self):
-        if os.path.exists(self.output_path):
+        if self.output_path and os.path.exists(self.output_path):
             # Just using os.unlink will fail when we're running TEST_SUDO
             # tests which hit this code path (because root will own
             # self.output_path)
@@ -93,6 +95,7 @@
             yield self._call("rm", "-f", self._pid_path)
 
     def _call(self, *args, **kwargs):
+        # sudo even with -E will strip pythonpath so pass it to the command.
         if self._use_sudo:
             if self._environ:
                 _args = ["%s=%s" % (k, v) for k, v in self._environ.items()]
@@ -105,28 +108,29 @@
         return deferToThread(_check_call, args, env=self._environ,
                              output_path=self.output_path)
 
-    def install(self):
-        if self._command is None:
-            raise ServiceError("Cannot manage agent: %s no command set" % (
-                self._name))
-
     @inlineCallbacks
     def start(self):
         if (yield self.is_running()):
+            return
             raise ServiceError(
                 "%s already running: pid (%s)" % (
                     self._name, self.get_pid()))
-
-        if not self.is_installed():
-            yield self.install()
-
         yield self._trash_output()
         yield self._call(*self._command, output_path=self.output_path)
+        yield self._sleep(0.2)
+
+    def _sleep(self, delay):
+        """Non-blocking sleep."""
+        from twisted.internet import reactor
+        deferred = Deferred()
+        reactor.callLater(delay, deferred.callback, None)
+        return deferred
 
     @inlineCallbacks
     def destroy(self):
-        if (yield self.is_running()):
-            yield self._call("kill", self.get_pid())
+        if not (yield self.is_running()):
+            return
+        yield self._call("kill", str(self.get_pid()))
         yield self._trash_output()
 
     def get_pid(self):
@@ -139,12 +143,10 @@
         if r != 0:
             return None
 
-        # verify that pid is a number but leave
-        # it as a string suitable for passing to kill
-        if not data.strip().isdigit():
+        data = data.strip()
+        if not data.isdigit():
             return None
-        pid = data.strip()
-        self._pid = pid
+        self._pid = int(data)
         return self._pid
 
     def is_running(self):
@@ -155,6 +157,3 @@
         if not os.path.exists(proc_file):
             return False
         return True
-
-    def is_installed(self):
-        return False

=== modified file 'juju/lib/tests/test_service.py'
--- juju/lib/tests/test_service.py	2012-10-05 16:05:39 +0000
+++ juju/lib/tests/test_service.py	2013-01-17 11:02:31 +0000
@@ -4,8 +4,10 @@
 from juju.lib.mocker import MATCH, KWARGS
 from juju.lib.service import TwistedDaemonService
 from juju.lib.lxc.tests.test_lxc import uses_sudo
+from juju.state.utils import get_open_port
 
 import os
+import subprocess
 
 
 class TwistedDaemonServiceTest(TestCase):
@@ -13,22 +15,16 @@
     @inlineCallbacks
     def setUp(self):
         yield super(TwistedDaemonServiceTest, self).setUp()
-        self.setup_service()
-
-    def setup_service(self):
-        service = TwistedDaemonService("juju-machine-agent",
-                                       "/tmp/.juju-test.pid",
-                                       use_sudo=False)
+        self.pid_path = self.makeFile()
+        self.output_path = self.makeFile()
+        service = TwistedDaemonService(
+            "juju-machine-agent", self.pid_path,
+            self.output_path, use_sudo=False)
         service.set_description("Juju machine agent")
         service.set_environ({"JUJU_MACHINE_ID": 0})
         service.set_command(["/bin/true", ])
         self.service = service
 
-        if os.path.exists("/tmp/.juju-test.pid"):
-            os.remove("/tmp/.juju-test.pid")
-
-        return service
-
     def setup_mock(self):
         self.check_call = self.mocker.replace("subprocess.check_call")
 
@@ -45,13 +41,18 @@
         self.setup_mock()
         self.mock_call("/bin/true")
         self.mocker.replay()
-
         yield self.service.start()
 
+    def test_simple_service_failure(self):
+        self.service.set_command(["/bin/false"])
+        return self.assertFailure(
+            self.service.start(),
+            subprocess.CalledProcessError)
+
     def test_set_output_path(self):
         # defaults work
-        self.assertEqual(self.service.output_path,
-                         "/tmp/juju-machine-agent.output")
+        self.assertEqual(
+            self.service.output_path, self.output_path)
         # override works
         self.service.output_path = "/tmp/valid.log"
         self.assertEqual(self.service.output_path, "/tmp/valid.log")
@@ -82,23 +83,30 @@
     def test_webservice_start(self):
         # test using a real twisted service (with --pidfile)
         # arg ordering matters here so we set pidfile manually
+
+        pid_file = self.makeFile()
+        log_file = self.makeFile()
+        web_dir = self.makeDir()
+
         self.service.set_command([
             "env", "twistd",
-            "--pidfile", "/tmp/.juju-test.pid",
-            "--logfile", "/tmp/.juju-test.log",
+            "--pidfile", pid_file,
+            "--logfile", log_file,
             "web",
-            "--port", "9871",
-            "--path", "/lib",
+            "--port", str(get_open_port()),
+            "--path", web_dir,
             ])
 
         yield self.service.start()
-        yield self.sleep(0.5)
+        yield self.sleep(0.2)
+
         self.assertTrue(self.service.get_pid())
         self.assertTrue(self.service.is_running())
-        self.assertTrue(os.path.exists("/tmp/.juju-test.pid"))
+        self.assertTrue(os.path.exists(pid_file))
         yield self.service.destroy()
         yield self.sleep(0.1)
-        self.assertFalse(os.path.exists("/tmp/.juju-test.pid"))
+        self.assertFalse(self.service.is_running())
+        self.assertFalse(os.path.exists(pid_file))
 
     @uses_sudo
     @inlineCallbacks
@@ -114,3 +122,18 @@
             contents = fh.read()
             self.assertIn("PYTHONPATH=foo2", contents)
             self.assertIn("JUJU_MACHINE_ID=0", contents)
+
+    @uses_sudo
+    @inlineCallbacks
+    def test_command_tuple(self):
+        self.service.set_daemon(False)
+        self.service.output_path = self.makeFile()
+        self.service.set_environ(
+            {"JUJU_MACHINE_ID": 0, "PYTHONPATH": "foo2"})
+        self.service.set_command(("/usr/bin/env",))
+        yield self.service.start()
+
+        with open(self.service.output_path) as fh:
+            contents = fh.read()
+            self.assertIn("PYTHONPATH=foo2", contents)
+            self.assertIn("JUJU_MACHINE_ID=0", contents)

=== added file 'juju/lib/tests/test_websockets.py'
--- juju/lib/tests/test_websockets.py	1970-01-01 00:00:00 +0000
+++ juju/lib/tests/test_websockets.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,227 @@
+from twisted.trial import unittest
+
+from juju.lib.websockets import (_CONTROLS, _make_accept, _mask,
+                                    _make_hybi07_frame, _parse_hybi07_frames)
+
+"""
+The WebSockets Protocol, according to RFC 6455
+(http://tools.ietf.org/html/rfc6455). When "RFC" is mentioned, it refers to
+this RFC. Some tests reference HyBi-10
+(http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10) or
+HyBi-07 (http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07),
+which are drafts of RFC 6455.
+"""
+
+
+class TestKeys(unittest.TestCase):
+
+    def test_make_accept_rfc(self):
+        """
+        L{_make_accept} makes responses according to the RFC.
+        """
+
+        key = "dGhlIHNhbXBsZSBub25jZQ=="
+
+        self.assertEqual(_make_accept(key), "s3pPLMBiTxaQ9kYGzzhZRbK+xOo=")
+
+    def test_make_accept_wikipedia(self):
+        """
+        L{_make_accept} makes responses according to Wikipedia.
+        """
+
+        key = "x3JJHMbDL1EzLkh9GBhXDw=="
+
+        self.assertEqual(_make_accept(key), "HSmrc0sMlYUkAGmm5OPpG2HaGWk=")
+
+
+class TestHyBi07Helpers(unittest.TestCase):
+    """
+    HyBi-07 is best understood as a large family of helper functions which
+    work together, somewhat dysfunctionally, to produce a mediocre
+    Thanksgiving every other year.
+    """
+
+    def test_mask_noop(self):
+        """
+        Blank keys perform a no-op mask.
+        """
+
+        key = "\x00\x00\x00\x00"
+        self.assertEqual(_mask("Test", key), "Test")
+
+    def test_mask_noop_long(self):
+        """
+        Blank keys perform a no-op mask regardless of the length of the input.
+        """
+
+        key = "\x00\x00\x00\x00"
+        self.assertEqual(_mask("LongTest", key), "LongTest")
+
+    def test_mask_noop_odd(self):
+        """
+        Masking works even when the data to be masked isn't a multiple of four
+        in length.
+        """
+
+        key = "\x00\x00\x00\x00"
+        self.assertEqual(_mask("LongestTest", key), "LongestTest")
+
+    def test_mask_hello(self):
+        """
+        A sample mask for "Hello" according to RFC 6455, 5.7.
+        """
+
+        key = "\x37\xfa\x21\x3d"
+        self.assertEqual(_mask("Hello", key), "\x7f\x9f\x4d\x51\x58")
+
+    def test_parse_hybi07_unmasked_text(self):
+        """
+        A sample unmasked frame of "Hello" from HyBi-10, 4.7.
+        """
+
+        frame = "\x81\x05Hello"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0], (_CONTROLS.NORMAL, "Hello"))
+        self.assertEqual(buf, "")
+
+    def test_parse_hybi07_masked_text(self):
+        """
+        A sample masked frame of "Hello" from HyBi-10, 4.7.
+        """
+
+        frame = "\x81\x857\xfa!=\x7f\x9fMQX"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0], (_CONTROLS.NORMAL, "Hello"))
+        self.assertEqual(buf, "")
+
+    def test_parse_hybi07_unmasked_text_fragments(self):
+        """
+        Fragmented masked packets are handled.
+
+        From HyBi-10, 4.7.
+        """
+
+        frame = "\x01\x03Hel\x80\x02lo"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 2)
+        self.assertEqual(frames[0], (_CONTROLS.NORMAL, "Hel"))
+        self.assertEqual(frames[1], (_CONTROLS.NORMAL, "lo"))
+        self.assertEqual(buf, "")
+
+    def test_parse_hybi07_ping(self):
+        """
+        Ping packets are decoded.
+
+        From HyBi-10, 4.7.
+        """
+
+        frame = "\x89\x05Hello"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0], (_CONTROLS.PING, "Hello"))
+        self.assertEqual(buf, "")
+
+    def test_parse_hybi07_pong(self):
+        """
+        Pong packets are decoded.
+
+        From HyBi-10, 4.7.
+        """
+
+        frame = "\x8a\x05Hello"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0], (_CONTROLS.PONG, "Hello"))
+        self.assertEqual(buf, "")
+
+    def test_parse_hybi07_close_empty(self):
+        """
+        A HyBi-07 close packet may have no body. In that case, it decodes with
+        the generic error code 1000, and has no particular justification or
+        error message.
+        """
+
+        frame = "\x88\x00"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0], (
+            _CONTROLS.CLOSE, (1000, "No reason given")))
+        self.assertEqual(buf, "")
+
+    def test_parse_hybi07_close_reason(self):
+        """
+        A HyBi-07 close packet must have its first two bytes be a numeric
+        error code, and may optionally include trailing text explaining why
+        the connection was closed.
+        """
+
+        frame = "\x88\x0b\x03\xe8No reason"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 1)
+        self.assertEqual(frames[0], (_CONTROLS.CLOSE, (1000, "No reason")))
+        self.assertEqual(buf, "")
+
+    def test_parse_hybi07_partial_no_length(self):
+        """
+        Partial frames are stored for later decoding.
+        """
+
+        frame = "\x81"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 0)
+        self.assertEqual(buf, "\x81")
+
+    def test_parse_hybi07_partial_truncated_length_int(self):
+        """
+        Partial frames are stored for later decoding, even if they are cut on
+        length boundaries.
+        """
+
+        frame = "\x81\xfe"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 0)
+        self.assertEqual(buf, "\x81\xfe")
+
+    def test_parse_hybi07_partial_truncated_length_double(self):
+        """
+        Partial frames are stored for later decoding, even if they are marked
+        as being extra-long.
+        """
+
+        frame = "\x81\xff"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 0)
+        self.assertEqual(buf, "\x81\xff")
+
+    def test_parse_hybi07_partial_no_data(self):
+        """
+        Partial frames with full headers but no data are stored for later
+        decoding.
+        """
+
+        frame = "\x81\x05"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 0)
+        self.assertEqual(buf, "\x81\x05")
+
+    def test_parse_hybi07_partial_truncated_data(self):
+        """
+        Partial frames with full headers and partial data are stored for later
+        decoding.
+        """
+
+        frame = "\x81\x05Hel"
+        frames, buf = _parse_hybi07_frames(frame)
+        self.assertEqual(len(frames), 0)
+        self.assertEqual(buf, "\x81\x05Hel")
+
+    def test_make_hybi07_hello(self):
+        """
+        L{_make_hybi07_frame} makes valid HyBi-07 packets.
+        """
+
+        frame = "\x81\x05Hello"
+        buf = _make_hybi07_frame("Hello")
+        self.assertEqual(frame, buf)

=== added file 'juju/lib/websockets.py'
--- juju/lib/websockets.py	1970-01-01 00:00:00 +0000
+++ juju/lib/websockets.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,521 @@
+# -*- test-case-name: twisted.web.test.test_websockets -*-
+# Copyright (c) 2011-2012 Oregon State University Open Source Lab
+#               2011-2012 Corbin Simpson
+#                    2012 Twisted Matrix Laboratories
+#
+# See MIT http://opensource.org/licenses/mit-license.php for details.
+
+"""
+The WebSockets protocol (RFC 6455), provided as a resource which wraps a
+factory.
+"""
+
+__all__ = ("WebSocketsResource",)
+
+from base64 import b64encode, b64decode
+from hashlib import sha1
+from struct import pack, unpack
+
+from twisted.protocols.policies import ProtocolWrapper, WrappingFactory
+from twisted.python import log
+from juju.lib.constants import NamedConstant, Names
+
+from twisted.web.resource import IResource, NoResource
+from twisted.web.server import NOT_DONE_YET
+from zope.interface import implements
+
+import logging
+
+ws_log = logging.getLogger('juju.ws')
+
+
+class _WSException(Exception):
+    """
+    Internal exception for control flow inside the WebSockets frame parser.
+    """
+
+# Control frame specifiers. Some versions of WS have control signals sent
+# in-band. Adorable, right?
+
+
+class _CONTROLS(Names):
+    """
+    Control frame specifiers.
+    """
+
+    NORMAL = NamedConstant()
+    CLOSE = NamedConstant()
+    PING = NamedConstant()
+    PONG = NamedConstant()
+
+_opcode_types = {
+    0x0: _CONTROLS.NORMAL,
+    0x1: _CONTROLS.NORMAL,
+    0x2: _CONTROLS.NORMAL,
+    0x8: _CONTROLS.CLOSE,
+    0x9: _CONTROLS.PING,
+    0xa: _CONTROLS.PONG,
+}
+
+_opcode_for_type = {
+    _CONTROLS.NORMAL: 0x1,
+    _CONTROLS.CLOSE: 0x8,
+    _CONTROLS.PING: 0x9,
+    _CONTROLS.PONG: 0xa,
+}
+
+_encoders = {
+    "base64": b64encode,
+}
+
+_decoders = {
+    "base64": b64decode,
+}
+
+# Authentication for WS.
+
+# The GUID for WebSockets, from RFC 6455.
+_WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+
+def _make_accept(key):
+    """
+    Create an "accept" response for a given key.
+
+    This dance is expected to somehow magically make WebSockets secure.
+
+    @type key: C{str}
+    @param key: The key to respond to.
+
+    @rtype: C{str}
+    @return: An encoded response.
+    """
+
+    return sha1("%s%s" % (key, _WS_GUID)).digest().encode("base64").strip()
+
+# Frame helpers.
+# Separated out to make unit testing a lot easier.
+# Frames are bonghits in newer WS versions, so helpers are appreciated.
+
+
+def _mask(buf, key):
+    """
+    Mask or unmask a buffer of bytes with a masking key.
+
+    @type buf: C{str}
+    @param buf: A buffer of bytes.
+
+    @type key: C{str}
+    @param key: The masking key. Must be exactly four bytes.
+
+    @rtype: C{str}
+    @return: A masked buffer of bytes.
+    """
+
+    # This is super-secure, I promise~
+    key = [ord(i) for i in key]
+    buf = list(buf)
+    for i, char in enumerate(buf):
+        buf[i] = chr(ord(char) ^ key[i % 4])
+    return "".join(buf)
+
+
+def _make_hybi07_frame(buf, _opcode=_CONTROLS.NORMAL):
+    """
+    Make a HyBi-07 frame.
+
+    This function always creates unmasked frames, and attempts to use the
+    smallest possible lengths.
+
+    @type buf: C{str}
+    @param buf: A buffer of bytes.
+
+    @type _opcode: C{_CONTROLS}
+    @param _opcode: Which type of frame to create.
+
+    @rtype: C{str}
+    @return: A packed frame.
+    """
+
+    if len(buf) > 0xffff:
+        length = "\x7f%s" % pack(">Q", len(buf))
+    elif len(buf) > 0x7d:
+        length = "\x7e%s" % pack(">H", len(buf))
+    else:
+        length = chr(len(buf))
+
+    # Always make a normal packet.
+    header = chr(0x80 | _opcode_for_type[_opcode])
+    frame = "%s%s%s" % (header, length, buf)
+    return frame
+
+
+def _parse_hybi07_frames(buf):
+    """
+    Parse HyBi-07 frames in a highly compliant manner.
+
+    @type buf: C{str}
+    @param buf: A buffer of bytes.
+
+    @rtype: C{list}
+    @return: A list of frames.
+    """
+
+    start = 0
+    frames = []
+
+    while True:
+        # If there's not at least two bytes in the buffer, bail.
+        if len(buf) - start < 2:
+            break
+
+        # Grab the header. This single byte holds some flags nobody cares
+        # about, and an opcode which nobody cares about.
+        header = ord(buf[start])
+        if header & 0x70:
+            # At least one of the reserved flags is set. Pork chop sandwiches!
+            raise _WSException("Reserved flag in HyBi-07 frame (%d)" % header)
+            frames.append(("", _CONTROLS.CLOSE))
+            return frames, buf
+
+        # Get the opcode, and translate it to a local enum which we actually
+        # care about.
+        opcode = header & 0xf
+        try:
+            opcode = _opcode_types[opcode]
+        except KeyError:
+            raise _WSException("Unknown opcode %d in HyBi-07 frame" % opcode)
+
+        # Get the payload length and determine whether we need to look for an
+        # extra length.
+        length = ord(buf[start + 1])
+        masked = length & 0x80
+        length &= 0x7f
+
+        # The offset we're gonna be using to walk through the frame. We use
+        # this because the offset is variable depending on the length and
+        # mask.
+        offset = 2
+
+        # Extra length fields.
+        if length == 0x7e:
+            if len(buf) - start < 4:
+                break
+
+            length = buf[start + 2:start + 4]
+            length = unpack(">H", length)[0]
+            offset += 2
+        elif length == 0x7f:
+            if len(buf) - start < 10:
+                break
+
+            # Protocol bug: The top bit of this long long *must* be cleared;
+            # that is, it is expected to be interpreted as signed. That's
+            # fucking stupid, if you don't mind me saying so, and so we're
+            # interpreting it as unsigned anyway. If you wanna send exabytes
+            # of data down the wire, then go ahead!
+            length = buf[start + 2:start + 10]
+            length = unpack(">Q", length)[0]
+            offset += 8
+
+        if masked:
+            if len(buf) - (start + offset) < 4:
+                break
+
+            key = buf[start + offset:start + offset + 4]
+            offset += 4
+
+        if len(buf) - (start + offset) < length:
+            break
+
+        data = buf[start + offset:start + offset + length]
+
+        if masked:
+            data = _mask(data, key)
+
+        if opcode == _CONTROLS.CLOSE:
+            if len(data) >= 2:
+                # Gotta unpack the opcode and return usable data here.
+                data = unpack(">H", data[:2])[0], data[2:]
+            else:
+                # No reason given; use generic data.
+                data = 1000, "No reason given"
+
+        frames.append((opcode, data))
+        start += offset + length
+
+    return frames, buf[start:]
+
+
+class _WebSocketsProtocol(ProtocolWrapper):
+    """
+    Protocol which wraps another protocol to provide a WebSockets transport
+    layer.
+    """
+
+    buf = ""
+    codec = None
+
+    def __init__(self, *args, **kwargs):
+        ProtocolWrapper.__init__(self, *args, **kwargs)
+        self._pending_frames = []
+
+    def connectionMade(self):
+        ProtocolWrapper.connectionMade(self)
+        log.msg("Opening connection with %s" % self.transport.getPeer())
+
+    def parseFrames(self):
+        """
+        Find frames in incoming data and pass them to the underlying protocol.
+        """
+
+        try:
+            frames, self.buf = _parse_hybi07_frames(self.buf)
+        except _WSException:
+            # Couldn't parse all the frames, something went wrong, let's bail.
+            log.err()
+            self.loseConnection()
+            return
+
+        for frame in frames:
+            opcode, data = frame
+            if opcode == _CONTROLS.NORMAL:
+                # Business as usual. Decode the frame, if we have a decoder.
+                if self.codec:
+                    data = _decoders[self.codec](data)
+                # Pass the frame to the underlying protocol.
+                ProtocolWrapper.dataReceived(self, data)
+            elif opcode == _CONTROLS.CLOSE:
+                # The other side wants us to close. I wonder why?
+                reason, text = data
+                log.msg("Closing connection: %r (%d)" % (text, reason))
+
+                # Close the connection.
+                self.loseConnection()
+                return
+            elif opcode == _CONTROLS.PING:
+                # 5.5.2 PINGs must be responded to with PONGs.
+                # 5.5.3 PONGs must contain the data that was sent with the
+                # provoking PING.
+                self.transport.write(_make_hybi07_frame(data,
+                    _opcode=_CONTROLS.PONG))
+
+    def sendFrames(self):
+        """
+        Send all pending frames.
+        """
+
+        for frame in self._pending_frames:
+            # Encode the frame before sending it.
+            if self.codec:
+                frame = _encoders[self.codec](frame)
+            packet = _make_hybi07_frame(frame)
+            self.transport.write(packet)
+        self._pending_frames = []
+
+    def dataReceived(self, data):
+        self.buf += data
+
+        self.parseFrames()
+
+        # Kick any pending frames. This is needed because frames might have
+        # started piling up early; we can get write()s from our protocol above
+        # when they makeConnection() immediately, before our browser client
+        # actually sends any data. In those cases, we need to manually kick
+        # pending frames.
+        if self._pending_frames:
+            self.sendFrames()
+
+    def write(self, data):
+        """
+        Write to the transport.
+
+        This method will only be called by the underlying protocol.
+        """
+
+        self._pending_frames.append(data)
+        self.sendFrames()
+
+    def writeSequence(self, data):
+        """
+        Write a sequence of data to the transport.
+
+        This method will only be called by the underlying protocol.
+        """
+
+        self._pending_frames.extend(data)
+        self.sendFrames()
+
+    def loseConnection(self):
+        """
+        Close the connection.
+
+        This includes telling the other side we're closing the connection.
+
+        If the other side didn't signal that the connection is being closed,
+        then we might not see their last message, but since their last message
+        should, according to the spec, be a simple acknowledgement, it
+        shouldn't be a problem.
+        """
+
+        # Send a closing frame. It's only polite. (And might keep the browser
+        # from hanging.)
+        if not self.disconnecting:
+            frame = _make_hybi07_frame("", _opcode=_CONTROLS.CLOSE)
+            self.transport.write(frame)
+
+            ProtocolWrapper.loseConnection(self)
+
+
+class _WebSocketsFactory(WrappingFactory):
+    """
+    Factory which wraps another factory to provide WebSockets frames for all
+    of its protocols.
+
+    This factory does not provide the HTTP headers required to perform a
+    WebSockets handshake; see C{WebSocketsResource}.
+    """
+
+    protocol = _WebSocketsProtocol
+
+
+class WebSocketsResource(object):
+    """
+    A resource for serving a protocol through WebSockets.
+
+    This class wraps a factory and connects it to WebSockets clients. Each
+    connecting client will be connected to a new protocol of the factory.
+
+    Due to unresolved questions of logistics, this resource cannot have
+    children.
+
+    @since 12.2
+    """
+
+    implements(IResource)
+
+    isLeaf = True
+
+    def __init__(self, factory):
+        self._factory = _WebSocketsFactory(factory)
+
+    def getChildWithDefault(self, name, request):
+        return NoResource("No such child resource.")
+
+    def putChild(self, path, child):
+        pass
+
+    def render(self, request):
+        """
+        Render a request.
+
+        We're not actually rendering a request. We are secretly going to
+        handle a WebSockets connection instead.
+        """
+        ws_log.info("render ws")
+        # If we fail at all, we're gonna fail with 400 and no response.
+        # You might want to pop open the RFC and read along.
+        failed = False
+        if request.method != "GET":
+            # 4.2.1.1 GET is required.
+            ws_log.info("fail: not get")
+            failed = True
+
+        upgrade = request.getHeader("Upgrade")
+        if upgrade is None or "websocket" not in upgrade.lower():
+            # 4.2.1.3 Upgrade: WebSocket is required.
+            failed = True
+            ws_log.info("fail: no upgrade ws")
+
+        connection = request.getHeader("Connection")
+        if connection is None or "upgrade" not in connection.lower():
+            # 4.2.1.4 Connection: Upgrade is required.
+            failed = True
+            ws_log.info("fail: no upgrade")
+
+        key = request.getHeader("Sec-WebSocket-Key")
+        if key is None:
+            # 4.2.1.5 The challenge key is required.
+            failed = True
+            ws_log.info("fail: no ws challenge key")
+
+        version = request.getHeader("Sec-WebSocket-Version")
+        if version != "13":
+            # 4.2.1.6 Only version 13 works.
+            failed = True
+            ws_log.info("fail: different ws version %s" % version)
+
+            # 4.4 Forward-compatible version checking.
+            request.setHeader("Sec-WebSocket-Version", "13")
+
+        # Check whether a codec is needed. WS calls this a "protocol" for
+        # reasons I cannot fathom. The specification permits multiple,
+        # comma-separated codecs to be listed, but this functionality isn't
+        # used in the wild. (If that ever changes, we'll have already added
+        # the requisite codecs here anyway.) The main reason why we check for
+        # codecs at all is that older draft versions of WebSockets used base64
+        # encoding to work around the inability to send \x00 bytes, and those
+        # runtimes would request base64 encoding during the handshake. We
+        # stand prepared to engage that behavior should any of those runtimes
+        # start supporting RFC WebSockets.
+        #
+        # We probably should remove this altogether, but I'd rather leave it
+        # because it will prove to be a useful reference if/when extensions
+        # are added, and it *does* work as advertised.
+        codec = request.getHeader("Sec-WebSocket-Protocol")
+
+        if codec == 'undefined':
+            codec = None
+
+        if codec:
+            if codec not in _encoders or codec not in _decoders:
+                log.msg("Codec %s is not implemented" % codec)
+                #failed = True
+            ws_log.info('codec requested %s' % codec)
+            codec = None
+
+        if failed:
+            ws_log.info("failed, closing")
+            request.setResponseCode(400)
+            return ""
+
+        # We are going to finish this handshake. We will return a valid status
+        # code.
+        # 4.2.2.5.1 101 Switching Protocols
+        request.setResponseCode(101)
+        # 4.2.2.5.2 Upgrade: websocket
+        request.setHeader("Upgrade", "WebSocket")
+        # 4.2.2.5.3 Connection: Upgrade
+        request.setHeader("Connection", "Upgrade")
+        # 4.2.2.5.4 Response to the key challenge
+        request.setHeader("Sec-WebSocket-Accept", _make_accept(key))
+        # 4.2.2.5.5 Optional codec declaration
+        if codec:
+            request.setHeader("Sec-WebSocket-Protocol", codec)
+
+        # Create the protocol. This could fail, in which case we deliver an
+        # error status. Status 502 was decreed by glyph; blame him.
+        protocol = self._factory.buildProtocol(request.transport.getPeer())
+        if not protocol:
+            request.setResponseCode(502)
+            return ""
+        if codec:
+            protocol.codec = codec
+
+        # Provoke request into flushing headers and finishing the handshake.
+        request.write("")
+
+        # And now take matters into our own hands. We shall manage the
+        # transport's lifecycle.
+        transport, request.transport = request.transport, None
+
+        # Connect the transport to our factory, and make things go. We need to
+        # do some stupid stuff here; see #3204, which could fix it.
+        if request.isSecure():
+            # Secure connections means one more wrapping: TLSMemoryBIOProtocol.
+            transport.protocol.wrappedProtocol = protocol
+        else:
+            transport.protocol = protocol
+        protocol.makeConnection(transport)
+
+        return NOT_DONE_YET

=== modified file 'juju/providers/common/cloudinit.py'
--- juju/providers/common/cloudinit.py	2013-01-15 19:53:21 +0000
+++ juju/providers/common/cloudinit.py	2013-01-17 11:02:31 +0000
@@ -81,6 +81,17 @@
     return service.get_cloud_init_commands()
 
 
+def _apiserver_scripts(zookeeper_hosts):
+    service = UpstartService("juju-api-agent")
+    service.set_description("Juju api agent")
+    service.set_environ({"JUJU_ZOOKEEPER": zookeeper_hosts})
+    service.set_command(
+        "python -m juju.agents.api --nodaemon "
+        "--logfile /var/log/juju/api-agent.log "
+        "--session-file /var/run/juju/api-agent.zksession")
+    return service.get_cloud_init_commands()
+
+
 def _provision_scripts(zookeeper_hosts):
     service = UpstartService("juju-provision-agent")
     service.set_description("Juju provisioning agent")
@@ -411,6 +422,7 @@
                 self._env_id))
         if self._provision:
             scripts.extend(_provision_scripts(self._join_zookeeper_hosts()))
+            scripts.extend(_apiserver_scripts(self._join_zookeeper_hosts()))
         return scripts
 
     def _collect_machine_data(self):

=== modified file 'juju/providers/common/tests/data/cloud_init_bootstrap'
--- juju/providers/common/tests/data/cloud_init_bootstrap	2012-08-23 16:14:42 +0000
+++ juju/providers/common/tests/data/cloud_init_bootstrap	2013-01-17 11:02:31 +0000
@@ -57,5 +57,28 @@
 
     EOF
 
-    ', /sbin/start juju-provision-agent]
+    ', /sbin/start juju-provision-agent, 'cat >> /etc/init/juju-api-agent.conf <<EOF
+
+    description "Juju api agent"
+
+    author "Juju Team <[e-mail]>"
+
+
+    start on runlevel [2345]
+
+    stop on runlevel [!2345]
+
+    respawn
+
+
+    env JUJU_ZOOKEEPER="localhost:2181"
+
+
+    exec python -m juju.agents.api --nodaemon --logfile /var/log/juju/api-agent.log
+    --session-file /var/run/juju/api-agent.zksession >> /tmp/juju-api-agent.output
+    2>&1
+
+    EOF
+
+    ', /sbin/start juju-api-agent]
 ssh_authorized_keys: [chubb]

=== modified file 'juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers'
--- juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers	2012-08-23 16:14:42 +0000
+++ juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers	2013-01-17 11:02:31 +0000
@@ -57,5 +57,28 @@
 
     EOF
 
-    ', /sbin/start juju-provision-agent]
+    ', /sbin/start juju-provision-agent, 'cat >> /etc/init/juju-api-agent.conf <<EOF
+
+    description "Juju api agent"
+
+    author "Juju Team <[e-mail]>"
+
+
+    start on runlevel [2345]
+
+    stop on runlevel [!2345]
+
+    respawn
+
+
+    env JUJU_ZOOKEEPER="cotswold:2181,longleat:2181,localhost:2181"
+
+
+    exec python -m juju.agents.api --nodaemon --logfile /var/log/juju/api-agent.log
+    --session-file /var/run/juju/api-agent.zksession >> /tmp/juju-api-agent.output
+    2>&1
+
+    EOF
+
+    ', /sbin/start juju-api-agent]
 ssh_authorized_keys: [chubb]

=== modified file 'juju/providers/common/tests/test_cloudinit.py'
--- juju/providers/common/tests/test_cloudinit.py	2012-10-09 18:55:55 +0000
+++ juju/providers/common/tests/test_cloudinit.py	2013-01-17 11:02:31 +0000
@@ -137,7 +137,8 @@
 
     def test_render_bootstrap_with_zookeepers(self):
         self.assert_render(
-            self.construct_bootstrap(True), "cloud_init_bootstrap_zookeepers")
+            self.construct_bootstrap(True),
+            "cloud_init_bootstrap_zookeepers")
 
     def test_render_no_machine_id(self):
         self.patch(juju, "__file__", "/not/installed/under/usr")

=== modified file 'juju/providers/dummy.py'
--- juju/providers/dummy.py	2012-04-06 16:35:31 +0000
+++ juju/providers/dummy.py	2013-01-17 11:02:31 +0000
@@ -66,9 +66,9 @@
             os.environ.get("ZOOKEEPER_ADDRESS", "127.0.0.1:2181"),
             session_timeout=1000).connect()
 
-    def get_machines(self, instance_ids=()):
+    def get_machines(self, instance_ids=None):
         """List all the machine running in the provider."""
-        if not instance_ids:
+        if instance_ids is None:
             return succeed(self._machines[:])
 
         machines_by_id = dict(((m.instance_id, m) for m in self._machines))

=== modified file 'juju/providers/local/__init__.py'
--- juju/providers/local/__init__.py	2012-09-28 06:32:46 +0000
+++ juju/providers/local/__init__.py	2013-01-17 11:02:31 +0000
@@ -12,7 +12,7 @@
 from juju.providers.common.connect import ZookeeperConnect
 from juju.providers.common.utils import get_user_authorized_keys
 
-from juju.providers.local.agent import ManagedMachineAgent
+from juju.providers.local.agent import ManagedMachineAgent, APIAgent
 from juju.providers.local.files import StorageServer, LocalStorage
 from juju.providers.local.machine import LocalMachine
 from juju.providers.local.network import Network
@@ -56,10 +56,11 @@
     def _get_storage_server(self, ip='127.0.0.1'):
         return StorageServer(
             self._qualified_name,
+            self._directory,
             storage_dir=os.path.join(self._directory, "files"),
             host=ip,
             port=get_open_port(ip),
-            logfile=os.path.join(self._directory, "storage-server.log"))
+            log_file=os.path.join(self._directory, "storage-server.log"))
 
     @inlineCallbacks
     def bootstrap(self, constraints):
@@ -87,6 +88,11 @@
         except LookupError, e:
             raise ProviderError(str(e))
 
+        # Get/create directory for zookeeper and files
+        zookeeper_dir = os.path.join(self._directory, "zookeeper")
+        if not os.path.exists(zookeeper_dir):
+            os.makedirs(zookeeper_dir)
+
         # Start networking, and get an open port.
         log.info("Starting networking...")
         net = Network()
@@ -103,7 +109,7 @@
             os.makedirs(zookeeper_dir)
 
         # Start ZooKeeper
-        log.info("Starting ZooKeeper...")
+        log.info("Starting zookeeper (192.168.122.1:%d)..." % port)
         # Run zookeeper as the current user, unless we're being run as root
         # in which case run zookeeper as the 'zookeeper' user.
         zookeeper_user = None
@@ -149,11 +155,21 @@
                                     juju_origin=juju_origin,
                                     public_key=public_key,
                                     juju_series=self.config["default-series"])
-
         log.info(
             "Starting machine agent (origin: %s)... ", agent.juju_origin)
         yield agent.start()
 
+        # Startup the api server
+        log.info("Starting api server")
+        log_file = os.path.join(self._directory, "api-agent.log")
+        port = self.config.get("api-port", 80)
+        secure = self.config.get("api-secure", False)
+        keys = self.config.get("api-keys")
+
+        agent = APIAgent(
+            self._qualified_name, self._directory, zookeeper.address,
+            int(port), secure, keys, log_file)
+        yield agent.start()
         log.info("Environment bootstrapped")
 
     def _validate_data_dir(self):
@@ -172,6 +188,11 @@
         log.info("Destroying unit containers...")
         yield self._destroy_containers()
 
+        # Stop the api agent
+        log.debug("Stopping api agent...")
+        agent = APIAgent(self._qualified_name, self._directory)
+        yield agent.stop()
+
         # Stop the machine agent
         log.debug("Stopping machine agent...")
         agent = ManagedMachineAgent(self._qualified_name,

=== modified file 'juju/providers/local/agent.py'
--- juju/providers/local/agent.py	2012-09-28 06:32:46 +0000
+++ juju/providers/local/agent.py	2013-01-17 11:02:31 +0000
@@ -1,11 +1,69 @@
 import sys
 import os
-import tempfile
 
 from juju.lib.service import TwistedDaemonService
 from juju.providers.common.cloudinit import get_default_origin, BRANCH
 
 
+class APIAgent(object):
+
+    agent_module = "juju.agents.api"
+
+    def __init__(
+        self, namespace, juju_directory, zookeeper_hosts=None, port=80,
+        secure=False, keys=None, log_file=None):
+        """
+        :param zookeeper_hosts: Zookeeper hosts to connect.
+        :param log_file: A file to use for the agent logs.
+        :param port: Port to use for the API endpoint.
+        :param juju_unit_namespace: The machine agent will create units with
+               a known a prefix to allow for multiple users and multiple
+               environments to create containers. The namespace should be
+               unique per user and per environment.
+        """
+
+        assert juju_directory
+        self._pid_file = os.path.join(
+            juju_directory, "%s-api-agent.pid" % namespace)
+
+        self._service = TwistedDaemonService(
+            "juju-%s-api-agent" % namespace,
+            self._pid_file, log_file, use_sudo=True)
+        self._service.set_description(
+            "Juju api agent for %s" % namespace)
+
+        env = {"JUJU_ZOOKEEPER": zookeeper_hosts,
+               "JUJU_HOME": juju_directory,
+               "PYTHONPATH": ":".join(sys.path)}
+        self._service.set_environ(env)
+        self._service_args = [
+            "/usr/bin/python", "-m", self.agent_module,
+            "--pidfile", self._pid_file,
+            "--logfile", log_file,
+            "--port", str(port),
+            "--session-file",
+            "/var/run/juju/%s-machine-agent.zksession" % namespace]
+        if secure:
+            self._service_args.extend(['--secure', '--keys', keys])
+
+    @property
+    def juju_origin(self):
+        return self._juju_origin
+
+    def start(self):
+        """Start the machine agent."""
+        self._service.set_command(self._service_args)
+        return self._service.start()
+
+    def stop(self):
+        """Stop the machine agent."""
+        return self._service.destroy()
+
+    def is_running(self):
+        """Boolean value, true if the machine agent is running."""
+        return self._service.is_running()
+
+
 class ManagedMachineAgent(object):
 
     agent_module = "juju.agents.machine"
@@ -49,12 +107,11 @@
         self._service = TwistedDaemonService(
             "juju-%s-machine-agent" % juju_unit_namespace,
             pidfile,
+            log_file,
             use_sudo=True)
         self._service.set_description(
             "Juju machine agent for %s" % juju_unit_namespace)
         self._service.set_environ(env)
-        self._service.output_path = log_file
-
         self._service_args = [
             "/usr/bin/python", "-m", self.agent_module,
             "--logfile", log_file,

=== modified file 'juju/providers/local/files.py'
--- juju/providers/local/files.py	2012-09-28 06:13:47 +0000
+++ juju/providers/local/files.py	2013-01-17 11:02:31 +0000
@@ -5,7 +5,7 @@
 from twisted.internet.error import ConnectionRefusedError
 from twisted.web.client import getPage
 
-from juju.errors import ProviderError, FileNotFound
+from juju.errors import ProviderError, FileNotFound, ServiceError
 from juju.lib import serializer
 from juju.lib.service import TwistedDaemonService
 from juju.providers.common.files import FileStorage
@@ -16,36 +16,35 @@
 
 class StorageServer(object):
 
-    def __init__(self, juju_unit_namespace, storage_dir=None,
-                 host=None, port=None, logfile=None):
+    def __init__(self, juju_unit_namespace, juju_directory,
+                 storage_dir=None, host=None, port=None, log_file=None):
         """Management facade for a web server on top of the provider storage.
 
         :param juju_unit_namespace: For disambiguation.
         :param host: Host interface to bind to.
         :param port: Port to bind to.
-        :param logfile: Path to store log output.
+        :param log_file: Path to store log output.
         """
         if storage_dir:
             storage_dir = os.path.abspath(storage_dir)
         self._storage_dir = storage_dir
         self._host = host
         self._port = port
-        self._logfile = logfile
-        if storage_dir:
-            self._pidfile = os.path.abspath(
-                os.path.join(storage_dir, '..', 'storage-server.pid'))
-        else:
-            self._pidfile = os.path.join('/tmp', 'storage-server.pid')
+        self._log_file = log_file
+
+        self._pid_file = os.path.join(
+            juju_directory, "%s-file-server.pid" % juju_unit_namespace)
 
         self._service = TwistedDaemonService(
-            "juju-%s-file-storage" % juju_unit_namespace, pidfile=self._pidfile,
-            use_sudo=False)
+            "juju-%s-file-storage" % juju_unit_namespace,
+            pidfile=self._pid_file,
+            output_path=self._log_file, use_sudo=False)
         self._service.set_description(
             "Juju file storage for %s" % juju_unit_namespace)
         self._service_args = [
             "twistd",
-            "--pidfile", self._pidfile,
-            "--logfile", logfile,
+            "--pidfile", self._pid_file,
+            "--logfile", log_file,
             "-d", self._storage_dir,
             "web",
             "--port", "tcp:%s:interface=%s" % (self._port, self._host),
@@ -69,10 +68,12 @@
         assert self._storage_dir, "no storage_dir set"
         assert self._host, "no host set"
         assert self._port, "no port set"
-        assert None not in self._service_args, "unset params"
+
+        assert None not in self._service_args, "unset params %s" % (
+            " ".join(self._service_args))
         assert os.path.exists(self._storage_dir), "Invalid storage directory"
         try:
-            with open(self._logfile, "a"):
+            with open(self._log_file, "a"):
                 pass
         except IOError:
             raise AssertionError("logfile not writable by this user")
@@ -86,6 +87,24 @@
         self._service.set_command(self._service_args)
         yield self._service.start()
 
+        # Capture the error for the user.
+        if not self._service.is_running():
+            content = self._capture_error()
+            raise ServiceError(
+                "Failed to start file-storage server: got output:\n"
+                "%s" % content)
+
+    def _capture_error(self):
+        if os.path.exists(self._log_file):
+            with open(self._log_file) as fh:
+                content = fh.read()
+        else:
+            content = ""
+        return content
+
+    def is_running(self):
+        return self._service.is_running()
+
     def get_pid(self):
         return self._service.get_pid()
 

=== modified file 'juju/providers/local/tests/test_agent.py'
--- juju/providers/local/tests/test_agent.py	2012-10-05 23:40:18 +0000
+++ juju/providers/local/tests/test_agent.py	2013-01-17 11:02:31 +0000
@@ -1,6 +1,5 @@
 import os
 import sys
-import tempfile
 import subprocess
 
 from twisted.internet.defer import inlineCallbacks
@@ -35,12 +34,6 @@
             juju_directory=juju_directory,
             log_file=log_file,
             juju_origin="lp:juju/trunk")
-
-        try:
-            os.remove(agent._service.output_path)
-        except OSError:
-            pass  # just make sure it's not there, so the .start()
-                  # doesn't insert a spurious rm
         yield agent.start()
 
         start = subprocess_calls[0]
@@ -66,7 +59,11 @@
     @inlineCallbacks
     def test_managed_agent_root(self):
         juju_directory = self.makeDir()
-        log_file = tempfile.mktemp()
+        os.mkdir(os.path.join(juju_directory, "charms"))
+        os.mkdir(os.path.join(juju_directory, "state"))
+        os.mkdir(os.path.join(juju_directory, "units"))
+
+        log_file = self.makeFile()
 
         # The pid file and log file get written as root
         def cleanup_root_file(cleanup_file):
@@ -84,13 +81,15 @@
         agent.agent_module = "juju.agents.dummy"
         self.assertFalse((yield agent.is_running()))
         yield agent.start()
-        # Give a moment for the process to start and write its config
+        # Give a moment for the process to start and write pid.
         yield self.sleep(0.1)
         self.assertTrue((yield agent.is_running()))
 
-        # running start again is fine, detects the process is running
+        # Running start again is fine, detects the process is running
         yield agent.start()
         yield agent.stop()
+        # A moment's peace to die.
+        yield self.sleep(0.1)
         self.assertFalse((yield agent.is_running()))
 
         # running stop again is fine, detects the process is stopped.

=== modified file 'juju/providers/local/tests/test_files.py'
--- juju/providers/local/tests/test_files.py	2012-09-28 06:13:47 +0000
+++ juju/providers/local/tests/test_files.py	2013-01-17 11:02:31 +0000
@@ -1,7 +1,6 @@
 import os
 import signal
-from StringIO  import StringIO
-import subprocess
+from StringIO import StringIO
 
 from twisted.internet.defer import inlineCallbacks, succeed
 from twisted.web.client import getPage
@@ -22,12 +21,17 @@
     @inlineCallbacks
     def setUp(self):
         yield super(WebFileStorageTest, self).setUp()
-        self._storage_path = self.makeDir()
-        self._logfile = self.makeFile()
-        self._storage = LocalStorage(self._storage_path)
+        self._juju_dir = self.makeDir()
+        self._storage_path = os.path.join(self._juju_dir, "files")
+        os.mkdir(self._storage_path)
+        self._log_file = self.makeFile()
+        self._storage = LocalStorage(
+            self._storage_path)
         self._port = get_open_port()
         self._server = StorageServer(
-            "ns1", self._storage_path, "localhost", self._port, self._logfile)
+            "ns1", self._juju_dir,
+            self._storage_path, "localhost",
+            self._port, self._log_file)
 
     @inlineCallbacks
     def wait_for_server(self, server):
@@ -50,8 +54,9 @@
         twisted = self.mocker.patch(TwistedDaemonService)
         twisted.start()
         self.mocker.result(succeed(True))
+        twisted.is_running()
+        self.mocker.result(True)
         self.mocker.replay()
-
         yield self._server.start()
 
     @uses_sudo
@@ -59,28 +64,34 @@
     def test_start_stop(self):
         yield self._storage.put("abc", StringIO("hello world"))
         yield self._server.start()
-        # Starting multiple times is fine.
-        yield self._server.start()
+
         storage_url = yield self._storage.get_url("abc")
 
         # It might not have started actually accepting connections yet...
         yield self.wait_for_server(self._server)
         self.assertEqual((yield getPage(storage_url)), "hello world")
 
+        # Starting multiple times is fine, existing process detected.
+        yield self._server.start()
+
         # Check that it can be killed by the current user (ie, is not running
         # as root) and still comes back up
         old_pid = yield self._server.get_pid()
         os.kill(old_pid, signal.SIGKILL)
-        new_pid = yield self._server.get_pid()
-        self.assertNotEquals(old_pid, new_pid)
-
+
+        # Give it a moment to die already.
+        yield self.sleep(0.1)
+
+        self.assertFalse(self._server.is_running())
+
+        # For when the return to upstart..
         # Give it a moment to actually start serving again
-        yield self.wait_for_server(self._server)
-        self.assertEqual((yield getPage(storage_url)), "hello world")
+        #yield self.wait_for_server(self._server)
+        #self.assertEqual((yield getPage(storage_url)), "hello world")
 
-        yield self._server.stop()
         # Stopping multiple times is fine too.
         yield self._server.stop()
+        yield self._server.stop()
 
     @uses_sudo
     @inlineCallbacks
@@ -91,7 +102,8 @@
         yield self._storage.put("some-path", StringIO("original"))
 
         alt_server = StorageServer(
-            "ns2", alt_storage_path, "localhost", get_open_port(),
+            "ns2", self._juju_dir,
+            alt_storage_path, "localhost", get_open_port(),
             self.makeFile())
         yield alt_server.start()
         yield self._server.start()
@@ -113,13 +125,13 @@
     def test_capture_errors(self):
         self._port = get_open_port()
         self._server = StorageServer(
-            "borken", self._storage_path, "lol borken", self._port,
-            self._logfile)
+            "borken", self._juju_dir,
+            self._storage_path, "lol broken example com", self._port,
+            self._log_file)
         d = self._server.start()
         e = yield self.assertFailure(d, ServiceError)
         self.assertTrue(str(e).startswith(
-            "Failed to start job juju-borken-file-storage; got output:\n"))
-        self.assertIn("Wrong number of arguments", str(e))
+            "Failed to start file-storage server: got output:"))
         yield self._server.stop()
 
 

=== modified file 'juju/providers/local/tests/test_provider.py'
--- juju/providers/local/tests/test_provider.py	2012-09-26 22:30:27 +0000
+++ juju/providers/local/tests/test_provider.py	2013-01-17 11:02:31 +0000
@@ -14,7 +14,7 @@
 from juju.machine.constraints import ConstraintSet
 from juju.providers.local import MachineProvider
 from juju.providers import local
-from juju.providers.local.agent import ManagedMachineAgent
+from juju.providers.local.agent import ManagedMachineAgent, APIAgent
 from juju.providers.local.files import StorageServer
 from juju.providers.local.network import Network
 from juju.lib import lxc as lxc_lib
@@ -77,10 +77,13 @@
 
         mock_zookeeper.address
         self.mocker.result(get_test_zookeeper_address())
-        self.mocker.count(3)
+        self.mocker.count(4)
 
         mock_agent = self.mocker.patch(ManagedMachineAgent)
         mock_agent.start()
+
+        mock_agent = self.mocker.patch(APIAgent)
+        mock_agent.start()
         self.mocker.result(succeed(True))
 
     def test_provider_type(self):
@@ -101,7 +104,7 @@
             sorted(children))
         output = self.output.getvalue()
         self.assertIn("Starting networking...", output)
-        self.assertIn("Starting ZooKeeper...", output)
+        self.assertIn("Starting zookeeper", output)
         self.assertIn("Initializing state...", output)
         self.assertIn("Starting storage server", output)
         self.assertIn("Starting machine agent", output)
@@ -166,6 +169,9 @@
         mock_agent = self.mocker.patch(ManagedMachineAgent)
         mock_agent.stop()
 
+        mock_agent = self.mocker.patch(APIAgent)
+        mock_agent.stop()
+
         mock_server = self.mocker.patch(StorageServer)
         mock_server.stop()
 

=== modified file 'juju/providers/tests/test_dummy.py'
--- juju/providers/tests/test_dummy.py	2012-03-29 01:37:57 +0000
+++ juju/providers/tests/test_dummy.py	2013-01-17 11:02:31 +0000
@@ -15,7 +15,9 @@
 
     def setUp(self):
         super(DummyProviderTest, self).setUp()
-        self.provider = MachineProvider("foo", {"peter": "rabbit"})
+        self.provider = MachineProvider(
+            "foo",
+            {"peter": "rabbit", "storage-directory": self.makeDir()})
         zookeeper.set_debug_level(0)
 
     def test_environment_name(self):
@@ -142,6 +144,7 @@
 
     def test_get_serialization_data(self):
         data = self.provider.get_serialization_data()
+        data.pop('storage-directory')
         self.assertEqual(
             data,
             {"peter": "rabbit",

=== added directory 'juju/rapi'
=== added file 'juju/rapi/__init__.py'
--- juju/rapi/__init__.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/__init__.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,1 @@
+#

=== added directory 'juju/rapi/cmd'
=== added file 'juju/rapi/cmd/__init__.py'
--- juju/rapi/cmd/__init__.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/__init__.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,1 @@
+#

=== added file 'juju/rapi/cmd/add_relation.py'
--- juju/rapi/cmd/add_relation.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/add_relation.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,43 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.errors import NoMatchingEndpoints, AmbiguousRelation
+from juju.state.relation import RelationStateManager
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def add_relation(context, *descriptors):
+
+    relation_state_manager = RelationStateManager(context.client)
+    service_state_manager = ServiceStateManager(context.client)
+    endpoint_pairs = yield service_state_manager.join_descriptors(
+            *descriptors)
+
+    context.log.debug("Endpoint pairs: %s", endpoint_pairs)
+
+    if len(endpoint_pairs) == 0:
+        raise NoMatchingEndpoints()
+    elif len(endpoint_pairs) > 1:
+        for pair in endpoint_pairs[1:]:
+            if not (pair[0].relation_name.startswith("juju-") or
+                    pair[1].relation_name.startswith("juju-")):
+                raise AmbiguousRelation(descriptors, endpoint_pairs)
+
+    # At this point we just have one endpoint pair. We need to pick
+    # just one of the endpoints if it's a peer endpoint, since that's
+    # our current API - join descriptors takes two descriptors, but
+    # add_relation_state takes one or two endpoints. TODO consider
+    # refactoring.
+    endpoints = endpoint_pairs[0]
+    if endpoints[0] == endpoints[1]:
+        endpoints = endpoints[0:1]
+    relation, svc_rels = yield relation_state_manager.add_relation_state(
+        *endpoints)
+    context.log.info("Added %s relation to all service units.",
+                     endpoints[0].relation_type)
+
+    yield relation.load()
+    returnValue({'id': relation.internal_id,
+                 'interface': relation.interface,
+                 'scope': relation.scope,
+                 'endpoints': relation.endpoints})

=== added file 'juju/rapi/cmd/add_unit.py'
--- juju/rapi/cmd/add_unit.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/add_unit.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,24 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+from juju.errors import JujuError
+from juju.state.placement import place_unit
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def add_unit(context, service_name, num_units=1, placement="unassigned"):
+    service_manager = ServiceStateManager(context.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.")
+
+    units_ids = []
+    for i in range(num_units):
+        unit_state = yield service_state.add_unit_state()
+        yield place_unit(context.client, placement, unit_state)
+        context.log.info(
+            "Unit %r added to service %r",
+            unit_state.unit_name, service_state.service_name)
+        units_ids.append(unit_state.unit_name)
+
+    returnValue(units_ids)

=== added file 'juju/rapi/cmd/config_get.py'
--- juju/rapi/cmd/config_get.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/config_get.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,37 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def config_get(context, service_name):
+    # Get the service
+    service_manager = ServiceStateManager(context.client)
+    service = yield service_manager.get_service_state(service_name)
+
+    # Retrieve schema
+    charm = yield service.get_charm_state()
+    schema = yield charm.get_config()
+    schema_dict = schema.as_dict()
+    display_dict = {"service": service.service_name,
+                    "charm": (yield service.get_charm_id()),
+                    "settings": schema_dict}
+
+    # Get current settings
+    settings = yield service.get_config()
+    settings = dict(settings.items())
+
+    # Merge current settings into schema/display dict
+    for k, v in schema_dict.items():
+        # Display defaults for unset values.
+        if k in settings:
+            v['value'] = settings[k]
+        else:
+            v['value'] = "-Not set-"
+
+        if 'default' in v:
+            if v['default'] == settings[k]:
+                v['default'] = True
+            else:
+                del v['default']
+
+    returnValue(display_dict)

=== added file 'juju/rapi/cmd/config_set.py'
--- juju/rapi/cmd/config_set.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/config_set.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,35 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.service import ServiceStateManager
+from juju.lib.format import get_charm_formatter
+from juju.lib.serializer import yaml_load
+
+
+@inlineCallbacks
+def config_set(context, service_name, service_options, data=None):
+    # Get the service and the charm
+    service_manager = ServiceStateManager(context.client)
+    service = yield service_manager.get_service_state(service_name)
+    charm = yield service.get_charm_state()
+    charm_format = (yield charm.get_metadata()).format
+    formatter = get_charm_formatter(charm_format)
+
+    # Use the charm's ConfigOptions instance to validate the
+    # arguments to config_set. Invalid options passed to this method
+    # will thrown an exception.
+    if not service_options and data:
+        options = yaml_load(data)
+    elif isinstance(service_options, dict):
+        options = service_options
+    else:
+        options = formatter.parse_keyvalue_pairs(service_options)
+
+    config = yield charm.get_config()
+    options = config.validate(options)
+
+    # Apply the change
+    state = yield service.get_config()
+    state.update(options)
+    yield state.write()
+
+    returnValue(True)

=== added file 'juju/rapi/cmd/constraints_get.py'
--- juju/rapi/cmd/constraints_get.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/constraints_get.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,33 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.environment import EnvironmentStateManager
+from juju.state.machine import MachineStateManager
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def constraints_get(context, entity_names=()):
+    if not entity_names:
+        esm = EnvironmentStateManager(context.client)
+        context.log.info("Fetching constraints for environment")
+        constraints = yield esm.get_constraints()
+        returnValue(dict(constraints))
+
+    msm = MachineStateManager(context.client)
+    ssm = ServiceStateManager(context.client)
+    result = {}
+
+    for name in entity_names:
+        if name.isdigit():
+            kind = "machine"
+            entity = yield msm.get_machine_state(name)
+        elif "/" in name:
+            kind = "service unit"
+            entity = yield ssm.get_unit_state(name)
+        else:
+            kind = "service"
+            entity = yield ssm.get_service_state(name)
+            context.log.info("Fetching constraints for %s %s", kind, name)
+            constraints = yield entity.get_constraints()
+            result[name] = dict(constraints)
+    returnValue(result)

=== added file 'juju/rapi/cmd/constraints_set.py'
--- juju/rapi/cmd/constraints_set.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/constraints_set.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,26 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.environment import EnvironmentStateManager
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def constraints_set(context, service_name, constraint_strs):
+    # XXX / TODO : provider constraints require privileged access to
+    # the provider, which the REST api shouldn't have ideally.
+
+    # Perhaps we could cache serialize provider constraints with
+    # periodic update. Also comes up do to frequence of constraint set
+    # access for deployment.
+    constraint_set = yield context.provider.get_constraint_set()
+    constraints = constraint_set.parse(constraint_strs)
+
+    if service_name is None:
+        esm = EnvironmentStateManager(context.client)
+        yield esm.set_constraints(constraints)
+    else:
+        ssm = ServiceStateManager(context.client)
+        service = yield ssm.get_service_state(service_name)
+        yield service.set_constraints(constraints)
+
+    returnValue(True)

=== added file 'juju/rapi/cmd/debug_hooks.py'
--- juju/rapi/cmd/debug_hooks.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/debug_hooks.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,72 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.charm.errors import InvalidCharmHook
+from juju.state.charm import CharmStateManager
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def debug_hooks(context, unit_name, hook_names):
+
+    manager = ServiceStateManager(context.client)
+    unit = yield manager.get_unit_state(unit_name)
+
+    # Verify hook name
+    if hook_names != ["*"]:
+        context.log.debug("Verifying hook names...")
+        yield validate_hooks(context.client, unit, hook_names)
+
+    # Enable debug hooks
+    context.log.debug(
+        "Enabling hook debug on unit (%r)..." % unit_name)
+    yield unit.enable_hook_debug(hook_names)
+
+    # Ensure the unit is up.
+    context.log.info("Waiting for unit")
+
+    # Wait and verify the agent is running.
+    while 1:
+        exists_d, watch_d = unit.watch_agent()
+        exists = yield exists_d
+        if exists:
+            context.log.info("Unit running")
+            break
+        yield watch_d
+
+
+@inlineCallbacks
+def validate_hooks(client, unit_state, hook_names):
+
+    # Assemble a list of valid hooks for the charm.
+    valid_hooks = ["start", "stop", "install", "config-changed"]
+    service_manager = ServiceStateManager(client)
+    endpoints = yield service_manager.get_relation_endpoints(
+        unit_state.service_name)
+    endpoint_names = [ep.relation_name for ep in endpoints]
+    for endpoint_name in endpoint_names:
+        valid_hooks.extend([
+            endpoint_name + "-relation-joined",
+            endpoint_name + "-relation-changed",
+            endpoint_name + "-relation-departed",
+            endpoint_name + "-relation-broken",
+        ])
+
+    # Verify the debug names.
+    for hook_name in hook_names:
+        if hook_name in valid_hooks:
+            continue
+        break
+    else:
+        returnValue(True)
+
+    # We dereference to the charm to give a fully qualified error
+    # message.  I wish this was a little easier to dereference, the
+    # service_manager.get_relation_endpoints effectively does this
+    # already.
+    service_manager = ServiceStateManager(client)
+    service_state = yield service_manager.get_service_state(
+        unit_state.service_name)
+    charm_id = yield service_state.get_charm_id()
+    charm_manager = CharmStateManager(client)
+    charm = yield charm_manager.get_charm_state(charm_id)
+    raise InvalidCharmHook(charm.id, hook_name)

=== added file 'juju/rapi/cmd/deploy.py'
--- juju/rapi/cmd/deploy.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/deploy.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,102 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.charm.errors import CharmNotFound, RepositoryNotFound
+from juju.charm.publisher import CharmPublisher
+from juju.charm.repository import resolve
+from juju.lib import serializer
+
+from juju.state.endpoint import RelationEndpoint
+from juju.state.placement import place_unit
+from juju.state.relation import RelationStateManager
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def deploy(context,
+           charm_name,
+           service_name=None,
+           constraint_strs=(),
+           config=None, config_raw=None, num_units=1):
+    """Deploy a charm within an environment.
+
+    This will publish the charm to the environment, creating
+    a service from the charm, and get it set to be launched
+    on a new machine. If --repository is not specified, it
+    will be taken from the environment variable JUJU_REPOSITORY.
+    """
+
+    # Locate charm, no local repos yet.
+    try:
+        store, charm_url = resolve(
+            charm_name, "/dev/null", context.default_series)
+    except RepositoryNotFound:
+        raise CharmNotFound("charm store", charm_name)
+
+    store.cache_path = context.charm_cache_dir
+
+    charm = yield store.find(charm_url)
+
+    # Validate config options prior to deployment attempt
+    service_name = service_name or charm_url.name
+    service_options = {}
+    if config_raw:
+        config = serializer.yaml_load(config_raw)
+    if config:
+        service_options = charm.config.validate(config)
+
+    charm_id = str(charm_url.with_revision(charm.get_revision()))
+    context.log.info("Deploying service %s using charm %s" % (
+        service_name, charm_id))
+    constraint_set = yield context.provider.get_constraint_set()
+    placement_policy = context.provider.get_placement_policy()
+    constraints = constraint_set.parse(constraint_strs)
+
+    # Publish the charm to juju
+    storage = yield context.provider.get_file_storage()
+    publisher = CharmPublisher(context.client, storage)
+    yield publisher.add_charm(charm_id, charm)
+    result = yield publisher.publish()
+
+    # In future we might have multiple charms be published at
+    # the same time.  For now, extract the charm_state from the
+    # list.
+    charm_state = result[0]
+
+    # Create the service state
+    service_manager = ServiceStateManager(context.client)
+    service_state = yield service_manager.add_service_state(
+        service_name, charm_state, constraints)
+
+    # Use the charm's ConfigOptions instance to validate service
+    # options.. Invalid options passed will thrown an exception
+    # and prevent the deploy.
+    state = yield service_state.get_config()
+    charm_config = yield charm_state.get_config()
+
+    # Return the validated options with the defaults included.
+    service_options = charm_config.validate(service_options)
+    state.update(service_options)
+    yield state.write()
+
+    # Create desired number of service units
+    if (yield service_state.is_subordinate()):
+        context.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(
+                context.client, placement_policy, unit_state)
+
+    # Check if we have any peer relations to establish
+    if charm.metadata.peers:
+        relation_manager = RelationStateManager(context.client)
+        for peer_name, peer_info in charm.metadata.peers.items():
+            yield relation_manager.add_relation_state(
+                RelationEndpoint(service_name,
+                                 peer_info["interface"],
+                                 peer_name,
+                                 "peer"))
+
+    context.log.info("Charm deployed as service: %r", service_name)
+    returnValue(True)

=== added file 'juju/rapi/cmd/destroy_service.py'
--- juju/rapi/cmd/destroy_service.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/destroy_service.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,42 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.errors import UnsupportedSubordinateServiceRemoval
+from juju.state.service import ServiceStateManager
+from juju.state.relation import RelationStateManager
+
+
+@inlineCallbacks
+def destroy_service(context, service_name):
+    service_manager = ServiceStateManager(context.client)
+    service_state = yield service_manager.get_service_state(service_name)
+
+    if (yield service_state.is_subordinate()):
+        # We can destroy the service if does not have relations.
+        # That implies that principals have already been torn
+        # down (or were never added).
+        relation_manager = RelationStateManager(context.client)
+        relations = yield relation_manager.get_relations_for_service(
+            service_state)
+
+        if relations:
+            principal_service = None
+            # if we don't have a container we can destroy the subordinate
+            # (revisit in the future)
+            for relation in relations:
+                if relation.relation_scope != "container":
+                    continue
+                services = yield relation.get_service_states()
+                remote_service = [s for s in services if s.service_name !=
+                                     service_state.service_name][0]
+                if not (yield remote_service.is_subordinate()):
+                    principal_service = remote_service
+                    break
+
+            if principal_service:
+                raise UnsupportedSubordinateServiceRemoval(
+                    service_state.service_name,
+                    principal_service.service_name)
+
+    yield service_manager.remove_service_state(service_state)
+    context.log.info("Service %r destroyed.", service_state.service_name)
+    returnValue(True)

=== added file 'juju/rapi/cmd/export.py'
--- juju/rapi/cmd/export.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/export.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,91 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.service import ServiceStateManager
+from juju.state.relation import RelationStateManager
+from juju.state.environment import EnvironmentStateManager
+
+
+@inlineCallbacks
+def export(context):
+    data = {'services': [],
+            'relations': []}
+
+    rels = set()
+
+    # Get services
+    services = ServiceStateManager(context.client)
+    relations = RelationStateManager(context.client)
+    environment = EnvironmentStateManager(context.client)
+
+    context.log.info("Exporting environment")
+
+    for s in (yield services.get_all_service_states()):
+        units = yield s.get_unit_names()
+        charm_id = yield s.get_charm_id()
+        constraints = yield s.get_constraints()
+        config = yield s.get_config()
+        exposed = yield s.get_exposed_flag()
+
+        context.log.info(
+            "Processing service %s / %s", s.service_name, charm_id)
+
+        # Really!? relation-type not available via state api
+        topology = yield relations._read_topology()
+
+        # More efficient to do this via topology, ie op per rel
+        # instead inspection of both sides by each endpoint, which is
+        # kinda of gross, need some state api support. But trying to
+        # stick to the state api as much as possible.
+        svc_rels = yield relations.get_relations_for_service(s)
+
+        for r in svc_rels:
+            relation_type = topology.get_relation_type(r.internal_relation_id)
+            rdata = [
+                (s.service_name,
+                 relation_type,
+                 r.relation_name,
+                 r.relation_role,
+                 r.relation_scope)]
+            if r.relation_role == "peer":
+                rels.add(tuple(rdata))
+                continue
+            rel_services = yield r.get_service_states()
+
+            # Get the endpoint's svc rel state.
+            found = None
+            for ep_svc in rel_services:
+                if ep_svc.service_name == s.service_name:
+                    continue
+                ep_rels = yield relations.get_relations_for_service(ep_svc)
+                for ep_r in ep_rels:
+                    if ep_r.internal_relation_id != r.internal_relation_id:
+                        continue
+                    found = (ep_svc, ep_r)
+                    break
+
+            if not found:
+                context.log.info("Couldn't decipher rel %s %s",
+                                 s.service_name, r)
+                continue
+
+            ep_svc, ep_r = found
+            rdata.append(
+                (ep_svc.service_name,
+                 relation_type,
+                 ep_r.relation_name,
+                 ep_r.relation_role,
+                 ep_r.relation_scope))
+            rdata.sort()
+            rels.add(tuple(rdata))
+
+        data['services'].append(
+            {'name': s.service_name,
+             'charm': charm_id,
+             'exposed': exposed,
+             'unit_count': len(units),
+             'constraints': constraints.data,
+             'config': dict(config.items())})
+
+    data['relations'] = list(rels)
+    data['constraints'] = (yield environment.get_constraints()).data
+    returnValue(data)

=== added file 'juju/rapi/cmd/expose.py'
--- juju/rapi/cmd/expose.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/expose.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,16 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def expose(context, service_name):
+    """Expose a service."""
+    service_manager = ServiceStateManager(context.client)
+    service_state = yield service_manager.get_service_state(service_name)
+    already_exposed = yield service_state.get_exposed_flag()
+    if not already_exposed:
+        yield service_state.set_exposed_flag()
+        context.log.info("Service %r was exposed.", service_name)
+    else:
+        context.log.info("Service %r was already exposed.", service_name)
+    returnValue(True)

=== added file 'juju/rapi/cmd/import_env.py'
--- juju/rapi/cmd/import_env.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/import_env.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,98 @@
+from twisted.internet.defer import inlineCallbacks
+
+from juju.charm.publisher import CharmPublisher
+from juju.charm.repository import (
+    CharmURL, RemoteCharmRepository, CS_STORE_URL)
+
+from juju.errors import JujuError
+
+from juju.state.endpoint import RelationEndpoint
+from juju.state.service import ServiceStateManager
+from juju.state.machine import MachineStateManager
+from juju.state.placement import _unassigned_placement
+from juju.state.relation import RelationStateManager
+
+
+@inlineCallbacks
+def load(context, data):
+    """
+
+    Check for name conflicts
+     - Upload charms
+     - Create services (+ config, constraints)
+     - Add units
+     - Add relations
+    """
+    # Get state managers
+    services = ServiceStateManager(context.client)
+    relations = RelationStateManager(context.client)
+    machines = MachineStateManager(context.client)
+
+    # First detect conflicts
+    existing_services = yield services.get_all_service_states()
+    env_svc_names = [e.service_name for e in existing_services]
+    import_svc_names = [i['name'] for i in data['services']]
+    conflict_svc_names = set(env_svc_names) & set(import_svc_names)
+    if conflict_svc_names:
+        raise JujuError(
+            "Import has name conflicts with existing services %s" % (
+                ", ".join(conflict_svc_names)))
+
+    store = RemoteCharmRepository(CS_STORE_URL)
+
+    charms = []
+    for s in data['services']:
+        curl = CharmURL.infer(s['charm'], context.default_series)
+        if s['charm'].startswith('local:'):
+            raise JujuError(
+                "Local charm needed but repository not specified")
+        else:
+            assert s['charm'].startswith('cs:')
+            charm = yield store.find(curl)
+            charms.append((s['charm'], charm))
+
+    # Upload charms to the environment
+    publisher = CharmPublisher(
+        context.client, context.provider.get_file_storage())
+    for cid, c in charms:
+        context.log.info("Publishing charm %s", cid)
+        yield publisher.add_charm(
+            str(CharmURL.infer(cid, context.default_series)),
+            c)
+    charm_states = yield publisher.publish()
+
+    # Index by url
+    charm_map = dict([(ci[0], cs) for ci, cs in zip(charms, charm_states)])
+    constraint_set = yield context.provider.get_constraint_set()
+
+    # Create services
+    for s in data['services']:
+        context.log.info(
+            "Creating service %s %s", s['name'], charm_map[s['charm']].id)
+        constraints = constraint_set.load(s['constraints'])
+        svc = yield services.add_service_state(
+            s['name'],
+            charm_map[s['charm']],
+            constraints)
+        config = yield svc.get_config()
+        config.update(s['config'])
+        yield config.write()
+
+        # Create units
+        context.log.info("Creating units")
+        for i in range(s['unit_count']):
+            unit = yield svc.add_unit_state()
+            yield _unassigned_placement(context.client, machines, unit)
+
+    # Add relations
+    for r in data['relations']:
+        if len(r) == 1:
+            eps = [RelationEndpoint(*r[0])]
+        else:
+            eps = [RelationEndpoint(*r[0]), RelationEndpoint(*r[1])]
+        context.log.info("Adding relation %s" % (
+            " ".join(map(
+                lambda r: "%s:%s %s" % (
+                    r.service_name, r.relation_name, r.relation_role),
+                eps))))
+        yield relations.add_relation_state(*eps)

=== added file 'juju/rapi/cmd/remove_relation.py'
--- juju/rapi/cmd/remove_relation.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/remove_relation.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,58 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.errors import (AmbiguousRelation, NoMatchingEndpoints,
+                               UnsupportedSubordinateServiceRemoval)
+from juju.state.relation import RelationStateManager
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def remove_relation(context, descriptors=()):
+
+    relation_state_manager = RelationStateManager(context.client)
+    service_state_manager = ServiceStateManager(context.client)
+    endpoint_pairs = yield service_state_manager.join_descriptors(
+            *descriptors)
+
+    if len(endpoint_pairs) == 0:
+        raise NoMatchingEndpoints()
+    elif len(endpoint_pairs) > 1:
+        raise AmbiguousRelation(descriptors, endpoint_pairs)
+
+    # At this point we just have one endpoint pair. We need to pick
+    # just one of the endpoints if it's a peer endpoint, since that's
+    # our current API - join descriptors takes two descriptors, but
+    # add_relation_state takes one or two endpoints. TODO consider
+    # refactoring.
+    endpoints = endpoint_pairs[0]
+    if endpoints[0] == endpoints[1]:
+        endpoints = endpoints[0:1]
+    relation_state = yield relation_state_manager.get_relation_state(
+        *endpoints)
+
+    # Look at both endpoints, if we are dealing with a container relation
+    # decide if one end is a principal.
+    service_pair = []  # ordered such that sub, principal
+
+    is_container = False
+    has_principal = True
+    for ep in endpoints:
+        if ep.relation_scope == "container":
+            is_container = True
+        service = yield service_state_manager.get_service_state(
+            ep.service_name)
+        if (yield service.is_subordinate()):
+            service_pair.append(service)
+            has_principal = True
+        else:
+            service_pair.insert(0, service)
+    if is_container and len(service_pair) == 2 and has_principal:
+        sub, principal = service_pair
+        raise UnsupportedSubordinateServiceRemoval(sub.service_name,
+                                                   principal.service_name)
+
+    yield relation_state_manager.remove_relation_state(relation_state)
+    context.log.info("Removed %s relation from all service units.",
+                     endpoints[0].relation_type)
+
+    returnValue(True)

=== added file 'juju/rapi/cmd/remove_unit.py'
--- juju/rapi/cmd/remove_unit.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/remove_unit.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,30 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.errors import (
+    UnsupportedSubordinateServiceRemoval, ServiceUnitStateNotFound)
+from juju.state.service import ServiceStateManager, parse_service_name
+
+
+@inlineCallbacks
+def remove_unit(context, unit_names):
+    service_manager = ServiceStateManager(context.client)
+    for unit_name in unit_names:
+        service_name = parse_service_name(unit_name)
+        service_state = yield service_manager.get_service_state(
+            service_name)
+        try:
+            unit_state = yield service_state.get_unit_state(unit_name)
+        except ServiceUnitStateNotFound:
+            context.log.warning("Unit %r does not exist", unit_name)
+            continue
+        if (yield service_state.is_subordinate()):
+            container = yield unit_state.get_container()
+            raise UnsupportedSubordinateServiceRemoval(
+                unit_state.unit_name,
+                container.unit_name)
+
+        yield service_state.remove_unit_state(unit_state)
+        context.log.info("Unit %r removed from service %r",
+                 unit_state.unit_name, service_state.service_name)
+
+    returnValue(True)

=== added file 'juju/rapi/cmd/resolved.py'
--- juju/rapi/cmd/resolved.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/resolved.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,70 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.service import ServiceStateManager, RETRY_HOOKS, NO_HOOKS
+from juju.state.relation import RelationStateManager
+from juju.state.errors import RelationStateNotFound
+from juju.unit.workflow import is_unit_running, is_relation_running
+
+
+@inlineCallbacks
+def resolved(context, unit_name, relation_name, retry):
+    """Mark an error as resolved in a unit or unit relation.
+
+    If one of a unit's charm non-relation hooks returns a non-zero exit
+    status, the entire unit can be considered to be in a non-running state.
+
+    As a resolution, the the unit can be manually returned a running state
+    via the juju resolved command. Optionally this command can also
+    rerun the failed hook.
+
+    This resolution also applies separately to each of the unit's relations.
+    If one of the relation-hooks failed. In that case there is no
+    notion of retrying (the change is gone), but resolving will allow
+    additional relation hooks for that relation to proceed.
+    """
+    service_manager = ServiceStateManager(context.client)
+    relation_manager = RelationStateManager(context.client)
+
+    unit_state = yield service_manager.get_unit_state(unit_name)
+    service_state = yield service_manager.get_service_state(
+        unit_name.split("/")[0])
+
+    retry = retry and RETRY_HOOKS or NO_HOOKS
+
+    if not relation_name:
+        running, workflow_state = yield is_unit_running(
+            context.client, unit_state)
+        if running:
+            context.log.info(
+                "Unit %r already running: %s", unit_name, workflow_state)
+            returnValue(False)
+
+        yield unit_state.set_resolved(retry)
+        context.log.info("Marked unit %r as resolved", unit_name)
+        returnValue(True)
+
+    # Check for the matching relations
+    service_relations = yield relation_manager.get_relations_for_service(
+        service_state)
+    service_relations = [
+        sr for sr in service_relations if sr.relation_name == relation_name]
+    if not service_relations:
+        raise RelationStateNotFound()
+
+    # Verify the relations are in need of resolution.
+    resolved_relations = {}
+    for service_relation in service_relations:
+        unit_relation = yield service_relation.get_unit_state(unit_state)
+        running, state = yield is_relation_running(
+            context.client, unit_relation)
+        if not running:
+            resolved_relations[unit_relation.internal_relation_id] = retry
+
+    if not resolved_relations:
+        context.log.warning("Matched relations are all running")
+        returnValue(False)
+
+    # Mark the relations as resolved.
+    yield unit_state.set_relation_resolved(resolved_relations)
+    context.log.info(
+        "Marked unit %r relation %r as resolved", unit_name, relation_name)

=== added file 'juju/rapi/cmd/status.py'
--- juju/rapi/cmd/status.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/status.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,471 @@
+from fnmatch import fnmatch
+
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.errors import ProviderError
+from juju.state.errors import UnitRelationStateNotFound
+from juju.state.charm import CharmStateManager
+from juju.state.machine import MachineStateManager
+from juju.state.service import ServiceStateManager, parse_service_name
+from juju.state.relation import RelationStateManager
+from juju.unit.workflow import WorkflowStateClient
+
+
+@inlineCallbacks
+def status(context, scope):
+    inspector = StatusInspector(
+        context.client, context.provider, context.log)
+    data = yield inspector(scope)
+    returnValue(data)
+
+
+def digest_scope(scope):
+    """Parse scope used to filter status information.
+
+    `scope`: a list of name specifiers. see collect()
+
+    Returns a tuple of (service_filter, unit_filter). The values in
+    either filter list will be passed as a glob to fnmatch
+    """
+
+    services = []
+    units = []
+
+    if scope is not None:
+        for value in scope:
+            if "/" in value:
+                units.append(value)
+            else:
+                services.append(value)
+
+    return (services, units)
+
+
+class StatusInspector(object):
+    def __init__(self, client, provider, log):
+        """
+        Status inspector.
+
+        `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 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
+
+        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")
+        open_ports = yield unit.get_open_ports()
+        if exposed:
+            u["open-ports"] = ["{port}/{proto}".format(**port_info)
+                               for port_info in open_ports]
+        elif open_ports:
+            # Ensure a hint is provided that there are open ports if
+            # not exposed by setting the key in the output
+            self.service_data[service.service_name]["exposed"] = False
+
+        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:
+            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)
+
+        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)
+
+        # Normalize the sets back to lists
+        for r in relation_data:
+            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 key that don't appear in output or come from container
+                for key in ("container", "machine", "public-address"):
+                    u.pop(key, None)
+            else:
+                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 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())
+                    for unit in units:
+                        unit_workflow_client = WorkflowStateClient(
+                            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
+                            m["agent-state"] = "down"
+                            break
+                    else:
+                        # otherwise we're probably just still waiting
+                        m["agent-state"] = "not-started"
+            except ProviderError:
+                # The provider doesn't have machine information
+                self.log.exception(
+                    "Machine provider information missing: machine %s" % (
+                        machine_state.id))
+
+        self.machine_data[machine_state.id] = m

=== added file 'juju/rapi/cmd/terminate_machine.py'
--- juju/rapi/cmd/terminate_machine.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/terminate_machine.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,41 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.errors import CannotTerminateMachine
+from juju.state.errors import MachineStateNotFound
+from juju.state.machine import MachineStateManager
+
+
+@inlineCallbacks
+def terminate_machine(context, machine_ids):
+    """Terminates the machines in `machine_ids`.
+
+    Like the underlying code in MachineStateManager, it's permissible
+    if the machine ID is already terminated or even never running. If
+    we determine this is not desired behavior, presumably propagate
+    that back to the state manager.
+
+    XXX However, we currently special case support of not terminating
+    the "root" machine, that is the one running the provisioning
+    agent. At some point, this will be managed like any other service,
+    but until then it seems best to ensure it's not terminated at this
+    level.
+    """
+    terminated_machine_ids = []
+    machine_state_manager = MachineStateManager(context.client)
+
+    for machine_id in machine_ids:
+        if machine_id == 0:
+            raise CannotTerminateMachine(
+                0, "environment would be destroyed")
+        removed = yield machine_state_manager.remove_machine_state(
+            machine_id)
+        if not removed:
+            raise MachineStateNotFound(machine_id)
+        terminated_machine_ids.append(machine_id)
+
+    if terminated_machine_ids:
+        context.log.info(
+            "Machines terminated: %s",
+                ", ".join(str(id) for id in terminated_machine_ids))
+
+    returnValue(True)

=== added directory 'juju/rapi/cmd/tests'
=== added file 'juju/rapi/cmd/tests/__init__.py'
--- juju/rapi/cmd/tests/__init__.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/tests/__init__.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,1 @@
+#

=== added file 'juju/rapi/cmd/unexpose.py'
--- juju/rapi/cmd/unexpose.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/cmd/unexpose.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,16 @@
+from twisted.internet.defer import inlineCallbacks, returnValue
+from juju.state.service import ServiceStateManager
+
+
+@inlineCallbacks
+def unexpose(context, service_name):
+    """Unexpose a service."""
+    service_manager = ServiceStateManager(context.client)
+    service_state = yield service_manager.get_service_state(service_name)
+    already_exposed = yield service_state.get_exposed_flag()
+    if already_exposed:
+        yield service_state.clear_exposed_flag()
+        context.log.info("Service %r was unexposed.", service_name)
+    else:
+        context.log.info("Service %r was not exposed.", service_name)
+    returnValue(True)

=== added file 'juju/rapi/context.py'
--- juju/rapi/context.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/context.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,332 @@
+from StringIO import StringIO
+from twisted.internet.defer import (
+    maybeDeferred, succeed, returnValue, inlineCallbacks)
+
+from juju.rapi.cmd import add_relation
+from juju.rapi.cmd import add_unit
+from juju.rapi.cmd import config_get
+from juju.rapi.cmd import config_set
+from juju.rapi.cmd import constraints_set
+from juju.rapi.cmd import constraints_get
+from juju.rapi.cmd import deploy
+from juju.rapi.cmd import debug_hooks
+from juju.rapi.cmd import destroy_service
+from juju.rapi.cmd import expose
+from juju.rapi.cmd import export
+from juju.rapi.cmd import import_env
+from juju.rapi.cmd import remove_relation
+from juju.rapi.cmd import remove_unit
+from juju.rapi.cmd import resolved
+from juju.rapi.cmd import status
+from juju.rapi.cmd import terminate_machine
+from juju.rapi.cmd import unexpose
+
+from juju.rapi import rest
+
+from juju.state.annotation import AnnotationManager
+from juju.state.security import Principal
+
+import logging
+import zookeeper
+
+log = logging.getLogger('juju.rapi.context')
+
+
+class LogBuffer(object):
+
+    def __init__(self):
+        self.msgs = []
+
+    def debug(self, msg, *args):
+        self.msgs.append(('debug', msg % args))
+
+    def error(self, msg, *args):
+        self.msgs.append(('error', msg % args))
+
+    def exception(self, msg, *args):
+        self.msgs.append(('error', msg % args))
+
+    def info(self, msg, *args):
+        self.msgs.append(('info', msg % args))
+
+    def warning(self, msg, *args):
+        self.msgs.append(('warning', msg % args))
+
+    def reset(self):
+        msgs = list(self.msgs)
+        self.msgs = []
+        return msgs
+
+
+class APIContext(object):
+
+    default_series = "precise"
+    charm_cache_dir = "/tmp"
+
+    def __init__(self, client, provider):
+        self.client = client
+        self.provider = provider
+        self.log = LogBuffer()
+
+    def connect(self, *args, **kw):
+        if self.client.connected:
+            return succeed(self)
+        d = self.client.connect(*args, **kw)
+        d.addCallback(lambda x: self)
+        return d
+
+    def close(self):
+        if self.client.connected:
+            self.client.close()
+
+    def _invoke(self, func, *args, **kw):
+        d = maybeDeferred(func, *args, **kw)
+        return d.addCallback(
+            lambda r: {'result': r, 'log': self.log.reset()}
+        ).addErrback(self._on_error)
+
+    def _on_error(self, failure):
+        io = StringIO()
+        failure.printTraceback(file=io)
+        return {'err': True, 'log': self.log.reset(),
+                'failure': io.getvalue()}
+
+    def add_relation(self, endpoint_a, endpoint_b):
+        """Add a relation to a service(s).
+        """
+        return self._invoke(
+            add_relation.add_relation,
+            self,
+            endpoint_a,
+            endpoint_b)
+
+    def add_unit(self, service_name, num_units):
+        """Add a unit to a service.
+        """
+        return self._invoke(
+            add_unit.add_unit,
+            self,
+            service_name,
+            num_units)
+
+    def get_annotations(self, entity):
+        """Retrieve annotations for an entity.
+        """
+        return self._invoke(self._get_annotations, entity)
+
+    def _get_annotations(self, entity):
+        return AnnotationManager(self.client).get(entity)
+
+    def get_service(self, service_name):
+        """Get information about the named service."""
+        return self._invoke(
+            rest.get_service,
+            self,
+            service_name)
+
+    def get_endpoints(self, service_names=()):
+        """Return available relation endpoints for the given services."""
+        return self._invoke(
+            rest.get_endpoints,
+            self,
+            service_names)
+
+    def get_charm(self, charm_url):
+        """Get information about the named charm from the env."""
+        return self._invoke(
+            rest.get_charm,
+            self,
+            charm_url)
+
+    def get_constraints(self, named_entities=()):
+        """Get the constraints of the named entities.
+
+        If no entities are specified, return the constraints
+        on the environment.
+        """
+        return self._invoke(
+            constraints_get.constraints_get,
+            self,
+            named_entities)
+
+    def get_config(self, service_name):
+        """Get configuration of a service.
+        """
+        return self._invoke(
+            config_get.config_get,
+            self,
+            service_name)
+
+    def deploy(self,
+               charm_url,
+               service_name=None,
+               charm_bundle=None,
+               constraints=(),
+               config=None,
+               config_raw=None,
+               num_units=1):
+        """Deploy a charm as a service
+        """
+        return self._invoke(
+            deploy.deploy,
+            self,
+            charm_url,
+            service_name,
+            constraints,
+            config,
+            config_raw,
+            num_units)
+
+    def debug_hooks(self, unit_name, hook_names=()):
+        """Enable hook debug on a unit.
+        """
+        return self._invoke(
+            debug_hooks.debug_hooks,
+            self,
+            unit_name,
+            hook_names)
+
+    def destroy_service(self, service_name):
+        """Destroy the named service.
+        """
+        return self._invoke(
+            destroy_service.destroy_service,
+            self,
+            service_name)
+
+    def export(self):
+        """Export an environment.
+        """
+        return self._invoke(
+            export.export,
+            self)
+
+    def expose(self, service_name):
+        """Expose a service for external access.
+        """
+        return self._invoke(
+            expose.expose,
+            self,
+            service_name)
+
+    def import_env(self, data):
+        """Import an environment from data serialization.
+        """
+        return self._invoke(
+            import_env.import_env,
+            self,
+            data)
+
+    def login(self, user, password):
+        return self._invoke(
+            self._login,
+            user,
+            password)
+
+    @inlineCallbacks
+    def _login(self, user, password):
+        principal = Principal(user, password)
+        yield principal.attach(self.client)
+        try:
+            yield self.client.get("/login")
+        except (zookeeper.NoAuthException, zookeeper.AuthFailedException):
+            self.log.error("Invalid credentials")
+            raise
+        else:
+            self.log.info("Login success")
+        returnValue(True)
+
+    def remove_annotations(self, entity, keys=()):
+        return self._invoke(self._remove_annotations, entity, keys)
+
+    def _remove_annotations(self, entity, keys):
+        return AnnotationManager(self.client).remove(entity, keys)
+
+    def remove_relation(self, endpoint_a, endpoint_b):
+        """Remove a relation from a service(s).
+        """
+        return self._invoke(
+            remove_relation.remove_relation,
+            self,
+            (endpoint_a, endpoint_b))
+
+    def remove_units(self, unit_names):
+        """Remove the given set of units.
+        """
+        return self._invoke(
+            remove_unit.remove_unit,
+            self,
+            unit_names)
+
+    def resolved(self, unit_name, relation_name=None, retry=False):
+        """Mark an error as fixed.
+        """
+        return self._invoke(
+            resolved.resolved,
+            self,
+            unit_name,
+            relation_name,
+            retry)
+
+    def set_config(self, service_name, config, data=None):
+        """Set a service's configuration.
+        """
+        return self._invoke(
+            config_set.config_set,
+            self,
+            service_name,
+            config,
+            data)
+
+    def set_constraints(self, service_name, constraints):
+        """Set constraints on the environment or service.
+        """
+        return self._invoke(
+            constraints_set.constraints_set,
+            self,
+            service_name,
+            constraints)
+
+    def status(self, scope=None):
+        """Get information about the environment and its contained items.
+        """
+        return self._invoke(
+            status.status,
+            self,
+            scope)
+
+    def terminate_machine(self, machine_ids):
+        """Terminate a machine.
+        """
+        return self._invoke(
+            terminate_machine.terminate_machine,
+            self,
+            machine_ids)
+
+    def unexpose(self, service_name):
+        """Remove external access from a service.
+        """
+        return self._invoke(
+            unexpose.unexpose,
+            self,
+            service_name)
+
+    def update_annotations(self, entity, data):
+        """Annotate an entity by name.
+
+        An entity is either a machine, unit, service, or the environment.
+        """
+        return self._invoke(self._update_annotations, entity, data)
+
+    def _update_annotations(self, entity, data):
+        return AnnotationManager(self.client).set(entity, data)
+
+    def upgrade_charm(self, service_name, local_charm=None):
+        """Upgrade a charm.
+        """
+        raise NotImplementedError()
+
+    def resolve_address(self, entity):
+        """Given an entity return its public address.
+        """
+        raise NotImplementedError()

=== added file 'juju/rapi/delta.py'
--- juju/rapi/delta.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/delta.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,275 @@
+"""
+Object Stream Delta
+ - status parsing atm
+ - topology usage for relation comparison
+"""
+import copy
+import logging
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.annotation import AnnotationManager
+# For unambigious relations deltas/identities.
+from juju.state.topology import InternalTopology
+
+
+log = logging.getLogger("juju.rapi.delta")
+
+
+def _unit_key(name):
+    name, number = name.split('/', 1)
+    return (name, int(number))
+
+
+class DeltaStreamManager(object):
+
+    def __init__(self, context):
+        self.context = context
+        self.previous = {
+            'services': {},
+            'machines': {},
+            'topology': None}
+        self.streams = []  # protocol instances
+        self.running = False
+        self.annotations = AnnotationManager(context.client)
+        self.annotation_stream = self.annotations.stream()
+
+    def start(self):
+        if self.running:
+            return
+
+        d = self.context.connect()
+
+        def _start(ctx):
+            self.running = True
+            return self.pump()
+
+        return d.addCallback(_start)
+
+    def stop(self):
+        self.running = False
+        self.context.close()
+
+    @inlineCallbacks
+    def pump(self, *ignored):
+        """Process state changes into notifications.
+        """
+        if not self.running:
+            return
+
+        try:
+            current = (yield self.context.status())['result']
+            self._annotate(
+                current, (yield self.annotation_stream.next()))
+            yield self.annotations.gc()
+        except Exception, e:
+            # The delta pump must go on.
+            log.exception("An error occurred %s" % str(e))
+            self._schedule()
+            return
+
+        current['topology'] = yield self._get_topology()
+
+        changes = []
+        delta(copy.deepcopy(self.previous),
+              copy.deepcopy(current),
+              changes.append)
+
+        self.previous = current
+        self.flush(changes)
+        self._schedule()
+
+    def _schedule(self):
+        """Schedule the next event stream pump.
+        """
+        if not self.running:
+            return
+
+        from twisted.internet import reactor
+        reactor.callLater(5, self.pump)
+
+    @inlineCallbacks
+    def _get_topology(self):
+        """Delta streams relation resolution needs this.
+        """
+        t = InternalTopology()
+        content, stat = yield self.context.client.get('/topology')
+        t.parse(content)
+        returnValue(t)
+
+    def _annotate(self, status, annotations):
+        for s in status['services']:
+            if s in annotations:
+                status['services'][s]['annotations'] = annotations[s]
+
+            for u in status['services'][s].get('units', ()):
+                if u in annotations:
+                    status['services'][s]['units'][u]['annotations'] = \
+                        annotations[u]
+        for m in status['machines']:
+            if m in annotations:
+                status['machines'][m]['annotations'] = annotations[m]
+
+        # Top level environment annotations
+        status['annotations'] = annotations.get('env', {})
+
+    def add(self, p):
+        """Add a stream/protocol
+        """
+        self.streams.append(p)
+
+    def remove(self, p):
+        """Add a stream/protocol
+        """
+        if p in self.streams:
+            self.streams.remove(p)
+
+    def get_current(self):
+        """Return current state as list of changes."""
+        changes = []
+        delta(
+            {'machines': {}, 'services': {}, 'topology': None},
+            copy.deepcopy(self.previous), changes.append)
+        return changes
+
+    def get_status(self):
+        """Return the current status output."""
+        status = dict(self.previous)
+        del status['topology']
+        return status
+
+    def flush(self, delta):
+        if not delta:
+            return None
+        for s in self.streams:
+            s.publish_changes(delta)
+
+
+def delta(prev, cur, stream):
+    """
+    Given two topology augmented status dictionaries, generate a
+    stream of object events corresponding to the delta between the
+    two states.
+
+    Logical order matters wrt to the event stream.
+
+    Bring Up / Bring down roughly reverse.
+    --------
+    Services
+    Relations
+    Machines
+    Units
+
+
+    TODO: A more efficient alternative to 1-1 delta changes, is
+    assuming intelligence on the client, and only sending logical
+    changes, ala sending remove service automatically removes units.
+    ie. operational transform.
+    """
+
+    ## Services
+    cur_svc_ids = set(cur['services'])
+    prev_svc_ids = set(prev['services'])
+
+    ## Relations
+    if not prev.get('topology'):
+        prev_rel_ids = set()
+    else:
+        prev_rel_ids = set(prev['topology'].get_relations())
+
+    if cur['topology']:
+        cur_rel_ids = set(cur['topology'].get_relations())
+    else:
+        cur_rel_ids = set()
+
+    ## Units
+    prev_units = {}
+    for s in prev['services']:
+        units = prev['services'][s].pop('units', ())
+        prev_units.update(units)
+        del units
+
+    cur_units = {}
+    for s in cur['services']:
+        units = cur['services'][s].pop('units', ())
+        cur_units.update(units)
+        del units
+
+    ## Machines
+    prev_machine_ids = set(prev['machines'].keys())
+    cur_machine_ids = set(cur['machines'].keys())
+
+    # svc add
+    for sid in cur_svc_ids - prev_svc_ids:
+        svc = dict(cur['services'][sid])
+        svc.pop('units', None)
+        svc.pop('relations', None)
+        svc['id'] = sid
+        stream(('service', 'add', svc))
+
+    # machine change
+    for mid in cur_machine_ids.intersection(prev_machine_ids):
+        if cur['machines'][mid] == prev['machines'][mid]:
+            continue
+        machine = cur['machines'][mid]
+        machine['id'] = mid
+        stream(('machine', 'change', machine))
+
+    # relation add
+    for rid in cur_rel_ids - prev_rel_ids:
+        scope = cur['topology'].get_relation_scope(rid)
+        interface = cur['topology'].get_relation_type(rid)
+        services = cur['topology'].get_relation_services(rid)
+
+        services = [
+            (cur['topology'].get_service_name(_sid),
+             services[_sid]) for _sid in services.keys()]
+        relation = {
+            'id': rid,
+            'interface': interface,
+            'scope': scope,
+            'endpoints': services}
+        stream(('relation', 'add', relation))
+
+    for mid in cur_machine_ids - prev_machine_ids:
+        machine = cur['machines'][mid]
+        machine['id'] = mid
+        stream(('machine', 'add', machine))
+
+    # We want the added units to be sent in ascending order by number.
+    for uid in sorted(set(cur_units) - set(prev_units), key=_unit_key):
+        unit = cur_units[uid]
+        unit['id'] = uid
+        stream(('unit', 'add', unit))
+
+    for uid in (set(cur_units).intersection(set(prev_units))):
+        if cur_units[uid] == prev_units[uid]:
+            continue
+        unit = cur_units[uid]
+        unit['id'] = uid
+        stream(('unit', 'change', unit))
+
+    for uid in (set(prev_units) - set(cur_units)):
+        stream(('unit', 'remove', uid))
+
+    for mid in prev_machine_ids - cur_machine_ids:
+        stream(('machine', 'remove', mid))
+
+    for rid in prev_rel_ids - cur_rel_ids:
+        # with svc ids
+        stream(('relation', 'remove', rid))
+
+    for sid in prev_svc_ids - cur_svc_ids:
+        stream(('service', 'remove', sid))
+
+    for sid in cur_svc_ids.intersection(prev_svc_ids):
+        svc = dict(cur['services'][sid])
+        svc.pop('units', None)
+        svc.pop('relations', None)
+
+        prev_svc = dict(prev['services'][sid])
+        prev_svc.pop('units', None)
+        prev_svc.pop('relations', None)
+
+        if svc != prev_svc:
+            svc['id'] = sid
+            stream(('service', 'change', svc))

=== added file 'juju/rapi/rest.py'
--- juju/rapi/rest.py	1970-01-01 00:00:00 +0000
+++ juju/rapi/rest.py	2013-01-17 11:02:31 +0000
@@ -0,0 +1,121 @@
+"""
+
+additional context commands for state representation.
+"""
+
+from twisted.internet.defer import inlineCallbacks, returnValue
+
+from juju.state.charm import CharmStateManager
+from juju.state.service import ServiceStateManager
+from juju.state.relation import RelationStateManager
+
+
+@inlineCallbacks
+def get_charm(context, charm_id):
+    """
+    GET /charms/:id
+
+    Charms have embedded '/'
+
+    Return back charm metadata.
+    """
+
+    charms = CharmStateManager(context.client)
+    charm = yield charms.get_charm_state(charm_id)
+    config = yield charm.get_config()
+    md = yield charm.get_metadata()
+
+    returnValue({
+        'name': charm.name,
+        'revision': charm.revision,
+        'url': charm.id,
+        'config': {'options': config.as_dict()},
+        'provides': md.provides,
+        'requires': md.requires,
+        'peers': md.peers,
+        'subordinate': md.is_subordinate,
+        })
+
+
+@inlineCallbacks
+def get_service(context, service_name):
+    """
+    get('/service/foobar')
+    set('/service/foobar/', value)
+
+    GET /service/:id
+    returns:
+
+    - Service Info
+    - Config
+    - Constraints
+    - Relations
+    - Charm identifier.
+
+    Set Service -> (context api set config, set constraints)
+    """
+    services = ServiceStateManager(context.client)
+    service = yield services.get_service_state(service_name)
+    config = yield service.get_config()
+    constraints = yield service.get_constraints()
+    charm_id = yield service.get_charm_id()
+    relations = RelationStateManager(context.client)
+    exposed = yield service.get_exposed_flag()
+
+    rels = []
+    for r in (yield relations.get_relations_for_service(service)):
+        endpoint = None
+        if r.relation_role != "peer":
+            for s in (yield r.get_service_states()):
+                if s.service_name != service.service_name:
+                    endpoint = s.service_name
+        rels.append(
+            dict(name=r.relation_name,
+                 ident=r.relation_ident,
+                 role=r.relation_role,
+                 scope=r.relation_scope,
+                 endpoint=endpoint))
+
+    returnValue({
+        'name': service.service_name,
+        'charm': charm_id,
+        'config': dict(config),
+        'exposed': exposed,
+        'constraints': constraints.data,
+        'rels': rels
+        })
+
+
+@inlineCallbacks
+def get_endpoints(context, service_names=()):
+    service_manager = ServiceStateManager(context.client)
+    if not service_names:
+        services = yield service_manager.get_all_service_states()
+    else:
+        services = []
+        for s in service_names:
+            services.append(
+                (yield service_manager.get_service_state(s)))
+
+    endpoint_mapping = {}
+
+    for svc in services:
+        charm = yield svc.get_charm_state()
+        metadata = yield charm.get_metadata()
+        endpoint_mapping[svc.service_name] = svc_rel_meta = {}
+        svc_rel_meta['provides'] = _flatter(metadata.provides)
+        svc_rel_meta['requires'] = _flatter(metadata.requires)
+
+    returnValue(endpoint_mapping)
+
+
+def _flatter(rel_meta):
+    flattened = []
+    if not rel_meta:
+        return flattened
+
+    for k in rel_meta:
+        rel = dict(rel_meta[k])
+        rel['name'] = k
+        flattened.append(rel)
+    return flattened