Merge lp:~hazmat/pyjuju/unit-with-addresses into lp:pyjuju

[Kapil Thangavelu]

Service units should know their public and private addresses.

This adds a two additional accessor/mutators to units for public/private
addresses, respectively. As well as provider specific implementation of address
detection, and unit agent initialization of those addresses on the unit state.

[Gustavo Niemeyer (niemeyer)]

This looks very nice too, thanks!

Just a couple of details:

[1]

+ elif provider_type == "lxc":

Please do not forget to rename the provider type to "local"
before making this public.

[2]

+ output = subprocess.check_output(["hostname", "-f"])

Why is this different for orchestra? Won't this fail if thethe release.
machine doesn't have a properly assigned domain name? I suspect
it will, and suggest using the same implementation of the local
case there as well.

review: Approve

[Kapil Thangavelu (hazmat)]

Excerpts from Gustavo Niemeyer's message of Mon Sep 26 13:15:39 UTC 2011:
> Review: Approve
>
> This looks very nice too, thanks!
>
> Just a couple of details:
>
>
> [1]
>
> + elif provider_type == "lxc":
>
> Please do not forget to rename the provider type to "local"
> before making this public.

sounds good, i'll put another branch in for the rename.

>
> [2]
>
> + output = subprocess.check_output(["hostname", "-f"])
>
> Why is this different for orchestra? Won't this fail if thethe release.
> machine doesn't have a properly assigned domain name? I suspect
> it will, and suggest using the same implementation of the local
> case there as well.
>

orchestra asserts that hostname is a valid fqdn. after long discussion on irc,
it seems that this is the most appropriate thing, and helps us get the
equivalent lines out of charms.

cheers,

Kapil

[lp:~hazmat/pyjuju/unit-with-addresses]

401. By Kapil Thangavelu on 2011-09-26

remove stray pdb

402. By Kapil Thangavelu on 2011-09-26

Merged lxc-omega-merge into unit-with-addresses.

403. By Kapil Thangavelu on 2011-09-27

Merged lxc-omega-merge into unit-with-addresses.

404. By Kapil Thangavelu on 2011-09-30

merge trunk and resolve conflict

=== modified file 'juju/agents/tests/test_unit.py'
--- juju/agents/tests/test_unit.py	2011-09-29 00:33:59 +0000
+++ juju/agents/tests/test_unit.py	2011-09-30 02:57:25 +0000
@@ -11,6 +11,7 @@
 from juju.charm import get_charm_from_path
 from juju.charm.url import CharmURL
 from juju.errors import JujuError
+from juju.state.environment import GlobalSettingsStateManager
 from juju.state.errors import ServiceStateNotFound
 from juju.state.service import NO_HOOKS, RETRY_HOOKS
 
@@ -29,6 +30,8 @@
     @inlineCallbacks
     def setUp(self):
         yield super(UnitAgentTestBase, self).setUp()
+        settings = GlobalSettingsStateManager(self.client)
+        yield settings.set_provider_type("dummy")
         self.change_environment(
             PATH=get_cli_environ_path(),
             JUJU_UNIT_NAME="mysql/0")
@@ -148,6 +151,18 @@
         return self.assertFailure(agent.startService(), ServiceStateNotFound)
 
     @inlineCallbacks
+    def test_agent_records_address_on_startup(self):
+        """On startup the agent will record the unit's addresses.
+        """
+        yield self.agent.startService()
+        self.assertEqual(
+            (yield self.agent.unit_state.get_public_address()),
+            "localhost")
+        self.assertEqual(
+            (yield self.agent.unit_state.get_private_address()),
+            "localhost")
+
+    @inlineCallbacks
     def test_agent_agent_executes_install_and_start_hooks_on_startup(self):
         """On initial startup, the unit agent executes install and start hooks.
         """
@@ -497,6 +512,8 @@
     @inlineCallbacks
     def setUp(self):
         yield super(UnitAgentTestBase, self).setUp()
+        settings = GlobalSettingsStateManager(self.client)
+        yield settings.set_provider_type("dummy")
         self.makeDir(path=os.path.join(self.juju_directory, "charms"))
 
     @inlineCallbacks
 
=== modified file 'juju/agents/unit.py'
--- juju/agents/unit.py	2011-09-27 19:18:08 +0000
+++ juju/agents/unit.py	2011-09-30 02:57:25 +0000
@@ -10,6 +10,7 @@
 from juju.hooks.protocol import UnitSettingsFactory
 from juju.hooks.executor import HookExecutor
 
+from juju.unit.address import get_unit_address
 from juju.unit.lifecycle import UnitLifecycle, HOOK_SOCKET_FILE
 from juju.unit.workflow import UnitWorkflowState
 
@@ -84,6 +85,13 @@
             os.path.join(self.unit_directory, HOOK_SOCKET_FILE),
             self.api_factory)
 
+        # Setup the unit state's address
+        address = yield get_unit_address(self.client)
+        yield self.unit_state.set_public_address(
+            (yield address.get_public_address()))
+        yield self.unit_state.set_private_address(
+            (yield address.get_private_address()))
+
         # Inform the system, we're alive.
         yield self.unit_state.connect_agent()
 
 
=== modified file 'juju/environment/config.py'
--- juju/environment/config.py	2011-09-27 04:29:30 +0000
+++ juju/environment/config.py	2011-09-30 02:57:25 +0000
@@ -57,6 +57,7 @@
                               "default-series": String()},
                              optional=["storage-url", "placement",
                                        "default-series"]),
+        "dummy": KeyDict({}),
         "lxc": KeyDict({"admin-secret": String(),
                         "data-dir": String(),
                         "placement": Constant("local"),
 
=== modified file 'juju/providers/lxc/__init__.py'
--- juju/providers/lxc/__init__.py	2011-09-27 04:29:30 +0000
+++ juju/providers/lxc/__init__.py	2011-09-30 02:57:25 +0000
@@ -46,6 +46,13 @@
                 "Unsupported placement policy for local provider")
         return LOCAL_POLICY
 
+    def get_placement_policy(self):
+        """Local dev supports only one unit placement policy."""
+        if self.config.get("placement", LOCAL_POLICY) != LOCAL_POLICY:
+            raise ProviderError(
+                "Unsupported placement policy for local provider")
+        return LOCAL_POLICY
+
     @property
     def provider_type(self):
         return "lxc"
 
=== modified file 'juju/providers/lxc/tests/test_provider.py'
--- juju/providers/lxc/tests/test_provider.py	2011-09-27 04:29:30 +0000
+++ juju/providers/lxc/tests/test_provider.py	2011-09-30 02:57:25 +0000
@@ -1,7 +1,6 @@
 import logging
 import os
 import pwd
-import subprocess
 from StringIO import StringIO
 import zookeeper
 
@@ -124,10 +123,11 @@
         lxc_ls_mock = self.mocker.mock()
         self.patch(lxc_lib, "_cmd", lxc_ls_mock)
         lxc_ls_mock(["lxc-ls"])
-        self.mocker.result((0,
-                            "%(name)s-local-test-unit-1\n%(name)s-local-test-unit-2\n"
-                            "%(name)s-local-test-unit-3\n%(name)s-local-test-unit-1\n"
-                            "%(name)s-local-test-unit-2\n" % dict(name=user_name)))
+        self.mocker.result(
+            (0,
+             "%(name)s-local-test-unit-1\n%(name)s-local-test-unit-2\n"
+             "%(name)s-local-test-unit-3\n%(name)s-local-test-unit-1\n"
+             "%(name)s-local-test-unit-2\n" % dict(name=user_name)))
 
         mock_container = self.mocker.patch(LXCContainer)
         mock_container.stop()
 
=== modified file 'juju/state/service.py'
--- juju/state/service.py	2011-09-28 23:54:04 +0000
+++ juju/state/service.py	2011-09-30 02:57:25 +0000
@@ -15,7 +15,7 @@
     ServiceUnitStateMachineAlreadyAssigned, ServiceStateNameInUse,
     BadDescriptor, BadServiceStateName, NoUnusedMachines,
     ServiceUnitDebugAlreadyEnabled, ServiceUnitResolvedAlreadyEnabled,
-    ServiceUnitRelationResolvedAlreadyEnabled, StopWatcher)
+    ServiceUnitRelationResolvedAlreadyEnabled, StopWatcher, StateError)
 from juju.state.charm import CharmStateManager
 from juju.state.relation import ServiceRelationState, RelationStateManager
 from juju.state.machine import _public_machine_id, MachineState
@@ -708,6 +708,64 @@
         return "/units/%s/agent" % self._internal_id
 
     @inlineCallbacks
+    def get_public_address(self):
+        """Get the public address of the unit.
+
+        If the unit is unassigned, or its unit agent hasn't started this
+        value maybe None.
+        """
+        unit_data, stat = yield self._client.get(
+            "/units/%s" % self.internal_id)
+        data = yaml.load(unit_data)
+        returnValue(data.get("public-address"))
+
+    @inlineCallbacks
+    def set_public_address(self, public_address):
+        """A unit's public address can be utilized to access the service.
+
+        The service must have been exposed for the service to be reachable
+        outside of the environment.
+        """
+        def update_private_address(content, stat):
+            data = yaml.load(content)
+            data["public-address"] = public_address
+            return yaml.safe_dump(data)
+
+        yield retry_change(
+            self._client,
+            "/units/%s" % self.internal_id,
+            update_private_address)
+
+    @inlineCallbacks
+    def get_private_address(self):
+        """Get the private address of the unit.
+
+        If the unit is unassigned, or its unit agent hasn't started this
+        value maybe None.
+        """
+        unit_data, stat = yield self._client.get(
+            "/units/%s" % self.internal_id)
+        data = yaml.load(unit_data)
+        returnValue(data.get("private-address"))
+
+    @inlineCallbacks
+    def set_private_address(self, private_address):
+        """A unit's address private to the environment.
+
+        Other service will see and utilize this address for relations.
+        """
+
+        def update_private_address(content, stat):
+            data = yaml.load(content)
+            data["private-address"] = private_address
+            return yaml.safe_dump(data)
+
+        yield retry_change(
+            self._client,
+            "/units/%s" % self.internal_id,
+            update_private_address)
+
+    @inlineCallbacks
     def get_charm_id(self):
         """Get the charm identifier that the unit is currently running."""
         unit_data, stat = yield self._client.get(
@@ -1331,6 +1389,7 @@
     sequence = int(sequence)
     return service_name, sequence
 
+
 def parse_service_name(unit_name):
     """Return the service name from a given unit name."""
     try:
 
=== modified file 'juju/state/tests/test_service.py'
--- juju/state/tests/test_service.py	2011-09-28 22:42:59 +0000
+++ juju/state/tests/test_service.py	2011-09-30 02:57:25 +0000
@@ -20,7 +20,7 @@
     ServiceUnitStateMachineAlreadyAssigned, ServiceStateNameInUse,
     BadDescriptor, BadServiceStateName, ServiceUnitDebugAlreadyEnabled,
     MachineStateNotFound, NoUnusedMachines, ServiceUnitResolvedAlreadyEnabled,
-    ServiceUnitRelationResolvedAlreadyEnabled, StopWatcher)
+    ServiceUnitRelationResolvedAlreadyEnabled, StopWatcher, StateError)
 
 
 from juju.state.tests.common import StateTestBase
@@ -532,6 +532,28 @@
             self.fail("Error not raised")
 
     @inlineCallbacks
+    def test_get_set_public_address(self):
+        service_state = yield self.service_state_manager.add_service_state(
+            "wordpress", self.charm_state)
+        unit_state = yield service_state.add_unit_state()
+        self.assertEqual((yield unit_state.get_public_address()), None)
+        yield unit_state.set_public_address("example.foobar.com")
+        yield self.assertEqual(
+            (yield unit_state.get_public_address()),
+             "example.foobar.com")
+
+    @inlineCallbacks
+    def test_get_set_private_address(self):
+        service_state = yield self.service_state_manager.add_service_state(
+            "wordpress", self.charm_state)
+        unit_state = yield service_state.add_unit_state()
+        self.assertEqual((yield unit_state.get_private_address()), None)
+        yield unit_state.set_private_address("example.local")
+        yield self.assertEqual(
+            (yield unit_state.get_private_address()),
+             "example.local")
+
+    @inlineCallbacks
     def test_get_service_unit_with_changing_state(self):
         """
         If a service is removed during operation, get_service_unit()
 
=== added file 'juju/unit/address.py'
--- juju/unit/address.py	1970-01-01 00:00:00 +0000
+++ juju/unit/address.py	2011-09-30 02:57:25 +0000
@@ -0,0 +1,86 @@
+"""Service units have both a public and private address.
+"""
+import subprocess
+
+from twisted.internet.defer import inlineCallbacks, returnValue, succeed
+from twisted.internet.threads import deferToThread
+from twisted.web import client
+
+from juju.errors import JujuError
+from juju.state.environment import GlobalSettingsStateManager
+
+
+@inlineCallbacks
+def get_unit_address(client):
+    settings = GlobalSettingsStateManager(client)
+    provider_type = yield settings.get_provider_type()
+    if provider_type == "ec2":
+        returnValue(EC2UnitAddress())
+    elif provider_type == "lxc":
+        returnValue(LocalUnitAddress())
+    elif provider_type == "orchestra":
+        returnValue(OrchestraUnitAddress())
+    elif provider_type == "dummy":
+        returnValue(DummyUnitAddress())
+
+    raise JujuError(
+        "Unknown provider type: %r, unit addresses unknown." % provider_type)
+
+
+class UnitAddress(object):
+
+    def get_private_address(self):
+        raise NotImplemented()
+
+    def get_public_address(self):
+        raise NotImplemented()
+
+
+class DummyUnitAddress(UnitAddress):
+
+    def get_private_address(self):
+        return succeed("localhost")
+
+    def get_public_address(self):
+        return succeed("localhost")
+
+
+class EC2UnitAddress(UnitAddress):
+
+    @inlineCallbacks
+    def get_private_address(self):
+        content = yield client.getPage(
+            "http://169.254.169.254/latest/meta-data/local-hostname")
+        returnValue(content.strip())
+
+    @inlineCallbacks
+    def get_public_address(self):
+        content = yield client.getPage(
+            "http://169.254.169.254/latest/meta-data/public-hostname")
+        returnValue(content.strip())
+
+
+class LocalUnitAddress(UnitAddress):
+
+    def get_private_address(self):
+        return deferToThread(self._get_address)
+
+    def get_public_address(self):
+        return deferToThread(self._get_address)
+
+    def _get_address(self):
+        output = subprocess.check_output(["hostname", "-I"])
+        return output.strip().split()[0]
+
+
+class OrchestraUnitAddress(UnitAddress):
+
+    def get_private_address(self):
+        return deferToThread(self._get_address)
+
+    def get_public_address(self):
+        return deferToThread(self._get_address)
+
+    def _get_address(self):
+        output = subprocess.check_output(["hostname", "-f"])
+        return output.strip()
 
=== added file 'juju/unit/tests/test_address.py'
--- juju/unit/tests/test_address.py	1970-01-01 00:00:00 +0000
+++ juju/unit/tests/test_address.py	2011-09-30 02:57:25 +0000
@@ -0,0 +1,126 @@
+import subprocess
+import zookeeper
+
+from twisted.internet.defer import inlineCallbacks, succeed, returnValue
+from twisted.web import client
+
+from juju.errors import JujuError
+from juju.lib.testing import TestCase
+from juju.unit.address import (
+    EC2UnitAddress, LocalUnitAddress, OrchestraUnitAddress, DummyUnitAddress,
+    get_unit_address)
+from juju.state.environment import GlobalSettingsStateManager
+
+
+class AddressTest(TestCase):
+
+    def setUp(self):
+        zookeeper.set_debug_level(0)
+        self.client = self.get_zookeeper_client()
+        return self.client.connect()
+
+    @inlineCallbacks
+    def get_address_for(self, provider_type):
+        settings = GlobalSettingsStateManager(self.client)
+        yield settings.set_provider_type(provider_type)
+        address = yield get_unit_address(self.client)
+        returnValue(address)
+
+    @inlineCallbacks
+    def test_get_ec2_address(self):
+        address = yield self.get_address_for("ec2")
+        self.assertTrue(isinstance(address, EC2UnitAddress))
+
+    @inlineCallbacks
+    def test_get_local_address(self):
+        address = yield self.get_address_for("lxc")
+        self.assertTrue(isinstance(address, LocalUnitAddress))
+
+    @inlineCallbacks
+    def test_get_orchestra_address(self):
+        address = yield self.get_address_for("orchestra")
+        self.assertTrue(isinstance(address, OrchestraUnitAddress))
+
+    @inlineCallbacks
+    def test_get_dummy_address(self):
+        address = yield self.get_address_for("dummy")
+        self.assertTrue(isinstance(address, DummyUnitAddress))
+
+    def test_get_unknown_address(self):
+        return self.assertFailure(self.get_address_for("foobar"), JujuError)
+
+
+class DummyAddressTest(TestCase):
+
+    def setUp(self):
+        self.address = DummyUnitAddress()
+
+    def test_get_address(self):
+
+        self.assertEqual(
+            (yield self.address.get_public_address()),
+            "localhost")
+
+        self.assertEqual(
+            (yield self.address.get_private_address()),
+            "localhost")
+
+
+class EC2AddressTest(TestCase):
+
+    def setUp(self):
+        self.address = EC2UnitAddress()
+
+    @inlineCallbacks
+    def test_get_address(self):
+        urls = [
+            "http://169.254.169.254/latest/meta-data/local-hostname",
+            "http://169.254.169.254/latest/meta-data/public-hostname"]
+
+        def verify_args(url):
+            self.assertEqual(urls.pop(0), url)
+            return succeed("foobar\n")
+
+        self.patch(client, "getPage", verify_args)
+        self.assertEqual(
+            (yield self.address.get_private_address()), "foobar")
+        self.assertEqual(
+            (yield self.address.get_public_address()), "foobar")
+
+
+class LocalAddressTest(TestCase):
+
+    def setUp(self):
+        self.address = LocalUnitAddress()
+
+    @inlineCallbacks
+    def test_get_address(self):
+        self.patch(
+            subprocess, "check_output",
+            lambda args: "192.168.1.122 127.0.0.1\n")
+        self.assertEqual(
+            (yield self.address.get_public_address()),
+            "192.168.1.122")
+        self.assertEqual(
+            (yield self.address.get_private_address()),
+            "192.168.1.122")
+
+
+class OrchestraAddressTest(TestCase):
+
+    def setUp(self):
+        self.address = OrchestraUnitAddress()
+
+    @inlineCallbacks
+    def test_get_address(self):
+        self.patch(
+            subprocess, "check_output",
+            lambda args: "slice.foobar.domain.net\n")
+
+        self.assertEqual(
+            (yield self.address.get_public_address()),
+            "slice.foobar.domain.net")
+
+        self.assertEqual(
+            (yield self.address.get_private_address()),
+            "slice.foobar.domain.net")