1
=== modified file 'ensemble/hooks/tests/test_invoker.py'
2
--- ensemble/hooks/tests/test_invoker.py	2010-12-07 19:05:09 +0000
3
+++ ensemble/hooks/tests/test_invoker.py	2010-12-10 23:06:27 +0000
4
@@ -11,6 +11,7 @@
5
11
from ensemble.hooks import invoker
11
from ensemble.hooks import invoker
6
12
from ensemble.hooks.protocol import UnitSettingsFactory
12
from ensemble.hooks.protocol import UnitSettingsFactory
7
13
from ensemble.state import hook
13
from ensemble.state import hook
8
14
from ensemble.state.endpoint import RelationEndpoint
9
14
from ensemble.state.tests.test_relation import RelationTestBase
15
from ensemble.state.tests.test_relation import RelationTestBase
10
15
16
11
16
17
12
@@ -104,11 +105,14 @@
13
104
105
14
105
    @defer.inlineCallbacks
106
    @defer.inlineCallbacks
15
106
    def _default_relations(self):
107
    def _default_relations(self):
21
107
        self.mysql_states = yield self.add_relation_service_unit(
108
        wordpress_ep = RelationEndpoint(
22
108
            "mysql", "mysql", "", "server")
109
            "wordpress", "client-server", "", "client")
23
109
        self.wordpress_states = yield self.add_relation_service_unit(
110
        mysql_ep = RelationEndpoint(
24
110
            "mysql", "wordpress", "", "client",
111
            "mysql", "client-server", "", "server")
25
111
            relation_state=self.mysql_states["relation"])
112
        self.wordpress_states = yield self.add_relation_service_unit_from_endpoints(
26
113
            wordpress_ep, mysql_ep)
27
114
        self.mysql_states = yield self.add_opposite_service_unit(
28
115
            self.wordpress_states)
29
112
        self.relation = self.mysql_states["unit_relation"]
116
        self.relation = self.mysql_states["unit_relation"]
30
113
117
31
114
    def _manage_path(self):
118
    def _manage_path(self):
32
115
119
33
=== modified file 'ensemble/state/endpoint.py'
34
--- ensemble/state/endpoint.py	2010-12-03 03:36:30 +0000
35
+++ ensemble/state/endpoint.py	2010-12-10 23:06:27 +0000
36
@@ -33,9 +33,9 @@
37
33
        if not isinstance(other, RelationEndpoint):
33
        if not isinstance(other, RelationEndpoint):
38
34
            raise TypeError("Not a RelationEndpoint", other)
34
            raise TypeError("Not a RelationEndpoint", other)
39
35
        return (self.relation_type == other.relation_type and
35
        return (self.relation_type == other.relation_type and
46
36
                ((self.relation_role == "provides" and
36
                ((self.relation_role == "server" and
47
37
                  other.relation_role == "requires") or
37
                  other.relation_role == "client") or
48
38
                 (self.relation_role == "requires" and
38
                 (self.relation_role == "client" and
49
39
                  other.relation_role == "provides") or
39
                  other.relation_role == "server") or
50
40
                 (self.relation_role == "peers" and
40
                 (self.relation_role == "peer" and
51
41
                  other.relation_role == "peers")))
41
                  other.relation_role == "peer")))
52
42
42
53
=== modified file 'ensemble/state/errors.py'
54
--- ensemble/state/errors.py	2010-12-10 04:55:47 +0000
55
+++ ensemble/state/errors.py	2010-12-10 23:06:27 +0000
56
@@ -94,18 +94,13 @@
57
94
               self.unit_name
94
               self.unit_name
58
95
95
59
96
96
61
97
class ServiceRelationAlreadyAssigned(StateError):
97
class RelationAlreadyExists(StateError):
62
98
98
67
99
    def __init__(self, service_name, relation_name, relation_role):
99
    def __init__(self, *endpoints):
68
100
        self.service_name = service_name
100
        self.endpoints = endpoints
65
101
        self.relation_name = relation_name
66
102
        self.relation_role = relation_role
69
103
101
70
104
    def __str__(self):
102
    def __str__(self):
75
105
        return (
103
        return "Relation already exists %r" % (self.endpoints,)
72
106
            "Service %r is already in relation with different name %r "
73
107
            "or role %r.") % (
74
108
            self.service_name, self.relation_name, self.relation_role)
76
109
104
77
110
105
78
111
class UnitRelationStateAlreadyAssigned(StateError):
106
class UnitRelationStateAlreadyAssigned(StateError):
79
@@ -156,7 +151,7 @@
80
156
            self.relation_role, self.service_name)
151
            self.relation_role, self.service_name)
81
157
152
82
158
153
84
159
class BadDescriptor(StateError):
154
class BadDescriptor(ValueError, EnsembleError):
85
160
    """Descriptor is not valid.
155
    """Descriptor is not valid.
86
161
156
87
162
    A descriptor must be of the form <service name>[:<relation name>].
157
    A descriptor must be of the form <service name>[:<relation name>].
88
@@ -169,3 +164,22 @@
89
169
164
90
170
    def __str__(self):
165
    def __str__(self):
91
171
        return "Bad descriptor: %r" % (self.descriptor,)
166
        return "Bad descriptor: %r" % (self.descriptor,)
92
167
93
168
94
169
class DuplicateEndpoints(StateError):
95
170
    """Endpoints cannot be duplicate."""
96
171
97
172
    def __init__(self, *endpoints):
98
173
        self.endpoints = endpoints
99
174
100
175
    def __str__(self):
101
176
        return "Duplicate endpoints: %r" % (self.endpoints,)
102
177
103
178
class IncompatibleEndpoints(StateError):
104
179
    """Endpoints are incompatible."""
105
180
106
181
    def __init__(self, *endpoints):
107
182
        self.endpoints = endpoints
108
183
109
184
    def __str__(self):
110
185
        return "Incompatible endpoints: %r" % (self.endpoints,)
111
172
186
112
=== modified file 'ensemble/state/relation.py'
113
--- ensemble/state/relation.py	2010-12-07 21:49:45 +0000
114
+++ ensemble/state/relation.py	2010-12-10 23:06:27 +0000
115
@@ -9,37 +9,107 @@
116
9
9
117
10
from ensemble.state.base import StateBase
10
from ensemble.state.base import StateBase
118
11
from ensemble.state.errors import (
11
from ensemble.state.errors import (
121
12
    StateChanged, ServiceRelationAlreadyAssigned, UnitRelationStateNotFound,
12
    DuplicateEndpoints, IncompatibleEndpoints, RelationAlreadyExists,
122
13
    UnitRelationStateAlreadyAssigned, UnknownRelationRole)
13
    StateChanged, UnitRelationStateAlreadyAssigned, UnitRelationStateNotFound,
123
14
    UnknownRelationRole)
124
14
15
125
15
16
126
16
class RelationStateManager(StateBase):
17
class RelationStateManager(StateBase):
127
17
    """Manages the state of relations in an environment."""
18
    """Manages the state of relations in an environment."""
128
18
19
129
19
    @inlineCallbacks
20
    @inlineCallbacks
132
20
    def add_relation_state(self, relation_type):
21
    def add_relation_state(self, *endpoints):
133
21
        """Add a new relation state. The relation is of the given type.
22
        """Add new relation state with the common relation type of `endpoints`.
134
22
23
137
23
        Type is used to distinguish the type of the relation, ie.
24
        There must be one or two endpoints specified, with the same
138
24
        'postgres', or 'varnish'.
25
        `relation_type`. Their corresponding services will be assigned
139
26
        atomically.
140
25
        """
27
        """
141
28
142
29
        # the TOODs in the following comments in this function are for
143
30
        # type checking to be implemented ASAP. However, this will
144
31
        # require some nontrivial test modification, so it's best to
145
32
        # be done in a future branch. This is because these tests use
146
33
        # such invalid role names as ``role``, ``dev``, and ``prod``;
147
34
        # or they add non-peer relations of only one endpoint.
148
35
149
36
        if len(endpoints) == 1:
150
37
            # TODO verify that the endpoint is a peer endpoint only
151
38
            pass
152
39
        elif len(endpoints) == 2:
153
40
            if endpoints[0] == endpoints[1]:
154
41
                raise DuplicateEndpoints(endpoints)
155
42
156
43
            # TODO verify that the relation roles are client or server
157
44
            # only
158
45
            if (endpoints[0].relation_role in ("client", "server") or
159
46
                endpoints[1].relation_role in ("client", "server")):
160
47
                if not endpoints[0].may_relate_to(endpoints[1]):
161
48
                    raise IncompatibleEndpoints(endpoints)
162
49
        else:
163
50
            raise TypeError("Requires 1 or 2 endpoints, %d given" % \
164
51
                            len(endpoints))
165
52
166
53
        # first check so as to prevent unnecessary garbage in ZK in
167
54
        # case this relation has been previously added
168
55
        topology = yield self._read_topology()
169
56
        if topology.has_relation_between_endpoints(endpoints):
170
57
            raise RelationAlreadyExists(endpoints)
171
58
172
59
        relation_type = endpoints[0].relation_type
173
60
        relation_id = yield self._add_relation_state(relation_type)
174
61
        services = []
175
62
        for endpoint in endpoints:
176
63
            service_id = topology.find_service_with_name(endpoint.service_name)
177
64
            yield self._add_service_relation_state(
178
65
                relation_id, service_id, endpoint)
179
66
            services.append(ServiceRelationState(self._client,
180
67
                                                 service_id,
181
68
                                                 relation_id,
182
69
                                                 endpoint.relation_role,
183
70
                                                 endpoint.relation_name))
184
71
185
72
        def add_relation(topology):
186
73
            if topology.has_relation_between_endpoints(endpoints):
187
74
                raise RelationAlreadyExists(endpoints)
188
75
            topology.add_relation(relation_id, relation_type)
189
76
            for service_relation in services:
190
77
                if not topology.has_service(service_id):
191
78
                    raise StateChanged()
192
79
                topology.assign_service_to_relation(
193
80
                    relation_id,
194
81
                    service_relation.internal_service_id,
195
82
                    service_relation.relation_name,
196
83
                    service_relation.relation_role)
197
84
        yield self._retry_topology_change(add_relation)
198
85
199
86
        returnValue((RelationState(self._client, relation_id), services))
200
87
201
88
    @inlineCallbacks
202
89
    def _add_relation_state(self, relation_type):
203
26
        path = yield self._client.create(
90
        path = yield self._client.create(
204
27
            "/relations/relation-", flags=zookeeper.SEQUENCE)
91
            "/relations/relation-", flags=zookeeper.SEQUENCE)
205
28
206
29
        internal_id = basename(path)
92
        internal_id = basename(path)
207
30
208
31
        # create the settings container, for individual units settings.
93
        # create the settings container, for individual units settings.
209
32
        yield self._client.create(path + "/settings")
94
        yield self._client.create(path + "/settings")
220
33
95
        returnValue(internal_id)
221
34
        # Not clear if we really need to update the topology till the relation
96
222
35
        # is in use. Topology updates are broadcasting to most connected
97
    @inlineCallbacks
223
36
        # clients. Perhaps a separate batch api would be useful to minimize
98
    def _add_service_relation_state(
224
37
        # broadcast events on the topology.
99
        self, relation_id, service_id, endpoint):
225
38
        def add_relation(topology):
100
        """Add a service relation state.
226
39
            topology.add_relation(internal_id, relation_type)
101
        """
227
40
        yield self._retry_topology_change(add_relation)
102
        # Add service container in relation.
228
41
103
        node_data = yaml.safe_dump(
229
42
        returnValue(RelationState(self._client, internal_id))
104
            {"name": endpoint.relation_name, "role": endpoint.relation_role})
230
105
        path = "/relations/%s/%s" % (relation_id, endpoint.relation_role)
231
106
232
107
        try:
233
108
            yield self._client.create(path, node_data)
234
109
        except zookeeper.NodeExistsException:
235
110
            # If its not, then update the node, and continue.
236
111
            yield retry_change(
237
112
                self._client, path, lambda content, stat: node_data)
238
43
113
239
44
    @inlineCallbacks
114
    @inlineCallbacks
240
45
    def remove_relation_state(self, relation_state):
115
    def remove_relation_state(self, relation_state):
241
@@ -86,89 +156,6 @@
242
86
    def internal_id(self):
156
    def internal_id(self):
243
87
        return self._internal_id
157
        return self._internal_id
244
88
158
245
89
    @inlineCallbacks
246
90
    def unassign_service(self, service_state):
247
91
        """Remove a service from the relation.
248
92
249
93
        Any removed service needs to have its zookeeper state garbage collected
250
94
        external to this api. The individual units should remove their
251
95
        contained nodes, upon notification but even then the service container
252
96
        node within the relation remains to be garbage collected.
253
97
        """
254
98
255
99
        def remove_service(topology):
256
100
            # Verify our relation and service still exist.
257
101
            if not topology.has_relation(self._internal_id) or \
258
102
               not topology.has_service(service_state.internal_id):
259
103
                raise StateChanged()
260
104
261
105
            # Ignore concurrent requests that achieve the same state.
262
106
            if not topology.relation_has_service(
263
107
                self._internal_id, service_state.internal_id):
264
108
                return
265
109
266
110
            topology.unassign_service_from_relation(
267
111
                self._internal_id, service_state.internal_id)
268
112
269
113
        yield self._retry_topology_change(remove_service)
270
114
271
115
    @inlineCallbacks
272
116
    def assign_service(self, service_state, relation_name, relation_role):
273
117
        """Add a service to the relation.
274
118
275
119
        @param service_state - The service to be added to the relation.
276
120
        @param name - The service's name for this relation.
277
121
        @param role - The service's role within this relation.
278
122
        """
279
123
        # Add service container in relation.
280
124
        node_data = yaml.safe_dump(
281
125
            {"name": relation_name, "role": relation_role})
282
126
        path = "/relations/%s/%s" % (self.internal_id, relation_role)
283
127
284
128
        try:
285
129
            yield self._client.create(path, node_data)
286
130
        except zookeeper.NodeExistsException:
287
131
            # because we don't garbage collect, we need to ascertain
288
132
            # if the service node is actually in use.
289
133
            topology = yield self._read_topology()
290
134
291
135
            # If it is assigned, its an error.
292
136
            # There's a small chance for a race condition between the check
293
137
            # and set.
294
138
            if topology.relation_has_service(
295
139
                self._internal_id, service_state.internal_id):
296
140
                raise ServiceRelationAlreadyAssigned(
297
141
                    service_state.service_name, relation_name, relation_role)
298
142
299
143
            # If its not, then update the node, and continue.
300
144
            yield retry_change(
301
145
                self._client, path, lambda content, stat: node_data)
302
146
303
147
        # Associate service to relation in the topology.
304
148
        def add_service(topology):
305
149
            # Verify our service and relation exists
306
150
            if not topology.has_relation(self._internal_id) or \
307
151
               not topology.has_service(service_state.internal_id):
308
152
                raise StateChanged()
309
153
310
154
            # Add it the topology if its not there.
311
155
            if not topology.relation_has_service(
312
156
                self._internal_id, service_state.internal_id):
313
157
                topology.assign_service_to_relation(
314
158
                    self.internal_id,
315
159
                    service_state.internal_id,
316
160
                    relation_name,
317
161
                    relation_role)
318
162
319
163
320
164
        yield self._retry_topology_change(add_service)
321
165
322
166
        returnValue(ServiceRelationState(self._client,
323
167
                                         service_state.internal_id,
324
168
                                         self.internal_id,
325
169
                                         relation_role,
326
170
                                         relation_name))
327
171
328
172
159
329
173
class ServiceRelationState(object):
160
class ServiceRelationState(object):
330
174
    """A state representative of a relation between one or more services."""
161
    """A state representative of a relation between one or more services."""
331
@@ -695,4 +682,3 @@
332
695
        """
682
        """
333
696
        return [unit_id for unit_id in units \
683
        return [unit_id for unit_id in units \
334
697
                if unit_id != self._watcher_unit.internal_unit_id]
684
                if unit_id != self._watcher_unit.internal_unit_id]
335
698
336
699
685
337
=== modified file 'ensemble/state/service.py'
338
--- ensemble/state/service.py	2010-12-10 04:59:54 +0000
339
+++ ensemble/state/service.py	2010-12-10 23:06:27 +0000
340
@@ -88,8 +88,11 @@
341
88
            formula_id)
88
            formula_id)
342
89
        formula_metadata = yield formula_state.get_metadata()
89
        formula_metadata = yield formula_state.get_metadata()
343
90
        endpoints = set()
90
        endpoints = set()
346
91
        for relation_role in ("peers", "provides", "requires"):
91
        relation_role_map = {
347
92
            relations = getattr(formula_metadata, relation_role)
92
            "peer": "peers", "client": "requires", "server": "provides"}
348
93
        for relation_role in ("peer", "client", "server"):
349
94
            relations = getattr(
350
95
                formula_metadata, relation_role_map[relation_role])
351
93
            if relations:
96
            if relations:
352
94
                for relation_name, spec in relations.iteritems():
97
                for relation_name, spec in relations.iteritems():
353
95
                    if (query_relation_name is None or
98
                    if (query_relation_name is None or
354
96
99
355
=== modified file 'ensemble/state/tests/test_endpoint.py'
356
--- ensemble/state/tests/test_endpoint.py	2010-11-25 05:28:27 +0000
357
+++ ensemble/state/tests/test_endpoint.py	2010-12-10 23:06:27 +0000
358
@@ -4,9 +4,9 @@
359
4
4
360
5
class RelationEndpointTest(TestCase):
5
class RelationEndpointTest(TestCase):
361
6
    def test_may_relate_to(self):
6
    def test_may_relate_to(self):
365
7
        mysql_ep = RelationEndpoint("mysqldb", "mysql", "db", "provides")
7
        mysql_ep = RelationEndpoint("mysqldb", "mysql", "db", "server")
366
8
        blog_ep = RelationEndpoint("blog", "mysql", "mysql", "requires")
8
        blog_ep = RelationEndpoint("blog", "mysql", "mysql", "client")
367
9
        pg_ep = RelationEndpoint("postgres", "postgres", "db", "provides")
9
        pg_ep = RelationEndpoint("postgres", "postgres", "db", "server")
368
10
10
369
11
        self.assertRaises(TypeError, mysql_ep.may_relate_to, 42)
11
        self.assertRaises(TypeError, mysql_ep.may_relate_to, 42)
370
12
12
371
@@ -21,15 +21,15 @@
372
21
        # antireflexive om relation_role -
21
        # antireflexive om relation_role -
373
22
        # must be consumer AND provider or vice versa
22
        # must be consumer AND provider or vice versa
374
23
        self.assertFalse(blog_ep.may_relate_to(
23
        self.assertFalse(blog_ep.may_relate_to(
376
24
            RelationEndpoint("foo", "mysql", "db", "requires")))
24
            RelationEndpoint("foo", "mysql", "db", "client")))
377
25
        self.assertFalse(mysql_ep.may_relate_to(
25
        self.assertFalse(mysql_ep.may_relate_to(
379
26
            RelationEndpoint("foo", "mysql", "db", "provides")))
26
            RelationEndpoint("foo", "mysql", "db", "server")))
380
27
27
382
28
        # irreflexive for provides/requires
28
        # irreflexive for server/client
383
29
        self.assertFalse(mysql_ep.may_relate_to(mysql_ep))
29
        self.assertFalse(mysql_ep.may_relate_to(mysql_ep))
384
30
        self.assertFalse(blog_ep.may_relate_to(blog_ep))
30
        self.assertFalse(blog_ep.may_relate_to(blog_ep))
385
31
        self.assertFalse(pg_ep.may_relate_to(pg_ep))
31
        self.assertFalse(pg_ep.may_relate_to(pg_ep))
386
32
32
389
33
        # but reflexive for peers
33
        # but reflexive for peer
390
34
        riak_ep = RelationEndpoint("riak", "riak", "riak", "peers")
34
        riak_ep = RelationEndpoint("riak", "riak", "riak", "peer")
391
35
        self.assert_(riak_ep.may_relate_to(riak_ep))
35
        self.assert_(riak_ep.may_relate_to(riak_ep))
392
36
36
393
=== modified file 'ensemble/state/tests/test_errors.py'
394
--- ensemble/state/tests/test_errors.py	2010-11-04 03:41:11 +0000
395
+++ ensemble/state/tests/test_errors.py	2010-12-10 23:06:27 +0000
396
@@ -1,12 +1,14 @@
397
1
from ensemble.lib.testing import TestCase
1
from ensemble.lib.testing import TestCase
398
2
2
399
3
from ensemble.state.endpoint import RelationEndpoint
400
3
from ensemble.state.errors import (
4
from ensemble.state.errors import (
401
4
    EnsembleError, StateError, StateChanged, FormulaStateNotFound,
5
    EnsembleError, StateError, StateChanged, FormulaStateNotFound,
402
5
    ServiceStateNotFound, ServiceUnitStateNotFound, MachineStateNotFound,
6
    ServiceStateNotFound, ServiceUnitStateNotFound, MachineStateNotFound,
403
6
    ServiceUnitStateMachineAlreadyAssigned, ServiceStateNameInUse,
7
    ServiceUnitStateMachineAlreadyAssigned, ServiceStateNameInUse,
404
7
    BadServiceStateName, EnvironmentStateNotFound,
8
    BadServiceStateName, EnvironmentStateNotFound,
407
8
    ServiceRelationAlreadyAssigned, UnitRelationStateNotFound,
9
    RelationAlreadyExists, UnitRelationStateNotFound,
408
9
    UnitRelationStateAlreadyAssigned, UnknownRelationRole)
10
    UnitRelationStateAlreadyAssigned, UnknownRelationRole,
409
11
    BadDescriptor, DuplicateEndpoints, IncompatibleEndpoints)
410
10
12
411
11
13
412
12
class StateErrorsTest(TestCase):
14
class StateErrorsTest(TestCase):
413
@@ -76,13 +78,13 @@
414
76
        self.assertEquals(str(error),
78
        self.assertEquals(str(error),
415
77
                          "Environment state was not found")
79
                          "Environment state was not found")
416
78
80
420
79
    def test_service_relation_already_assigned(self):
81
    def test_relation_already_exists(self):
421
80
        error = ServiceRelationAlreadyAssigned(
82
        error = RelationAlreadyExists(
422
81
            "wordpress", "mysql", "client")
83
            RelationEndpoint("wordpress", "mysql", "mysql", "client"),
423
84
            RelationEndpoint("mysql", "mysql", "db", "server"))
424
82
        self.assertIsStateError(error)
85
        self.assertIsStateError(error)
428
83
        msg = ("Service 'wordpress' is already in relation with different "
86
        self.assertTrue("wordpress" in str(error))
429
84
               "name 'mysql' or role 'client'.")
87
        self.assertTrue("mysql" in str(error))
427
85
        self.assertEquals(str(error), msg)
430
86
88
431
87
    def test_unit_relation_state_not_found(self):
89
    def test_unit_relation_state_not_found(self):
432
88
        error = UnitRelationStateNotFound(
90
        error = UnitRelationStateNotFound(
433
@@ -103,3 +105,24 @@
434
103
        self.assertIsStateError(error)
105
        self.assertIsStateError(error)
435
104
        msg = "Unknown relation role 'server2' for service 'service-name'"
106
        msg = "Unknown relation role 'server2' for service 'service-name'"
436
105
        self.assertEquals(str(error), msg)
107
        self.assertEquals(str(error), msg)
437
108
438
109
    def test_bad_descriptor(self):
439
110
        error = BadDescriptor("a:b:c")
440
111
        self.assertTrue(isinstance(error, EnsembleError))
441
112
        msg = "Bad descriptor: 'a:b:c'"
442
113
        self.assertEquals(str(error), msg)
443
114
444
115
    def test_duplicate_endpoints(self):
445
116
        riak_ep = RelationEndpoint("riak", "riak", "ring", "peer")
446
117
        error = DuplicateEndpoints(riak_ep, riak_ep)
447
118
        self.assertIsStateError(error)
448
119
        self.assertTrue("riak" in str(error))
449
120
450
121
    def test_incompatible_endpoints(self):
451
122
        error = IncompatibleEndpoints(
452
123
            RelationEndpoint("mysql", "mysql", "db", "server"),
453
124
            RelationEndpoint("riak", "riak", "ring", "peer"))
454
125
        self.assertIsStateError(error)
455
126
        self.assertTrue("mysql" in str(error))
456
127
        self.assertTrue("riak" in str(error))
457
128
458
106
129
459
=== modified file 'ensemble/state/tests/test_hook.py'
460
--- ensemble/state/tests/test_hook.py	2010-12-03 00:13:01 +0000
461
+++ ensemble/state/tests/test_hook.py	2010-12-10 23:06:27 +0000
462
@@ -3,6 +3,7 @@
463
3
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
464
4
from ensemble.lib.testing import TestCase
4
from ensemble.lib.testing import TestCase
465
5
5
466
6
from ensemble.state.endpoint import RelationEndpoint
467
6
from ensemble.state.hook import RelationChange, HookContext
7
from ensemble.state.hook import RelationChange, HookContext
468
7
from ensemble.state.errors import UnitRelationStateNotFound, StateError
8
from ensemble.state.errors import UnitRelationStateNotFound, StateError
469
8
from ensemble.state.tests.test_relation import RelationTestBase
9
from ensemble.state.tests.test_relation import RelationTestBase
470
@@ -23,11 +24,14 @@
471
23
    @inlineCallbacks
24
    @inlineCallbacks
472
24
    def setUp(self):
25
    def setUp(self):
473
25
        yield super(ExecutionContextTest, self).setUp()
26
        yield super(ExecutionContextTest, self).setUp()
479
26
        self.mysql_states = yield self.add_relation_service_unit(
27
        wordpress_ep = RelationEndpoint(
480
27
            "mysql", "mysql", "", "server")
28
            "wordpress", "client-server", "", "client")
481
28
        self.wordpress_states = yield self.add_relation_service_unit(
29
        mysql_ep = RelationEndpoint(
482
29
            "mysql", "wordpress", "", "client",
30
            "mysql", "client-server", "", "server")
483
30
            relation_state=self.mysql_states["relation"])
31
        self.wordpress_states = yield self.add_relation_service_unit_from_endpoints(
484
32
            wordpress_ep, mysql_ep)
485
33
        self.mysql_states = yield self.add_opposite_service_unit(
486
34
            self.wordpress_states)
487
31
        self.relation = self.mysql_states["relation"]
35
        self.relation = self.mysql_states["relation"]
488
32
36
489
33
    def get_execution_context(self, states, change_type, unit_name):
37
    def get_execution_context(self, states, change_type, unit_name):
490
34
38
491
=== modified file 'ensemble/state/tests/test_relation.py'
492
--- ensemble/state/tests/test_relation.py	2010-12-07 00:22:20 +0000
493
+++ ensemble/state/tests/test_relation.py	2010-12-10 23:06:27 +0000
494
@@ -8,11 +8,12 @@
495
8
    inlineCallbacks, returnValue, Deferred, fail, succeed)
8
    inlineCallbacks, returnValue, Deferred, fail, succeed)
496
9
from txzookeeper import ZookeeperClient
9
from txzookeeper import ZookeeperClient
497
10
10
498
11
from ensemble.state.endpoint import RelationEndpoint
499
11
from ensemble.state.formula import FormulaStateManager
12
from ensemble.state.formula import FormulaStateManager
500
12
from ensemble.state.errors import (
13
from ensemble.state.errors import (
504
13
    StateChanged, ServiceRelationAlreadyAssigned,
14
    DuplicateEndpoints, IncompatibleEndpoints, RelationAlreadyExists,
505
14
    UnitRelationStateNotFound, UnitRelationStateAlreadyAssigned,
15
    StateChanged, UnitRelationStateAlreadyAssigned,
506
15
    UnknownRelationRole)
16
    UnitRelationStateNotFound, UnknownRelationRole)
507
16
from ensemble.state.relation import (
17
from ensemble.state.relation import (
508
17
    RelationStateManager, ServiceRelationState, UnitRelationState)
18
    RelationStateManager, ServiceRelationState, UnitRelationState)
509
18
from ensemble.state.service import ServiceStateManager
19
from ensemble.state.service import ServiceStateManager
510
@@ -40,13 +41,95 @@
511
40
41
512
41
    @inlineCallbacks
42
    @inlineCallbacks
513
42
    def add_relation(self, relation_type, *services):
43
    def add_relation(self, relation_type, *services):
516
43
        relation_state = yield self.relation_manager.add_relation_state(
44
        """Support older tests that don't use `RelationEndpoint`s"""
517
44
            relation_type)
45
        endpoints = []
518
45
        for service_meta in services:
46
        for service_meta in services:
519
46
            service_state, relation_name, relation_role = service_meta
47
            service_state, relation_name, relation_role = service_meta
523
47
            yield relation_state.assign_service(
48
            endpoints.append(RelationEndpoint(
524
48
                service_state, relation_name, relation_role)
49
                service_state.service_name,
525
49
        returnValue(relation_state)
50
                relation_type,
526
51
                relation_name,
527
52
                relation_role))
528
53
        relation_state = yield self.relation_manager.add_relation_state(
529
54
            *endpoints)
530
55
        returnValue(relation_state[0])
531
56
532
57
    @inlineCallbacks
533
58
    def add_relation_service_unit_from_endpoints(self, *endpoints):
534
59
        """Build the relation and add one service unit to the first endpoint.
535
60
536
61
        This method is used to migrate older tests that would create
537
62
        the relation, assign one service, add a service unit, AND then
538
63
        assign a service. However, service assignment is now done all
539
64
        at once with the relation creation. Because we are interested
540
65
        in testing what happens with the changes to the service units,
541
66
        such tests remain valid.
542
67
543
68
        Returns a dict to collect together the various state objects
544
69
        being created. This is created from the perspective of the
545
70
        first endpoint, but the states of all of the endpoints are
546
71
        also captured, so it can be worked with from the opposite
547
72
        endpoint, as seen in :func:`add_opposite_service_unit`.
548
73
        """
549
74
        # 1. Setup all service states
550
75
        service_states = []
551
76
        for endpoint in endpoints:
552
77
            service_state = yield self.add_service(endpoint.service_name)
553
78
            service_states.append(service_state)
554
79
555
80
        # 2. And join together in a relation
556
81
        relation_state, service_relation_states = \
557
82
                        yield self.relation_manager.add_relation_state(
558
83
            *endpoints)
559
84
        
560
85
        # 3. Add a service unit to only the first endpoint - we need
561
86
        #    to test what happens when service units are added to the
562
87
        #    other service state (if any), so do so separately
563
88
        unit_state = yield service_states[0].add_unit_state()
564
89
        relation_unit_state = yield service_relation_states[0].add_unit_state(
565
90
            unit_state)
566
91
567
92
        returnValue({
568
93
            "service": service_states[0],
569
94
            "services": service_states,
570
95
            "unit": unit_state,
571
96
            "relation": relation_state,
572
97
            "service_relation": service_relation_states[0],
573
98
            "unit_relation": relation_unit_state,
574
99
            "service_relations": service_relation_states})
575
100
576
101
    @inlineCallbacks
577
102
    def add_opposite_service_unit(self, other_states):
578
103
        """Given `other_states`, add a service unit to the opposite endpoint.
579
104
580
105
        Like :func:`add_relation_service_unit_from_endpoints`, this is
581
106
        used to support older tests. Although it's slightly awkward to
582
107
        use because of attempt to be backwards compatible, it does
583
108
        enable the testing of a typical case: we are now bringing
584
109
        online a service unit on the opposite side of a relation
585
110
        endpoint pairing.
586
111
587
112
        TODO: there's probably a better name for this method.
588
113
        """
589
114
        
590
115
        assert len(other_states["services"]) == 2
591
116
        unit_state = yield other_states["services"][1].add_unit_state()
592
117
        relation_unit_state = yield other_states["service_relations"][1].\
593
118
                              add_unit_state(unit_state)
594
119
595
120
        def rotate(X):
596
121
            rotated = X[1:]
597
122
            rotated.append(X[0])
598
123
            return rotated
599
124
600
125
        returnValue({
601
126
            "service": other_states["services"][1],
602
127
            "services": rotate(other_states["services"]),
603
128
            "unit": unit_state,
604
129
            "relation": other_states["relation"],
605
130
            "service_relation": other_states["service_relations"][1],
606
131
            "unit_relation": relation_unit_state,
607
132
            "service_relations": rotate(other_states["service_relations"])})
608
50
133
609
51
    @inlineCallbacks
134
    @inlineCallbacks
610
52
    def add_relation_service_unit(self,
135
    def add_relation_service_unit(self,
611
@@ -54,7 +137,6 @@
612
54
                                  service_name,
137
                                  service_name,
613
55
                                  relation_name="name",
138
                                  relation_name="name",
614
56
                                  relation_role="role",
139
                                  relation_role="role",
615
57
                                  relation_state=None,
616
58
                                  client=None):
140
                                  client=None):
617
59
        """
141
        """
618
60
        Create a relation, service, and service unit, with the
142
        Create a relation, service, and service unit, with the
619
@@ -63,21 +145,11 @@
620
63
        the service relation and the service relation state will
145
        the service relation and the service relation state will
621
64
        utilize that as their zookeeper client.
146
        utilize that as their zookeeper client.
622
65
        """
147
        """
624
66
        # Add the service
148
        # Add the service, relation, unit states
625
67
        service_state = yield self.add_service(service_name)
149
        service_state = yield self.add_service(service_name)
639
68
150
        relation_state = yield self.add_relation(
640
69
        if relation_state is None:
151
            relation_type,
641
70
            # If no relation is passed, create the relation
152
            (service_state, relation_name, relation_role))
629
71
            # and associate the service to it.
630
72
            relation_state = yield self.add_relation(
631
73
                relation_type,
632
74
                (service_state, relation_name, relation_role))
633
75
        else:
634
76
            # If the relation exists, assign the service to it.
635
77
            yield relation_state.assign_service(
636
78
                service_state, relation_name, relation_role)
637
79
638
80
        # add a unit of the service
642
81
        unit_state = yield service_state.add_unit_state()
153
        unit_state = yield service_state.add_unit_state()
643
82
154
644
83
        # Get the service relation.
155
        # Get the service relation.
645
@@ -132,11 +204,11 @@
646
132
204
647
133
    @inlineCallbacks
205
    @inlineCallbacks
648
134
    def test_add_relation_state(self):
206
    def test_add_relation_state(self):
654
135
        """
207
        """Adding a relation will create a relation node and update topology."""
655
136
        Adding a relation will create a relation node and update the topology.
208
        mysql_ep = RelationEndpoint("mysql", "mysql", "db", "server")
656
137
        """
209
        yield self.add_service("mysql")
657
138
        relation_state = yield self.relation_manager.add_relation_state(
210
        relation_state = (yield self.relation_manager.add_relation_state(
658
139
            "mysql")
211
            mysql_ep))[0]
659
140
        topology = yield self.get_topology()
212
        topology = yield self.get_topology()
660
141
        self.assertTrue(topology.has_relation(relation_state.internal_id))
213
        self.assertTrue(topology.has_relation(relation_state.internal_id))
661
142
        exists = yield self.client.exists(
214
        exists = yield self.client.exists(
662
@@ -147,12 +219,118 @@
663
147
        self.assertTrue(exists)
219
        self.assertTrue(exists)
664
148
220
665
149
    @inlineCallbacks
221
    @inlineCallbacks
666
222
    def test_add_relation_state_to_missing_service(self):
667
223
        """Test adding a relation to a nonexistent service"""
668
224
        mysql_ep = RelationEndpoint("mysql", "mysql", "db", "server")
669
225
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
670
226
        yield self.add_service("mysql")
671
227
        # but didn't create the service for wordpress
672
228
        yield self.assertFailure(
673
229
            self.relation_manager.add_relation_state(
674
230
                mysql_ep, blog_ep),
675
231
            StateChanged)
676
232
677
233
    @inlineCallbacks
678
234
    def test_add_relation_state_bad_relation_role(self):
679
235
        """Test adding a relation with a bad role when is one is well defined (client or server)"""
680
236
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
681
237
        mysql_ep = RelationEndpoint("mysql", "mysql", "db", "server")
682
238
        bad_mysql_ep = RelationEndpoint("mysql", "mysql", "db", "bad-server-role")
683
239
        bad_blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "bad-client-role")
684
240
        yield self.add_service("mysql")
685
241
        yield self.add_service("wordpress")      
686
242
        yield self.assertFailure(
687
243
            self.relation_manager.add_relation_state(
688
244
                bad_mysql_ep, blog_ep),
689
245
            IncompatibleEndpoints)
690
246
        yield self.assertFailure(
691
247
            self.relation_manager.add_relation_state(
692
248
                bad_blog_ep, mysql_ep),
693
249
            IncompatibleEndpoints)
694
250
        # TODO in future branch referenced in relation, also test
695
251
        # bad_blog_ep *and* bad_mysql_ep
696
252
        
697
253
    @inlineCallbacks
698
254
    def test_add_binary_relation_state_twice(self):
699
255
        """Test adding the same relation twice"""
700
256
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
701
257
        mysql_ep = RelationEndpoint("mysql", "mysql", "db", "server")
702
258
        yield self.add_service("mysql")
703
259
        yield self.add_service("wordpress")      
704
260
        yield self.relation_manager.add_relation_state(mysql_ep, blog_ep)
705
261
        yield self.assertFailure(
706
262
            self.relation_manager.add_relation_state(blog_ep, mysql_ep),
707
263
            RelationAlreadyExists)
708
264
        yield self.assertFailure(
709
265
            self.relation_manager.add_relation_state(mysql_ep, blog_ep),
710
266
            RelationAlreadyExists)
711
267
712
268
    @inlineCallbacks
713
269
    def test_add_peer_relation_state_twice(self):
714
270
        """Test adding the same relation twice"""
715
271
        riak_ep = RelationEndpoint("riak", "riak", "ring", "peer")
716
272
        yield self.add_service("riak")
717
273
        yield self.relation_manager.add_relation_state(riak_ep)
718
274
        yield self.assertFailure(
719
275
            self.relation_manager.add_relation_state(riak_ep),
720
276
            RelationAlreadyExists)
721
277
722
278
    @inlineCallbacks
723
279
    def test_add_relation_state_no_endpoints(self):
724
280
        """Test adding a relation with no endpoints (no longer allowed)"""
725
281
        yield self.assertFailure(
726
282
            self.relation_manager.add_relation_state(),
727
283
            TypeError)
728
284
        
729
285
    @inlineCallbacks
730
286
    def test_add_relation_state_relation_type_unshared(self):
731
287
        """Test adding a relation with endpoints not sharing a relation type"""
732
288
        pg_ep = RelationEndpoint("pg", "postgres", "db", "server")
733
289
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
734
290
        yield self.assertFailure(
735
291
            self.relation_manager.add_relation_state(pg_ep, blog_ep),
736
292
            IncompatibleEndpoints)
737
293
738
294
    @inlineCallbacks
739
295
    def test_add_relation_state_too_many_endpoints(self):
740
296
        """Test adding a relation between too many endpoints (> 2)"""
741
297
        mysql_ep = RelationEndpoint("mysql", "mysql", "db", "server")
742
298
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
743
299
        yield self.add_service("mysql")
744
300
        yield self.add_service("wordpress")
745
301
        yield self.assertFailure(
746
302
            self.relation_manager.add_relation_state(
747
303
                mysql_ep, blog_ep, mysql_ep),
748
304
            TypeError)
749
305
750
306
    @inlineCallbacks
751
307
    def test_add_relation_state_duplicate_peer_endpoints(self):
752
308
        """Test adding a relation between duplicate peer endpoints"""
753
309
        riak_ep = RelationEndpoint("riak", "riak", "ring", "peer")
754
310
        yield self.add_service("riak")
755
311
        yield self.assertFailure(
756
312
            self.relation_manager.add_relation_state(riak_ep, riak_ep),
757
313
            DuplicateEndpoints)
758
314
759
315
    @inlineCallbacks
760
316
    def test_add_relation_state_endpoints_duplicate_role(self):
761
317
        """Test adding a relation with services overlapped by duplicate role"""
762
318
        mysql_ep = RelationEndpoint("mysql", "mysql", "db", "server")
763
319
        drizzle_ep = RelationEndpoint("drizzle", "mysql", "db", "server")
764
320
        yield self.add_service("mysql")
765
321
        yield self.add_service("drizzle")
766
322
        yield self.assertFailure(
767
323
            self.relation_manager.add_relation_state(mysql_ep, drizzle_ep),
768
324
            IncompatibleEndpoints)
769
325
770
326
    @inlineCallbacks
771
150
    def test_remove_relation_state(self):
327
    def test_remove_relation_state(self):
774
151
        """Removing a relation will remove it from the topology.
328
        """Removing a relation will remove it from the topology."""
773
152
        """
775
153
        # Simulate add and remove.
329
        # Simulate add and remove.
778
154
        relation_state = yield self.relation_manager.add_relation_state(
330
        varnish_ep = RelationEndpoint("varnish", "webcache", "cache", "server")
779
155
            "varnish")
331
        yield self.add_service("varnish")
780
332
        relation_state = (yield self.relation_manager.add_relation_state(
781
333
            varnish_ep))[0]
782
156
        topology = yield self.get_topology()
334
        topology = yield self.get_topology()
783
157
        self.assertTrue(topology.has_relation(relation_state.internal_id))
335
        self.assertTrue(topology.has_relation(relation_state.internal_id))
784
158
        yield self.relation_manager.remove_relation_state(relation_state)
336
        yield self.relation_manager.remove_relation_state(relation_state)
785
@@ -164,8 +342,10 @@
786
164
    @inlineCallbacks
342
    @inlineCallbacks
787
165
    def test_remove_relation_with_changing_state(self):
343
    def test_remove_relation_with_changing_state(self):
788
166
        # Simulate add and remove.
344
        # Simulate add and remove.
791
167
        relation_state = yield self.relation_manager.add_relation_state(
345
        varnish_ep = RelationEndpoint("varnish", "webcache", "cache", "server")
792
168
            "varnish")
346
        yield self.add_service("varnish")
793
347
        relation_state = (yield self.relation_manager.add_relation_state(
794
348
            varnish_ep))[0]
795
169
        topology = yield self.get_topology()
349
        topology = yield self.get_topology()
796
170
        self.assertTrue(topology.has_relation(relation_state.internal_id))
350
        self.assertTrue(topology.has_relation(relation_state.internal_id))
797
171
        yield self.relation_manager.remove_relation_state(relation_state)
351
        yield self.relation_manager.remove_relation_state(relation_state)
798
@@ -218,8 +398,8 @@
799
218
    def setUp(self):
398
    def setUp(self):
800
219
        yield super(RelationStateTest, self).setUp()
399
        yield super(RelationStateTest, self).setUp()
801
220
400
804
221
        self.relation_state = yield self.relation_manager.add_relation_state(
401
        self.relation_state = (yield self.relation_manager.add_relation_state(
805
222
            "rel-type")
402
            "rel-type"))[0]
806
223
        self.formula_state = yield self.formula_manager.add_formula_state(
403
        self.formula_state = yield self.formula_manager.add_formula_state(
807
224
            "namespace", self.formula)
404
            "namespace", self.formula)
808
225
        self.service_state1 = yield self.service_manager.add_service_state(
405
        self.service_state1 = yield self.service_manager.add_service_state(
809
@@ -227,106 +407,6 @@
810
227
        self.service_state2 = yield self.service_manager.add_service_state(
407
        self.service_state2 = yield self.service_manager.add_service_state(
811
228
            "wordpress-dev", self.formula_state)
408
            "wordpress-dev", self.formula_state)
812
229
409
813
230
    @inlineCallbacks
814
231
    def test_assign_service(self):
815
232
        yield self.relation_state.assign_service(
816
233
            self.service_state1,
817
234
            "dev-instance",
818
235
            "prod")
819
236
820
237
        yield self.relation_state.assign_service(
821
238
            self.service_state2,
822
239
            "prod-instance",
823
240
            "dev")
824
241
825
242
        topology = yield self.get_topology()
826
243
827
244
        self.assertEqual(
828
245
            topology.get_relations_for_service(
829
246
                self.service_state1.internal_id),
830
247
            [(self.relation_state.internal_id,
831
248
              "rel-type",
832
249
              {"name": "dev-instance", "role": "prod"})])
833
250
834
251
        self.assertEqual(
835
252
            topology.get_relation_services(self.relation_state.internal_id),
836
253
            {'service-0000000000': {'name': 'dev-instance', 'role': 'prod'},
837
254
             'service-0000000001': {'name': 'prod-instance', 'role': 'dev'}})
838
255
839
256
    @inlineCallbacks
840
257
    def test_assign_service_already_assigned(self):
841
258
        """
842
259
        Attempting to add a service to a relation multiple times
843
260
        will raise an error if its already there.
844
261
        """
845
262
        # Assign and verify
846
263
        yield self.relation_state.assign_service(self.service_state1,
847
264
                                                 "dev-instance",
848
265
                                                 "prod")
849
266
        topology = yield self.get_topology()
850
267
        self.assertTrue(topology.relation_has_service(
851
268
            self.relation_state.internal_id, self.service_state1.internal_id))
852
269
853
270
        # If we attempt to add again, we'll get an error.
854
271
        yield self.assertFailure(
855
272
            self.relation_state.assign_service(self.service_state1,
856
273
                                               "dev-instance",
857
274
                                               "prod"),
858
275
            ServiceRelationAlreadyAssigned)
859
276
860
277
        # If we unassign and assign again, the service container state updates.
861
278
        yield self.relation_state.unassign_service(self.service_state1)
862
279
        yield self.relation_state.assign_service(self.service_state1,
863
280
                                                 "dev-instance2",
864
281
                                                 "prod")
865
282
        content, stat = yield self.client.get(
866
283
            "/relations/%s/%s" % (
867
284
                self.relation_state.internal_id, "prod"))
868
285
869
286
        node_data = yaml.load(content)
870
287
        self.assertEqual(node_data["name"], "dev-instance2")
871
288
872
289
        # Attempting to assign when the relation or service has gone away
873
290
        # raises a state changed error.
874
291
        yield self.relation_manager.remove_relation_state(self.relation_state)
875
292
        topology = yield self.get_topology()
876
293
        self.assertFalse(
877
294
            topology.has_relation(self.relation_state.internal_id))
878
295
879
296
        yield self.assertFailure(
880
297
            self.relation_state.assign_service(self.service_state1,
881
298
                                               "dev-instance2",
882
299
                                               "prod2"),
883
300
            StateChanged)
884
301
885
302
    @inlineCallbacks
886
303
    def test_unassign_service(self):
887
304
        """A service can be disassociated from a relation.
888
305
        """
889
306
        yield self.relation_state.assign_service(self.service_state1,
890
307
                                                 "dev-instance",
891
308
                                                 "prod")
892
309
        topology = yield self.get_topology()
893
310
        self.assertTrue(topology.relation_has_service(
894
311
            self.relation_state.internal_id,
895
312
            self.service_state1.internal_id))
896
313
897
314
        # Remove and verify
898
315
        yield self.relation_state.unassign_service(self.service_state1)
899
316
        topology = yield self.get_topology()
900
317
        self.assertFalse(topology.relation_has_service(
901
318
            self.relation_state.internal_id,
902
319
            self.service_state1.internal_id))
903
320
904
321
        # if we remove again, we'll succed as the final state is the same.
905
322
        yield self.relation_state.unassign_service(self.service_state1)
906
323
907
324
        # Removing again, without the relation state, errors on state change.
908
325
        yield self.relation_manager.remove_relation_state(self.relation_state)
909
326
        yield self.assertFailure(
910
327
            self.relation_state.unassign_service(self.service_state1),
911
328
            StateChanged)
912
329
913
330
410
914
331
class ServiceRelationStateTest(RelationTestBase):
411
class ServiceRelationStateTest(RelationTestBase):
915
332
412
916
@@ -596,53 +676,16 @@
917
596
        self.assertEqual(path, container_path)
676
        self.assertEqual(path, container_path)
918
597
677
919
598
    @inlineCallbacks
678
    @inlineCallbacks
920
599
    def test_watch_start_existing_service(self):
921
600
        """Invoking watcher.start returns a deferred that only fires
922
601
        after watch on the container is in place. In the case of an
923
602
        existing service, this is after a child watch is established.
924
603
        """
925
604
        wordpress_states = yield self.add_relation_service_unit(
926
605
            "client-server", "wordpress", "", "client")
927
606
928
607
        mysql_states = yield self.add_relation_service_unit(
929
608
            "client-server", "mysql", "", "server",
930
609
            relation_state = wordpress_states["relation"])
931
610
932
611
        results = []
933
612
        wait_callback = [Deferred() for i in range(5)]
934
613
935
614
        def watch_related(old_units=None, new_units=None, modified=None):
936
615
            results.append((old_units, new_units, modified))
937
616
            wait_callback[len(results)-1].callback(True)
938
617
939
618
        def invoked(*args, **kw):
940
619
            # sleep to make sure that things haven't fired till the watch is
941
620
            # in place.
942
621
            time.sleep(0.1)
943
622
            self.assertFalse(results)
944
623
945
624
        mock_client = self.mocker.patch(self.client)
946
625
        mock_client.get_children_and_watch("/relations/%s/server" % (
947
626
            wordpress_states["relation"].internal_id))
948
627
949
628
        self.mocker.call(invoked)
950
629
        self.mocker.passthrough()
951
630
        self.mocker.replay()
952
631
953
632
        watcher = yield wordpress_states["unit_relation"].watch_related_units(
954
633
            watch_related)
955
634
        yield watcher.start()
956
635
        yield wait_callback[0]
957
636
958
637
    @inlineCallbacks
959
638
    def test_watch_start_new_service(self):
679
    def test_watch_start_new_service(self):
960
639
        """Invoking watcher.start returns a deferred that only fires
680
        """Invoking watcher.start returns a deferred that only fires
961
640
        after watch on the containr is in place. In the case of a new
681
        after watch on the containr is in place. In the case of a new
962
641
        service this after an existance watch is established on the
682
        service this after an existance watch is established on the
963
642
        container.
683
        container.
964
643
        """
684
        """
967
644
        wordpress_states = yield self.add_relation_service_unit(
685
        wordpress_ep = RelationEndpoint(
968
645
            "client-server", "wordpress", "", "client")
686
            "wordpress", "client-server", "", "client")
969
687
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
970
688
            wordpress_ep)
971
646
689
972
647
        results = []
690
        results = []
973
648
691
974
@@ -673,8 +716,12 @@
975
673
        first within relation, and start to monitor the server service
716
        first within relation, and start to monitor the server service
976
674
        as it joins the relation, adds a unit, modifies, the unit.
717
        as it joins the relation, adds a unit, modifies, the unit.
977
675
        """
718
        """
980
676
        wordpress_states = yield self.add_relation_service_unit(
719
        wordpress_ep = RelationEndpoint(
981
677
            "client-server", "wordpress", "", "client")
720
            "wordpress", "client-server", "", "client")
982
721
        mysql_ep = RelationEndpoint(
983
722
            "mysql", "client-server", "", "server")
984
723
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
985
724
            wordpress_ep, mysql_ep)
986
678
725
987
679
        # setup watch callbacks, and start watching.
726
        # setup watch callbacks, and start watching.
988
680
        wait_callback = [Deferred() for i in range(5)]
727
        wait_callback = [Deferred() for i in range(5)]
989
@@ -700,9 +747,8 @@
990
700
        self.assertFalse(results)
747
        self.assertFalse(results)
991
701
748
992
702
        # add the server service and a unit of that
749
        # add the server service and a unit of that
996
703
        mysql_states = yield self.add_relation_service_unit(
750
        mysql_states = yield self.add_opposite_service_unit(
997
704
            "client-server", "mysql", "", "server",
751
            wordpress_states)
995
705
            relation_state=wordpress_states["relation"])
998
706
752
999
707
        topology = yield self.get_topology()
753
        topology = yield self.get_topology()
1000
708
        # assert the relation is established correctly
754
        # assert the relation is established correctly
1001
@@ -734,17 +780,18 @@
1002
734
    @inlineCallbacks
780
    @inlineCallbacks
1003
735
    def test_watch_client_server_with_existing_service(self):
781
    def test_watch_client_server_with_existing_service(self):
1004
736
        """We simulate a scenario where the client and server are both
782
        """We simulate a scenario where the client and server are both
1006
737
        in place before the client begins observing. The server subequently,
783
        in place before the client begins observing. The server subsequently
1007
738
        modifies, and remove its unit from the relation.
784
        modifies, and remove its unit from the relation.
1008
739
        """
785
        """
1009
740
        # add the client service and a unit of that
786
        # add the client service and a unit of that
1017
741
        wordpress_states = yield self.add_relation_service_unit(
787
        wordpress_ep = RelationEndpoint(
1018
742
            "client-server", "wordpress", "", "client")
788
            "wordpress", "client-server", "", "client")
1019
743
789
        mysql_ep = RelationEndpoint(
1020
744
        # add the server service and a unit of that
790
            "mysql", "client-server", "", "server")
1021
745
        mysql_states = yield self.add_relation_service_unit(
791
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
1022
746
            "client-server", "mysql", "", "server",
792
            wordpress_ep, mysql_ep)
1023
747
            relation_state=wordpress_states["relation"])
793
        mysql_states = yield self.add_opposite_service_unit(
1024
794
            wordpress_states)
1025
748
795
1026
749
        # setup callbacks and start observing.
796
        # setup callbacks and start observing.
1027
750
        wait_callback = [Deferred() for i in range(5)]
797
        wait_callback = [Deferred() for i in range(5)]
1028
@@ -784,9 +831,13 @@
1029
784
    def test_watch_server_client_with_new_service(self):
831
    def test_watch_server_client_with_new_service(self):
1030
785
        """We simulate a server watching a client.
832
        """We simulate a server watching a client.
1031
786
        """
833
        """
1032
834
        wordpress_ep = RelationEndpoint(
1033
835
            "wordpress", "client-server", "", "client")
1034
836
        mysql_ep = RelationEndpoint(
1035
837
            "mysql", "client-server", "", "server")
1036
787
        # add the server service and a unit of that
838
        # add the server service and a unit of that
1039
788
        mysql_states = yield self.add_relation_service_unit(
839
        mysql_states = yield self.add_relation_service_unit_from_endpoints(
1040
789
            "client-server", "mysql", "", "server")
840
            mysql_ep, wordpress_ep)
1041
790
841
1042
791
        # setup callbacks and start observing.
842
        # setup callbacks and start observing.
1043
792
        wait_callback = [Deferred() for i in range(5)]
843
        wait_callback = [Deferred() for i in range(5)]
1044
@@ -804,9 +855,8 @@
1045
804
        self.assertFalse(results)
855
        self.assertFalse(results)
1046
805
856
1047
806
        # add the client service and a unit of that
857
        # add the client service and a unit of that
1051
807
        wordpress_states = yield self.add_relation_service_unit(
858
        wordpress_states = yield self.add_opposite_service_unit(
1052
808
            "client-server", "wordpress", "", "client",
859
            mysql_states)
1050
809
            relation_state=mysql_states["relation"])
1053
810
860
1054
811
        yield wait_callback[0]
861
        yield wait_callback[0]
1055
812
        self.verify_unit_watch_result(
862
        self.verify_unit_watch_result(
1056
@@ -817,10 +867,9 @@
1057
817
        """Peer relations always watch the peer container.
867
        """Peer relations always watch the peer container.
1058
818
        """
868
        """
1059
819
        # add the peer relation and two unit of the service.
869
        # add the peer relation and two unit of the service.
1064
820
        relation_state = yield self.relation_manager.add_relation_state("peer")
870
        riak_ep = RelationEndpoint("riak", "peer", "riak-db", "peer")
1065
821
        riak_states = yield self.add_relation_service_unit(
871
        riak_states = yield self.add_relation_service_unit_from_endpoints(
1066
822
            "peer", "riak", "riak-db", "peer",
872
            riak_ep)
1063
823
            relation_state=relation_state)
1067
824
873
1068
825
        riak2_unit = yield riak_states["service"].add_unit_state()
874
        riak2_unit = yield riak_states["service"].add_unit_state()
1069
826
        yield riak_states["service_relation"].add_unit_state(riak2_unit)
875
        yield riak_states["service_relation"].add_unit_state(riak2_unit)
1070
@@ -878,13 +927,15 @@
1071
878
        created container is detected correctly and the observation
927
        created container is detected correctly and the observation
1072
879
        works immediately.
928
        works immediately.
1073
880
        """
929
        """
1081
881
        # Add the server service and a service unit.
930
        # Add the relation, services, and related units.
1082
882
        mysql_states = yield self.add_relation_service_unit(
931
        wordpress_ep = RelationEndpoint(
1083
883
            "client-server", "mysql", "", "server")
932
            "wordpress", "client-server", "", "client")
1084
884
933
        mysql_ep = RelationEndpoint(
1085
885
        wordpress_states = yield self.add_relation_service_unit(
934
            "mysql", "client-server", "", "server")
1086
886
            "client-server", "wordpress", "", "client",
935
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
1087
887
            relation_state=mysql_states["relation"])
936
            wordpress_ep, mysql_ep)
1088
937
        mysql_states = yield self.add_opposite_service_unit(
1089
938
            wordpress_states)
1090
888
939
1091
889
        container_path = "/relations/%s/client" % (
940
        container_path = "/relations/%s/client" % (
1092
890
            mysql_states["relation"].internal_id)
941
            mysql_states["relation"].internal_id)
1093
@@ -929,12 +980,14 @@
1094
929
        notification.
980
        notification.
1095
930
        """
981
        """
1096
931
        # Add the relation, services, and related units.
982
        # Add the relation, services, and related units.
1103
932
        mysql_states = yield self.add_relation_service_unit(
983
        wordpress_ep = RelationEndpoint(
1104
933
            "client-server", "mysql", "", "server")
984
            "wordpress", "client-server", "", "client")
1105
934
985
        mysql_ep = RelationEndpoint(
1106
935
        wordpress_states = yield self.add_relation_service_unit(
986
            "mysql", "client-server", "", "server")
1107
936
            "client-server", "wordpress", "", "client",
987
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
1108
937
            relation_state=mysql_states["relation"])
988
            wordpress_ep, mysql_ep)
1109
989
        mysql_states = yield self.add_opposite_service_unit(
1110
990
            wordpress_states)
1111
938
991
1112
939
        # setup callbacks and start observing.
992
        # setup callbacks and start observing.
1113
940
        wait_callback = [Deferred() for i in range(5)]
993
        wait_callback = [Deferred() for i in range(5)]
1114
@@ -981,12 +1034,14 @@
1115
981
        the unit is being observed, the watcher will ignore the deletion.
1034
        the unit is being observed, the watcher will ignore the deletion.
1116
982
        """
1035
        """
1117
983
        # Add the relation, services, and related units.
1036
        # Add the relation, services, and related units.
1124
984
        mysql_states = yield self.add_relation_service_unit(
1037
        wordpress_ep = RelationEndpoint(
1125
985
            "client-server", "mysql", "", "server")
1038
            "wordpress", "client-server", "", "client")
1126
986
1039
        mysql_ep = RelationEndpoint(
1127
987
        wordpress_states = yield self.add_relation_service_unit(
1040
            "mysql", "client-server", "", "server")
1128
988
            "client-server", "wordpress", "", "client",
1041
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
1129
989
            relation_state=mysql_states["relation"])
1042
            wordpress_ep, mysql_ep)
1130
1043
        mysql_states = yield self.add_opposite_service_unit(
1131
1044
            wordpress_states)
1132
990
1045
1133
991
        # setup callbacks and start observing.
1046
        # setup callbacks and start observing.
1134
992
        wait_callback = [Deferred() for i in range(5)]
1047
        wait_callback = [Deferred() for i in range(5)]
1135
@@ -1039,12 +1094,14 @@
1136
1039
        without additional callbacks.
1094
        without additional callbacks.
1137
1040
        """
1095
        """
1138
1041
        # Add the relation, services, and related units.
1096
        # Add the relation, services, and related units.
1145
1042
        mysql_states = yield self.add_relation_service_unit(
1097
        wordpress_ep = RelationEndpoint(
1146
1043
            "client-server", "mysql", "", "server")
1098
            "wordpress", "client-server", "", "client")
1147
1044
1099
        mysql_ep = RelationEndpoint(
1148
1045
        wordpress_states = yield self.add_relation_service_unit(
1100
            "mysql", "client-server", "", "server")
1149
1046
            "client-server", "wordpress", "", "client",
1101
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
1150
1047
            relation_state=mysql_states["relation"])
1102
            wordpress_ep, mysql_ep)
1151
1103
        mysql_states = yield self.add_opposite_service_unit(
1152
1104
            wordpress_states)
1153
1048
1105
1154
1049
        # setup callbacks and start observing.
1106
        # setup callbacks and start observing.
1155
1050
        wait_callback = [Deferred() for i in range(5)]
1107
        wait_callback = [Deferred() for i in range(5)]
1156
@@ -1099,8 +1156,12 @@
1157
1099
        without additional callbacks.
1156
        without additional callbacks.
1158
1100
        """
1157
        """
1159
1101
        # Add the relation, services, and related units.
1158
        # Add the relation, services, and related units.
1162
1102
        mysql_states = yield self.add_relation_service_unit(
1159
        wordpress_ep = RelationEndpoint(
1163
1103
            "client-server", "mysql", "", "server")
1160
            "wordpress", "client-server", "", "client")
1164
1161
        mysql_ep = RelationEndpoint(
1165
1162
            "mysql", "client-server", "", "server")
1166
1163
        mysql_states = yield self.add_relation_service_unit_from_endpoints(
1167
1164
            mysql_ep, wordpress_ep)
1168
1104
1165
1169
1105
        # setup callbacks and start observing.
1166
        # setup callbacks and start observing.
1170
1106
        wait_callback = [Deferred() for i in range(5)]
1167
        wait_callback = [Deferred() for i in range(5)]
1171
@@ -1119,9 +1180,8 @@
1172
1119
        watcher.stop()
1180
        watcher.stop()
1173
1120
1181
1174
1121
        # Add the new service and a unit
1182
        # Add the new service and a unit
1178
1122
        wordpress_states = yield self.add_relation_service_unit(
1183
        wordpress_states = yield self.add_opposite_service_unit(
1179
1123
            "client-server", "wordpress", "", "client",
1184
            mysql_states)
1177
1124
            relation_state=mysql_states["relation"])
1180
1125
1185
1181
1126
        # Add another unit
1186
        # Add another unit
1182
1127
        wordpress2_states = yield self.add_related_service_unit(
1187
        wordpress2_states = yield self.add_related_service_unit(
1183
@@ -1314,12 +1374,14 @@
1184
1314
        watcher_callback = ParallelWatcherCallback()
1374
        watcher_callback = ParallelWatcherCallback()
1185
1315
1375
1186
1316
        # Add the relation, services, and related units.
1376
        # Add the relation, services, and related units.
1193
1317
        mysql_states = yield self.add_relation_service_unit(
1377
        wordpress_ep = RelationEndpoint(
1194
1318
            "client-server", "mysql", "", "server")
1378
            "wordpress", "client-server", "", "client")
1195
1319
1379
        mysql_ep = RelationEndpoint(
1196
1320
        wordpress_states = yield self.add_relation_service_unit(
1380
            "mysql", "client-server", "", "server")
1197
1321
            "client-server", "wordpress", "", "client",
1381
        wordpress_states = yield self.add_relation_service_unit_from_endpoints(
1198
1322
            relation_state=mysql_states["relation"])
1382
            wordpress_ep, mysql_ep)
1199
1383
        mysql_states = yield self.add_opposite_service_unit(
1200
1384
            wordpress_states)
1201
1323
1385
1202
1324
        # Start watching, and give a moment to establish
1386
        # Start watching, and give a moment to establish
1203
1325
        watcher = yield mysql_states["unit_relation"].watch_related_units(
1387
        watcher = yield mysql_states["unit_relation"].watch_related_units(
1204
1326
1388
1205
=== modified file 'ensemble/state/tests/test_service.py'
1206
--- ensemble/state/tests/test_service.py	2010-12-10 04:59:54 +0000
1207
+++ ensemble/state/tests/test_service.py	2010-12-10 23:06:27 +0000
1208
@@ -27,8 +27,8 @@
1209
27
        self.formula_state_manager = FormulaStateManager(self.client)
27
        self.formula_state_manager = FormulaStateManager(self.client)
1210
28
        self.service_state_manager = ServiceStateManager(self.client)
28
        self.service_state_manager = ServiceStateManager(self.client)
1211
29
        self.machine_state_manager = MachineStateManager(self.client)
29
        self.machine_state_manager = MachineStateManager(self.client)
1214
30
        self.formula_state = yield self.formula_state_manager.add_formula_state(
30
        self.formula_state = yield self.formula_state_manager.\
1215
31
            "namespace", self.formula)
31
                             add_formula_state("namespace", self.formula)
1216
32
        self.relation_state_manager = RelationStateManager(self.client)
32
        self.relation_state_manager = RelationStateManager(self.client)
1217
33
33
1218
34
    @inlineCallbacks
34
    @inlineCallbacks
1219
@@ -39,13 +39,17 @@
1220
39
39
1221
40
    @inlineCallbacks
40
    @inlineCallbacks
1222
41
    def add_relation(self, relation_type, *services):
41
    def add_relation(self, relation_type, *services):
1225
42
        relation_state = yield self.relation_state_manager.add_relation_state(
42
        endpoints = []
1224
43
            relation_type)
1226
44
        for service_meta in services:
43
        for service_meta in services:
1227
45
            service_state, relation_name, relation_role = service_meta
44
            service_state, relation_name, relation_role = service_meta
1231
46
            yield relation_state.assign_service(
45
            endpoints.append(RelationEndpoint(
1232
47
                service_state, relation_name, relation_role)
46
                service_state.service_name,
1233
48
        returnValue(relation_state)
47
                relation_type,
1234
48
                relation_name,
1235
49
                relation_role))
1236
50
        relation_state = yield self.relation_state_manager.add_relation_state(
1237
51
            *endpoints)
1238
52
        returnValue(relation_state[0])
1239
49
53
1240
50
    @inlineCallbacks
54
    @inlineCallbacks
1241
51
    def remove_service(self, internal_service_id):
55
    def remove_service(self, internal_service_id):
1242
@@ -435,55 +439,12 @@
1243
435
        yield self.assertFailure(d, StateChanged)
439
        yield self.assertFailure(d, StateChanged)
1244
436
440
1245
437
    @inlineCallbacks
441
    @inlineCallbacks
1246
438
    def test_watch_relations_with_changing_topology(self):
1247
439
        """
1248
440
        If the topology changes in an unrelated way, the
1249
441
        relations watch callback should not be called.
1250
442
        """
1251
443
        service_state = yield self.add_service("wordpress")
1252
444
        relation_state = yield self.add_relation("rel-type")
1253
445
1254
446
        wait_callback = [Deferred() for i in range(5)]
1255
447
        calls = []
1256
448
1257
449
        def watch_relations(old_relations, new_relations):
1258
450
            calls.append((old_relations, new_relations))
1259
451
            wait_callback[len(calls)-1].callback(True)
1260
452
1261
453
        # Start watching
1262
454
        service_state.watch_relation_states(watch_relations)
1263
455
1264
456
        # Callback is still untouched.
1265
457
        self.assertEquals(calls, [])
1266
458
1267
459
        # assign service to relation, and wait for callback
1268
460
        yield relation_state.assign_service(service_state, "name", "role")
1269
461
        yield wait_callback[0]
1270
462
        yield self.sleep(0.1)
1271
463
        self.assertEqual(len(calls), 2)
1272
464
        self.assertEquals(calls[0], (None, []))
1273
465
        self.assertEquals(calls[1][0], [])
1274
466
        self.assertEquals(
1275
467
            calls[1][1][0].internal_service_id, service_state.internal_id)
1276
468
        self.assertEquals(
1277
469
            calls[1][1][0].internal_relation_id, relation_state.internal_id)
1278
470
1279
471
        # Change the topology in an unrelated way, and give it some time
1280
472
        # in case a callback happens.
1281
473
        yield self.add_service("s-1")
1282
474
        yield self.add_relation("r-2-type")
1283
475
        yield self.sleep(0.2)
1284
476
1285
477
        # Assert no changes observed.
1286
478
        self.assertEquals(len(calls), 2)
1287
479
1288
480
    @inlineCallbacks
1289
481
    def test_watch_relations_when_being_created(self):
442
    def test_watch_relations_when_being_created(self):
1290
482
        """
443
        """
1291
483
        We can watch relations before we have any.
444
        We can watch relations before we have any.
1292
484
        """
445
        """
1293
485
        service_state = yield self.add_service("wordpress")
446
        service_state = yield self.add_service("wordpress")
1295
486
        relation_state = yield self.add_relation("rel-type")
447
1296
487
448
1297
488
        wait_callback = [Deferred() for i in range(5)]
449
        wait_callback = [Deferred() for i in range(5)]
1298
489
        calls = []
450
        calls = []
1299
@@ -499,10 +460,11 @@
1300
499
        self.assertEquals(calls, [])
460
        self.assertEquals(calls, [])
1301
500
461
1302
501
        # add a service relation and wait for the callback
462
        # add a service relation and wait for the callback
1304
502
        yield relation_state.assign_service(service_state, "name", "role")
463
        relation_state = yield self.add_relation(
1305
464
            "rel-type", [service_state, "name", "role"])
1306
503
        yield wait_callback[1]
465
        yield wait_callback[1]
1307
504
466
1309
505
        # verify the result
467
        # # verify the result
1310
506
        self.assertEquals(len(calls), 2)
468
        self.assertEquals(len(calls), 2)
1311
507
        old_relations, new_relations = calls[1]
469
        old_relations, new_relations = calls[1]
1312
508
        self.assertFalse(old_relations)
470
        self.assertFalse(old_relations)
1313
@@ -511,7 +473,6 @@
1314
511
        # add a new relation with the service assigned to it.
473
        # add a new relation with the service assigned to it.
1315
512
        relation_state2 = yield self.add_relation(
474
        relation_state2 = yield self.add_relation(
1316
513
            "rel-type2", [service_state, "app", "server"])
475
            "rel-type2", [service_state, "app", "server"])
1317
514
1318
515
        yield wait_callback[2]
476
        yield wait_callback[2]
1319
516
477
1320
517
        self.assertEquals(len(calls), 3)
478
        self.assertEquals(len(calls), 3)
1321
@@ -555,7 +516,7 @@
1322
555
516
1323
556
        # Assign to another relation.
517
        # Assign to another relation.
1324
557
        yield self.add_relation("rel-type",
518
        yield self.add_relation("rel-type",
1326
558
                          (service_state, "name", "role"))
519
                          (service_state, "name2", "role"))
1327
559
520
1328
560
        # Give a chance for something bad to happen.
521
        # Give a chance for something bad to happen.
1329
561
        yield self.sleep(0.3)
522
        yield self.sleep(0.3)
1330
@@ -573,61 +534,6 @@
1331
573
        self.assertEquals(len(calls), 2)
534
        self.assertEquals(len(calls), 2)
1332
574
535
1333
575
    @inlineCallbacks
536
    @inlineCallbacks
1334
576
    def test_watch_relation_assign_and_unassign_at_once(self):
1335
577
        """
1336
578
        If a service is quickly assigned and unassigned to a relation, the
1337
579
        change maybe be observed, as a single modificaiton in state.
1338
580
        """
1339
581
        wait_callback = [Deferred() for i in range(10)]
1340
582
1341
583
        calls = []
1342
584
1343
585
        def watch_units(old_units, new_units):
1344
586
            calls.append((old_units, new_units))
1345
587
            wait_callback[len(calls)-1].callback(True)
1346
588
1347
589
        # Create the service
1348
590
        service_state = yield self.add_service("s-1")
1349
591
1350
592
        # Create a relation with the service assigned.
1351
593
        relation_state1 = yield self.add_relation(
1352
594
            "rel-type", (service_state, "name", "role"))
1353
595
        relation_state2 = yield self.add_relation("rel-type")
1354
596
1355
597
        # Start watching
1356
598
        yield service_state.watch_relation_states(watch_units)
1357
599
1358
600
        yield wait_callback[0]
1359
601
        self.assertEquals(len(calls), 1)
1360
602
        old_relations, new_relations = calls[0]
1361
603
        self.assertEqual(old_relations, None)
1362
604
1363
605
        # Modify the topology by hand so we get notification of multiple
1364
606
        # things simultaneously.
1365
607
        topology = yield self.get_topology()
1366
608
        topology.unassign_service_from_relation(
1367
609
            relation_state1.internal_id,
1368
610
            service_state.internal_id)
1369
611
1370
612
        topology.assign_service_to_relation(
1371
613
            relation_state2.internal_id,
1372
614
            service_state.internal_id,
1373
615
            "role", "name")
1374
616
1375
617
        yield self.set_topology(topology)
1376
618
1377
619
        yield wait_callback[1]
1378
620
        self.assertEqual(len(calls), 2)
1379
621
        old_relations, new_relations = calls[1]
1380
622
1381
623
        # Verify the changes seen.
1382
624
        self.assertEqual([r.internal_relation_id for r in old_relations],
1383
625
                         [relation_state1.internal_id])
1384
626
1385
627
        self.assertEqual([r.internal_relation_id for r in new_relations],
1386
628
                         [relation_state2.internal_id])
1387
629
1388
630
    @inlineCallbacks
1389
631
    def add_service_from_formula(self, service_name):
537
    def add_service_from_formula(self, service_name):
1390
632
        formula_dir = FormulaDirectory(os.path.join(
538
        formula_dir = FormulaDirectory(os.path.join(
1391
633
            test_repository_path, service_name))
539
            test_repository_path, service_name))
1392
@@ -644,17 +550,17 @@
1393
644
        self.assertEqual(
550
        self.assertEqual(
1394
645
            (yield self.service_state_manager.get_relation_endpoints(
551
            (yield self.service_state_manager.get_relation_endpoints(
1395
646
            "wordpress")),
552
            "wordpress")),
1398
647
            set([RelationEndpoint("wordpress", "http", "url", "provides"),
553
            set([RelationEndpoint("wordpress", "http", "url", "server"),
1399
648
                 RelationEndpoint("wordpress", "mysql", "db", "requires"),
554
                 RelationEndpoint("wordpress", "mysql", "db", "client"),
1400
649
                 RelationEndpoint(
555
                 RelationEndpoint(
1402
650
                     "wordpress", "varnish", "cache", "requires")]))
556
                     "wordpress", "varnish", "cache", "client")]))
1403
651
        yield self.add_service_from_formula("riak")
557
        yield self.add_service_from_formula("riak")
1404
652
        self.assertEqual(
558
        self.assertEqual(
1405
653
            (yield self.service_state_manager.get_relation_endpoints(
559
            (yield self.service_state_manager.get_relation_endpoints(
1406
654
            "riak")),
560
            "riak")),
1410
655
            set([RelationEndpoint("riak", "http", "admin", "provides"),
561
            set([RelationEndpoint("riak", "http", "admin", "server"),
1411
656
                 RelationEndpoint("riak", "http", "endpoint", "provides"),
562
                 RelationEndpoint("riak", "http", "endpoint", "server"),
1412
657
                 RelationEndpoint("riak", "riak", "ring", "peers")]))
563
                 RelationEndpoint("riak", "riak", "ring", "peer")]))
1413
658
        
564
        
1414
659
    @inlineCallbacks
565
    @inlineCallbacks
1415
660
    def test_get_relation_endpoints_service_name_relation_name(self):
566
    def test_get_relation_endpoints_service_name_relation_name(self):
1416
@@ -663,21 +569,21 @@
1417
663
        self.assertEqual(
569
        self.assertEqual(
1418
664
            (yield self.service_state_manager.get_relation_endpoints(
570
            (yield self.service_state_manager.get_relation_endpoints(
1419
665
            "wordpress:url")),
571
            "wordpress:url")),
1421
666
            set([RelationEndpoint("wordpress", "http", "url", "provides")]))
572
            set([RelationEndpoint("wordpress", "http", "url", "server")]))
1422
667
        self.assertEqual(
573
        self.assertEqual(
1423
668
            (yield self.service_state_manager.get_relation_endpoints(
574
            (yield self.service_state_manager.get_relation_endpoints(
1424
669
            "wordpress:db")),
575
            "wordpress:db")),
1426
670
            set([RelationEndpoint("wordpress", "mysql", "db", "requires")]))
576
            set([RelationEndpoint("wordpress", "mysql", "db", "client")]))
1427
671
        self.assertEqual(
577
        self.assertEqual(
1428
672
            (yield self.service_state_manager.get_relation_endpoints(
578
            (yield self.service_state_manager.get_relation_endpoints(
1429
673
            "wordpress:cache")),
579
            "wordpress:cache")),
1430
674
             set([RelationEndpoint(
580
             set([RelationEndpoint(
1432
675
                "wordpress", "varnish", "cache", "requires")]))
581
                "wordpress", "varnish", "cache", "client")]))
1433
676
        yield self.add_service_from_formula("riak")
582
        yield self.add_service_from_formula("riak")
1434
677
        self.assertEqual(
583
        self.assertEqual(
1435
678
            (yield self.service_state_manager.get_relation_endpoints(
584
            (yield self.service_state_manager.get_relation_endpoints(
1436
679
            "riak:ring")),
585
            "riak:ring")),
1438
680
            set([RelationEndpoint("riak", "riak", "ring", "peers")]))
586
            set([RelationEndpoint("riak", "riak", "ring", "peer")]))
1439
681
587
1440
682
    @inlineCallbacks
588
    @inlineCallbacks
1441
683
    def test_descriptor_for_services_without_formulas(self):
589
    def test_descriptor_for_services_without_formulas(self):
1442
@@ -718,20 +624,20 @@
1443
718
        self.assertEqual(
624
        self.assertEqual(
1444
719
            (yield self.service_state_manager.join_descriptors(
625
            (yield self.service_state_manager.join_descriptors(
1445
720
                "wordpress", "mysql")),
626
                "wordpress", "mysql")),
1448
721
            [(RelationEndpoint("wordpress", "mysql", "db", "requires"),
627
            [(RelationEndpoint("wordpress", "mysql", "db", "client"),
1449
722
              RelationEndpoint("mysql", "mysql", "server", "provides"))])
628
              RelationEndpoint("mysql", "mysql", "server", "server"))])
1450
723
        # symmetric - note the pair has rotated
629
        # symmetric - note the pair has rotated
1451
724
        self.assertEqual(
630
        self.assertEqual(
1452
725
            (yield self.service_state_manager.join_descriptors(
631
            (yield self.service_state_manager.join_descriptors(
1453
726
                "mysql", "wordpress")),
632
                "mysql", "wordpress")),
1456
727
            [(RelationEndpoint("mysql", "mysql", "server", "provides"),
633
            [(RelationEndpoint("mysql", "mysql", "server", "server"),
1457
728
              RelationEndpoint("wordpress", "mysql", "db", "requires"))])
634
              RelationEndpoint("wordpress", "mysql", "db", "client"))])
1458
729
        yield self.add_service_from_formula("varnish")
635
        yield self.add_service_from_formula("varnish")
1459
730
        self.assertEqual(
636
        self.assertEqual(
1460
731
            (yield self.service_state_manager.join_descriptors(
637
            (yield self.service_state_manager.join_descriptors(
1461
732
                "wordpress", "varnish")),
638
                "wordpress", "varnish")),
1464
733
            [(RelationEndpoint("wordpress", "varnish", "cache", "requires"),
639
            [(RelationEndpoint("wordpress", "varnish", "cache", "client"),
1465
734
              RelationEndpoint("varnish", "varnish", "webcache", "provides"))])
640
              RelationEndpoint("varnish", "varnish", "webcache", "server"))])
1466
735
641
1467
736
    @inlineCallbacks
642
    @inlineCallbacks
1468
737
    def test_join_descriptors_service_name_relation_name(self):
643
    def test_join_descriptors_service_name_relation_name(self):
1469
@@ -741,30 +647,30 @@
1470
741
        self.assertEqual(
647
        self.assertEqual(
1471
742
            (yield self.service_state_manager.join_descriptors(
648
            (yield self.service_state_manager.join_descriptors(
1472
743
                "wordpress:db", "mysql")),
649
                "wordpress:db", "mysql")),
1475
744
            [(RelationEndpoint("wordpress", "mysql", "db", "requires"),
650
            [(RelationEndpoint("wordpress", "mysql", "db", "client"),
1476
745
              RelationEndpoint("mysql", "mysql", "server", "provides"))])
651
              RelationEndpoint("mysql", "mysql", "server", "server"))])
1477
746
        self.assertEqual(
652
        self.assertEqual(
1478
747
            (yield self.service_state_manager.join_descriptors(
653
            (yield self.service_state_manager.join_descriptors(
1479
748
                "mysql:server", "wordpress")),
654
                "mysql:server", "wordpress")),
1482
749
            [(RelationEndpoint("mysql", "mysql", "server", "provides"),
655
            [(RelationEndpoint("mysql", "mysql", "server", "server"),
1483
750
              RelationEndpoint("wordpress", "mysql", "db", "requires"))])
656
              RelationEndpoint("wordpress", "mysql", "db", "client"))])
1484
751
        self.assertEqual(
657
        self.assertEqual(
1485
752
            (yield self.service_state_manager.join_descriptors(
658
            (yield self.service_state_manager.join_descriptors(
1486
753
                "mysql:server", "wordpress:db")),
659
                "mysql:server", "wordpress:db")),
1489
754
            [(RelationEndpoint("mysql", "mysql", "server", "provides"),
660
            [(RelationEndpoint("mysql", "mysql", "server", "server"),
1490
755
              RelationEndpoint("wordpress", "mysql", "db", "requires"))])
661
              RelationEndpoint("wordpress", "mysql", "db", "client"))])
1491
756
662
1492
757
        yield self.add_service_from_formula("varnish")
663
        yield self.add_service_from_formula("varnish")
1493
758
        self.assertEqual(
664
        self.assertEqual(
1494
759
            (yield self.service_state_manager.join_descriptors(
665
            (yield self.service_state_manager.join_descriptors(
1495
760
                "wordpress:cache", "varnish")),
666
                "wordpress:cache", "varnish")),
1498
761
            [(RelationEndpoint("wordpress", "varnish", "cache", "requires"),
667
            [(RelationEndpoint("wordpress", "varnish", "cache", "client"),
1499
762
              RelationEndpoint("varnish", "varnish", "webcache", "provides"))])
668
              RelationEndpoint("varnish", "varnish", "webcache", "server"))])
1500
763
        self.assertEqual(
669
        self.assertEqual(
1501
764
            (yield self.service_state_manager.join_descriptors(
670
            (yield self.service_state_manager.join_descriptors(
1502
765
                "wordpress:cache", "varnish:webcache")),
671
                "wordpress:cache", "varnish:webcache")),
1505
766
            [(RelationEndpoint("wordpress", "varnish", "cache", "requires"),
672
            [(RelationEndpoint("wordpress", "varnish", "cache", "client"),
1506
767
              RelationEndpoint("varnish", "varnish", "webcache", "provides"))])
673
              RelationEndpoint("varnish", "varnish", "webcache", "server"))])
1507
768
674
1508
769
    @inlineCallbacks
675
    @inlineCallbacks
1509
770
    def test_join_peer_descriptors(self):
676
    def test_join_peer_descriptors(self):
1510
@@ -773,18 +679,18 @@
1511
773
        self.assertEqual(
679
        self.assertEqual(
1512
774
            (yield self.service_state_manager.join_descriptors(
680
            (yield self.service_state_manager.join_descriptors(
1513
775
                "riak", "riak")),
681
                "riak", "riak")),
1516
776
            [(RelationEndpoint("riak", "riak", "ring", "peers"),
682
            [(RelationEndpoint("riak", "riak", "ring", "peer"),
1517
777
              RelationEndpoint("riak", "riak", "ring", "peers"))])
683
              RelationEndpoint("riak", "riak", "ring", "peer"))])
1518
778
        self.assertEqual(
684
        self.assertEqual(
1519
779
            (yield self.service_state_manager.join_descriptors(
685
            (yield self.service_state_manager.join_descriptors(
1520
780
                "riak:ring", "riak")),
686
                "riak:ring", "riak")),
1523
781
            [(RelationEndpoint("riak", "riak", "ring", "peers"),
687
            [(RelationEndpoint("riak", "riak", "ring", "peer"),
1524
782
              RelationEndpoint("riak", "riak", "ring", "peers"))])
688
              RelationEndpoint("riak", "riak", "ring", "peer"))])
1525
783
        self.assertEqual(
689
        self.assertEqual(
1526
784
            (yield self.service_state_manager.join_descriptors(
690
            (yield self.service_state_manager.join_descriptors(
1527
785
                "riak:ring", "riak:ring")),
691
                "riak:ring", "riak:ring")),
1530
786
            [(RelationEndpoint("riak", "riak", "ring", "peers"),
692
            [(RelationEndpoint("riak", "riak", "ring", "peer"),
1531
787
              RelationEndpoint("riak", "riak", "ring", "peers"))])
693
              RelationEndpoint("riak", "riak", "ring", "peer"))])
1532
788
        self.assertEqual(
694
        self.assertEqual(
1533
789
            (yield self.service_state_manager.join_descriptors(
695
            (yield self.service_state_manager.join_descriptors(
1534
790
                "riak:no-ring", "riak:ring")),
696
                "riak:no-ring", "riak:ring")),
1535
@@ -828,3 +734,4 @@
1536
828
        yield self.assertFailure(
734
        yield self.assertFailure(
1537
829
            self.service_state_manager.join_descriptors("notyet", "nosuch"),
735
            self.service_state_manager.join_descriptors("notyet", "nosuch"),
1538
830
            ServiceStateNotFound)
736
            ServiceStateNotFound)
1539
737
1540
831
738
1541
=== modified file 'ensemble/state/tests/test_topology.py'
1542
--- ensemble/state/tests/test_topology.py	2010-11-17 20:40:28 +0000
1543
+++ ensemble/state/tests/test_topology.py	2010-12-10 23:06:27 +0000
1544
@@ -1,9 +1,8 @@
1545
1
import yaml
1
import yaml
1546
2
2
1547
3
from ensemble.lib.testing import TestCase
3
from ensemble.lib.testing import TestCase
1551
4
4
from ensemble.state.endpoint import RelationEndpoint
1552
5
from ensemble.state.topology import (
5
from ensemble.state.topology import InternalTopology, InternalTopologyError
1550
6
    InternalTopology, InternalTopologyError)
1553
7
6
1554
8
7
1555
9
class InternalTopologyMapTest(TestCase):
8
class InternalTopologyMapTest(TestCase):
1556
@@ -790,8 +789,7 @@
1557
790
        self.assertFalse(self.topology.get_relations_for_service("s-0"))
789
        self.assertFalse(self.topology.get_relations_for_service("s-0"))
1558
791
790
1559
792
    def test_relation_has_service(self):
791
    def test_relation_has_service(self):
1562
793
        """We can test to see if a service is associated to a relation.
792
        """We can test to see if a service is associated to a relation."""
1561
794
        """
1563
795
        self.assertFalse(self.topology.relation_has_service("r-1", "s-0"))
793
        self.assertFalse(self.topology.relation_has_service("r-1", "s-0"))
1564
796
        self.topology.add_relation("r-1", "type")
794
        self.topology.add_relation("r-1", "type")
1565
797
        self.topology.add_service("s-0", "wordpress")
795
        self.topology.add_service("s-0", "wordpress")
1566
@@ -799,8 +797,7 @@
1567
799
        self.assertTrue(self.topology.relation_has_service("r-1", "s-0"))
797
        self.assertTrue(self.topology.relation_has_service("r-1", "s-0"))
1568
800
798
1569
801
    def test_get_relation_service(self):
799
    def test_get_relation_service(self):
1572
802
        """We can fetch the setting of a service within a relation.
800
        """We can fetch the setting of a service within a relation."""
1571
803
        """
1573
804
        # Invalid relations cause an exception.
801
        # Invalid relations cause an exception.
1574
805
        self.assertRaises(InternalTopologyError,
802
        self.assertRaises(InternalTopologyError,
1575
806
                          self.topology.get_relation_service,
803
                          self.topology.get_relation_service,
1576
@@ -903,3 +900,54 @@
1577
903
        self.assertRaises(InternalTopologyError,
900
        self.assertRaises(InternalTopologyError,
1578
904
                          self.topology.remove_service,
901
                          self.topology.remove_service,
1579
905
                          "s-0")
902
                          "s-0")
1580
903
1581
904
    def test_has_relation_between_dyadic_endpoints(self):
1582
905
        mysql_ep = RelationEndpoint("mysqldb", "mysql", "db", "server")
1583
906
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
1584
907
        self.topology.add_service("s-0", "wordpress")
1585
908
        self.topology.add_service("s-1", "mysqldb")
1586
909
        self.topology.add_relation("r-0", "mysql")
1587
910
        self.topology.assign_service_to_relation(
1588
911
            "r-0", "s-0", "mysql", "client")
1589
912
        self.topology.assign_service_to_relation(
1590
913
            "r-0", "s-1", "db", "server")
1591
914
        self.assertTrue(self.topology.has_relation_between_endpoints([
1592
915
            mysql_ep, blog_ep]))
1593
916
        self.assertTrue(self.topology.has_relation_between_endpoints([
1594
917
            blog_ep, mysql_ep]))
1595
918
1596
919
    def test_has_relation_between_dyadic_endpoints_missing_assignment(self):
1597
920
        mysql_ep = RelationEndpoint("mysqldb", "mysql", "db", "server")
1598
921
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
1599
922
        self.topology.add_service("s-0", "wordpress")
1600
923
        self.topology.add_service("s-1", "mysqldb")
1601
924
        self.topology.add_relation("r-0", "mysql")
1602
925
        self.topology.assign_service_to_relation(
1603
926
            "r-0", "s-1", "db", "server")
1604
927
        self.assertFalse(self.topology.has_relation_between_endpoints([
1605
928
            mysql_ep, blog_ep]))
1606
929
        self.assertFalse(self.topology.has_relation_between_endpoints([
1607
930
            blog_ep, mysql_ep]))
1608
931
1609
932
    def test_has_relation_between_dyadic_endpoints_wrong_relation_name(self):
1610
933
        mysql_ep = RelationEndpoint("mysqldb", "mysql", "wrong-name", "server")
1611
934
        blog_ep = RelationEndpoint("wordpress", "mysql", "mysql", "client")
1612
935
        self.topology.add_service("s-0", "wordpress")
1613
936
        self.topology.add_service("s-1", "mysqldb")
1614
937
        self.topology.add_relation("r-0", "mysql")
1615
938
        self.topology.assign_service_to_relation(
1616
939
            "r-0", "s-0", "mysql", "client")
1617
940
        self.topology.assign_service_to_relation(
1618
941
            "r-0", "s-1", "db", "server")
1619
942
        self.assertFalse(self.topology.has_relation_between_endpoints([
1620
943
            mysql_ep, blog_ep]))
1621
944
        self.assertFalse(self.topology.has_relation_between_endpoints([
1622
945
            blog_ep, mysql_ep]))
1623
946
1624
947
    def test_has_relation_between_monadic_endpoints(self):
1625
948
        riak_ep = RelationEndpoint("riak", "riak", "riak", "peer")
1626
949
        self.topology.add_service("s-0", "riak")
1627
950
        self.topology.add_relation("r-0", "riak")
1628
951
        self.topology.assign_service_to_relation("r-0", "s-0", "riak", "peer")
1629
952
        self.assertTrue(self.topology.has_relation_between_endpoints(
1630
953
            [riak_ep]))
1631
906
954
1632
=== modified file 'ensemble/state/topology.py'
1633
--- ensemble/state/topology.py	2010-11-17 20:40:28 +0000
1634
+++ ensemble/state/topology.py	2010-12-10 23:06:27 +0000
1635
@@ -308,8 +308,7 @@
1636
308
        return relation_type
308
        return relation_type
1637
309
309
1638
310
    def relation_has_service(self, relation_id, service_id):
310
    def relation_has_service(self, relation_id, service_id):
1641
311
        """Return true if service_id is assigned to relation_id.
311
        """Return if `service_id` is assigned to `relation_id`."""
1640
312
        """
1642
313
        relations = self._state.get("relations", self._nil_dict)
312
        relations = self._state.get("relations", self._nil_dict)
1643
314
        relation_type, services = relations.get(relation_id,
313
        relation_type, services = relations.get(relation_id,
1644
315
                                                (None, self._nil_dict))
314
                                                (None, self._nil_dict))
1645
@@ -396,3 +395,29 @@
1646
396
            raise InternalTopologyError(
395
            raise InternalTopologyError(
1647
397
                "Service unit %s not found in service %s" % (
396
                "Service unit %s not found in service %s" % (
1648
398
                    unit_id, service_id))
397
                    unit_id, service_id))
1649
398
1650
399
    def has_relation_between_endpoints(self, endpoints):
1651
400
        """Examine topology to check if relation exists between `endpoints`.
1652
401
1653
402
        The relation, with a ``relation type`` common to the
1654
403
        endpoints, must exist between all endpoints (presumably one
1655
404
        for peer, two for client-server). The topology for the
1656
405
        relations looks like the following in YAML::
1657
406
1658
407
          relations:
1659
408
            relation-0000000000:
1660
409
            - mysql
1661
410
            - service-0000000000: {name: db, role: client}
1662
411
              service-0000000001: {name: server, role: server}
1663
412
        """
1664
413
        service_ids = dict((e, self.find_service_with_name(e.service_name))
1665
414
                           for e in endpoints)
1666
415
        relations = self._state.get("relations", self._nil_dict)
1667
416
        for _, services in relations.itervalues():
1668
417
            for endpoint in endpoints:
1669
418
                service = services.get(service_ids[endpoint])
1670
419
                if not service or service["name"] != endpoint.relation_name:
1671
420
                    break
1672
421
            else:
1673
422
                return True
1674
423
        return False
Status:	Merged
Approved by:	Gustavo Niemeyer on 2010-12-13
Approved revision:	131
Merged at revision:	115
Proposed branch:	lp:~jimbaker/pyjuju/rel-mgmt-add-relation-simple
Merge into:	lp:pyjuju
Diff against target:	1674 lines (+608/-532) 12 files modified ensemble/hooks/tests/test_invoker.py (+9/-5) ensemble/state/endpoint.py (+6/-6) ensemble/state/errors.py (+24/-10) ensemble/state/relation.py (+88/-102) ensemble/state/service.py (+5/-2) ensemble/state/tests/test_endpoint.py (+8/-8) ensemble/state/tests/test_errors.py (+31/-8) ensemble/state/tests/test_hook.py (+9/-5) ensemble/state/tests/test_relation.py (+297/-235) ensemble/state/tests/test_service.py (+49/-142) ensemble/state/tests/test_topology.py (+55/-7) ensemble/state/topology.py (+27/-2)
To merge this branch:	bzr merge lp:~jimbaker/pyjuju/rel-mgmt-add-relation-simple
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Gustavo Niemeyer		2010-12-04	Approve on 2010-12-13
Review via email: mp+42704@code.launchpad.net