Merge lp:~hazmat/pyjuju/agent-state into lp:pyjuju

[Kapil Thangavelu]

Basic generic agent observation and connection, wired into machine state and service unit states.

[Gustavo Niemeyer (niemeyer)]

Neat! +1!

review: Approve

=== modified file 'ensemble/lib/testing.py'
--- ensemble/lib/testing.py	2010-11-11 23:33:18 +0000
+++ ensemble/lib/testing.py	2010-11-18 23:58:09 +0000
@@ -6,7 +6,11 @@
 from twisted.internet.defer import Deferred
 from twisted.internet import reactor
 from twisted.trial.unittest import TestCase as TrialTestCase
+
+from txzookeeper import ZookeeperClient
+
 from ensemble.lib.mocker import MockerTestCase
+from ensemble.tests.common import get_test_zookeeper_address
 
 
 class TestCase(TrialTestCase, MockerTestCase):
@@ -93,3 +97,8 @@
         deferred = Deferred()
         reactor.callLater(delay, deferred.callback, None)
         return deferred
+
+    def get_zookeeper_client(self):
+        client = ZookeeperClient(
+            get_test_zookeeper_address(), session_timeout=1000)
+        return client

=== added file 'ensemble/state/agent.py'
--- ensemble/state/agent.py	1970-01-01 00:00:00 +0000
+++ ensemble/state/agent.py	2010-11-18 23:58:09 +0000
@@ -0,0 +1,42 @@
+import zookeeper
+
+
+class AgentStateMixin(object):
+    """A mixin for state objects that will have agents processes.
+
+    Provides for the observation and connection of agent processes.
+    Subclasses must implement M{_get_agent_path}.
+    """
+
+    def has_agent(self):
+        """Does this domain object have an agent connected.
+
+        Return boolean deferred informing whether an agent is
+        connected.
+        """
+        d = self._client.exists(self._get_agent_path())
+        d.addCallback(lambda result: bool(result))
+        return d
+
+    def _get_agent_path(self):
+        raise NotImplementedError
+
+    def watch_agent(self):
+        """Observe changes to an agent's presence.
+
+        Return two boolean deferreds informing whether an agent is
+        connected, and whether a change happened. Both presence
+        and content changes are encapsulated in the second deferred,
+        callers interested in only presence need to perform event
+        filtering as needed.
+        """
+        exists_d, watch_d = self._client.exists_and_watch(
+            self._get_agent_path())
+        exists_d.addCallback(lambda result: bool(result))
+        return exists_d, watch_d
+
+    def connect_agent(self):
+        """Inform Ensemble that this associated agent is alive.
+        """
+        return self._client.create(
+            self._get_agent_path(), flags=zookeeper.EPHEMERAL)

=== modified file 'ensemble/state/machine.py'
--- ensemble/state/machine.py	2010-10-15 20:46:21 +0000
+++ ensemble/state/machine.py	2010-11-18 23:58:09 +0000
@@ -7,6 +7,8 @@
 
 from txzookeeper.utils import retry_change
 
+
+from ensemble.state.agent import AgentStateMixin
 from ensemble.state.errors import MachineStateNotFound, StateChanged
 from ensemble.state.base import StateBase
 
@@ -101,7 +103,7 @@
         self._watch_topology(watch_topology)
 
 
-class MachineState(StateBase):
+class MachineState(StateBase, AgentStateMixin):
 
     def __init__(self, client, internal_id):
         super(MachineState, self).__init__(client)
@@ -126,6 +128,10 @@
         """
         return "/machines/" + self.internal_id
 
+    def _get_agent_path(self):
+        """Get the zookeeper path for the machine agent."""
+        return "%s/agent" % self._zk_path
+
     def set_instance_id(self, instance_id):
         """Set the provider-specific machine id in this machine state."""
 

=== modified file 'ensemble/state/service.py'
--- ensemble/state/service.py	2010-11-04 12:55:48 +0000
+++ ensemble/state/service.py	2010-11-18 23:58:09 +0000
@@ -4,6 +4,7 @@
 
 from twisted.internet.defer import inlineCallbacks, returnValue
 
+from ensemble.state.agent import AgentStateMixin
 from ensemble.state.errors import (
     StateChanged, ServiceStateNotFound, ServiceUnitStateNotFound,
     ServiceUnitStateMachineAlreadyAssigned, ServiceStateNameInUse,
@@ -211,7 +212,7 @@
     return service_relations
 
 
-class ServiceUnitState(StateBase):
+class ServiceUnitState(StateBase, AgentStateMixin):
     """State of a service unit registered in an environment.
 
     Each service is composed by units, and each unit represents an
@@ -242,6 +243,10 @@
         """Get a nice user-oriented identifier for this unit."""
         return "%s/%d" % (self._service_name, self._unit_sequence)
 
+    def _get_agent_path(self):
+        """Get the zookeeper path for the service unit agent."""
+        return "/units/%s/agent" % self._internal_id
+
     def assign_to_machine(self, machine_state):
         """Assign this service unit to the given machine.
         """

=== added file 'ensemble/state/tests/test_agent.py'
--- ensemble/state/tests/test_agent.py	1970-01-01 00:00:00 +0000
+++ ensemble/state/tests/test_agent.py	2010-11-18 23:58:09 +0000
@@ -0,0 +1,94 @@
+import zookeeper
+
+from twisted.internet.defer import inlineCallbacks
+from txzookeeper.tests.utils import deleteTree
+
+from ensemble.lib.testing import TestCase
+from ensemble.state.base import StateBase
+from ensemble.state.agent import AgentStateMixin
+
+
+class DomainObject(StateBase, AgentStateMixin):
+
+    def _get_agent_path(self):
+        return "/agent"
+
+
+class AgentDomainTest(TestCase):
+
+    @inlineCallbacks
+    def setUp(self):
+        zookeeper.set_debug_level(0)
+        yield super(TestCase, self).setUp()
+        self.client = self.get_zookeeper_client()
+        yield self.client.connect()
+
+    @inlineCallbacks
+    def tearDown(self):
+        yield self.client.close()
+        client = self.get_zookeeper_client()
+        yield client.connect()
+        deleteTree("/", client.handle)
+        yield client.close()
+
+    @inlineCallbacks
+    def test_has_agent(self):
+        domain = DomainObject(self.client)
+        exists = yield domain.has_agent()
+        self.assertIs(exists, False)
+        yield domain.connect_agent()
+        exists = yield domain.has_agent()
+        self.assertIs(exists, True)
+
+    @inlineCallbacks
+    def test_watch_agent(self):
+        domain = DomainObject(self.client)
+        results = []
+
+        def on_change(event):
+            results.append(event)
+
+        exists_d, watch_d = domain.watch_agent()
+        exists = yield exists_d
+        self.assertIs(exists, False)
+        watch_d.addCallback(on_change)
+        self.assertFalse(results)
+
+        # connect the agent, and ensure its observed.
+        yield domain.connect_agent()
+        yield self.sleep(0.1)
+        self.assertEqual(len(results), 1)
+
+        # restablish the watch and manually delete.
+        exists_d, watch_d = domain.watch_agent()
+        exists = yield exists_d
+        self.assertIs(exists, True)
+        watch_d.addCallback(on_change)
+        yield self.client.delete("/agent")
+
+        self.assertEqual(results[0].type_name, "created")
+        self.assertEqual(results[1].type_name, "deleted")
+
+    @inlineCallbacks
+    def test_connect_agent(self):
+        client = self.get_zookeeper_client()
+        yield client.connect()
+
+        exists_d, watch_d = self.client.exists_and_watch("/agent")
+        exists = yield exists_d
+        self.assertFalse(exists)
+
+        domain = DomainObject(client)
+        yield domain.connect_agent()
+
+        event = yield watch_d
+        self.assertEqual(event.type_name, "created")
+
+        exists_d, watch_d = self.client.exists_and_watch("/agent")
+
+        # Force the connection of the domain object to disappear
+        yield client.close()
+
+        event = yield watch_d
+        self.assertEqual(event.type_name, "deleted")
+        yield exists_d

=== modified file 'ensemble/state/tests/test_machine.py'
--- ensemble/state/tests/test_machine.py	2010-10-27 21:18:51 +0000
+++ ensemble/state/tests/test_machine.py	2010-11-18 23:58:09 +0000
@@ -186,6 +186,20 @@
         self.assertEquals(instance_id, None)
 
     @inlineCallbacks
+    def test_machine_agent(self):
+        """A machine state has an associated machine agent.
+        """
+        machine_state = yield self.machine_state_manager.add_machine_state()
+        exists_d, watch_d = machine_state.watch_agent()
+        exists = yield exists_d
+        self.assertFalse(exists)
+        yield machine_state.connect_agent()
+        event = yield watch_d
+        self.assertEqual(event.type_name, "created")
+        self.assertEqual(event.path,
+                         "/machines/%s/agent" % machine_state.internal_id)
+
+    @inlineCallbacks
     def test_watch_machines_when_being_created(self):
         """
         It should be possible to start watching machines even

=== modified file 'ensemble/state/tests/test_service.py'
--- ensemble/state/tests/test_service.py	2010-11-04 12:53:38 +0000
+++ ensemble/state/tests/test_service.py	2010-11-18 23:58:09 +0000
@@ -351,6 +351,22 @@
             None)
 
     @inlineCallbacks
+    def test_service_unit_agent(self):
+        """A service unit state has an associated unit agent.
+        """
+        service_state = yield self.service_state_manager.add_service_state(
+            "wordpress", self.formula_state)
+        unit_state = yield service_state.add_unit_state()
+        exists_d, watch_d = unit_state.watch_agent()
+        exists = yield exists_d
+        self.assertFalse(exists)
+        yield unit_state.connect_agent()
+        event = yield watch_d
+        self.assertEqual(event.type_name, "created")
+        self.assertEqual(event.path,
+                         "/units/%s/agent" % unit_state.internal_id)
+
+    @inlineCallbacks
     def test_unassign_unit_from_machine_without_being_assigned(self):
         """
         When unassigning a machine from a unit, it is possible that