1
=== added file 'docs/source/internals/constraints-notes.rst'
2
--- docs/source/internals/constraints-notes.rst	1970-01-01 00:00:00 +0000
3
+++ docs/source/internals/constraints-notes.rst	2012-03-30 16:56:32 +0000
4
@@ -0,0 +1,78 @@
5
1
Notes on the current state of machine constraints
6
2
=================================================
7
3
8
4
Summary
9
5
-------
10
6
11
7
EC2 constraints and generic constraints can each be used to provision EC2 machines as intended. Orchestra support is not implemented, and should remain on hold until we get some clarity about MaaS. Environment constraints are not implemented; machine reuse is limited but predictable. Unit constraints, and a get-constraints command, should probably be added despite not being in the initial spec.
12
8
13
9
We should prepare the ground for, and implement, environment constraints above all else. Adding a --constraints argument to add-unit will be very easy, and adding a get-constraints command won't be much harder, and the feature will feel much more complete with these capabilities, so they should come next. After that we should, with care and discretion, start tweaking the unit/machine matching algorithms such that we do the Right Thing more often without running the risk of doing a surprising and/or costly Wrong Thing.
14
10
15
11
16
12
Code overview
17
13
-------------
18
14
19
15
`juju.machine.constraints` contains a `Constraints` type and a `_Constraint` type (which holds the configuration for a given constraint). The actual configuration is set up in `juju.machine.constraints_info` by means of calls to `register_constraint` and `register_conflicts`. Note that `ubuntu-series` and `provider-type` are themselves modelled as constraints (largely for ease/ consitency of representation) but are not exposed via `from_strs`, thereby preventing users from specifying things that should only be set by the code.
20
16
21
17
The juju defaults are contained in the individual configured `_Constraint` objects; empty values are converted to defaults at `from_strs` time (when a provider type and a list of strings are used to construct a `Constraints` object). Therefore, the juju defaults are not themselves a separate `Constraints` object.
22
18
23
19
Once created, `Constraints` objects store everything in their `_layer_data` dict, which contains keys for (1) every constraint specified explicitly and (2) every constraint conflicting with one specified explicitly (these are set to None). When storing constraints in ZK, all you need to do is serialise this dict (exposed as `layer_data`); `Constraints` objects can then be reconstructed directly from such dicts.
24
20
25
21
This layer data does not necessarily include all possible constraints; so, when a `Constraints` is being used as a dict, we ensure we return default values for every key not in `_layer_data` (we also convert values from their textual representations to more-easily-consumable ones; so, eg, a mem of "4G" becomes 4096.0). However, we don't have any reason to store unset constraints at any stage; doing so would make it far harder to update one `Constraints` object with another. This is because `_layer_data` is effectively a mask: by updating A with B, the conflict Nones in B will overwrite any values set in A; while any keys not overridden will retain their values or conflict Nones, which ensures that we don't accidentally insert defaults due to missing values.  Consider:
26
22
27
23
A = "orchestra-name=jimbob" (masks arch, cpu, mem, orchestra-classes)
28
24
B = "arch=arm orchestra-classes=ultralightweight" (masks orchestra-name)
29
25
30
26
Now, if we A.update(B): orchestra-name gets masked out; cpu and mem remain masked out from before; the only remaining (user-visible) constraints are arch and orchestra-classes. Because the "ultralightweight" orchestra-class could easily be referring to a set of machines with very low cpu values, we *don't* want to reapply the default cpu constraint: we want to keep it masked as None, so we don't end up with a surprisingly unfulfillable request.
31
27
32
28
It's a bit tricker on EC2: if arch overrides ec2-instance-type, this masks out cpu and mem as before and will therefore, in the absence of other constraints, deliver a t1.micro. IMO this is acceptable because: if someone's already thinking in instance-types, that's what they'll use in practice, so it's an edge case anyway; the results are actually not unreasonable; and the cost of incorrect behaviour is very low. The alternative -- of treating ec2-instance-type constraints as implicit arch/cpu/mem constraints, (so the update would end up with: a blank ec2-instance type; arch from the strings; and cpu/mem from the previous layer's ec2-instance-type) -- seems to me to be more likely to lead to surprising and potentially costly behaviour. This behaviour could be bolted on with little effort if deemed helpful, though.
33
29
34
30
There are a couple of extra notes on EC2 in the source, both in `constraints_info` and in the ec2 provider code itself. (Note that ec2 constraints are defined in `constraints_info`, not the provider itself, because I want to be sure (without excessive magic or circular imports) that all constraints have been registered *before* any `Constraints` object is constructed, lest one be constructed with a incorrect mask. (It would be quick and easy to notify `_Constraint` once a `Constraints` is constructed, and refuse to register further constraints and conflicts, to ensure nobody does this accidentally; I only just thought if this though.) Most of the code for interpreting constraints is in the ec2 provider, though; this is because it only comes into play at provisioning time.
35
31
36
32
37
33
Usage
38
34
-----
39
35
40
36
Actual use is pretty trivial, but involved an irritating weight of API changes: service states, unit states, and machine states all now require constraints, and it's tricky to figure out what the right "default" would be. (Well, we could grab provider-type from `GlobalSettingsStateManager` and construct it from an empty string list, but I have a disinclination to access such things without a very good reason; and since now, I think, all the "real" uses (as opposed to "test") can be expected to have constraints readily available, the inconvenience of changing all the tests doesn't seem like a valid argument against explicit specification. Does pollute the diffs a bit, though; sorry.)
41
37
42
38
Basically, constraints are set on a service via `deploy` or `set-constraints`; then, when a unit is added, they're copied from the service to the unit (note: will be trivial to combine with env constraints and save the combined constraints... that is, when we actually have some env constraints); then, when a machine is added for a unit, the constraints are matched against existing machines' states, or used to construct a new one onto which the unit will be placed; and finally, those machine constraints are eventually passed into the provider by the provisioning agent.
43
39
44
40
Bootstrap remains less than ideal -- but since we know the ubuntu-series and the provider-type, both on the client and on the bootstrap node, we can construct a full `Constraints` object and just use the default values for the other constraints; and, we can do so both when provisioning the initial machine (on the client) and when creating the bootstrap node's machine state (on the bootstrap node itself). When we have env constraints, we'll need to use them for provisioning *and* feed them through to the initialize command on the bootstrap node, so we can set up the correct machine state (in addition to the environment constraint state we'll need to set up).
45
41
46
42
47
43
Merge pipeline
48
44
--------------
49
45
50
46
* placement-spec (Just the spec. Despite the MaaS-related inaccuracies, worth merging, IMO.)
51
47
52
48
* constraint-types (Add `juju.machine.constraints` and `juju.machine.constraints_info`. Oh, and `juju.errors.ConstraintError`.)
53
49
54
50
* set-service-constraints (Add `set-constraints` command; add param to `deploy` command; store constraints in service state.)
55
51
56
52
* apply-machine-constraints (Constraints are set on the unit state by the service state, and on the machine state by (or from) the unit state; `initialize` command sets default constraints on machine/0.)
57
53
58
54
* pa-start-machine-constraints (When launching machines, the provisioning agent passes "constraints" in machine_data, which are now actually used by the ec2 provider (I couldn't break this up further: once the constraints were passed in, ec2 had to change). Also removed "default-instance-type" and "default-ami" from ec2 environment config, and set bootstrap to provision a machine from juju defaults. Note: appears to actually work as expected.)
59
55
60
56
61
57
Known problems
62
58
--------------
63
59
64
60
* Most horrifyingly: MaaS plans imply that we shouldn't depend on being able to specify `arch`, `cpu`, `mem`, or `orchestra-classes`, and I'm more than somewhat blindsided by this... certainly, with those (er) constraints, the eventual implementation cannot match the spec as currently written.
65
61
66
62
* No environment constraints are implemented; it's not hard per se (add handling to `bootstrap` and `set-constraints`; store them somewhere sensible; get and combine them at unit-add time) but (as discussed) it would be a good idea to make the environment settings behaviour saner *before* we add constraints to the mix. Once that's done, we need to remember to actually use the information at bootstrap time, both for provisioning the bootstrap node and constructing its ZK state.
67
63
68
64
  * I think it's fine for people to specify non-connection info inside their environments.yaml~s; but I think all such settings should be in a sub-dict called "initial" (or "bootstrap", or possibly even "default", as discussed at P-rally; I'm not sure which word carries the most appropriate semantic payload, but I'm not sure "default" is quite right).
69
65
70
66
* Unused machines are not reused very sensibly: we just grab the first one we see that fulfils the relevant service unit's constraints. It would be trivial to build up a list of matching machines; it's not immediately clear just how we should go about picking the most appropriate machine from such a list.
71
67
72
68
  * Well, ok, it's pretty clear -- we can "just" define a cost method on `Constraints`, and pick the cheapest. (But should we really reuse a cc1.4xlarge for a job that only demands an m1.small? Even if that's an easy question, what about orchestra? If we're interested in picking cheap machines -- and even assuming we can come up with a universally appropriate cost function -- we still need to consider the unused machines as well if we want to get a good answer.)
73
69
74
70
  I remain convinced that it'll have to take the provider into consideration somehow -- and, tangentially, that we'll need to be a bit more sophisticated about matching `ec2-instance-type` constraints against generic constraints and vice versa -- and so I'm getting a little concerned that the "single type for Constraints" preference expressed by you and Gustavo is not going to be workable in the long term (but it's set up to require a provider-type to create a `Constraints` anyway, so it should be trivial to factoryise it by provider-type anyway).
75
71
76
72
* We should probably bulk out machine constraints with actual data from the provider, once they've been provisioned (so we can tell, for example, what ec2-zone we ended up in (if it was left unspecified)). This affects how well we can match existing machines with new units; but what with MaaS, it remains an open question how much of this we'll even be able to do on orchestra(-without-landscape, anyway).
77
73
78
74
  Note that this functionality -- and other upgrades in machine-reuse sophistication, like the previous bullet -- should IMO be added slowly and incrementally; I think we'll inevitably make mistakes here, at least until we've properly figured out the usage patterns, and I think for our users' sake it's more important that the rules be *clear* than that they be clever.
79
75
80
76
* No `get-constraints` command exists. This command makes sense for all of env, service, unit, and machine; and on reflection, IMO, it should display the full constraints-as-dict in all cases (not just the layer data) so there's no chance of ambiguity; however, we should consider the implications of exporting explicit constraints as they were set, or as they "are" -- ie if we output mem as "4G" it will be irritating for machines but convenient for humans, while 4096.0 will be better suited for machine consumption (and also gives visibility into exactly what params will be passed to the provider itself). Not specced, but hard to justify leaving out.
81
77
82
78
* No explicit unit constraints are implemented; the code as it stands would make it *very* easy to set them at add-unit time, and some constraints (well, orchestra-name in particular) only really make sense at the unit level. Nonetheless, it was deliberately left out of the spec, and can be worked around by users where necesssary, so it's not really a priority; but IMO the benefit outwieghs the very small cost of implementing it.
83
0
79
84
=== modified file 'juju/agents/provision.py'
85
--- juju/agents/provision.py	2012-02-01 15:39:08 +0000
86
+++ juju/agents/provision.py	2012-03-30 16:56:32 +0000
87
@@ -6,7 +6,7 @@
88
6
from juju.environment.config import EnvironmentsConfig
6
from juju.environment.config import EnvironmentsConfig
89
7
from juju.errors import ProviderError
7
from juju.errors import ProviderError
90
8
from juju.lib.twistutils import concurrent_execution_guard
8
from juju.lib.twistutils import concurrent_execution_guard
92
9
from juju.state.errors import MachineStateNotFound, StateChanged, StopWatcher
9
from juju.state.errors import MachineStateNotFound, StopWatcher
93
10
from juju.state.firewall import FirewallManager
10
from juju.state.firewall import FirewallManager
94
11
from juju.state.machine import MachineStateManager
11
from juju.state.machine import MachineStateManager
95
12
from juju.state.service import ServiceStateManager
12
from juju.state.service import ServiceStateManager
96
@@ -223,8 +223,9 @@
97
223
        # Verify a machine id has state and is running, else launch it.
223
        # Verify a machine id has state and is running, else launch it.
98
224
        if instance_id is None or not instance_id in provider_machine_map:
224
        if instance_id is None or not instance_id in provider_machine_map:
99
225
            log.info("Starting machine id:%s ...", machine_state.id)
225
            log.info("Starting machine id:%s ...", machine_state.id)
100
226
            constraints = yield machine_state.get_constraints()
101
226
            machines = yield self.provider.start_machine(
227
            machines = yield self.provider.start_machine(
103
227
                {"machine-id": machine_state.id})
228
                {"machine-id": machine_state.id, "constraints": constraints})
104
228
            instance_id = machines[0].instance_id
229
            instance_id = machines[0].instance_id
105
229
            yield machine_state.set_instance_id(instance_id)
230
            yield machine_state.set_instance_id(instance_id)
106
230
231
107
231
232
108
=== modified file 'juju/agents/tests/common.py'
109
--- juju/agents/tests/common.py	2011-11-28 12:28:57 +0000
110
+++ juju/agents/tests/common.py	2012-03-30 16:56:32 +0000
111
@@ -5,30 +5,23 @@
112
5
from txzookeeper.tests.utils import deleteTree
5
from txzookeeper.tests.utils import deleteTree
113
6
6
114
7
from juju.agents.base import TwistedOptionNamespace
7
from juju.agents.base import TwistedOptionNamespace
115
8
from juju.environment.config import EnvironmentsConfig
116
9
from juju.state.tests.common import StateTestBase
8
from juju.state.tests.common import StateTestBase
117
10
from juju.tests.common import get_test_zookeeper_address
9
from juju.tests.common import get_test_zookeeper_address
118
11
10
119
12
11
120
13
SAMPLE_ENV = """\
121
14
environments:
122
15
  myfirstenv:
123
16
    type: dummy
124
17
    foo: bar
125
18
    storage-directory: %s
126
19
"""
127
20
128
21
129
22
class AgentTestBase(StateTestBase):
12
class AgentTestBase(StateTestBase):
130
23
13
131
24
    agent_class = None
14
    agent_class = None
132
25
    juju_directory = None
15
    juju_directory = None
133
16
    setup_environment = True
134
26
17
135
27
    @inlineCallbacks
18
    @inlineCallbacks
136
28
    def setUp(self):
19
    def setUp(self):
137
29
        self.juju_directory = self.makeDir()
20
        self.juju_directory = self.makeDir()
138
30
        yield super(AgentTestBase, self).setUp()
21
        yield super(AgentTestBase, self).setUp()
139
31
        assert self.agent_class, "Agent Class must be specified on test"
22
        assert self.agent_class, "Agent Class must be specified on test"
140
23
        if self.setup_environment:
141
24
            yield self.push_default_config()
142
32
        self.agent = self.agent_class()
25
        self.agent = self.agent_class()
143
33
        self.options = yield self.get_agent_config()
26
        self.options = yield self.get_agent_config()
144
34
        self.agent.configure(self.options)
27
        self.agent.configure(self.options)
145
@@ -42,15 +35,6 @@
146
42
            deleteTree("/", self.client.handle)
35
            deleteTree("/", self.client.handle)
147
43
            self.client.close()
36
            self.client.close()
148
44
37
149
45
    def get_test_environment_config(self):
150
46
        sample_config = SAMPLE_ENV % self.makeDir()
151
47
        config = EnvironmentsConfig()
152
48
        config.parse(sample_config)
153
49
        return config
154
50
155
51
    def get_test_environment(self):
156
52
        return self.get_test_environment_config().get_default()
157
53
158
54
    def get_agent_config(self):
38
    def get_agent_config(self):
159
55
        options = TwistedOptionNamespace()
39
        options = TwistedOptionNamespace()
160
56
        options["juju_directory"] = self.juju_directory
40
        options["juju_directory"] = self.juju_directory
161
57
41
162
=== modified file 'juju/agents/tests/test_machine.py'
163
--- juju/agents/tests/test_machine.py	2012-03-16 16:54:43 +0000
164
+++ juju/agents/tests/test_machine.py	2012-03-30 16:56:32 +0000
165
@@ -2,8 +2,7 @@
166
2
import logging
2
import logging
167
3
import os
3
import os
168
4
4
171
5
from twisted.internet.defer import (
5
from twisted.internet.defer import inlineCallbacks, returnValue, fail, Deferred
170
6
    inlineCallbacks, returnValue, succeed, fail, Deferred)
172
7
6
173
8
from juju.agents.base import TwistedOptionNamespace
7
from juju.agents.base import TwistedOptionNamespace
174
9
from juju.agents.machine import MachineAgent
8
from juju.agents.machine import MachineAgent
175
@@ -14,8 +13,8 @@
176
14
from juju.charm.tests import local_charm_id
13
from juju.charm.tests import local_charm_id
177
15
from juju.charm.tests.test_repository import RepositoryTestBase
14
from juju.charm.tests.test_repository import RepositoryTestBase
178
16
from juju.lib.mocker import MATCH
15
from juju.lib.mocker import MATCH
181
17
from juju.machine.constraints import Constraints
16
from juju.machine.tests.test_constraints import (
182
18
from juju.state.environment import EnvironmentStateManager
17
    dummy_constraints, series_constraints)
183
19
from juju.state.machine import MachineStateManager, MachineState
18
from juju.state.machine import MachineStateManager, MachineState
184
20
from juju.state.service import ServiceStateManager
19
from juju.state.service import ServiceStateManager
185
21
from juju.tests.common import get_test_zookeeper_address
20
from juju.tests.common import get_test_zookeeper_address
186
@@ -36,13 +35,7 @@
187
36
        yield super(MachineAgentTest, self).setUp()
35
        yield super(MachineAgentTest, self).setUp()
188
37
36
189
38
        self.output = self.capture_logging(level=logging.DEBUG)
37
        self.output = self.capture_logging(level=logging.DEBUG)
197
39
38
        environment = self.config.get_default()
191
40
        config = self.get_test_environment_config()
192
41
        environment = config.get_default()
193
42
194
43
        # Store the environment to zookeeper
195
44
        environment_state_manager = EnvironmentStateManager(self.client)
196
45
        yield environment_state_manager.set_config_state(config, "myfirstenv")
198
46
39
199
47
        # Load the environment with the charm state and charm binary
40
        # Load the environment with the charm state and charm binary
200
48
        self.provider = environment.get_machine_provider()
41
        self.provider = environment.get_machine_provider()
201
@@ -58,8 +51,7 @@
202
58
        # the machine.
51
        # the machine.
203
59
        self.service_state_manager = ServiceStateManager(self.client)
52
        self.service_state_manager = ServiceStateManager(self.client)
204
60
        self.service = yield self.service_state_manager.add_service_state(
53
        self.service = yield self.service_state_manager.add_service_state(
207
61
            "fatality-blog", self.charm_state,
54
            "fatality-blog", self.charm_state, dummy_constraints)
206
62
            Constraints.from_strs("dummy", []))
208
63
55
209
64
    @inlineCallbacks
56
    @inlineCallbacks
210
65
    def get_agent_config(self):
57
    def get_agent_config(self):
211
@@ -68,7 +60,7 @@
212
68
        machine_state_manager = MachineStateManager(self.client)
60
        machine_state_manager = MachineStateManager(self.client)
213
69
61
214
70
        self.machine_state = yield machine_state_manager.add_machine_state(
62
        self.machine_state = yield machine_state_manager.add_machine_state(
216
71
            Constraints.from_strs("dummy", []).with_series("series"))
63
            series_constraints)
217
72
64
218
73
        self.change_environment(
65
        self.change_environment(
219
74
            JUJU_MACHINE_ID="0",
66
            JUJU_MACHINE_ID="0",
220
75
67
221
=== modified file 'juju/agents/tests/test_provision.py'
222
--- juju/agents/tests/test_provision.py	2012-01-09 16:57:13 +0000
223
+++ juju/agents/tests/test_provision.py	2012-03-30 16:56:32 +0000
224
@@ -1,18 +1,12 @@
225
1
import logging
1
import logging
226
2
2
227
3
import zookeeper
228
4
229
5
from twisted.internet.defer import inlineCallbacks, fail, succeed
3
from twisted.internet.defer import inlineCallbacks, fail, succeed
230
6
from twisted.internet import reactor
4
from twisted.internet import reactor
231
7
5
232
8
from txzookeeper.client import ZOO_OPEN_ACL_UNSAFE
233
9
234
10
from juju.agents.provision import ProvisioningAgent
6
from juju.agents.provision import ProvisioningAgent
235
11
from juju.environment.environment import Environment
7
from juju.environment.environment import Environment
236
12
from juju.environment.config import EnvironmentsConfig
237
13
from juju.environment.errors import EnvironmentsConfigError
8
from juju.environment.errors import EnvironmentsConfigError
240
14
from juju.environment.tests.test_config import SAMPLE_ENV
9
from juju.machine.tests.test_constraints import dummy_cs, series_constraints
239
15
from juju.machine.constraints import Constraints
241
16
from juju.errors import ProviderInteractionError
10
from juju.errors import ProviderInteractionError
242
17
from juju.lib.mocker import MATCH
11
from juju.lib.mocker import MATCH
243
18
from juju.providers.dummy import DummyMachine
12
from juju.providers.dummy import DummyMachine
244
@@ -37,23 +31,21 @@
245
37
        yield super(ProvisioningTestBase, self).setUp()
31
        yield super(ProvisioningTestBase, self).setUp()
246
38
        self.machine_manager = MachineStateManager(self.client)
32
        self.machine_manager = MachineStateManager(self.client)
247
39
33
249
40
    def add_machine_state(self):
34
    def add_machine_state(self, constraints=None):
250
41
        return self.machine_manager.add_machine_state(
35
        return self.machine_manager.add_machine_state(
257
42
            Constraints.from_strs("dummy", []).with_series("series"))
36
            constraints or series_constraints)
252
43
253
44
    def get_serialized_environment(self):
254
45
        config = EnvironmentsConfig()
255
46
        config.parse(SAMPLE_ENV)
256
47
        return config.serialize("myfirstenv")
258
48
37
259
49
38
260
50
class ProvisioningAgentStartupTest(ProvisioningTestBase):
39
class ProvisioningAgentStartupTest(ProvisioningTestBase):
261
51
40
262
41
    setup_environment = False
263
42
264
52
    @inlineCallbacks
43
    @inlineCallbacks
265
53
    def setUp(self):
44
    def setUp(self):
266
54
        yield super(ProvisioningAgentStartupTest, self).setUp()
45
        yield super(ProvisioningAgentStartupTest, self).setUp()
267
55
        yield self.agent.connect()
46
        yield self.agent.connect()
268
56
47
269
48
    @inlineCallbacks
270
57
    def test_agent_waits_for_environment(self):
49
    def test_agent_waits_for_environment(self):
271
58
        """
50
        """
272
59
        When the agent starts it waits for the /environment node to exist.
51
        When the agent starts it waits for the /environment node to exist.
273
@@ -61,31 +53,20 @@
274
61
        deserialize it into an environment object.
53
        deserialize it into an environment object.
275
62
        """
54
        """
276
63
        env_loaded_deferred = self.agent.configure_environment()
55
        env_loaded_deferred = self.agent.configure_environment()
291
64
56
        reactor.callLater(
292
65
        def verify_environment(result):
57
            0.3, self.push_default_config, with_constraints=False)
293
66
            self.assertTrue(isinstance(result, Environment))
58
        result = yield env_loaded_deferred
294
67
            self.assertEqual(result.name, "myfirstenv")
59
        self.assertTrue(isinstance(result, Environment))
295
68
60
        self.assertEqual(result.name, "firstenv")
282
69
        env_loaded_deferred.addCallback(verify_environment)
283
70
284
71
        def create_environment_node():
285
72
            self.assertFalse(env_loaded_deferred.called)
286
73
            return self.client.create(
287
74
                "/environment", self.get_serialized_environment())
288
75
289
76
        reactor.callLater(0.3, create_environment_node)
290
77
        return env_loaded_deferred
296
78
61
297
79
    @inlineCallbacks
62
    @inlineCallbacks
298
80
    def test_agent_with_existing_environment(self):
63
    def test_agent_with_existing_environment(self):
299
81
        """An agent should load an existing environment to configure itself."""
64
        """An agent should load an existing environment to configure itself."""
303
82
65
        yield self.push_default_config()
301
83
        yield self.client.create(
302
84
            "/environment", self.get_serialized_environment())
304
85
66
305
86
        def verify_environment(result):
67
        def verify_environment(result):
306
87
            self.assertTrue(isinstance(result, Environment))
68
            self.assertTrue(isinstance(result, Environment))
308
88
            self.assertEqual(result.name, "myfirstenv")
69
            self.assertEqual(result.name, "firstenv")
309
89
70
310
90
        d = self.agent.configure_environment()
71
        d = self.agent.configure_environment()
311
91
        d.addCallback(verify_environment)
72
        d.addCallback(verify_environment)
312
@@ -103,15 +84,13 @@
313
103
        while the agent is processing the NoNodeException, it should detect
84
        while the agent is processing the NoNodeException, it should detect
314
104
        this and configure normally.
85
        this and configure normally.
315
105
        """
86
        """
316
106
        data = self.get_serialized_environment()
317
107
        exists_and_watch = self.agent.client.exists_and_watch
87
        exists_and_watch = self.agent.client.exists_and_watch
318
108
88
319
109
        mock_client = self.mocker.patch(self.agent.client)
89
        mock_client = self.mocker.patch(self.agent.client)
320
110
        mock_client.exists_and_watch("/environment")
90
        mock_client.exists_and_watch("/environment")
321
111
91
322
112
        def inject_creation(path):
92
        def inject_creation(path):
325
113
            zookeeper.create(
93
            self.push_default_config(with_constraints=False)
324
114
                self.agent.client.handle, path, data, [ZOO_OPEN_ACL_UNSAFE])
326
115
            return exists_and_watch(path)
94
            return exists_and_watch(path)
327
116
95
328
117
        self.mocker.call(inject_creation)
96
        self.mocker.call(inject_creation)
329
@@ -131,8 +110,6 @@
330
131
    @inlineCallbacks
110
    @inlineCallbacks
331
132
    def setUp(self):
111
    def setUp(self):
332
133
        yield super(ProvisioningAgentTest, self).setUp()
112
        yield super(ProvisioningAgentTest, self).setUp()
333
134
        yield self.client.create(
334
135
            "/environment", self.get_serialized_environment())
335
136
        self.agent.set_watch_enabled(False)
113
        self.agent.set_watch_enabled(False)
336
137
        yield self.agent.startService()
114
        yield self.agent.startService()
337
138
        self.output = self.capture_logging("juju.agents.provision",
115
        self.output = self.capture_logging("juju.agents.provision",
338
@@ -268,8 +245,7 @@
339
268
        If the environment changes the agent reconfigures itself
245
        If the environment changes the agent reconfigures itself
340
269
        """
246
        """
341
270
        provider = self.agent.provider
247
        provider = self.agent.provider
344
271
        data = self.get_serialized_environment()
248
        yield self.push_default_config()
343
272
        yield self.client.set("/environment", data)
345
273
        yield self.sleep(0.2)
249
        yield self.sleep(0.2)
346
274
        self.assertNotIdentical(provider, self.agent.provider)
250
        self.assertNotIdentical(provider, self.agent.provider)
347
275
251
348
@@ -314,14 +290,22 @@
349
314
        If there's an error when processing changes, the agent should log
290
        If there's an error when processing changes, the agent should log
350
315
        the error and continue.
291
        the error and continue.
351
316
        """
292
        """
354
317
        machine_state0 = yield self.add_machine_state()
293
        machine_state0 = yield self.add_machine_state(
355
318
        machine_state1 = yield self.add_machine_state()
294
            dummy_cs.parse(["cpu=10"]).with_series("series"))
356
295
        machine_state1 = yield self.add_machine_state(
357
296
            dummy_cs.parse(["cpu=20"]).with_series("series"))
358
319
297
359
320
        mock_provider = self.mocker.patch(self.agent.provider)
298
        mock_provider = self.mocker.patch(self.agent.provider)
361
321
        mock_provider.start_machine({"machine-id": 0})
299
        mock_provider.start_machine({
362
300
            "machine-id": 0, "constraints": {
363
301
                "arch": "amd64", "cpu": 10, "mem": 512,
364
302
                "provider-type": "dummy", "ubuntu-series": "series"}})
365
322
        self.mocker.result(fail(ProviderInteractionError()))
303
        self.mocker.result(fail(ProviderInteractionError()))
366
323
304
368
324
        mock_provider.start_machine({"machine-id": 1})
305
        mock_provider.start_machine({
369
306
            "machine-id": 1, "constraints": {
370
307
                "arch": "amd64", "cpu": 20, "mem": 512,
371
308
                "provider-type": "dummy", "ubuntu-series": "series"}})
372
325
        self.mocker.passthrough()
309
        self.mocker.passthrough()
373
326
        self.mocker.replay()
310
        self.mocker.replay()
374
327
311
375
@@ -476,8 +460,6 @@
376
476
    @inlineCallbacks
460
    @inlineCallbacks
377
477
    def setUp(self):
461
    def setUp(self):
378
478
        yield super(FirewallManagerTest, self).setUp()
462
        yield super(FirewallManagerTest, self).setUp()
379
479
        yield self.client.create(
380
480
            "/environment", self.get_serialized_environment())
381
481
        self.agent.set_watch_enabled(False)
463
        self.agent.set_watch_enabled(False)
382
482
        yield self.agent.startService()
464
        yield self.agent.startService()
383
483
465
384
@@ -509,11 +491,14 @@
385
509
        # Modify services, while subsequently poking to ensure service
491
        # Modify services, while subsequently poking to ensure service
386
510
        # watch is processed on each modification
492
        # watch is processed on each modification
387
511
        yield self.add_service("wordpress")
493
        yield self.add_service("wordpress")
389
512
        yield self.poke_zk()
494
        while len(seen) < 1:
390
495
            yield self.poke_zk()
391
513
        mysql = yield self.add_service("mysql")
496
        mysql = yield self.add_service("mysql")
393
514
        yield self.poke_zk()
497
        while len(seen) < 2:
394
498
            yield self.poke_zk()
395
515
        yield self.service_state_manager.remove_service_state(mysql)
499
        yield self.service_state_manager.remove_service_state(mysql)
397
516
        yield self.poke_zk()
500
        while len(seen) < 3:
398
501
            yield self.poke_zk()
399
517
502
400
518
        self.assertEqual(
503
        self.assertEqual(
401
519
            seen,
504
            seen,
402
520
505
403
=== modified file 'juju/control/__init__.py'
404
--- juju/control/__init__.py	2011-12-15 17:12:26 +0000
405
+++ juju/control/__init__.py	2012-03-30 16:56:32 +0000
406
@@ -12,6 +12,7 @@
407
12
import bootstrap
12
import bootstrap
408
13
import config_get
13
import config_get
409
14
import config_set
14
import config_set
410
15
import constraints_get
411
15
import constraints_set
16
import constraints_set
412
16
import debug_hooks
17
import debug_hooks
413
17
import debug_log
18
import debug_log
414
@@ -39,6 +40,7 @@
415
39
    bootstrap,
40
    bootstrap,
416
40
    config_get,
41
    config_get,
417
41
    config_set,
42
    config_set,
418
43
    constraints_get,
419
42
    constraints_set,
44
    constraints_set,
420
43
    debug_log,
45
    debug_log,
421
44
    debug_hooks,
46
    debug_hooks,
422
45
47
423
=== modified file 'juju/control/add_unit.py'
424
--- juju/control/add_unit.py	2011-11-29 22:50:38 +0000
425
+++ juju/control/add_unit.py	2012-03-30 16:56:32 +0000
426
@@ -2,7 +2,8 @@
427
2
2
428
3
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
429
4
4
431
5
from juju.control.utils import get_environment
5
from juju.control import legacy
432
6
from juju.control.utils import get_environment, sync_environment_state
433
6
from juju.state.placement import place_unit
7
from juju.state.placement import place_unit
434
7
from juju.state.service import ServiceStateManager
8
from juju.state.service import ServiceStateManager
435
8
9
436
@@ -44,6 +45,10 @@
437
44
    client = yield provider.connect()
45
    client = yield provider.connect()
438
45
46
439
46
    try:
47
    try:
440
48
        yield legacy.check_environment(
441
49
            client, provider.get_legacy_config_keys())
442
50
        yield sync_environment_state(client, config, environment.name)
443
51
444
47
        service_manager = ServiceStateManager(client)
52
        service_manager = ServiceStateManager(client)
445
48
        service_state = yield service_manager.get_service_state(service_name)
53
        service_state = yield service_manager.get_service_state(service_name)
446
49
        for i in range(num_units):
54
        for i in range(num_units):
447
50
55
448
=== modified file 'juju/control/bootstrap.py'
449
--- juju/control/bootstrap.py	2011-09-22 13:23:00 +0000
450
+++ juju/control/bootstrap.py	2012-03-30 16:56:32 +0000
451
@@ -1,6 +1,7 @@
452
1
from twisted.internet.defer import inlineCallbacks
1
from twisted.internet.defer import inlineCallbacks
453
2
2
455
3
from juju.control.utils import get_environment
3
from juju.control import legacy
456
4
from juju.control.utils import expand_constraints, get_environment
457
4
5
458
5
6
459
6
def configure_subparser(subparsers):
7
def configure_subparser(subparsers):
460
@@ -9,6 +10,11 @@
461
9
    sub_parser.add_argument(
10
    sub_parser.add_argument(
462
10
        "--environment", "-e",
11
        "--environment", "-e",
463
11
        help="juju environment to operate in.")
12
        help="juju environment to operate in.")
464
13
    sub_parser.add_argument(
465
14
        "--constraints",
466
15
        help="default hardware constraints for this environment.",
467
16
        default=[],
468
17
        type=expand_constraints)
469
12
    return sub_parser
18
    return sub_parser
470
13
19
471
14
20
472
@@ -19,6 +25,14 @@
473
19
    """
25
    """
474
20
    environment = get_environment(options)
26
    environment = get_environment(options)
475
21
    provider = environment.get_machine_provider()
27
    provider = environment.get_machine_provider()
476
28
    legacy_keys = provider.get_legacy_config_keys()
477
29
    if legacy_keys:
478
30
        legacy.error(legacy_keys)
479
31
480
32
    constraint_set = yield provider.get_constraint_set()
481
33
    constraints = constraint_set.parse(options.constraints)
482
34
    constraints = constraints.with_series(environment.default_series)
483
35
484
22
    options.log.info("Bootstrapping environment %r (type: %s)..." % (
36
    options.log.info("Bootstrapping environment %r (type: %s)..." % (
485
23
        environment.name, environment.type))
37
        environment.name, environment.type))
487
24
    yield provider.bootstrap()
38
    yield provider.bootstrap(constraints)
488
25
39
489
=== added file 'juju/control/constraints_get.py'
490
--- juju/control/constraints_get.py	1970-01-01 00:00:00 +0000
491
+++ juju/control/constraints_get.py	2012-03-30 16:56:32 +0000
492
@@ -0,0 +1,75 @@
493
1
import argparse
494
2
import sys
495
3
import yaml
496
4
497
5
from twisted.internet.defer import inlineCallbacks
498
6
499
7
from juju.control.utils import get_environment, sync_environment_state
500
8
from juju.state.environment import EnvironmentStateManager
501
9
from juju.state.machine import MachineStateManager
502
10
from juju.state.service import ServiceStateManager
503
11
504
12
505
13
def configure_subparser(subparsers):
506
14
    sub_parser = subparsers.add_parser(
507
15
        "get-constraints",
508
16
        help=command.__doc__,
509
17
        formatter_class=argparse.RawDescriptionHelpFormatter,
510
18
        description=constraints_get.__doc__)
511
19
512
20
    sub_parser.add_argument(
513
21
        "--environment", "-e",
514
22
        help="Environment to affect")
515
23
516
24
    sub_parser.add_argument(
517
25
        "entities",
518
26
        nargs="*",
519
27
        help="names of machines, units or services")
520
28
521
29
    return sub_parser
522
30
523
31
524
32
def command(options):
525
33
    """Show currently applicable constraints"""
526
34
    environment = get_environment(options)
527
35
    return constraints_get(
528
36
        options.environments, environment, options.entities, options.log)
529
37
530
38
531
39
@inlineCallbacks
532
40
def constraints_get(env_config, environment, entity_names, log):
533
41
    """
534
42
    Show the complete set of applicable constraints for each specified entity.
535
43
536
44
    This will show the final computed values of all constraints (including
537
45
    internal constraints which cannot be set directly via set-constraints).
538
46
    """
539
47
    provider = environment.get_machine_provider()
540
48
    client = yield provider.connect()
541
49
    result = {}
542
50
    try:
543
51
        yield sync_environment_state(client, env_config, environment.name)
544
52
        if entity_names:
545
53
            msm = MachineStateManager(client)
546
54
            ssm = ServiceStateManager(client)
547
55
            for name in entity_names:
548
56
                if name.isdigit():
549
57
                    kind = "machine"
550
58
                    entity = yield msm.get_machine_state(name)
551
59
                elif "/" in name:
552
60
                    kind = "service unit"
553
61
                    entity = yield ssm.get_unit_state(name)
554
62
                else:
555
63
                    kind = "service"
556
64
                    entity = yield ssm.get_service_state(name)
557
65
                log.info("Fetching constraints for %s %s", kind, name)
558
66
                constraints = yield entity.get_constraints()
559
67
                result[name] = dict(constraints)
560
68
        else:
561
69
            esm = EnvironmentStateManager(client)
562
70
            log.info("Fetching constraints for environment")
563
71
            constraints = yield esm.get_constraints()
564
72
            result = dict(constraints)
565
73
        yaml.safe_dump(result, sys.stdout)
566
74
    finally:
567
75
        yield client.close()
568
0
76
569
=== modified file 'juju/control/constraints_set.py'
570
--- juju/control/constraints_set.py	2012-03-09 09:02:06 +0000
571
+++ juju/control/constraints_set.py	2012-03-30 16:56:32 +0000
572
@@ -2,8 +2,9 @@
573
2
2
574
3
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
575
4
4
578
5
from juju.control.utils import get_environment
5
from juju.control import legacy
579
6
from juju.machine.constraints import Constraints
6
from juju.control.utils import get_environment, sync_environment_state
580
7
from juju.state.environment import EnvironmentStateManager
581
7
from juju.state.service import ServiceStateManager
8
from juju.state.service import ServiceStateManager
582
8
9
583
9
10
584
@@ -34,36 +35,43 @@
585
34
    """Set machine constraints for the environment, or for a named service.
35
    """Set machine constraints for the environment, or for a named service.
586
35
    """
36
    """
587
36
    environment = get_environment(options)
37
    environment = get_environment(options)
588
38
    env_config = options.environments
589
37
    return constraints_set(
39
    return constraints_set(
591
38
        environment, options.service, options.constraints)
40
        env_config, environment, options.service, options.constraints)
592
39
41
593
40
42
594
41
@inlineCallbacks
43
@inlineCallbacks
596
42
def constraints_set(environment, service_name, constraint_strs):
44
def constraints_set(env_config, environment, service_name, constraint_strs):
597
43
    """
45
    """
598
44
    Machine constraints allow you to pick the hardware to which your services
46
    Machine constraints allow you to pick the hardware to which your services
599
45
    will be deployed. Examples:
47
    will be deployed. Examples:
600
46
48
601
47
    $ juju set-constraints --service-name mysql mem=8G cpu=4
49
    $ juju set-constraints --service-name mysql mem=8G cpu=4
602
48
50
617
49
    $ juju set-constraints ec2-instance-type=t1.micro
51
    $ juju set-constraints instance-type=t1.micro
618
50
52
619
51
    "arch", "cpu" and "mem" are always available; other constraints are
53
    Available constraints vary by provider type, and will be ignored if not
620
52
    provider-specific, and will be ignored if specified in an environment of
54
    understood by the current environment's provider. The current set of
621
53
    the wrong kind. The recognised constraints are currently:
55
    available constraints across all providers is:
622
54
56
623
55
    * arch (CPU architecture: x86/amd64/arm; unset by default)
57
    On Amazon EC2:
624
56
    * cpu (processing power in Amazon ECU; 1 by default)
58
625
57
    * mem (memory in [MGT]iB; 512M by default)
59
        * arch (CPU architecture: i386/amd64/arm; amd64 by default)
626
58
    * ec2-region (us-east-1 by default)
60
        * cpu (processing power in Amazon ECU; 1 by default)
627
59
    * ec2-zone (unset by default)
61
        * mem (memory in [MGT]iB; 512M by default)
628
60
    * ec2-instance-type (unset by default)
62
        * instance-type (unset by default)
629
61
    * orchestra-classes (unset by default)
63
        * ec2-zone (unset by default)
630
62
    * orchestra-name (unset by default)
64
631
65
    On Orchestra:
632
66
633
67
        * orchestra-classes (unset by default)
634
68
635
69
    On MAAS:
636
70
637
71
        * maas-name (unset by default)
638
63
72
639
64
    Service settings, if specified, will override environment settings, which
73
    Service settings, if specified, will override environment settings, which
642
65
    will in turn override the juju defaults of mem=512M, cpu=1,
74
    will in turn override the juju defaults of mem=512M, cpu=1, arch=amd64.
641
66
    ec2-region=us-east-1.
643
67
75
644
68
    New constraints set on an entity will completely replace that entity's
76
    New constraints set on an entity will completely replace that entity's
645
69
    pre-existing constraints.
77
    pre-existing constraints.
646
@@ -72,17 +80,22 @@
647
72
    service constraints, just specify "name=" (rather than just not specifying
80
    service constraints, just specify "name=" (rather than just not specifying
648
73
    the constraint at all, which will cause it to inherit the environment's
81
    the constraint at all, which will cause it to inherit the environment's
649
74
    value).
82
    value).
650
83
651
84
    To entirely unset a constraint, specify "name=any".
652
75
    """
85
    """
653
76
    constraints = Constraints.from_strs(environment.type, constraint_strs)
654
77
655
78
    if service_name is None:
656
79
        raise NotImplementedError("Environment constraints not implemented")
657
80
658
81
    provider = environment.get_machine_provider()
86
    provider = environment.get_machine_provider()
659
87
    constraint_set = yield provider.get_constraint_set()
660
88
    constraints = constraint_set.parse(constraint_strs)
661
82
    client = yield provider.connect()
89
    client = yield provider.connect()
662
83
    try:
90
    try:
666
84
        service_state_manager = ServiceStateManager(client)
91
        yield legacy.check_constraints(client, constraint_strs)
667
85
        service = yield service_state_manager.get_service_state(service_name)
92
        yield sync_environment_state(client, env_config, environment.name)
668
86
        yield service.set_constraints(constraints)
93
        if service_name is None:
669
94
            esm = EnvironmentStateManager(client)
670
95
            yield esm.set_constraints(constraints)
671
96
        else:
672
97
            ssm = ServiceStateManager(client)
673
98
            service = yield ssm.get_service_state(service_name)
674
99
            yield service.set_constraints(constraints)
675
87
    finally:
100
    finally:
676
88
        yield client.close()
101
        yield client.close()
677
89
102
678
=== modified file 'juju/control/deploy.py'
679
--- juju/control/deploy.py	2012-03-22 16:15:02 +0000
680
+++ juju/control/deploy.py	2012-03-30 16:56:32 +0000
681
@@ -4,26 +4,20 @@
682
4
4
683
5
from twisted.internet.defer import inlineCallbacks
5
from twisted.internet.defer import inlineCallbacks
684
6
6
686
7
from juju.control.utils import get_environment, expand_path
7
from juju.control import legacy
687
8
from juju.control.utils import (
688
9
    expand_constraints, expand_path, get_environment, sync_environment_state)
689
8
10
690
9
from juju.charm.errors import ServiceConfigValueError
11
from juju.charm.errors import ServiceConfigValueError
691
10
from juju.charm.publisher import CharmPublisher
12
from juju.charm.publisher import CharmPublisher
692
11
from juju.charm.repository import resolve
13
from juju.charm.repository import resolve
693
12
from juju.errors import CharmError
14
from juju.errors import CharmError
694
13
from juju.machine.constraints import Constraints
695
14
from juju.state.endpoint import RelationEndpoint
15
from juju.state.endpoint import RelationEndpoint
696
15
from juju.state.environment import EnvironmentStateManager
697
16
from juju.state.placement import place_unit
16
from juju.state.placement import place_unit
698
17
from juju.state.relation import RelationStateManager
17
from juju.state.relation import RelationStateManager
699
18
from juju.state.service import ServiceStateManager
18
from juju.state.service import ServiceStateManager
700
19
19
701
20
20
702
21
def _expand_constraints(s):
703
22
    if s:
704
23
        return s.split(" ")
705
24
    return []
706
25
707
26
708
27
def configure_subparser(subparsers):
21
def configure_subparser(subparsers):
709
28
    sub_parser = subparsers.add_parser("deploy", help=command.__doc__,
22
    sub_parser = subparsers.add_parser("deploy", help=command.__doc__,
710
29
            description=deploy.__doc__)
23
            description=deploy.__doc__)
711
@@ -50,7 +44,7 @@
712
50
        "--constraints",
44
        "--constraints",
713
51
        help="Hardware constraints for the service",
45
        help="Hardware constraints for the service",
714
52
        default=[],
46
        default=[],
716
53
        type=_expand_constraints)
47
        type=expand_constraints)
717
54
48
718
55
    sub_parser.add_argument(
49
    sub_parser.add_argument(
719
56
        "charm", nargs=None,
50
        "charm", nargs=None,
720
@@ -134,23 +128,23 @@
721
134
        service_options = parse_config_options(
128
        service_options = parse_config_options(
722
135
            config_file, service_name, charm)
129
            config_file, service_name, charm)
723
136
130
724
137
    constraints = Constraints.from_strs(environment.type, constraint_strs)
725
138
726
139
    charm = yield repo.find(charm_url)
131
    charm = yield repo.find(charm_url)
727
140
    charm_id = str(charm_url.with_revision(charm.get_revision()))
132
    charm_id = str(charm_url.with_revision(charm.get_revision()))
728
141
133
729
142
    provider = environment.get_machine_provider()
134
    provider = environment.get_machine_provider()
730
143
    placement_policy = provider.get_placement_policy()
135
    placement_policy = provider.get_placement_policy()
731
136
    constraint_set = yield provider.get_constraint_set()
732
137
    constraints = constraint_set.parse(constraint_strs)
733
144
    client = yield provider.connect()
138
    client = yield provider.connect()
734
145
139
735
146
    try:
140
    try:
736
141
        yield legacy.check_constraints(client, constraint_strs)
737
142
        yield legacy.check_environment(
738
143
            client, provider.get_legacy_config_keys())
739
144
        yield sync_environment_state(client, env_config, environment.name)
740
145
741
146
        # Publish the charm to juju
742
147
        storage = yield provider.get_file_storage()
147
        storage = yield provider.get_file_storage()
743
148
        service_manager = ServiceStateManager(client)
744
149
        environment_state_manager = EnvironmentStateManager(client)
745
150
        yield environment_state_manager.set_config_state(
746
151
            env_config, environment.name)
747
152
748
153
        # Publish the charm to juju
749
154
        publisher = CharmPublisher(client, storage)
148
        publisher = CharmPublisher(client, storage)
750
155
        yield publisher.add_charm(charm_id, charm)
149
        yield publisher.add_charm(charm_id, charm)
751
156
        result = yield publisher.publish()
150
        result = yield publisher.publish()
752
@@ -161,6 +155,7 @@
753
161
        charm_state = result[0]
155
        charm_state = result[0]
754
162
156
755
163
        # Create the service state
157
        # Create the service state
756
158
        service_manager = ServiceStateManager(client)
757
164
        service_state = yield service_manager.add_service_state(
159
        service_state = yield service_manager.add_service_state(
758
165
            service_name, charm_state, constraints)
160
            service_name, charm_state, constraints)
759
166
161
760
167
162
761
=== modified file 'juju/control/initialize.py'
762
--- juju/control/initialize.py	2011-09-23 20:35:02 +0000
763
+++ juju/control/initialize.py	2012-03-30 16:56:32 +0000
764
@@ -1,4 +1,6 @@
765
1
from base64 import b64decode
766
1
import os
2
import os
767
3
import yaml
768
2
4
769
3
from twisted.internet.defer import inlineCallbacks
5
from twisted.internet.defer import inlineCallbacks
770
4
6
771
@@ -12,11 +14,13 @@
772
12
    sub_parser.add_argument(
14
    sub_parser.add_argument(
773
13
        "--instance-id", required=True,
15
        "--instance-id", required=True,
774
14
        help="Provider instance id for the bootstrap node")
16
        help="Provider instance id for the bootstrap node")
775
15
776
16
    sub_parser.add_argument(
17
    sub_parser.add_argument(
777
17
        "--admin-identity", required=True,
18
        "--admin-identity", required=True,
778
18
        help="Admin access control identity for zookeeper ACLs")
19
        help="Admin access control identity for zookeeper ACLs")
779
19
    sub_parser.add_argument(
20
    sub_parser.add_argument(
780
21
        "--constraints-data", required=True,
781
22
        help="Base64-encoded yaml dump of the environment constraints data")
782
23
    sub_parser.add_argument(
783
20
        "--provider-type", required=True,
24
        "--provider-type", required=True,
784
21
        help="Environment machine provider type")
25
        help="Environment machine provider type")
785
22
    return sub_parser
26
    return sub_parser
786
@@ -30,10 +34,12 @@
787
30
    zk_address = os.environ.get("ZOOKEEPER_ADDRESS", "127.0.0.1:2181")
34
    zk_address = os.environ.get("ZOOKEEPER_ADDRESS", "127.0.0.1:2181")
788
31
    client = yield ZookeeperClient(zk_address).connect()
35
    client = yield ZookeeperClient(zk_address).connect()
789
32
    try:
36
    try:
790
37
        constraints_data = yaml.load(b64decode(options.constraints_data))
791
33
        hierarchy = StateHierarchy(
38
        hierarchy = StateHierarchy(
792
34
            client,
39
            client,
793
35
            options.admin_identity,
40
            options.admin_identity,
794
36
            options.instance_id,
41
            options.instance_id,
795
42
            constraints_data,
796
37
            options.provider_type)
43
            options.provider_type)
797
38
        yield hierarchy.initialize()
44
        yield hierarchy.initialize()
798
39
    finally:
45
    finally:
799
40
46
800
=== added file 'juju/control/legacy.py'
801
--- juju/control/legacy.py	1970-01-01 00:00:00 +0000
802
+++ juju/control/legacy.py	2012-03-30 16:56:32 +0000
803
@@ -0,0 +1,41 @@
804
1
from twisted.internet.defer import inlineCallbacks
805
2
806
3
from juju.errors import JujuError
807
4
from juju.state.environment import EnvironmentStateManager
808
5
809
6
_ERROR = """
810
7
Your environments.yaml contains deprecated keys; they must not be used other
811
8
than in legacy deployments. The affected keys are:
812
9
813
10
    %s
814
11
815
12
This error can be resolved according to the instructions available at:
816
13
817
14
    https://juju.ubuntu.com/DeprecatedEnvironmentSettings
818
15
"""
819
16
820
17
821
18
def error(keys):
822
19
    raise JujuError(_ERROR % "\n    ".join(sorted(keys)))
823
20
824
21
825
22
@inlineCallbacks
826
23
def check_environment(client, keys):
827
24
    if not keys:
828
25
        return
829
26
    esm = EnvironmentStateManager(client)
830
27
    if not (yield esm.get_in_legacy_environment()):
831
28
        error(keys)
832
29
833
30
834
31
@inlineCallbacks
835
32
def check_constraints(client, constraint_strs):
836
33
    if not constraint_strs:
837
34
        return
838
35
    esm = EnvironmentStateManager(client)
839
36
    if (yield esm.get_in_legacy_environment()):
840
37
        raise JujuError(
841
38
            "Constraints are not valid in legacy deployments. To use machine "
842
39
            "constraints, please deploy your environment again from scratch. "
843
40
            "You can continue to use this environment as before, but any "
844
41
            "attempt to set constraints will fail.")
845
0
42
846
=== modified file 'juju/control/terminate_machine.py'
847
--- juju/control/terminate_machine.py	2011-09-15 18:50:23 +0000
848
+++ juju/control/terminate_machine.py	2012-03-30 16:56:32 +0000
849
@@ -2,6 +2,7 @@
850
2
2
851
3
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
852
4
4
853
5
from juju.control.utils import sync_environment_state
854
5
from juju.errors import CannotTerminateMachine
6
from juju.errors import CannotTerminateMachine
855
6
from juju.environment.errors import EnvironmentsConfigError
7
from juju.environment.errors import EnvironmentsConfigError
856
7
from juju.state.errors import MachineStateNotFound
8
from juju.state.errors import MachineStateNotFound
857
@@ -57,6 +58,7 @@
858
57
    client = yield provider.connect()
58
    client = yield provider.connect()
859
58
    terminated_machine_ids = []
59
    terminated_machine_ids = []
860
59
    try:
60
    try:
861
61
        yield sync_environment_state(client, config, environment.name)
862
60
        machine_state_manager = MachineStateManager(client)
62
        machine_state_manager = MachineStateManager(client)
863
61
        for machine_id in machine_ids:
63
        for machine_id in machine_ids:
864
62
            if machine_id == 0:
64
            if machine_id == 0:
865
63
65
866
=== modified file 'juju/control/tests/test_add_relation.py'
867
--- juju/control/tests/test_add_relation.py	2012-02-09 03:52:45 +0000
868
+++ juju/control/tests/test_add_relation.py	2012-03-30 16:56:32 +0000
869
@@ -1,5 +1,4 @@
870
1
import logging
1
import logging
871
2
import yaml
872
3
2
873
4
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
874
5
4
875
@@ -15,12 +14,6 @@
876
15
    @inlineCallbacks
14
    @inlineCallbacks
877
16
    def setUp(self):
15
    def setUp(self):
878
17
        yield super(ControlAddRelationTest, self).setUp()
16
        yield super(ControlAddRelationTest, self).setUp()
879
18
        config = {
880
19
            "environments": {
881
20
                "firstenv": {
882
21
                    "type": "dummy", "admin-secret": "homer"}}}
883
22
        self.write_config(yaml.dump(config))
884
23
        self.config.load()
885
24
        self.output = self.capture_logging()
17
        self.output = self.capture_logging()
886
25
        self.stderr = self.capture_stream("stderr")
18
        self.stderr = self.capture_stream("stderr")
887
26
19
888
27
20
889
=== modified file 'juju/control/tests/test_add_unit.py'
890
--- juju/control/tests/test_add_unit.py	2012-02-01 11:27:42 +0000
891
+++ juju/control/tests/test_add_unit.py	2012-03-30 16:56:32 +0000
892
@@ -1,7 +1,9 @@
893
1
from yaml import dump
894
2
895
1
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
896
2
from yaml import dump
897
3
4
898
4
from juju.control import main
5
from juju.control import main
899
6
from juju.state.environment import EnvironmentStateManager
900
5
7
901
6
from .common import MachineControlToolTest
8
from .common import MachineControlToolTest
902
7
9
903
@@ -11,11 +13,6 @@
904
11
    @inlineCallbacks
13
    @inlineCallbacks
905
12
    def setUp(self):
14
    def setUp(self):
906
13
        yield super(ControlAddUnitTest, self).setUp()
15
        yield super(ControlAddUnitTest, self).setUp()
907
14
        config = {
908
15
            "environments": {"firstenv": {"type": "dummy"}}}
909
16
910
17
        self.write_config(dump(config))
911
18
        self.config.load()
912
19
        self.service_state1 = yield self.add_service_from_charm("mysql")
16
        self.service_state1 = yield self.add_service_from_charm("mysql")
913
20
        self.service_unit1 = yield self.service_state1.add_unit_state()
17
        self.service_unit1 = yield self.service_state1.add_unit_state()
914
21
        self.machine_state1 = yield self.add_machine_state()
18
        self.machine_state1 = yield self.add_machine_state()
915
@@ -36,9 +33,15 @@
916
36
        finished = self.setup_cli_reactor()
33
        finished = self.setup_cli_reactor()
917
37
        self.setup_exit(0)
34
        self.setup_exit(0)
918
38
        self.mocker.replay()
35
        self.mocker.replay()
919
36
        # trash environment to check syncing
920
37
        yield self.client.delete("/environment")
921
39
        main(["add-unit", "mysql"])
38
        main(["add-unit", "mysql"])
922
40
        yield finished
39
        yield finished
923
41
40
924
41
        # verify the env state was synced
925
42
        esm = EnvironmentStateManager(self.client)
926
43
        yield esm.get_config()
927
44
928
42
        # verify the unit and its machine assignment.
45
        # verify the unit and its machine assignment.
929
43
        unit_names = yield self.service_state1.get_unit_names()
46
        unit_names = yield self.service_state1.get_unit_names()
930
44
        self.assertEqual(len(unit_names), 2)
47
        self.assertEqual(len(unit_names), 2)
931
@@ -121,9 +124,7 @@
932
121
            "environments": {"firstenv": {
124
            "environments": {"firstenv": {
933
122
                    "placement": "local",
125
                    "placement": "local",
934
123
                    "type": "dummy"}}}
126
                    "type": "dummy"}}}
938
124
127
        yield self.push_config("firstenv", config)
936
125
        self.write_config(dump(config))
937
126
        self.config.load()
939
127
128
940
128
        ms0 = yield self.machine_state_manager.get_machine_state(0)
129
        ms0 = yield self.machine_state_manager.get_machine_state(0)
941
129
        yield self.service_unit1.unassign_from_machine()
130
        yield self.service_unit1.unassign_from_machine()
942
@@ -149,3 +150,37 @@
943
149
            self.output.getvalue())
150
            self.output.getvalue())
944
150
        # adding a second unit still assigns to machine 0 with local policy
151
        # adding a second unit still assigns to machine 0 with local policy
945
151
        yield self.assert_machine_assignments("mysql", [0, 0])
152
        yield self.assert_machine_assignments("mysql", [0, 0])
946
153
947
154
    @inlineCallbacks
948
155
    def test_legacy_option_in_legacy_env(self):
949
156
        yield self.client.delete("/constraints")
950
157
951
158
        finished = self.setup_cli_reactor()
952
159
        self.setup_exit(0)
953
160
        self.mocker.replay()
954
161
        main(["add-unit", "mysql"])
955
162
        yield finished
956
163
957
164
        unit_names = yield self.service_state1.get_unit_names()
958
165
        self.assertEqual(len(unit_names), 2)
959
166
960
167
    @inlineCallbacks
961
168
    def test_legacy_option_in_fresh_env(self):
962
169
        local_config = {
963
170
            "environments": {"firstenv": {
964
171
                    "some-legacy-key": "blah",
965
172
                    "type": "dummy"}}}
966
173
        self.write_config(dump(local_config))
967
174
        self.config.load()
968
175
969
176
        finished = self.setup_cli_reactor()
970
177
        self.setup_exit(0)
971
178
        self.mocker.replay()
972
179
        main(["add-unit", "mysql"])
973
180
        yield finished
974
181
975
182
        output = self.output.getvalue()
976
183
        self.assertIn(
977
184
            "Your environments.yaml contains deprecated keys", output)
978
185
        unit_names = yield self.service_state1.get_unit_names()
979
186
        self.assertEqual(len(unit_names), 1)
980
152
187
981
=== modified file 'juju/control/tests/test_bootstrap.py'
982
--- juju/control/tests/test_bootstrap.py	2011-09-22 13:23:00 +0000
983
+++ juju/control/tests/test_bootstrap.py	2012-03-30 16:56:32 +0000
984
@@ -19,32 +19,29 @@
985
19
        config = {
19
        config = {
986
20
            "environments": {
20
            "environments": {
987
21
                "firstenv": {
21
                "firstenv": {
989
22
                    "type": "dummy", "admin-secret": "homer"},
22
                    "type": "dummy", "default-series": "homer"},
990
23
                "secondenv": {
23
                "secondenv": {
992
24
                    "type": "dummy", "admin-secret": "marge"}}}
24
                    "type": "dummy", "default-series": "marge"}}}
993
25
25
994
26
        self.write_config(dump(config))
26
        self.write_config(dump(config))
995
27
        finished = self.setup_cli_reactor()
27
        finished = self.setup_cli_reactor()
996
28
        self.setup_exit(0)
28
        self.setup_exit(0)
997
29
29
998
30
        envs = set(("firstenv", "secondenv"))
999
31
1000
32
        def track_bootstrap_call(self):
1001
33
            envs.remove(self.environment_name)
1002
34
            return succeed(True)
1003
35
1004
36
        provider = self.mocker.patch(MachineProvider)
30
        provider = self.mocker.patch(MachineProvider)
1008
37
31
        provider.bootstrap({
1009
38
        provider.bootstrap()
32
            "ubuntu-series": "homer",
1010
39
        self.mocker.call(track_bootstrap_call, with_object=True)
33
            "provider-type": "dummy",
1011
34
            "arch": "arm",
1012
35
            "cpu": 2.0,
1013
36
            "mem": 512.0})
1014
37
        self.mocker.result(succeed(True))
1015
40
        self.mocker.replay()
38
        self.mocker.replay()
1016
41
39
1017
42
        self.capture_stream("stderr")
40
        self.capture_stream("stderr")
1019
43
        main(["bootstrap", "-e", "firstenv"])
41
        main(["bootstrap", "-e", "firstenv",
1020
42
              "--constraints", "arch=arm cpu=2"])
1021
44
        yield finished
43
        yield finished
1022
45
44
1023
46
        self.assertEqual(envs, set(["secondenv"]))
1024
47
1025
48
        lines = filter(None, self.log.getvalue().split("\n"))
45
        lines = filter(None, self.log.getvalue().split("\n"))
1026
49
        self.assertEqual(
46
        self.assertEqual(
1027
50
            lines,
47
            lines,
1028
@@ -96,3 +93,25 @@
1029
96
        msg = "Invalid environment 'thirdenv'"
93
        msg = "Invalid environment 'thirdenv'"
1030
97
        self.assertIn(msg, self.log.getvalue())
94
        self.assertIn(msg, self.log.getvalue())
1031
98
        self.assertIn(msg, output.getvalue())
95
        self.assertIn(msg, output.getvalue())
1032
96
1033
97
    @inlineCallbacks
1034
98
    def test_bootstrap_legacy_config_keys(self):
1035
99
        """
1036
100
        If the environment specified does not exist an error message is given.
1037
101
        """
1038
102
        config = {
1039
103
            "environments": {
1040
104
                "firstenv": {
1041
105
                    "type": "dummy", "some-legacy-key": "blah"}}}
1042
106
        self.write_config(dump(config))
1043
107
        finished = self.setup_cli_reactor()
1044
108
        self.setup_exit(1)
1045
109
        self.mocker.replay()
1046
110
1047
111
        output = self.capture_stream("stderr")
1048
112
        main(["bootstrap"])
1049
113
        yield finished
1050
114
1051
115
        msg = "Your environments.yaml contains deprecated keys"
1052
116
        self.assertIn(msg, self.log.getvalue())
1053
117
        self.assertIn(msg, output.getvalue())
1054
99
118
1055
=== modified file 'juju/control/tests/test_config_get.py'
1056
--- juju/control/tests/test_config_get.py	2012-01-30 22:20:37 +0000
1057
+++ juju/control/tests/test_config_get.py	2012-03-30 16:56:32 +0000
1058
@@ -13,10 +13,6 @@
1059
13
    @inlineCallbacks
13
    @inlineCallbacks
1060
14
    def setUp(self):
14
    def setUp(self):
1061
15
        yield super(ControlJujuGetTest, self).setUp()
15
        yield super(ControlJujuGetTest, self).setUp()
1062
16
        config = {
1063
17
            "environments": {"firstenv": {"type": "dummy"}}}
1064
18
        self.write_config(yaml.dump(config))
1065
19
        self.config.load()
1066
20
        self.stderr = self.capture_stream("stderr")
16
        self.stderr = self.capture_stream("stderr")
1067
21
17
1068
22
    @inlineCallbacks
18
    @inlineCallbacks
1069
23
19
1070
=== modified file 'juju/control/tests/test_config_set.py'
1071
--- juju/control/tests/test_config_set.py	2012-03-09 13:24:58 +0000
1072
+++ juju/control/tests/test_config_set.py	2012-03-30 16:56:32 +0000
1073
@@ -12,10 +12,6 @@
1074
12
    @inlineCallbacks
12
    @inlineCallbacks
1075
13
    def setUp(self):
13
    def setUp(self):
1076
14
        yield super(ControlJujuSetTest, self).setUp()
14
        yield super(ControlJujuSetTest, self).setUp()
1077
15
        config = {
1078
16
            "environments": {"firstenv": {"type": "dummy"}}}
1079
17
        self.write_config(dump(config))
1080
18
        self.config.load()
1081
19
        self.service_state = yield self.add_service_from_charm("wordpress")
15
        self.service_state = yield self.add_service_from_charm("wordpress")
1082
20
        self.service_unit = yield self.service_state.add_unit_state()
16
        self.service_unit = yield self.service_state.add_unit_state()
1083
21
        self.environment = self.config.get_default()
17
        self.environment = self.config.get_default()
1084
22
18
1085
=== added file 'juju/control/tests/test_constraints_get.py'
1086
--- juju/control/tests/test_constraints_get.py	1970-01-01 00:00:00 +0000
1087
+++ juju/control/tests/test_constraints_get.py	2012-03-30 16:56:32 +0000
1088
@@ -0,0 +1,116 @@
1089
1
import yaml
1090
2
1091
3
from twisted.internet.defer import inlineCallbacks
1092
4
1093
5
from juju.control import main
1094
6
from juju.machine.tests.test_constraints import dummy_cs
1095
7
from juju.state.environment import EnvironmentStateManager
1096
8
1097
9
from .common import MachineControlToolTest
1098
10
1099
11
env_log = "Fetching constraints for environment"
1100
12
machine_log = "Fetching constraints for machine 1"
1101
13
service_log = "Fetching constraints for service mysql"
1102
14
unit_log = "Fetching constraints for service unit mysql/0"
1103
15
1104
16
1105
17
class ConstraintsGetTest(MachineControlToolTest):
1106
18
1107
19
    @inlineCallbacks
1108
20
    def setUp(self):
1109
21
        yield super(ConstraintsGetTest, self).setUp()
1110
22
        env_constraints = dummy_cs.parse(["mem=1024"])
1111
23
        esm = EnvironmentStateManager(self.client)
1112
24
        yield esm.set_constraints(env_constraints)
1113
25
        self.expect_env = {
1114
26
            "arch": "amd64", "cpu": 1.0, "mem": 1024.0,
1115
27
            "provider-type": "dummy", "ubuntu-series": None}
1116
28
1117
29
        service_constraints = dummy_cs.parse(["cpu=10"])
1118
30
        service = yield self.add_service_from_charm(
1119
31
            "mysql", constraints=service_constraints)
1120
32
        # unit will snapshot the state of service when added
1121
33
        unit = yield service.add_unit_state()
1122
34
        self.expect_unit = {
1123
35
            "arch": "amd64", "cpu": 10.0, "mem": 1024.0,
1124
36
            "provider-type": "dummy", "ubuntu-series": "series"}
1125
37
1126
38
        # machine gets its own constraints
1127
39
        machine_constraints = dummy_cs.parse(["cpu=15", "mem=8G"])
1128
40
        machine = yield self.add_machine_state(
1129
41
            constraints=machine_constraints.with_series("series"))
1130
42
        self.expect_machine = {
1131
43
            "arch": "amd64", "cpu": 15.0, "mem": 8192.0,
1132
44
            "provider-type": "dummy", "ubuntu-series": "series"}
1133
45
        yield unit.assign_to_machine(machine)
1134
46
1135
47
        # service gets new constraints, leaves unit untouched
1136
48
        yield service.set_constraints(dummy_cs.parse(["mem=16G"]))
1137
49
        self.expect_service = {
1138
50
            "arch": "amd64", "cpu": 1.0, "mem": 16384.0,
1139
51
            "provider-type": "dummy", "ubuntu-series": "series"}
1140
52
1141
53
        self.log = self.capture_logging()
1142
54
        self.stdout = self.capture_stream("stdout")
1143
55
        self.finished = self.setup_cli_reactor()
1144
56
        self.setup_exit(0)
1145
57
        self.mocker.replay()
1146
58
1147
59
    def assert_messages(self, *messages):
1148
60
        log = self.log.getvalue()
1149
61
        for message in messages:
1150
62
            self.assertIn(message, log)
1151
63
1152
64
    @inlineCallbacks
1153
65
    def test_env(self):
1154
66
        main(["get-constraints"])
1155
67
        yield self.finished
1156
68
        result = yaml.load(self.stdout.getvalue())
1157
69
        self.assertEquals(result, self.expect_env)
1158
70
        self.assert_messages(env_log)
1159
71
1160
72
    @inlineCallbacks
1161
73
    def test_service(self):
1162
74
        main(["get-constraints", "mysql"])
1163
75
        yield self.finished
1164
76
        result = yaml.load(self.stdout.getvalue())
1165
77
        self.assertEquals(result, {"mysql": self.expect_service})
1166
78
        self.assert_messages(service_log)
1167
79
1168
80
    @inlineCallbacks
1169
81
    def test_unit(self):
1170
82
        main(["get-constraints", "mysql/0"])
1171
83
        yield self.finished
1172
84
        result = yaml.load(self.stdout.getvalue())
1173
85
        self.assertEquals(result, {"mysql/0": self.expect_unit})
1174
86
        self.assert_messages(unit_log)
1175
87
1176
88
    @inlineCallbacks
1177
89
    def test_machine(self):
1178
90
        main(["get-constraints", "1"])
1179
91
        yield self.finished
1180
92
        result = yaml.load(self.stdout.getvalue())
1181
93
        self.assertEquals(result, {"1": self.expect_machine})
1182
94
        self.assert_messages(machine_log)
1183
95
1184
96
    @inlineCallbacks
1185
97
    def test_all(self):
1186
98
        main(["get-constraints", "mysql", "mysql/0", "1"])
1187
99
        yield self.finished
1188
100
        result = yaml.load(self.stdout.getvalue())
1189
101
        expect = {"mysql": self.expect_service,
1190
102
                  "mysql/0": self.expect_unit,
1191
103
                  "1": self.expect_machine}
1192
104
        self.assertEquals(result, expect)
1193
105
        self.assert_messages(service_log, unit_log, machine_log)
1194
106
1195
107
    @inlineCallbacks
1196
108
    def test_syncs_environment(self):
1197
109
        """If the environment were not synced, it would be impossible to create
1198
110
        the Constraints, so tool success proves sync."""
1199
111
        yield self.client.delete("/environment")
1200
112
        main(["get-constraints", "mysql/0"])
1201
113
        yield self.finished
1202
114
        result = yaml.load(self.stdout.getvalue())
1203
115
        self.assertEquals(result, {"mysql/0": self.expect_unit})
1204
116
        self.assert_messages(unit_log)
1205
0
117
1206
=== modified file 'juju/control/tests/test_constraints_set.py'
1207
--- juju/control/tests/test_constraints_set.py	2012-03-09 09:02:06 +0000
1208
+++ juju/control/tests/test_constraints_set.py	2012-03-30 16:56:32 +0000
1209
@@ -1,8 +1,7 @@
1210
1
from yaml import dump
1211
2
1212
3
from twisted.internet.defer import inlineCallbacks
1
from twisted.internet.defer import inlineCallbacks
1213
4
2
1214
5
from juju.control import main
3
from juju.control import main
1215
4
from juju.state.environment import EnvironmentStateManager
1216
6
5
1217
7
from .common import MachineControlToolTest
6
from .common import MachineControlToolTest
1218
8
7
1219
@@ -12,11 +11,6 @@
1220
12
    @inlineCallbacks
11
    @inlineCallbacks
1221
13
    def setUp(self):
12
    def setUp(self):
1222
14
        yield super(ControlSetConstraintsTest, self).setUp()
13
        yield super(ControlSetConstraintsTest, self).setUp()
1223
15
        config = {
1224
16
            "environments": {"firstenv": {"type": "dummy"}}}
1225
17
1226
18
        self.write_config(dump(config))
1227
19
        self.config.load()
1228
20
        self.service_state = yield self.add_service_from_charm("mysql")
14
        self.service_state = yield self.add_service_from_charm("mysql")
1229
21
        self.output = self.capture_logging()
15
        self.output = self.capture_logging()
1230
22
        self.stderr = self.capture_stream("stderr")
16
        self.stderr = self.capture_stream("stderr")
1231
@@ -31,7 +25,7 @@
1232
31
25
1233
32
        constraints = yield self.service_state.get_constraints()
26
        constraints = yield self.service_state.get_constraints()
1234
33
        expect = {
27
        expect = {
1236
34
            "arch": None, "cpu": 8, "mem": 1024,
28
            "arch": "amd64", "cpu": 8, "mem": 1024,
1237
35
            "provider-type": "dummy", "ubuntu-series": "series"}
29
            "provider-type": "dummy", "ubuntu-series": "series"}
1238
36
        self.assertEquals(constraints, expect)
30
        self.assertEquals(constraints, expect)
1239
37
31
1240
@@ -53,15 +47,32 @@
1241
53
47
1242
54
    @inlineCallbacks
48
    @inlineCallbacks
1243
55
    def test_environment_constraint(self):
49
    def test_environment_constraint(self):
1249
56
        initial_constraints = yield self.service_state.get_constraints()
50
        yield self.client.delete("/environment")
1250
57
        finished = self.setup_cli_reactor()
51
        finished = self.setup_cli_reactor()
1251
58
        self.setup_exit(1)
52
        self.setup_exit(0)
1252
59
        self.mocker.replay()
53
        self.mocker.replay()
1253
60
        main(["set-constraints", "arch=arm"])
54
        main(["set-constraints", "arch=arm", "cpu=any"])
1254
55
        yield finished
1255
56
1256
57
        esm = EnvironmentStateManager(self.client)
1257
58
        yield esm.get_config()
1258
59
        constraints = yield esm.get_constraints()
1259
60
        self.assertEquals(constraints, {
1260
61
            "ubuntu-series": None,
1261
62
            "provider-type": "dummy",
1262
63
            "arch": "arm",
1263
64
            "cpu": None,
1264
65
            "mem": 512.0})
1265
66
1266
67
    @inlineCallbacks
1267
68
    def test_legacy_environment(self):
1268
69
        yield self.client.delete("/constraints")
1269
70
        finished = self.setup_cli_reactor()
1270
71
        self.setup_exit(0)
1271
72
        self.mocker.replay()
1272
73
        main(["set-constraints", "arch=arm", "cpu=any"])
1273
61
        yield finished
74
        yield finished
1274
62
75
1275
63
        self.assertIn(
76
        self.assertIn(
1280
64
            "Environment constraints not implemented", self.stderr.getvalue())
77
            "Constraints are not valid in legacy deployments.",
1281
65
78
            self.stderr.getvalue())
1278
66
        constraints = yield self.service_state.get_constraints()
1279
67
        self.assertEquals(constraints, initial_constraints)
1282
68
79
1283
=== modified file 'juju/control/tests/test_control.py'
1284
--- juju/control/tests/test_control.py	2011-09-15 19:24:47 +0000
1285
+++ juju/control/tests/test_control.py	2012-03-30 16:56:32 +0000
1286
@@ -4,7 +4,6 @@
1287
4
4
1288
5
from StringIO import StringIO
5
from StringIO import StringIO
1289
6
from argparse import Namespace
6
from argparse import Namespace
1290
7
from yaml import dump
1291
8
7
1292
9
from twisted.internet.defer import inlineCallbacks
8
from twisted.internet.defer import inlineCallbacks
1293
10
9
1294
@@ -12,6 +11,7 @@
1295
12
from juju.control import setup_logging, main, setup_parser
11
from juju.control import setup_logging, main, setup_parser
1296
13
from juju.control.options import ensure_abs_path
12
from juju.control.options import ensure_abs_path
1297
14
from juju.control.command import Commander
13
from juju.control.command import Commander
1298
14
from juju.state.tests.common import StateTestBase
1299
15
15
1300
16
from juju.lib.testing import TestCase
16
from juju.lib.testing import TestCase
1301
17
17
1302
@@ -36,17 +36,12 @@
1303
36
            self.fail("EnvironmentsConfigError not raised")
36
            self.fail("EnvironmentsConfigError not raised")
1304
37
37
1305
38
38
1307
39
class ControlOutputTest(ControlToolTest):
39
class ControlOutputTest(ControlToolTest, StateTestBase):
1308
40
40
1309
41
    @inlineCallbacks
1310
41
    def setUp(self):
42
    def setUp(self):
1319
42
        super(ControlOutputTest, self).setUp()
43
        yield super(ControlOutputTest, self).setUp()
1320
43
        config = {
44
        yield self.push_default_config()
1313
44
            "environments": {
1314
45
                "firstenv": {
1315
46
                    "type": "dummy", "admin-secret": "homer"},
1316
47
                "secondenv": {
1317
48
                    "type": "dummy", "admin-secret": "marge"}}}
1318
49
        self.write_config(dump(config))
1321
50
45
1322
51
    def test_sans_args_produces_help(self):
46
    def test_sans_args_produces_help(self):
1323
52
        """
47
        """
1324
53
48
1325
=== modified file 'juju/control/tests/test_debug_hooks.py'
1326
--- juju/control/tests/test_debug_hooks.py	2012-02-01 11:27:42 +0000
1327
+++ juju/control/tests/test_debug_hooks.py	2012-03-30 16:56:32 +0000
1328
@@ -1,8 +1,6 @@
1329
1
import logging
1
import logging
1330
2
import os
2
import os
1331
3
3
1332
4
import yaml
1333
5
1334
6
from twisted.internet.defer import (
4
from twisted.internet.defer import (
1335
7
    inlineCallbacks, returnValue, succeed, Deferred)
5
    inlineCallbacks, returnValue, succeed, Deferred)
1336
8
6
1337
@@ -22,13 +20,6 @@
1338
22
    @inlineCallbacks
20
    @inlineCallbacks
1339
23
    def setUp(self):
21
    def setUp(self):
1340
24
        yield super(ControlDebugHookTest, self).setUp()
22
        yield super(ControlDebugHookTest, self).setUp()
1341
25
        config = {
1342
26
            "environments": {
1343
27
                "firstenv": {
1344
28
                    "type": "dummy", "admin-secret": "homer"}}}
1345
29
        self.write_config(yaml.dump(config))
1346
30
        self.config.load()
1347
31
1348
32
        self.environment = self.config.get_default()
23
        self.environment = self.config.get_default()
1349
33
        self.provider = self.environment.get_machine_provider()
24
        self.provider = self.environment.get_machine_provider()
1350
34
25
1351
35
26
1352
=== modified file 'juju/control/tests/test_debug_log.py'
1353
--- juju/control/tests/test_debug_log.py	2011-09-15 19:24:47 +0000
1354
+++ juju/control/tests/test_debug_log.py	2012-03-30 16:56:32 +0000
1355
@@ -1,5 +1,4 @@
1356
1
import json
1
import json
1357
2
import yaml
1358
3
2
1359
4
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
1360
5
4
1361
@@ -13,12 +12,7 @@
1362
13
    @inlineCallbacks
12
    @inlineCallbacks
1363
14
    def setUp(self):
13
    def setUp(self):
1364
15
        yield super(ControlDebugLogTest, self).setUp()
14
        yield super(ControlDebugLogTest, self).setUp()
1371
16
        config = {
15
        yield self.push_default_config()
1366
17
            "environments": {
1367
18
                "firstenv": {
1368
19
                    "type": "dummy", "admin-secret": "homer"}}}
1369
20
        self.write_config(yaml.dump(config))
1370
21
        self.config.load()
1372
22
16
1373
23
    @inlineCallbacks
17
    @inlineCallbacks
1374
24
    def test_replay(self):
18
    def test_replay(self):
1375
25
19
1376
=== modified file 'juju/control/tests/test_deploy.py'
1377
--- juju/control/tests/test_deploy.py	2012-03-09 20:13:36 +0000
1378
+++ juju/control/tests/test_deploy.py	2012-03-30 16:56:32 +0000
1379
@@ -32,7 +32,6 @@
1380
32
    @inlineCallbacks
32
    @inlineCallbacks
1381
33
    def setUp(self):
33
    def setUp(self):
1382
34
        yield super(ControlDeployTest, self).setUp()
34
        yield super(ControlDeployTest, self).setUp()
1383
35
1384
36
        config = {
35
        config = {
1385
37
            "environments": {
36
            "environments": {
1386
38
                "firstenv": {
37
                "firstenv": {
1387
@@ -40,8 +39,7 @@
1388
40
                    "admin-secret": "homer",
39
                    "admin-secret": "homer",
1389
41
                    "placement": "unassigned",
40
                    "placement": "unassigned",
1390
42
                    "default-series": "series"}}}
41
                    "default-series": "series"}}}
1393
43
        self.write_config(yaml.dump(config))
42
        yield self.push_config("firstenv", config)
1392
44
        self.config.load()
1394
45
43
1395
46
    def test_deploy_multiple_environments_none_specified(self):
44
    def test_deploy_multiple_environments_none_specified(self):
1396
47
        """
45
        """
1397
@@ -228,7 +226,7 @@
1398
228
        self.assertEquals(charm_id, "local:series/sample-2")
226
        self.assertEquals(charm_id, "local:series/sample-2")
1399
229
        constraints = yield service_state.get_constraints()
227
        constraints = yield service_state.get_constraints()
1400
230
        expect_constraints = {
228
        expect_constraints = {
1402
231
            "arch": None, "cpu": 123, "mem": 512,
229
            "arch": "amd64", "cpu": 123, "mem": 512,
1403
232
            "provider-type": "dummy", "ubuntu-series": "series"}
230
            "provider-type": "dummy", "ubuntu-series": "series"}
1404
233
        self.assertEquals(constraints, expect_constraints)
231
        self.assertEquals(constraints, expect_constraints)
1405
234
232
1406
@@ -490,9 +488,7 @@
1407
490
                    "placement": "local",
488
                    "placement": "local",
1408
491
                    "type": "dummy",
489
                    "type": "dummy",
1409
492
                    "default-series": "series"}}}
490
                    "default-series": "series"}}}
1413
493
491
        yield self.push_config("firstenv", config)
1411
494
        self.write_config(yaml.dump(config))
1412
495
        self.config.load()
1414
496
492
1415
497
        finished = self.setup_cli_reactor()
493
        finished = self.setup_cli_reactor()
1416
498
        self.setup_exit(0)
494
        self.setup_exit(0)
1417
@@ -508,3 +504,66 @@
1418
508
        unit = units[0]
504
        unit = units[0]
1419
509
        machine_id = yield unit.get_assigned_machine_id()
505
        machine_id = yield unit.get_assigned_machine_id()
1420
510
        self.assertEqual(machine_id, 0)
506
        self.assertEqual(machine_id, 0)
1421
507
1422
508
    @inlineCallbacks
1423
509
    def test_deploy_legacy_keys_in_legacy_env(self):
1424
510
        yield self.client.delete("/constraints")
1425
511
1426
512
        finished = self.setup_cli_reactor()
1427
513
        self.setup_exit(0)
1428
514
        self.mocker.replay()
1429
515
1430
516
        main(["deploy", "--repository", self.unbundled_repo_path,
1431
517
              "local:sample", "beekeeper"])
1432
518
        yield finished
1433
519
1434
520
        service_manager = ServiceStateManager(self.client)
1435
521
        yield service_manager.get_service_state("beekeeper")
1436
522
1437
523
    @inlineCallbacks
1438
524
    def test_deploy_legacy_keys_in_fresh_env(self):
1439
525
        yield self.push_default_config()
1440
526
        local_config = {
1441
527
            "environments": {"firstenv": {
1442
528
                    "type": "dummy",
1443
529
                    "some-legacy-key": "blah",
1444
530
                    "default-series": "series"}}}
1445
531
        self.write_config(yaml.dump(local_config))
1446
532
        self.config.load()
1447
533
        finished = self.setup_cli_reactor()
1448
534
        self.setup_exit(0)
1449
535
        self.mocker.replay()
1450
536
        stderr = self.capture_stream("stderr")
1451
537
1452
538
        main(["deploy", "--repository", self.unbundled_repo_path,
1453
539
              "local:sample", "beekeeper"])
1454
540
        yield finished
1455
541
1456
542
        self.assertIn(
1457
543
            "Your environments.yaml contains deprecated keys",
1458
544
            stderr.getvalue())
1459
545
        service_manager = ServiceStateManager(self.client)
1460
546
        yield self.assertFailure(
1461
547
            service_manager.get_service_state("beekeeper"),
1462
548
            ServiceStateNotFound)
1463
549
1464
550
    @inlineCallbacks
1465
551
    def test_deploy_constraints_in_legacy_env(self):
1466
552
        yield self.client.delete("/constraints")
1467
553
1468
554
        finished = self.setup_cli_reactor()
1469
555
        self.setup_exit(0)
1470
556
        self.mocker.replay()
1471
557
        stderr = self.capture_stream("stderr")
1472
558
1473
559
        main(["deploy", "--repository", self.unbundled_repo_path,
1474
560
              "local:sample", "beekeeper", "--constraints", "arch=i386"])
1475
561
        yield finished
1476
562
1477
563
        self.assertIn(
1478
564
            "Constraints are not valid in legacy deployments.",
1479
565
            stderr.getvalue())
1480
566
        service_manager = ServiceStateManager(self.client)
1481
567
        yield self.assertFailure(
1482
568
            service_manager.get_service_state("beekeeper"),
1483
569
            ServiceStateNotFound)
1484
511
570
1485
=== modified file 'juju/control/tests/test_destroy_service.py'
1486
--- juju/control/tests/test_destroy_service.py	2011-09-15 19:24:47 +0000
1487
+++ juju/control/tests/test_destroy_service.py	2012-03-30 16:56:32 +0000
1488
@@ -1,5 +1,4 @@
1489
1
from twisted.internet.defer import inlineCallbacks
1
from twisted.internet.defer import inlineCallbacks
1490
2
from yaml import dump
1491
3
2
1492
4
from juju.control import main
3
from juju.control import main
1493
5
4
1494
@@ -15,11 +14,7 @@
1495
15
    @inlineCallbacks
14
    @inlineCallbacks
1496
16
    def setUp(self):
15
    def setUp(self):
1497
17
        yield super(ControlStopServiceTest, self).setUp()
16
        yield super(ControlStopServiceTest, self).setUp()
1498
18
        config = {
1499
19
            "environments": {"firstenv": {"type": "dummy"}}}
1500
20
17
1501
21
        self.write_config(dump(config))
1502
22
        self.config.load()
1503
23
        self.service_state1 = yield self.add_service_from_charm("mysql")
18
        self.service_state1 = yield self.add_service_from_charm("mysql")
1504
24
        self.service1_unit = yield self.service_state1.add_unit_state()
19
        self.service1_unit = yield self.service_state1.add_unit_state()
1505
25
        self.service_state2 = yield self.add_service_from_charm("wordpress")
20
        self.service_state2 = yield self.add_service_from_charm("wordpress")
1506
26
21
1507
=== modified file 'juju/control/tests/test_initialize.py'
1508
--- juju/control/tests/test_initialize.py	2011-09-23 20:35:02 +0000
1509
+++ juju/control/tests/test_initialize.py	2012-03-30 16:56:32 +0000
1510
@@ -1,3 +1,6 @@
1511
1
from base64 import b64encode
1512
2
from yaml import safe_dump
1513
3
1514
1
from twisted.internet.defer import succeed
4
from twisted.internet.defer import succeed
1515
2
5
1516
3
from txzookeeper import ZookeeperClient
6
from txzookeeper import ZookeeperClient
1517
@@ -26,7 +29,27 @@
1518
26
        self.setup_exit(0)
29
        self.setup_exit(0)
1519
27
        self.mocker.replay()
30
        self.mocker.replay()
1520
28
31
1524
29
        admin(["initialize",
32
        constraints_data = b64encode(safe_dump({
1525
30
               "--instance-id", "foobar",
33
            "ubuntu-series": "foo", "provider-type": "bar"}))
1526
31
               "--admin-identity", "admin:genie",
34
1527
35
        admin(["initialize",
1528
36
               "--instance-id", "foobar",
1529
37
               "--admin-identity", "admin:genie",
1530
38
               "--constraints-data", constraints_data,
1531
39
               "--provider-type", "dummy"])
1532
40
1533
41
    def test_bad_constraints_data(self):
1534
42
        """Test that failing to unpack --constraints-data aborts initialize"""
1535
43
        client = self.mocker.patch(ZookeeperClient)
1536
44
        self.setup_cli_reactor()
1537
45
        client.connect()
1538
46
        self.mocker.result(succeed(client))
1539
47
        self.capture_stream('stderr')
1540
48
        self.setup_exit(1)
1541
49
        self.mocker.replay()
1542
50
1543
51
        admin(["initialize",
1544
52
               "--instance-id", "foobar",
1545
53
               "--admin-identity", "admin:genie",
1546
54
               "--constraints-data", "zaphod's just this guy, you know?",
1547
32
               "--provider-type", "dummy"])
55
               "--provider-type", "dummy"])
1548
33
56
1549
=== modified file 'juju/control/tests/test_remove_unit.py'
1550
--- juju/control/tests/test_remove_unit.py	2012-02-01 11:27:42 +0000
1551
+++ juju/control/tests/test_remove_unit.py	2012-03-30 16:56:32 +0000
1552
@@ -2,7 +2,6 @@
1553
2
import sys
2
import sys
1554
3
3
1555
4
from twisted.internet.defer import inlineCallbacks
4
from twisted.internet.defer import inlineCallbacks
1556
5
from yaml import dump
1557
6
import zookeeper
5
import zookeeper
1558
7
6
1559
8
from .common import ControlToolTest
7
from .common import ControlToolTest
1560
@@ -18,11 +17,6 @@
1561
18
    @inlineCallbacks
17
    @inlineCallbacks
1562
19
    def setUp(self):
18
    def setUp(self):
1563
20
        yield super(ControlRemoveUnitTest, self).setUp()
19
        yield super(ControlRemoveUnitTest, self).setUp()
1564
21
        config = {
1565
22
            "environments": {"firstenv": {"type": "dummy"}}}
1566
23
1567
24
        self.write_config(dump(config))
1568
25
        self.config.load()
1569
26
20
1570
27
        self.environment = self.config.get_default()
21
        self.environment = self.config.get_default()
1571
28
        self.provider = self.environment.get_machine_provider()
22
        self.provider = self.environment.get_machine_provider()
1572
29
23
1573
=== modified file 'juju/control/tests/test_resolved.py'
1574
--- juju/control/tests/test_resolved.py	2012-03-27 22:06:24 +0000
1575
+++ juju/control/tests/test_resolved.py	2012-03-30 16:56:32 +0000
1576
@@ -1,5 +1,4 @@
1577
1
from twisted.internet.defer import inlineCallbacks, returnValue
1
from twisted.internet.defer import inlineCallbacks, returnValue
1578
2
from yaml import dump
1579
3
2
1580
4
from juju.control import main
3
from juju.control import main
1581
5
from juju.control.tests.common import ControlToolTest
4
from juju.control.tests.common import ControlToolTest
1582
@@ -20,11 +19,6 @@
1583
20
    @inlineCallbacks
19
    @inlineCallbacks
1584
21
    def setUp(self):
20
    def setUp(self):
1585
22
        yield super(ControlResolvedTest, self).setUp()
21
        yield super(ControlResolvedTest, self).setUp()
1586
23
        config = {
1587
24
            "environments": {"firstenv": {"type": "dummy"}}}
1588
25
1589
26
        self.write_config(dump(config))
1590
27
        self.config.load()
1591
28
22
1592
29
        yield self.add_relation_state("wordpress", "mysql")
23
        yield self.add_relation_state("wordpress", "mysql")
1593
30
        yield self.add_relation_state("wordpress", "varnish")
24
        yield self.add_relation_state("wordpress", "varnish")
1594
31
25
1595
=== modified file 'juju/control/tests/test_scp.py'
1596
--- juju/control/tests/test_scp.py	2012-02-01 11:27:42 +0000
1597
+++ juju/control/tests/test_scp.py	2012-03-30 16:56:32 +0000
1598
@@ -19,14 +19,7 @@
1599
19
    @inlineCallbacks
19
    @inlineCallbacks
1600
20
    def setUp(self):
20
    def setUp(self):
1601
21
        yield super(SCPTest, self).setUp()
21
        yield super(SCPTest, self).setUp()
1602
22
        config = {
1603
23
            "environments": {
1604
24
                "firstenv": {
1605
25
                    "type": "dummy", "admin-secret": "homer"}}}
1606
26
        self.write_config(dump(config))
1607
27
        self.setup_exit(0)
22
        self.setup_exit(0)
1608
28
1609
29
        self.config.load()
1610
30
        self.environment = self.config.get_default()
23
        self.environment = self.config.get_default()
1611
31
        self.provider = self.environment.get_machine_provider()
24
        self.provider = self.environment.get_machine_provider()
1612
32
25
1613
@@ -53,10 +46,6 @@
1614
53
    @inlineCallbacks
46
    @inlineCallbacks
1615
54
    def test_scp_unit_name(self):
47
    def test_scp_unit_name(self):
1616
55
        """Verify scp command is invoked against the host for a unit name."""
48
        """Verify scp command is invoked against the host for a unit name."""
1617
56
        mock_environment = self.mocker.patch(Environment)
1618
57
        mock_environment.get_machine_provider()
1619
58
        self.mocker.result(self.provider)
1620
59
1621
60
        # Verify expected call against scp
49
        # Verify expected call against scp
1622
61
        mock_exec = self.mocker.replace(os.execvp)
50
        mock_exec = self.mocker.replace(os.execvp)
1623
62
        mock_exec("scp", [
51
        mock_exec("scp", [
1624
@@ -79,6 +68,8 @@
1625
79
    @inlineCallbacks
68
    @inlineCallbacks
1626
80
    def test_scp_machine_id(self):
69
    def test_scp_machine_id(self):
1627
81
        """Verify scp command is invoked against the host for a machine ID."""
70
        """Verify scp command is invoked against the host for a machine ID."""
1628
71
        # We need to do this because separate instances of DummyProvider don't
1629
72
        # share instance state.
1630
82
        mock_environment = self.mocker.patch(Environment)
73
        mock_environment = self.mocker.patch(Environment)
1631
83
        mock_environment.get_machine_provider()
74
        mock_environment.get_machine_provider()
1632
84
        self.mocker.result(self.provider)
75
        self.mocker.result(self.provider)
1633
@@ -111,10 +102,6 @@
1634
111
102
1635
112
          $ juju scp -o "ConnectTimeout 60" foo mysql/0:/foo/bar
103
          $ juju scp -o "ConnectTimeout 60" foo mysql/0:/foo/bar
1636
113
        """
104
        """
1637
114
        mock_environment = self.mocker.patch(Environment)
1638
115
        mock_environment.get_machine_provider()
1639
116
        self.mocker.result(self.provider)
1640
117
1641
118
        # Verify expected call against scp
105
        # Verify expected call against scp
1642
119
        mock_exec = self.mocker.replace(os.execvp)
106
        mock_exec = self.mocker.replace(os.execvp)
1643
120
        mock_exec("scp", [
107
        mock_exec("scp", [
1644
@@ -141,11 +128,6 @@
1645
141
    @inlineCallbacks
128
    @inlineCallbacks
1646
142
    def setUp(self):
129
    def setUp(self):
1647
143
        yield super(ParseErrorsTest, self).setUp()
130
        yield super(ParseErrorsTest, self).setUp()
1648
144
        config = {
1649
145
            "environments": {"firstenv": {"type": "dummy"}}}
1650
146
1651
147
        self.write_config(dump(config))
1652
148
        self.config.load()
1653
149
        self.stderr = self.capture_stream("stderr")
131
        self.stderr = self.capture_stream("stderr")
1654
150
132
1655
151
    def test_passthrough_args_parse_error(self):
133
    def test_passthrough_args_parse_error(self):
1656
152
134
1657
=== modified file 'juju/control/tests/test_ssh.py'
1658
--- juju/control/tests/test_ssh.py	2012-03-23 02:13:50 +0000
1659
+++ juju/control/tests/test_ssh.py	2012-03-30 16:56:32 +0000
1660
@@ -23,14 +23,7 @@
1661
23
    @inlineCallbacks
23
    @inlineCallbacks
1662
24
    def setUp(self):
24
    def setUp(self):
1663
25
        yield super(ControlShellTest, self).setUp()
25
        yield super(ControlShellTest, self).setUp()
1664
26
        config = {
1665
27
            "environments": {
1666
28
                "firstenv": {
1667
29
                    "type": "dummy", "admin-secret": "homer"}}}
1668
30
        self.write_config(dump(config))
1669
31
        self.setup_exit(0)
26
        self.setup_exit(0)
1670
32
1671
33
        self.config.load()
1672
34
        self.environment = self.config.get_default()
27
        self.environment = self.config.get_default()
1673
35
        self.provider = self.environment.get_machine_provider()
28
        self.provider = self.environment.get_machine_provider()
1674
36
29
1675
@@ -346,10 +339,6 @@
1676
346
    def test_shell_with_unassigned_unit(self):
339
    def test_shell_with_unassigned_unit(self):
1677
347
        """If the service unit is not assigned, attempting to
340
        """If the service unit is not assigned, attempting to
1678
348
        connect, raises an error."""
341
        connect, raises an error."""
1679
349
        mock_environment = self.mocker.patch(Environment)
1680
350
        mock_environment.get_machine_provider()
1681
351
        self.mocker.result(self.provider)
1682
352
1683
353
        finished = self.setup_cli_reactor()
342
        finished = self.setup_cli_reactor()
1684
354
        self.mocker.replay()
343
        self.mocker.replay()
1685
355
344
1686
@@ -384,11 +373,6 @@
1687
384
    @inlineCallbacks
373
    @inlineCallbacks
1688
385
    def setUp(self):
374
    def setUp(self):
1689
386
        yield super(ParseErrorsTest, self).setUp()
375
        yield super(ParseErrorsTest, self).setUp()
1690
387
        config = {
1691
388
            "environments": {"firstenv": {"type": "dummy"}}}
1692
389
1693
390
        self.write_config(dump(config))
1694
391
        self.config.load()
1695
392
        self.stderr = self.capture_stream("stderr")
376
        self.stderr = self.capture_stream("stderr")
1696
393
377
1697
394
    def test_passthrough_args_parse_error(self):
378
    def test_passthrough_args_parse_error(self):
1698
395
379
1699
=== modified file 'juju/control/tests/test_status.py'
1700
--- juju/control/tests/test_status.py	2012-03-29 02:50:29 +0000
1701
+++ juju/control/tests/test_status.py	2012-03-30 16:56:32 +0000
1702
@@ -46,14 +46,6 @@
1703
46
        yield settings.set_provider_type("dummy")
46
        yield settings.set_provider_type("dummy")
1704
47
        self.log = self.capture_logging()
47
        self.log = self.capture_logging()
1705
48
48
1706
49
        config = {
1707
50
            "environments": {
1708
51
                "firstenv": {
1709
52
                    "type": "dummy",
1710
53
                    "admin-secret": "homer"}}}
1711
54
        self.write_config(yaml.dump(config))
1712
55
        self.config.load()
1713
56
1714
57
        self.environment = self.config.get_default()
49
        self.environment = self.config.get_default()
1715
58
        self.provider = self.environment.get_machine_provider()
50
        self.provider = self.environment.get_machine_provider()
1716
59
        self.machine_count = 0
51
        self.machine_count = 0
1717
60
52
1718
=== modified file 'juju/control/tests/test_terminate_machine.py'
1719
--- juju/control/tests/test_terminate_machine.py	2012-01-09 16:57:13 +0000
1720
+++ juju/control/tests/test_terminate_machine.py	2012-03-30 16:56:32 +0000
1721
@@ -1,5 +1,4 @@
1722
1
import logging
1
import logging
1723
2
import yaml
1724
3
2
1725
4
from twisted.internet.defer import inlineCallbacks
3
from twisted.internet.defer import inlineCallbacks
1726
5
4
1727
@@ -7,6 +6,7 @@
1728
7
from juju.control.tests.common import MachineControlToolTest
6
from juju.control.tests.common import MachineControlToolTest
1729
8
from juju.errors import CannotTerminateMachine
7
from juju.errors import CannotTerminateMachine
1730
9
from juju.state.errors import MachineStateInUse, MachineStateNotFound
8
from juju.state.errors import MachineStateInUse, MachineStateNotFound
1731
9
from juju.state.environment import EnvironmentStateManager
1732
10
10
1733
11
11
1734
12
class ControlTerminateMachineTest(MachineControlToolTest):
12
class ControlTerminateMachineTest(MachineControlToolTest):
1735
@@ -14,12 +14,6 @@
1736
14
    @inlineCallbacks
14
    @inlineCallbacks
1737
15
    def setUp(self):
15
    def setUp(self):
1738
16
        yield super(ControlTerminateMachineTest, self).setUp()
16
        yield super(ControlTerminateMachineTest, self).setUp()
1739
17
        config = {
1740
18
            "environments": {
1741
19
                "firstenv": {
1742
20
                    "type": "dummy", "admin-secret": "homer"}}}
1743
21
        self.write_config(yaml.dump(config))
1744
22
        self.config.load()
1745
23
        self.output = self.capture_logging()
17
        self.output = self.capture_logging()
1746
24
        self.stderr = self.capture_stream("stderr")
18
        self.stderr = self.capture_stream("stderr")
1747
25
19
1748
@@ -113,8 +107,16 @@
1749
113
        yield wordpress_unit_state.unassign_from_machine()
107
        yield wordpress_unit_state.unassign_from_machine()
1750
114
        yield mysql_unit_state.unassign_from_machine()
108
        yield mysql_unit_state.unassign_from_machine()
1751
115
        yield self.assert_machine_states([0, 1, 2, 3], [])
109
        yield self.assert_machine_states([0, 1, 2, 3], [])
1752
110
1753
111
        # trash environment to check syncing
1754
112
        yield self.client.delete("/environment")
1755
116
        main(["terminate-machine", "1", "3"])
113
        main(["terminate-machine", "1", "3"])
1756
117
        yield wait_on_reactor_stopped
114
        yield wait_on_reactor_stopped
1757
115
1758
116
        # check environment synced
1759
117
        esm = EnvironmentStateManager(self.client)
1760
118
        yield esm.get_config()
1761
119
1762
118
        self.assertIn(
120
        self.assertIn(
1763
119
            "Machines terminated: 1, 3", self.output.getvalue())
121
            "Machines terminated: 1, 3", self.output.getvalue())
1764
120
        yield self.assert_machine_states([0, 2], [1, 3])
122
        yield self.assert_machine_states([0, 2], [1, 3])
1765
121
123
1766
=== modified file 'juju/control/tests/test_upgrade_charm.py'
1767
--- juju/control/tests/test_upgrade_charm.py	2012-03-26 17:22:23 +0000
1768
+++ juju/control/tests/test_upgrade_charm.py	2012-03-30 16:56:32 +0000
1769
@@ -56,11 +56,7 @@
1770
56
    @inlineCallbacks
56
    @inlineCallbacks
1771
57
    def setUp(self):
57
    def setUp(self):
1772
58
        yield super(ControlCharmUpgradeTest, self).setUp()
58
        yield super(ControlCharmUpgradeTest, self).setUp()
1773
59
        config = {
1774
60
            "environments": {"firstenv": {"type": "dummy"}}}
1775
61
59
1776
62
        self.write_config(dump(config))
1777
63
        self.config.load()
1778
64
        self.service_state1 = yield self.add_service_from_charm("mysql")
60
        self.service_state1 = yield self.add_service_from_charm("mysql")
1779
65
        self.service_unit1 = yield self.service_state1.add_unit_state()
61
        self.service_unit1 = yield self.service_state1.add_unit_state()
1780
66
62
1781
@@ -459,12 +455,6 @@
1782
459
    @inlineCallbacks
455
    @inlineCallbacks
1783
460
    def setUp(self):
456
    def setUp(self):
1784
461
        yield super(RemoteUpgradeCharmTest, self).setUp()
457
        yield super(RemoteUpgradeCharmTest, self).setUp()
1785
462
        config = {
1786
463
            "environments": {"firstenv": {"type": "dummy"}}}
1787
464
1788
465
        self.write_config(dump(config))
1789
466
        self.config.load()
1790
467
1791
468
        charm = CharmDirectory(os.path.join(
458
        charm = CharmDirectory(os.path.join(
1792
469
            test_repository_path, "series", "mysql"))
459
            test_repository_path, "series", "mysql"))
1793
470
        self.charm_state_manager.add_charm_state(
460
        self.charm_state_manager.add_charm_state(
1794
471
461
1795
=== modified file 'juju/control/tests/test_utils.py'
1796
--- juju/control/tests/test_utils.py	2012-03-09 13:24:58 +0000
1797
+++ juju/control/tests/test_utils.py	2012-03-30 16:56:32 +0000
1798
@@ -24,12 +24,6 @@
1799
24
    @inlineCallbacks
24
    @inlineCallbacks
1800
25
    def setUp(self):
25
    def setUp(self):
1801
26
        yield super(LookupTest, self).setUp()
26
        yield super(LookupTest, self).setUp()
1802
27
        config = {
1803
28
            "environments": {
1804
29
                "firstenv": {
1805
30
                    "type": "dummy", "admin-secret": "homer"}}}
1806
31
        self.write_config(dump(config))
1807
32
        self.config.load()
1808
33
        self.environment = self.config.get_default()
27
        self.environment = self.config.get_default()
1809
34
        self.provider = self.environment.get_machine_provider()
28
        self.provider = self.environment.get_machine_provider()
1810
35
29
1811
36
30
1812
=== modified file 'juju/control/utils.py'
1813
--- juju/control/utils.py	2012-02-15 23:32:23 +0000
1814
+++ juju/control/utils.py	2012-03-30 16:56:32 +0000
1815
@@ -5,6 +5,7 @@
1816
5
5
1817
6
from juju.environment.errors import EnvironmentsConfigError
6
from juju.environment.errors import EnvironmentsConfigError
1818
7
from juju.state.errors import ServiceUnitStateMachineNotAssigned
7
from juju.state.errors import ServiceUnitStateMachineNotAssigned
1819
8
from juju.state.environment import EnvironmentStateManager
1820
8
from juju.state.machine import MachineStateManager
9
from juju.state.machine import MachineStateManager
1821
9
from juju.state.service import ServiceStateManager
10
from juju.state.service import ServiceStateManager
1822
10
11
1823
@@ -20,6 +21,26 @@
1824
20
    return environment
21
    return environment
1825
21
22
1826
22
23
1827
24
def sync_environment_state(client, config, name):
1828
25
    """Push the local environment config to zookeeper.
1829
26
1830
27
    This needs to be done:
1831
28
1832
29
      * On any command which can cause the provisioning agent to take action
1833
30
        against the provider (ie create/destroy a machine), because the PA
1834
31
        needs to use credentials stored in the environment config to do so.
1835
32
      * On any command which uses constraints-related code (even if indirectly)
1836
33
        because Constraints objects are provider-specific, and need to be
1837
34
        created with the help of a MachineProvider; and the only way state code
1838
35
        can get a MachineProvider is by getting one from ZK (we certainly don't
1839
36
        want to thread the relevant provider from juju.control and/or the PA
1840
37
        itself all the way through the state code). So, we sync, to ensure
1841
38
        that state code can use an EnvironmentStateManager to get a provider.
1842
39
    """
1843
40
    esm = EnvironmentStateManager(client)
1844
41
    return esm.set_config_state(config, name)
1845
42
1846
43
1847
23
@inlineCallbacks
44
@inlineCallbacks
1848
24
def get_ip_address_for_machine(client, provider, machine_id):
45
def get_ip_address_for_machine(client, provider, machine_id):
1849
25
    """Returns public DNS name and machine state for the machine id.
46
    """Returns public DNS name and machine state for the machine id.
1850
@@ -59,6 +80,12 @@
1851
59
    return os.path.abspath(os.path.expanduser(p))
80
    return os.path.abspath(os.path.expanduser(p))
1852
60
81
1853
61
82
1854
83
def expand_constraints(s):
1855
84
    if s:
1856
85
        return s.split(" ")
1857
86
    return []
1858
87
1859
88
1860
62
class ParseError(Exception):
89
class ParseError(Exception):
1861
63
    """Used to support returning custom parse errors in passthrough parsing.
90
    """Used to support returning custom parse errors in passthrough parsing.
1862
64
91
1863
65
92
1864
=== modified file 'juju/environment/config.py'
1865
--- juju/environment/config.py	2012-02-29 20:38:01 +0000
1866
+++ juju/environment/config.py	2012-03-30 16:56:32 +0000
1867
@@ -4,20 +4,10 @@
1868
4
4
1869
5
from juju.environment.environment import Environment
5
from juju.environment.environment import Environment
1870
6
from juju.environment.errors import EnvironmentsConfigError
6
from juju.environment.errors import EnvironmentsConfigError
1875
7
from juju.errors import (
7
from juju.errors import FileAlreadyExists, FileNotFound
1872
8
    FileAlreadyExists,
1873
9
    FileNotFound,
1874
10
    )
1876
11
from juju.lib.schema import (
8
from juju.lib.schema import (
1886
12
    Constant,
9
    Constant, Dict, KeyDict, OAuthString, OneOf, SchemaError, SelectDict,
1887
13
    Dict,
10
    String)
1879
14
    KeyDict,
1880
15
    OAuthString,
1881
16
    OneOf,
1882
17
    SchemaError,
1883
18
    SelectDict,
1884
19
    String,
1885
20
    )
1888
21
11
1889
22
12
1890
23
DEFAULT_CONFIG_PATH = "~/.juju/environments.yaml"
13
DEFAULT_CONFIG_PATH = "~/.juju/environments.yaml"
1891
@@ -31,56 +21,60 @@
1892
31
    default-series: oneiric
21
    default-series: oneiric
1893
32
"""
22
"""
1894
33
23
1895
24
_EITHER_PLACEMENT = OneOf(Constant("unassigned"), Constant("local"))
1896
34
25
1897
35
SCHEMA = KeyDict({
26
SCHEMA = KeyDict({
1898
36
    "default": String(),
27
    "default": String(),
1899
37
    "environments": Dict(String(), SelectDict("type", {
28
    "environments": Dict(String(), SelectDict("type", {
1936
38
        "ec2": KeyDict({"control-bucket": String(),
29
        "ec2": KeyDict({
1937
39
                        "admin-secret": String(),
30
            "control-bucket": String(),
1938
40
                        "access-key": String(),
31
            "admin-secret": String(),
1939
41
                        "secret-key": String(),
32
            "access-key": String(),
1940
42
                        "region": OneOf(
33
            "secret-key": String(),
1941
43
                            Constant("us-east-1"),
34
            "region": OneOf(
1942
44
                            Constant("us-west-1"),
35
                Constant("us-east-1"),
1943
45
                            Constant("us-west-2"),
36
                Constant("us-west-1"),
1944
46
                            Constant("eu-west-1"),
37
                Constant("us-west-2"),
1945
47
                            Constant("sa-east-1"),
38
                Constant("eu-west-1"),
1946
48
                            Constant("ap-northeast-1"),
39
                Constant("sa-east-1"),
1947
49
                            Constant("ap-southeast-1")),
40
                Constant("ap-northeast-1"),
1948
50
                        "default-instance-type": String(),
41
                Constant("ap-southeast-1")),
1949
51
                        "default-ami": String(),
42
            "ec2-uri": String(),
1950
52
                        "ec2-uri": String(),
43
            "s3-uri": String(),
1951
53
                        "s3-uri": String(),
44
            "placement": _EITHER_PLACEMENT,
1952
54
                        "placement": OneOf(
45
            "default-series": String()},
1953
55
                                Constant("unassigned"),
46
            optional=[
1954
56
                                Constant("local")),
47
                "access-key", "secret-key", "region", "ec2-uri", "s3-uri",
1955
57
                        "default-series": String()},
48
                "placement"]),
1956
58
                       optional=["access-key", "secret-key",
49
        "orchestra": KeyDict({
1957
59
                                 "default-instance-type", "default-ami",
50
            "orchestra-server": String(),
1958
60
                                 "region", "ec2-uri", "s3-uri", "placement"]),
51
            "orchestra-user": String(),
1959
61
        "orchestra": KeyDict({"orchestra-server": String(),
52
            "orchestra-pass": String(),
1960
62
                              "orchestra-user": String(),
53
            "admin-secret": String(),
1961
63
                              "orchestra-pass": String(),
54
            "acquired-mgmt-class": String(),
1962
64
                              "admin-secret": String(),
55
            "available-mgmt-class": String(),
1963
65
                              "acquired-mgmt-class": String(),
56
            "storage-url": String(),
1964
66
                              "available-mgmt-class": String(),
57
            "storage-user": String(),
1965
67
                              "storage-url": String(),
58
            "storage-pass": String(),
1966
68
                              "storage-user": String(),
59
            "placement": _EITHER_PLACEMENT,
1967
69
                              "storage-pass": String(),
60
            "default-series": String()},
1968
70
                              "placement": String(),
61
            optional=[
1969
71
                              "default-series": String()},
62
                "storage-url", "storage-user", "storage-pass", "placement"]),
1934
72
                             optional=["storage-url", "storage-user",
1935
73
                                       "storage-pass", "placement"]),
1970
74
        "maas": KeyDict({
63
        "maas": KeyDict({
1971
75
            "maas-server": String(),
64
            "maas-server": String(),
1972
76
            "maas-oauth": OAuthString(),
65
            "maas-oauth": OAuthString(),
1973
77
            "admin-secret": String(),
66
            "admin-secret": String(),
1980
78
            }),
67
            "placement": _EITHER_PLACEMENT,
1981
79
        "local": KeyDict({"admin-secret": String(),
68
            # MAAS currently only provisions precise; any other default-series
1982
80
                        "data-dir": String(),
69
            # would just lead to errors down the line.
1983
81
                        "placement": Constant("local"),
70
            "default-series": Constant("precise")},
1984
82
                        "default-series": String()},
71
            optional=["placement"]),
1985
83
                       optional=["placement"]),
72
        "local": KeyDict({
1986
73
            "admin-secret": String(),
1987
74
            "data-dir": String(),
1988
75
            "placement": Constant("local"),
1989
76
            "default-series": String()},
1990
77
            optional=["placement"]),
1991
84
        "dummy": KeyDict({})}))},
78
        "dummy": KeyDict({})}))},
1992
85
    optional=["default"])
79
    optional=["default"])
1993
86
80
1994
87
81
1995
=== modified file 'juju/environment/tests/test_config.py'
1996
--- juju/environment/tests/test_config.py	2011-10-06 22:24:21 +0000
1997
+++ juju/environment/tests/test_config.py	2012-03-30 16:56:32 +0000
1998
@@ -8,6 +8,7 @@
1999
8
from juju.environment.environment import Environment
8
from juju.environment.environment import Environment
2000
9
from juju.environment.errors import EnvironmentsConfigError
9
from juju.environment.errors import EnvironmentsConfigError
2001
10
from juju.errors import FileNotFound, FileAlreadyExists
10
from juju.errors import FileNotFound, FileAlreadyExists
2002
11
from juju.state.environment import EnvironmentStateManager
2003
11
12
2004
12
from juju.lib.testing import TestCase
13
from juju.lib.testing import TestCase
2005
13
14
2006
@@ -38,6 +39,16 @@
2007
38
    default-series: oneiric
39
    default-series: oneiric
2008
39
"""
40
"""
2009
40
41
2010
42
SAMPLE_MAAS = """
2011
43
environments:
2012
44
  sample:
2013
45
    type: maas
2014
46
    maas-server: somewhe.re
2015
47
    maas-oauth: foo:bar:baz
2016
48
    admin-secret: garden
2017
49
    default-series: precise
2018
50
"""
2019
51
2020
41
SAMPLE_LOCAL = """
52
SAMPLE_LOCAL = """
2021
42
ensemble: environments
53
ensemble: environments
2022
43
54
2023
@@ -58,7 +69,7 @@
2024
58
        self.patch(environment, "LSB_RELEASE_PATH", release_path)
69
        self.patch(environment, "LSB_RELEASE_PATH", release_path)
2025
59
        self.old_home = os.environ.get("HOME")
70
        self.old_home = os.environ.get("HOME")
2026
60
        self.tmp_home = self.makeDir()
71
        self.tmp_home = self.makeDir()
2028
61
        self.change_environment(HOME=self.tmp_home)
72
        self.change_environment(HOME=self.tmp_home, PATH=os.environ["PATH"])
2029
62
        self.default_path = os.path.join(self.tmp_home,
73
        self.default_path = os.path.join(self.tmp_home,
2030
63
                                         ".juju/environments.yaml")
74
                                         ".juju/environments.yaml")
2031
64
        self.other_path = os.path.join(self.tmp_home,
75
        self.other_path = os.path.join(self.tmp_home,
2032
@@ -76,6 +87,30 @@
2033
76
        with open(path, "w") as file:
87
        with open(path, "w") as file:
2034
77
            file.write(config_text)
88
            file.write(config_text)
2035
78
89
2036
90
    # The following methods expect to be called *after* a subclass has set
2037
91
    # self.client.
2038
92
2039
93
    def push_config(self, name, config):
2040
94
        self.write_config(yaml.dump(config))
2041
95
        self.config.load()
2042
96
        esm = EnvironmentStateManager(self.client)
2043
97
        return esm.set_config_state(self.config, name)
2044
98
2045
99
    @inlineCallbacks
2046
100
    def push_env_constraints(self, *constraint_strs):
2047
101
        esm = EnvironmentStateManager(self.client)
2048
102
        constraint_set = yield esm.get_constraint_set()
2049
103
        yield esm.set_constraints(constraint_set.parse(constraint_strs))
2050
104
2051
105
    @inlineCallbacks
2052
106
    def push_default_config(self, with_constraints=True):
2053
107
        config = {
2054
108
            "environments": {"firstenv": {
2055
109
                "type": "dummy", "storage-directory": self.makeDir()}}}
2056
110
        yield self.push_config("firstenv", config)
2057
111
        if with_constraints:
2058
112
            yield self.push_env_constraints()
2059
113
2060
79
114
2061
80
class EnvironmentsConfigTest(EnvironmentsConfigTestBase):
115
class EnvironmentsConfigTest(EnvironmentsConfigTestBase):
2062
81
116
2063
@@ -540,6 +575,9 @@
2064
540
    def test_ec2_sample_config_without_admin_secret(self):
575
    def test_ec2_sample_config_without_admin_secret(self):
2065
541
        self.assert_ec2_sample_config("admin-secret")
576
        self.assert_ec2_sample_config("admin-secret")
2066
542
577
2067
578
    def test_ec2_sample_config_without_default_series(self):
2068
579
        self.assert_ec2_sample_config("default-series")
2069
580
2070
543
    def test_ec2_sample_config_without_control_buckets(self):
581
    def test_ec2_sample_config_without_control_buckets(self):
2071
544
        self.assert_ec2_sample_config("control-bucket")
582
        self.assert_ec2_sample_config("control-bucket")
2072
545
583
2073
@@ -603,7 +641,6 @@
2074
603
641
2075
604
    def test_orchestra_respects_default_series(self):
642
    def test_orchestra_respects_default_series(self):
2076
605
        config = yaml.load(SAMPLE_ORCHESTRA)
643
        config = yaml.load(SAMPLE_ORCHESTRA)
2077
606
2078
607
        config["environments"]["sample"]["default-series"] = "magnificent"
644
        config["environments"]["sample"]["default-series"] = "magnificent"
2079
608
        self.write_config(yaml.dump(config), other_path=True)
645
        self.write_config(yaml.dump(config), other_path=True)
2080
609
        self.config.load(self.other_path)
646
        self.config.load(self.other_path)
2081
@@ -613,6 +650,58 @@
2082
613
650
2083
614
    def test_orchestra_verifies_placement(self):
651
    def test_orchestra_verifies_placement(self):
2084
615
        config = yaml.load(SAMPLE_ORCHESTRA)
652
        config = yaml.load(SAMPLE_ORCHESTRA)
2085
653
        config["environments"]["sample"]["placement"] = "random"
2086
654
        self.write_config(yaml.dump(config), other_path=True)
2087
655
        e = self.assertRaises(
2088
656
            EnvironmentsConfigError, self.config.load, self.other_path)
2089
657
        self.assertIn("expected 'unassigned', got 'random'",
2090
658
                       str(e))
2091
659
2092
660
        config["environments"]["sample"]["placement"] = "local"
2093
661
        self.write_config(yaml.dump(config), other_path=True)
2094
662
        self.config.load(self.other_path)
2095
663
2096
664
        data = self.config.get_default().placement
2097
665
        self.assertEqual(data, "local")
2098
666
2099
667
    def test_maas_schema_requires(self):
2100
668
        requires = "maas-server maas-oauth admin-secret default-series".split()
2101
669
        for require in requires:
2102
670
            config = yaml.load(SAMPLE_MAAS)
2103
671
            del config["environments"]["sample"][require]
2104
672
            self.write_config(yaml.dump(config), other_path=True)
2105
673
2106
674
            try:
2107
675
                self.config.load(self.other_path)
2108
676
            except EnvironmentsConfigError as error:
2109
677
                self.assertEquals(str(error),
2110
678
                                  "Environments configuration error: %s: "
2111
679
                                  "environments.sample.%s: "
2112
680
                                  "required value not found"
2113
681
                                  % (self.other_path, require))
2114
682
            else:
2115
683
                self.fail("Did not properly require %s when type == maas"
2116
684
                          % require)
2117
685
2118
686
    def test_maas_default_series(self):
2119
687
        config = yaml.load(SAMPLE_MAAS)
2120
688
        config["environments"]["sample"]["default-series"] = "magnificent"
2121
689
        self.write_config(yaml.dump(config), other_path=True)
2122
690
        e = self.assertRaises(
2123
691
            EnvironmentsConfigError, self.config.load, self.other_path)
2124
692
        self.assertIn(
2125
693
            "environments.sample.default-series: expected 'precise', got "
2126
694
            "'magnificent'",
2127
695
            str(e))
2128
696
2129
697
    def test_maas_verifies_placement(self):
2130
698
        config = yaml.load(SAMPLE_MAAS)
2131
699
        config["environments"]["sample"]["placement"] = "random"
2132
700
        self.write_config(yaml.dump(config), other_path=True)
2133
701
        e = self.assertRaises(
2134
702
            EnvironmentsConfigError, self.config.load, self.other_path)
2135
703
        self.assertIn("expected 'unassigned', got 'random'",
2136
704
                       str(e))
2137
616
705
2138
617
        config["environments"]["sample"]["placement"] = "local"
706
        config["environments"]["sample"]["placement"] = "local"
2139
618
        self.write_config(yaml.dump(config), other_path=True)
707
        self.write_config(yaml.dump(config), other_path=True)
2140
@@ -623,25 +712,17 @@
2141
623
712
2142
624
    def test_lxc_requires_data_dir(self):
713
    def test_lxc_requires_data_dir(self):
2143
625
        """lxc dev only supports local placement."""
714
        """lxc dev only supports local placement."""
2144
626
        self.config.write_sample()
2145
627
        config = yaml.load(SAMPLE_LOCAL)
715
        config = yaml.load(SAMPLE_LOCAL)
2146
628
2147
629
        self.write_config(yaml.dump(config), other_path=True)
716
        self.write_config(yaml.dump(config), other_path=True)
2148
630
        error = self.assertRaises(
717
        error = self.assertRaises(
2152
631
            EnvironmentsConfigError,
718
            EnvironmentsConfigError, self.config.load, self.other_path)
2150
632
            self.config.load,
2151
633
            self.other_path)
2153
634
        self.assertIn("data-dir: required value not found", str(error))
719
        self.assertIn("data-dir: required value not found", str(error))
2154
635
720
2155
636
    def test_lxc_verifies_placement(self):
721
    def test_lxc_verifies_placement(self):
2156
637
        """lxc dev only supports local placement."""
722
        """lxc dev only supports local placement."""
2157
638
        self.config.write_sample()
2158
639
        config = yaml.load(SAMPLE_LOCAL)
723
        config = yaml.load(SAMPLE_LOCAL)
2159
640
2160
641
        config["environments"]["sample"]["placement"] = "unassigned"
724
        config["environments"]["sample"]["placement"] = "unassigned"
2161
642
        self.write_config(yaml.dump(config), other_path=True)
725
        self.write_config(yaml.dump(config), other_path=True)
2162
643
        error = self.assertRaises(
726
        error = self.assertRaises(
2166
644
            EnvironmentsConfigError,
727
            EnvironmentsConfigError, self.config.load, self.other_path)
2164
645
            self.config.load,
2165
646
            self.other_path)
2167
647
        self.assertIn("expected 'local', got 'unassigned'", str(error))
728
        self.assertIn("expected 'local', got 'unassigned'", str(error))
2168
648
729
2169
=== modified file 'juju/hooks/tests/test_invoker.py'
2170
--- juju/hooks/tests/test_invoker.py	2012-03-29 02:50:29 +0000
2171
+++ juju/hooks/tests/test_invoker.py	2012-03-30 16:56:32 +0000
2172
@@ -12,12 +12,12 @@
2173
12
import juju
12
import juju
2174
13
from juju import errors
13
from juju import errors
2175
14
from juju.control.tests.test_status import StatusTestBase
14
from juju.control.tests.test_status import StatusTestBase
2176
15
from juju.environment.tests.test_config import EnvironmentsConfigTestBase
2177
15
from juju.lib.pick import pick_attr
16
from juju.lib.pick import pick_attr
2178
16
from juju.hooks import invoker
17
from juju.hooks import invoker
2179
17
from juju.hooks import commands
18
from juju.hooks import commands
2180
18
from juju.hooks.protocol import UnitSettingsFactory
19
from juju.hooks.protocol import UnitSettingsFactory
2181
19
from juju.lib.mocker import MATCH
20
from juju.lib.mocker import MATCH
2182
20
from juju.lib.testing import TestCase
2183
21
from juju.lib.twistutils import get_module_directory
21
from juju.lib.twistutils import get_module_directory
2184
22
from juju.state import hook
22
from juju.state import hook
2185
23
from juju.state.endpoint import RelationEndpoint
23
from juju.state.endpoint import RelationEndpoint
2186
@@ -132,7 +132,12 @@
2187
132
    return ":".join(search_path)
132
    return ":".join(search_path)
2188
133
133
2189
134
134
2191
135
class InvokerTestBase(TestCase):
135
class InvokerTestBase(EnvironmentsConfigTestBase):
2192
136
2193
137
    @defer.inlineCallbacks
2194
138
    def setUp(self):
2195
139
        yield super(InvokerTestBase, self).setUp()
2196
140
        yield self.push_default_config()
2197
136
141
2198
137
    def update_invoker_env(self, local_unit, remote_unit):
142
    def update_invoker_env(self, local_unit, remote_unit):
2199
138
        """Update os.env for a hook invocation.
143
        """Update os.env for a hook invocation.
2200
139
144
2201
=== modified file 'juju/machine/constraints.py'
2202
--- juju/machine/constraints.py	2012-03-09 13:24:58 +0000
2203
+++ juju/machine/constraints.py	2012-03-30 16:56:32 +0000
2204
@@ -1,64 +1,197 @@
2205
1
import logging
2206
1
import operator
2
import operator
2207
2
from string import ascii_lowercase
2208
3
from UserDict import DictMixin
3
from UserDict import DictMixin
2209
4
4
2210
5
from juju.errors import ConstraintError, UnknownConstraintError
5
from juju.errors import ConstraintError, UnknownConstraintError
2211
6
6
2230
7
7
log = logging.getLogger("juju.machine.constraints")
2231
8
class Constraints(object, DictMixin):
8
2232
9
    """A Constraints object encapsulates a set of machine constraints.
9
# To allow providers to construct ConstraintSets which silently ignore known-
2233
10
10
# but-inapplicable constraints (ec2-zone on orchestra, for example), we keep
2234
11
    Constraints objects are expected to be initially constructed using the
11
# a hardcoded global registry here. It will not be hard to remember to update
2235
12
    `from_strs` method to parse user input; they can subsequently be serialised
12
# this when working with providers, because _ConstraintTypes with unknown
2236
13
    as a `data` dict and reconstructed directly from same.
13
# names cannot be created and will cause test failures so long as the added
2237
14
14
# constraint registration code is exercised in the provider tests.
2238
15
    They also implement a dict interface, which exposes all constraints for
15
ALL_NAMES = (
2239
16
    the appropriate provider, and is the expected mode of usage for clients
16
    "ubuntu-series", "provider-type",
2240
17
    not concerned with the construction or comparison of Constraints objects.
17
    "arch", "cpu", "mem", "instance-type",
2241
18
18
    "ec2-zone",
2242
19
    A Constraints object only ever contains a single "layer" of data, but can
19
    "maas-name",
2243
20
    be combined with other Constraints objects in such a way as to produce a
20
    "orchestra-classes",
2244
21
    single object following the rules laid down in internals/placement-spec.
21
)
2245
22
22
2246
23
    Constraints objects can be compared, in a limited sense, by using the
23
2247
24
    `can_satisfy` method.
24
def _dont_convert(s):
2248
25
    return s
2249
26
2250
27
2251
28
class _ConstraintType(object):
2252
29
    """Defines a constraint.
2253
30
2254
31
    :param str name: The constraint's name
2255
32
    :param default: The default value as a str, or None to indicate "unset"
2256
33
    :param converter: Function to convert str value to "real" value (and
2257
34
        thereby implicitly validate it; should raise ValueError)
2258
35
    :param comparer: Function used to determine whether one constraint
2259
36
        satisfies another
2260
37
    :param bool visible: If False, indicates a computed constraint which
2261
38
        should not be settable by a user.
2262
39
2263
40
    Merely creating a Constraint does not activate it; you also need to
2264
41
    register it with a specific ConstraintSet.
2265
25
    """
42
    """
2266
26
43
2281
27
    def __init__(self, data):
44
    def __init__(self, name, default, converter, comparer, visible):
2282
28
        # To avoid inconsistency, all Constraints objects must be constructed
45
        assert name in ALL_NAMES, "please update ALL_NAMES"
2283
29
        # with the same set of _Constraint~s (and conflicts) in play.
46
        self.name = name
2284
30
        _Constraint.freeze()
47
        self.default = default
2285
31
        assert data.get("provider-type"), "missing provider-type"
48
        self._converter = converter
2286
32
        for k, v in data.items():
49
        self._comparer = comparer
2287
33
            _Constraint.get(k).convert(v)
50
        self.visible = visible
2288
34
        self._data = data
51
2289
35
52
    def convert(self, s):
2290
36
    @classmethod
53
        """Convert a string representation of a constraint into a useful form.
2291
37
    def from_strs(cls, provider, strs):
54
        """
2292
38
        """Create from strings (as used on the command line)"""
55
        if s is None:
2293
39
        data = {"provider-type": provider}
56
            return
2294
40
        relevant_names = _Constraint.names(provider)
57
        try:
2295
58
            return self._converter(s)
2296
59
        except ValueError as e:
2297
60
            raise ConstraintError(
2298
61
                "Bad %r constraint %r: %s" % (self.name, s, e))
2299
62
2300
63
    def can_satisfy(self, candidate, benchmark):
2301
64
        """Check whether candidate can satisfy benchmark"""
2302
65
        return self._comparer(candidate, benchmark)
2303
66
2304
67
2305
68
class ConstraintSet(object):
2306
69
    """A ConstraintSet represents all constraints applicable to a provider.
2307
70
2308
71
    Individual providers can construct ConstraintSets which will be used to
2309
72
    construct Constraints objects directly relevant to that provider."""
2310
73
2311
74
    def __init__(self, provider_type):
2312
75
        self._provider_type = provider_type
2313
76
        self._registry = {}
2314
77
        self._conflicts = {}
2315
78
2316
79
        # These constraints must always be available (but are not user-visible
2317
80
        # or -settable).
2318
81
        self.register("ubuntu-series", visible=False)
2319
82
        self.register("provider-type", visible=False)
2320
83
2321
84
    def register(self, name, default=None, converter=_dont_convert,
2322
85
                 comparer=operator.eq, visible=True):
2323
86
        """Register a constraint to be handled by this ConstraintSet.
2324
87
2325
88
        :param str name: The constraint's name
2326
89
        :param default: The default value as a str, or None to indicate "unset"
2327
90
        :param converter: Function to convert str value to "real" value (and
2328
91
            thereby implicitly validate it; should raise ValueError)
2329
92
        :param comparer: Function used to determine whether one constraint
2330
93
            satisfies another
2331
94
        :param bool visible: If False, indicates a computed constraint which
2332
95
            should not be settable by a user.
2333
96
        """
2334
97
        self._registry[name] = _ConstraintType(
2335
98
            name, default, converter, comparer, visible)
2336
99
        self._conflicts[name] = set()
2337
100
2338
101
    def register_conflicts(self, reds, blues):
2339
102
        """Set cross-constraint override behaviour.
2340
103
2341
104
        :param reds: list of constraint names which affect all constraints
2342
105
            specified in `blues`
2343
106
        :param blues: list of constraint names which affect all constraints
2344
107
            specified in `reds`
2345
108
2346
109
        When two constraints conflict:
2347
110
2348
111
        * It is an error to set both constraints in the same Constraints.
2349
112
        * When a Constraints overrides another which specifies a conflicting
2350
113
          constraint, the value in the overridden Constraints is cleared.
2351
114
        """
2352
115
        for red in reds:
2353
116
            self._conflicts[red].update(blues)
2354
117
        for blue in blues:
2355
118
            self._conflicts[blue].update(reds)
2356
119
2357
120
    def register_generics(self, instance_type_names):
2358
121
        """Register a common set of constraints.
2359
122
2360
123
        This always includes arch, cpu, and mem; and will include instance-type
2361
124
        if instance_type_names is not empty. This is because we believe
2362
125
        instance-type to be a broadly applicable concept, even though the only
2363
126
        provider that registers names here (and hence accepts the constraint)
2364
127
        is currently EC2.
2365
128
        """
2366
129
        self.register("arch", default="amd64", converter=_convert_arch)
2367
130
        self.register(
2368
131
            "cpu", default="1", converter=_convert_cpu, comparer=operator.ge)
2369
132
        self.register(
2370
133
            "mem", default="512M", converter=_convert_mem,
2371
134
            comparer=operator.ge)
2372
135
2373
136
        if instance_type_names:
2374
137
2375
138
            def convert(instance_type_name):
2376
139
                if instance_type_name in instance_type_names:
2377
140
                    return instance_type_name
2378
141
                raise ValueError("unknown instance type")
2379
142
2380
143
            self.register("instance-type", converter=convert)
2381
144
            self.register_conflicts(["cpu", "mem"], ["instance-type"])
2382
145
2383
146
    def names(self):
2384
147
        """Get the names of all registered constraints."""
2385
148
        return self._registry.keys()
2386
149
2387
150
    def get(self, name):
2388
151
        """Get the (internal) _ConstraintType object corresponding to `name`.
2389
152
2390
153
        If `name` is known, but not registered in this ConstraintSet, None will
2391
154
        be returned; if the constraint name is entirely unknown, an
2392
155
        UnknownConstraintError will be raised.
2393
156
        """
2394
157
        try:
2395
158
            return self._registry[name]
2396
159
        except KeyError:
2397
160
            if name not in ALL_NAMES:
2398
161
                raise UnknownConstraintError(name)
2399
162
2400
163
    def parse(self, strs):
2401
164
        """Create a Constraints from strings (as used on the command line)"""
2402
165
        data = {"provider-type": self._provider_type}
2403
41
        for s in strs:
166
        for s in strs:
2404
42
            try:
167
            try:
2405
43
                name, value = s.split("=", 1)
168
                name, value = s.split("=", 1)
2409
44
                constraint = _Constraint.get(name)
169
                constraint = self.get(name)
2410
45
            except KeyError:
170
                if constraint is None:
2411
46
                raise UnknownConstraintError(name)
171
                    # A constraint called name does exist for some provider (if
2412
172
                    # it didn't exist anywhere, .get would have raised) but is
2413
173
                    # not relevant for this provider.
2414
174
                    log.warn(
2415
175
                        "ignored irrelevant %r constraint", name)
2416
176
                    continue
2417
177
                if value == "any":
2418
178
                    value = None
2419
179
                if value == "":
2420
180
                    value = constraint.default
2421
181
                constraint.convert(value)
2422
47
            except ValueError as e:
182
            except ValueError as e:
2423
48
                raise ConstraintError(
183
                raise ConstraintError(
2424
49
                    "Could not interpret %r constraint: %s" % (s, e))
184
                    "Could not interpret %r constraint: %s" % (s, e))
2425
50
            if name not in relevant_names:
2426
51
                continue
2427
52
            if not constraint.visible:
185
            if not constraint.visible:
2428
53
                raise ConstraintError(
186
                raise ConstraintError(
2429
54
                    "Cannot set computed constraint: %r" % name)
187
                    "Cannot set computed constraint: %r" % name)
2431
55
            data[name] = value or constraint.default
188
            data[name] = value
2432
56
189
2433
57
        conflicts = set()
190
        conflicts = set()
2434
58
        for name in sorted(data):
191
        for name in sorted(data):
2438
59
            for conflict in sorted(_Constraint.get(name).conflicts):
192
            if data[name] is None:
2439
60
                if conflict not in relevant_names:
193
                continue
2440
61
                    continue
194
            for conflict in sorted(self._conflicts[name]):
2441
62
                if conflict in data:
195
                if conflict in data:
2442
63
                    raise ConstraintError(
196
                    raise ConstraintError(
2443
64
                        "Ambiguous constraints: %r overlaps with %r"
197
                        "Ambiguous constraints: %r overlaps with %r"
2444
@@ -66,13 +199,54 @@
2445
66
                conflicts.add(conflict)
199
                conflicts.add(conflict)
2446
67
200
2447
68
        data.update(dict((conflict, None) for conflict in conflicts))
201
        data.update(dict((conflict, None) for conflict in conflicts))
2449
69
        return Constraints(data)
202
        return Constraints(self, data)
2450
203
2451
204
    def load(self, data):
2452
205
        """Convert a data dict to a Constraints"""
2453
206
        for k, v in data.items():
2454
207
            self.get(k).convert(v)
2455
208
        return Constraints(self, data)
2456
209
2457
210
2458
211
class Constraints(object, DictMixin):
2459
212
    """A Constraints object encapsulates a set of machine constraints.
2460
213
2461
214
    Constraints instances should not be constructed directly; please use
2462
215
    ConstraintSet's parse and load methods instead.
2463
216
2464
217
    They implement a dict interface, which exposes all constraints for the
2465
218
    appropriate provider, and is the expected mode of usage for clients not
2466
219
    concerned with the construction or comparison of Constraints objects.
2467
220
2468
221
    A Constraints object only ever contains a single "layer" of data, but can
2469
222
    be combined with other Constraints objects in such a way as to produce a
2470
223
    single object following the rules laid down in internals/placement-spec.
2471
224
2472
225
    Constraints objects can be compared, in a limited sense, by using the
2473
226
    `can_satisfy` method.
2474
227
    """
2475
228
2476
229
    def __init__(self, available, data):
2477
230
        self._available = available
2478
231
        self._data = data
2479
232
2480
233
    def keys(self):
2481
234
        """DictMixin"""
2482
235
        return self._available.names()
2483
236
2484
237
    def __getitem__(self, name):
2485
238
        """DictMixin"""
2486
239
        if name not in self.keys():
2487
240
            raise KeyError(name)
2488
241
        constraint = self._available.get(name)
2489
242
        raw_value = self.data.get(name, constraint.default)
2490
243
        return constraint.convert(raw_value)
2491
70
244
2492
71
    def with_series(self, series):
245
    def with_series(self, series):
2493
72
        """Return a Constraints with the "ubuntu-series" set to `series`"""
246
        """Return a Constraints with the "ubuntu-series" set to `series`"""
2494
73
        data = dict(self._data)
247
        data = dict(self._data)
2495
74
        data["ubuntu-series"] = series
248
        data["ubuntu-series"] = series
2497
75
        return Constraints(data)
249
        return self._available.load(data)
2498
76
250
2499
77
    @property
251
    @property
2500
78
    def complete(self):
252
    def complete(self):
2501
@@ -108,7 +282,11 @@
2502
108
                # place unit on machine
282
                # place unit on machine
2503
109
        """
283
        """
2504
110
        if not (self.complete and other.complete):
284
        if not (self.complete and other.complete):
2506
111
            raise ConstraintError("Cannot compare incomplete constraints")
285
            # Incomplete constraints cannot satisfy or be satisfied; we should
2507
286
            # only ever hit this branch if we're running new code (that knows
2508
287
            # about constraints) against an old deployment (which will contain
2509
288
            # at least *some* services/machines which don't have constraints).
2510
289
            return False
2511
112
290
2512
113
        for (name, unit_value) in other.items():
291
        for (name, unit_value) in other.items():
2513
114
            if unit_value is None:
292
            if unit_value is None:
2514
@@ -116,168 +294,29 @@
2515
116
                continue
294
                continue
2516
117
            machine_value = self[name]
295
            machine_value = self[name]
2517
118
            if machine_value is None:
296
            if machine_value is None:
2528
119
                # The unit *does* care, and the machine value isn't specified,
297
                # The unit *does* care, and the machine value isn't
2529
120
                # so we can't guarantee a match. If we were to update machine
298
                # specified, so we can't guarantee a match. If we were
2530
121
                # constraints after provisioning (ie when we knew the values of
299
                # to update machine constraints after provisioning (ie
2531
122
                # the constraints left unspecified) we'd hit this branch less
300
                # when we knew the values of the constraints left
2532
123
                # often.
301
                # unspecified) we'd hit this branch less often.  We
2533
124
                # We may also need to do something clever here to get sensible
302
                # may also need to do something clever here to get
2534
125
                # machine reuse on ec2 -- in what circumstances, if ever, is it
303
                # sensible machine reuse on ec2 -- in what
2535
126
                # OK to place a unit specced for one instance-type on a machine
304
                # circumstances, if ever, is it OK to place a unit
2536
127
                # of another type? Does it matter if either or both were derived
305
                # specced for one instance-type on a machine of
2537
128
                # from generic constraints? What about cost?
306
                # another type? Does it matter if either or both were
2538
307
                # derived from generic constraints? What about cost?
2539
129
                return False
308
                return False
2541
130
            if not _Constraint.get(name).can_satisfy(machine_value, unit_value):
309
            constraint = self._available.get(name)
2542
310
            if not constraint.can_satisfy(machine_value, unit_value):
2543
131
                # The machine's value is definitely not ok for the unit.
311
                # The machine's value is definitely not ok for the unit.
2544
132
                return False
312
                return False
2545
133
313
2546
134
        return True
314
        return True
2547
135
315
2691
136
    # DictMixin methods
316
2692
137
317
#==============================================================================
2693
138
    def keys(self):
318
# Generic constraint information (used by multiple providers).
2551
139
        return _Constraint.names(self._data.get("provider-type"))
2552
140
2553
141
    def __getitem__(self, name):
2554
142
        if name not in self.keys():
2555
143
            raise KeyError(name)
2556
144
        constraint = _Constraint.get(name)
2557
145
        raw_value = self.data.get(name, constraint.default)
2558
146
        return constraint.convert(raw_value)
2559
147
2560
148
2561
149
#======================================================================
2562
150
# Constraint type registration
2563
151
2564
152
def _dont_convert(s):
2565
153
    return s
2566
154
2567
155
2568
156
class _Constraint(object):
2569
157
2570
158
    _registry = {}
2571
159
    _conflicts = {}
2572
160
    _frozen = False
2573
161
2574
162
    def __init__(self, name, default, converter, comparer, provider, visible):
2575
163
        self._name = name
2576
164
        self._default = default
2577
165
        self._converter = converter
2578
166
        self._comparer = comparer
2579
167
        self._provider = provider
2580
168
        self._visible = visible
2581
169
2582
170
    @classmethod
2583
171
    def freeze(cls):
2584
172
        """Once called, prevents register and register_conflicts from working.
2585
173
2586
174
        Intent is to enforce consistency of Constraints construction and
2587
175
        overriding: if the set of constraints or the registered overlaps
2588
176
        were to change at runtime, the same operations could end up
2589
177
        producing different results.
2590
178
        """
2591
179
        cls._frozen = True
2592
180
2593
181
    @classmethod
2594
182
    def register(cls, name, default=None, converter=_dont_convert,
2595
183
                 comparer=operator.eq, provider=None, visible=True):
2596
184
        """Define a constraint.
2597
185
2598
186
        :param str name: The constraint's name
2599
187
        :param default: The default value as a str, or None to indicate "unset"
2600
188
        :param converter: Function to convert str value to "real" value
2601
189
        :param comparer: Function used to determine whether one constraint
2602
190
            satisfies another
2603
191
        :param provider: The name of the provider for which this constraint is
2604
192
            meaningful (None indicates always meaningful)
2605
193
        :param bool visible: If False, indicates a computed constraint which
2606
194
            should not be settable by a user.
2607
195
2608
196
        In service of consistency, is an error to attempt to register a new
2609
197
        constraint once a Constraints object has been created.
2610
198
        """
2611
199
        assert not cls._frozen
2612
200
        inst = cls(name, default, converter, comparer, provider, visible)
2613
201
        cls._registry[name] = inst
2614
202
        cls._conflicts[name] = set()
2615
203
2616
204
    @classmethod
2617
205
    def register_conflicts(cls, reds, blues):
2618
206
        """Set cross-constraint override behaviour.
2619
207
2620
208
        :param reds: list of constraint names which affect all constraints
2621
209
            specified in `blues`
2622
210
        :param blues: list of constraint names which affect all constraints
2623
211
            specified in `reds`
2624
212
2625
213
        When two constraints conflict:
2626
214
2627
215
        * It is an error to set both constraints in the same Constraints.
2628
216
        * When a Constraints overrides another which specifies a conflicting
2629
217
          constraint, the value in the overridden Constraints is cleared.
2630
218
2631
219
        In service of consistency, is an error to attempt to register any new
2632
220
        conflicts once a Constraints object has been created.
2633
221
        """
2634
222
        assert not cls._frozen
2635
223
        for red in reds:
2636
224
            cls._conflicts[red].update(blues)
2637
225
        for blue in blues:
2638
226
            cls._conflicts[blue].update(reds)
2639
227
2640
228
    @classmethod
2641
229
    def get(cls, name):
2642
230
        try:
2643
231
            return cls._registry[name]
2644
232
        except KeyError:
2645
233
            raise UnknownConstraintError(name)
2646
234
2647
235
    @classmethod
2648
236
    def names(cls, provider):
2649
237
        return [
2650
238
            name for (name, constraint) in cls._registry.items()
2651
239
            if constraint.provider in set([None, provider])]
2652
240
2653
241
    @property
2654
242
    def conflicts(self):
2655
243
        return self._conflicts[self._name]
2656
244
2657
245
    @property
2658
246
    def default(self):
2659
247
        return self._default
2660
248
2661
249
    @property
2662
250
    def provider(self):
2663
251
        return self._provider
2664
252
2665
253
    @property
2666
254
    def visible(self):
2667
255
        return self._visible
2668
256
2669
257
    def convert(self, s):
2670
258
        if s is None:
2671
259
            return
2672
260
        try:
2673
261
            return self._converter(s)
2674
262
        except ValueError as e:
2675
263
            raise ConstraintError(
2676
264
                "Bad %r constraint %r: %s" % (self._name, s, e))
2677
265
2678
266
    def can_satisfy(self, candidate, benchmark):
2679
267
        return self._comparer(candidate, benchmark)
2680
268
2681
269
2682
270
#======================================================================
2683
271
# Generic (but not user-visible) constraints; always relevant
2684
272
_Constraint.register("ubuntu-series", visible=False)
2685
273
_Constraint.register("provider-type", visible=False)
2686
274
2687
275
2688
276
#======================================================================
2689
277
# Generic (user-visible) constraints; always relevant
2690
278
2694
279
_VALID_ARCHS = ("i386", "amd64", "arm")
319
_VALID_ARCHS = ("i386", "amd64", "arm")
2695
280
2696
281
_MEGABYTES = 1
320
_MEGABYTES = 1
2697
282
_GIGABYTES = _MEGABYTES * 1024
321
_GIGABYTES = _MEGABYTES * 1024
2698
283
_TERABYTES = _GIGABYTES * 1024
322
_TERABYTES = _GIGABYTES * 1024
2699
@@ -292,7 +331,7 @@
2700
292
331
2701
293
def _convert_cpu(s):
332
def _convert_cpu(s):
2702
294
    value = float(s)
333
    value = float(s)
2704
295
    if value > 0:
334
    if value >= 0:
2705
296
        return value
335
        return value
2706
297
    raise ValueError("must be non-negative")
336
    raise ValueError("must be non-negative")
2707
298
337
2708
@@ -302,56 +341,6 @@
2709
302
        value = float(s[:-1]) * _MEM_SUFFIXES[s[-1]]
341
        value = float(s[:-1]) * _MEM_SUFFIXES[s[-1]]
2710
303
    else:
342
    else:
2711
304
        value = float(s)
343
        value = float(s)
2713
305
    if value > 0:
344
    if value >= 0:
2714
306
        return value
345
        return value
2715
307
    raise ValueError("must be non-negative")
346
    raise ValueError("must be non-negative")
2716
308
2717
309
2718
310
_Constraint.register("arch", converter=_convert_arch)
2719
311
_Constraint.register(
2720
312
    "mem", default="512M", converter=_convert_mem, comparer=operator.ge)
2721
313
_Constraint.register(
2722
314
    "cpu", default="1", converter=_convert_cpu, comparer=operator.ge)
2723
315
2724
316
2725
317
#======================================================================
2726
318
# Orchestra-only
2727
319
2728
320
def _convert_orchestra_classes(s):
2729
321
    return s.split(",")
2730
322
2731
323
2732
324
def _compare_orchestra_classes(candidate, benchmark):
2733
325
    return set(candidate) >= set(benchmark)
2734
326
2735
327
2736
328
_Constraint.register(
2737
329
    "orchestra-classes", converter=_convert_orchestra_classes,
2738
330
    comparer=_compare_orchestra_classes, provider="orchestra")
2739
331
_Constraint.register("orchestra-name", provider="orchestra")
2740
332
2741
333
2742
334
#======================================================================
2743
335
# EC2-only
2744
336
2745
337
def _convert_ec2_zone(s):
2746
338
    if s not in ascii_lowercase:
2747
339
        raise ValueError("expected lowercase ascii char")
2748
340
    return s
2749
341
2750
342
2751
343
_Constraint.register("ec2-instance-type", provider="ec2")
2752
344
_Constraint.register("ec2-zone", converter=_convert_ec2_zone, provider="ec2")
2753
345
2754
346
2755
347
#======================================================================
2756
348
# All conflicts
2757
349
2758
350
_Constraint.register_conflicts(["orchestra-name"], ["orchestra-classes"])
2759
351
_Constraint.register_conflicts(
2760
352
    ["ec2-instance-type", "orchestra-name"], ["arch", "cpu", "mem"])
2761
353
2762
354
#=====================================================================
2763
355
# Ensure consistency
2764
356
2765
357
_Constraint.freeze()
2766
358
347
2767
=== modified file 'juju/machine/tests/test_constraints.py'
2768
--- juju/machine/tests/test_constraints.py	2012-03-09 13:24:58 +0000
2769
+++ juju/machine/tests/test_constraints.py	2012-03-30 16:56:32 +0000
2770
@@ -1,270 +1,168 @@
2771
1
import operator
2772
2
2773
1
from juju.errors import ConstraintError
3
from juju.errors import ConstraintError
2774
2
from juju.lib.testing import TestCase
4
from juju.lib.testing import TestCase
2776
3
from juju.machine.constraints import Constraints
5
from juju.machine.constraints import Constraints, ConstraintSet
2777
4
6
2778
7
# These objects exist for the convenience of other test files
2779
8
dummy_cs = ConstraintSet("dummy")
2780
9
dummy_cs.register_generics([])
2781
10
dummy_constraints = dummy_cs.parse([])
2782
11
series_constraints = dummy_constraints.with_series("series")
2783
5
12
2784
6
generic_defaults = {
13
generic_defaults = {
2786
7
    "arch": None, "cpu": 1, "mem": 512,
14
    "arch": "amd64", "cpu": 1, "mem": 512,
2787
8
    "ubuntu-series": None, "provider-type": None}
15
    "ubuntu-series": None, "provider-type": None}
2788
9
dummy_defaults = dict(generic_defaults, **{
16
dummy_defaults = dict(generic_defaults, **{
2789
10
    "provider-type": "dummy"})
17
    "provider-type": "dummy"})
2790
11
ec2_defaults = dict(generic_defaults, **{
18
ec2_defaults = dict(generic_defaults, **{
2791
12
    "provider-type": "ec2",
19
    "provider-type": "ec2",
2792
13
    "ec2-zone": None,
20
    "ec2-zone": None,
2795
14
    "ec2-instance-type": None})
21
    "instance-type": None})
2796
15
orchestra_defaults = dict(generic_defaults, **{
22
orchestra_defaults = {
2797
16
    "provider-type": "orchestra",
23
    "provider-type": "orchestra",
2800
17
    "orchestra-name": None,
24
    "ubuntu-series": None,
2801
18
    "orchestra-classes": None})
25
    "orchestra-classes": None}
2802
19
26
2803
20
all_providers = ["dummy", "ec2", "orchestra"]
27
all_providers = ["dummy", "ec2", "orchestra"]
2804
21
28
2805
29
2806
22
class ConstraintsTestCase(TestCase):
30
class ConstraintsTestCase(TestCase):
2807
23
31
2808
24
    def assert_error(self, message, *raises_args):
32
    def assert_error(self, message, *raises_args):
2809
25
        e = self.assertRaises(ConstraintError, *raises_args)
33
        e = self.assertRaises(ConstraintError, *raises_args)
2810
26
        self.assertEquals(str(e), message)
34
        self.assertEquals(str(e), message)
2811
27
35
2813
28
    def assert_roundtrip_equal(self, constraints, expected):
36
    def assert_roundtrip_equal(self, cs, constraints, expected):
2814
37
        self.assertEquals(dict(constraints), expected)
2815
29
        self.assertEquals(constraints, expected)
38
        self.assertEquals(constraints, expected)
2817
30
        self.assertEquals(Constraints(constraints.data), expected)
39
        self.assertEquals(dict(cs.load(constraints.data)), expected)
2818
40
        self.assertEquals(cs.load(constraints.data), expected)
2819
31
41
2820
32
42
2821
33
class ConstraintsTest(ConstraintsTestCase):
43
class ConstraintsTest(ConstraintsTestCase):
2822
34
44
2830
35
    def test_defaults(self):
45
    def test_equality(self):
2831
36
        constraints = Constraints.from_strs("orchestra", [])
46
        self.assert_roundtrip_equal(
2832
37
        self.assert_roundtrip_equal(constraints, orchestra_defaults)
47
            dummy_cs, dummy_constraints, dummy_defaults)
2826
38
        constraints = Constraints.from_strs("ec2", [])
2827
39
        self.assert_roundtrip_equal(constraints, ec2_defaults)
2828
40
        constraints = Constraints.from_strs("dummy", [])
2829
41
        self.assert_roundtrip_equal(constraints, dummy_defaults)
2833
42
48
2834
43
    def test_complete(self):
49
    def test_complete(self):
2837
44
        incomplete_constraints = Constraints.from_strs("womble", [])
50
        incomplete_constraints = dummy_cs.parse([])
2836
45
        self.assertFalse(incomplete_constraints.complete)
2838
46
        complete_constraints = incomplete_constraints.with_series("wandering")
51
        complete_constraints = incomplete_constraints.with_series("wandering")
2839
47
        self.assertTrue(complete_constraints.complete)
52
        self.assertTrue(complete_constraints.complete)
2840
48
53
2852
49
    def assert_invalid(self, message, providers, *constraint_strs):
54
    def assert_invalid(self, message, *constraint_strs):
2853
50
        for provider in providers:
55
        self.assert_error(
2854
51
            self.assert_error(
56
            message, dummy_cs.parse, constraint_strs)
2844
52
                message, Constraints.from_strs, provider, constraint_strs)
2845
53
2846
54
        if len(providers) != len(all_providers):
2847
55
            # Check it *is* valid for other providers
2848
56
            for provider in all_providers:
2849
57
                if provider in providers:
2850
58
                    continue
2851
59
                Constraints.from_strs(provider, constraint_strs)
2855
60
57
2856
61
    def test_invalid_input(self):
58
    def test_invalid_input(self):
2857
62
        """Reject nonsense constraints"""
59
        """Reject nonsense constraints"""
2858
63
        self.assert_invalid(
60
        self.assert_invalid(
2859
64
            "Could not interpret 'BLAH' constraint: need more than 1 value to "
61
            "Could not interpret 'BLAH' constraint: need more than 1 value to "
2860
65
            "unpack",
62
            "unpack",
2862
66
            all_providers, "BLAH")
63
            "BLAH")
2863
67
        self.assert_invalid(
64
        self.assert_invalid(
2864
68
            "Unknown constraint: 'foo'",
65
            "Unknown constraint: 'foo'",
2866
69
            all_providers, "foo=", "bar=")
66
            "foo=", "bar=")
2867
70
67
2868
71
    def test_invalid_constraints(self):
68
    def test_invalid_constraints(self):
2869
72
        """Reject nonsensical constraint values"""
69
        """Reject nonsensical constraint values"""
2870
73
        self.assert_invalid(
70
        self.assert_invalid(
2872
74
            "Bad 'arch' constraint 'leg': unknown architecture", all_providers,
71
            "Bad 'arch' constraint 'leg': unknown architecture",
2873
75
            "arch=leg")
72
            "arch=leg")
2874
76
        self.assert_invalid(
73
        self.assert_invalid(
2876
77
            "Bad 'cpu' constraint '-1': must be non-negative", all_providers,
74
            "Bad 'cpu' constraint '-1': must be non-negative",
2877
78
            "cpu=-1")
75
            "cpu=-1")
2878
79
        self.assert_invalid(
76
        self.assert_invalid(
2879
80
            "Bad 'cpu' constraint 'fish': could not convert string to float: "
77
            "Bad 'cpu' constraint 'fish': could not convert string to float: "
2880
81
            "fish",
78
            "fish",
2882
82
            all_providers, "cpu=fish")
79
            "cpu=fish")
2883
83
        self.assert_invalid(
80
        self.assert_invalid(
2885
84
            "Bad 'mem' constraint '-1': must be non-negative", all_providers,
81
            "Bad 'mem' constraint '-1': must be non-negative",
2886
85
            "mem=-1")
82
            "mem=-1")
2887
86
        self.assert_invalid(
83
        self.assert_invalid(
2888
87
            "Bad 'mem' constraint '4P': invalid literal for float(): 4P",
84
            "Bad 'mem' constraint '4P': invalid literal for float(): 4P",
2893
88
            all_providers, "mem=4P")
85
            "mem=4P")
2890
89
        self.assert_invalid(
2891
90
            "Bad 'ec2-zone' constraint 'Q': expected lowercase ascii char",
2892
91
            ["ec2"], "ec2-zone=Q")
2894
92
86
2895
93
    def test_hidden_constraints(self):
87
    def test_hidden_constraints(self):
2896
94
        """Reject attempts to explicitly specify computed constraints"""
88
        """Reject attempts to explicitly specify computed constraints"""
2897
95
        self.assert_invalid(
89
        self.assert_invalid(
2899
96
            "Cannot set computed constraint: 'ubuntu-series'", all_providers,
90
            "Cannot set computed constraint: 'ubuntu-series'",
2900
97
            "ubuntu-series=cheesy")
91
            "ubuntu-series=cheesy")
2901
98
        self.assert_invalid(
92
        self.assert_invalid(
2903
99
            "Cannot set computed constraint: 'provider-type'", all_providers,
93
            "Cannot set computed constraint: 'provider-type'",
2904
100
            "provider-type=dummy")
94
            "provider-type=dummy")
2905
101
95
2906
102
    def test_overlap_ec2(self):
2907
103
        """Overlapping ec2 constraints should be detected"""
2908
104
        self.assert_invalid(
2909
105
            "Ambiguous constraints: 'arch' overlaps with 'ec2-instance-type'",
2910
106
            ["ec2"], "ec2-instance-type=m1.small", "arch=i386")
2911
107
        self.assert_invalid(
2912
108
            "Ambiguous constraints: 'cpu' overlaps with 'ec2-instance-type'",
2913
109
            ["ec2"], "ec2-instance-type=m1.small", "cpu=1")
2914
110
        self.assert_invalid(
2915
111
            "Ambiguous constraints: 'ec2-instance-type' overlaps with 'mem'",
2916
112
            ["ec2"], "ec2-instance-type=m1.small", "mem=2G")
2917
113
2918
114
    def test_overlap_orchestra(self):
2919
115
        """Overlapping orchestra constraints should be detected"""
2920
116
        self.assert_invalid(
2921
117
            "Ambiguous constraints: 'arch' overlaps with 'orchestra-name'",
2922
118
            ["orchestra"], "orchestra-name=herbert", "arch=i386")
2923
119
        self.assert_invalid(
2924
120
            "Ambiguous constraints: 'cpu' overlaps with 'orchestra-name'",
2925
121
            ["orchestra"], "orchestra-name=herbert", "cpu=1")
2926
122
        self.assert_invalid(
2927
123
            "Ambiguous constraints: 'mem' overlaps with 'orchestra-name'",
2928
124
            ["orchestra"], "orchestra-name=herbert", "mem=2G")
2929
125
        self.assert_invalid(
2930
126
            "Ambiguous constraints: 'orchestra-classes' overlaps with "
2931
127
            "'orchestra-name'",
2932
128
            ["orchestra"], "orchestra-name=herbert", "orchestra-classes=x,y")
2933
129
2934
130
96
2935
131
class ConstraintsUpdateTest(ConstraintsTestCase):
97
class ConstraintsUpdateTest(ConstraintsTestCase):
2936
132
98
2939
133
    def assert_constraints(self, provider, strss, expected):
99
    def assert_constraints(self, strss, expected):
2940
134
        constraints = Constraints.from_strs(provider, strss[0])
100
        constraints = dummy_cs.parse(strss[0])
2941
135
        for strs in strss[1:]:
101
        for strs in strss[1:]:
2946
136
            constraints.update(Constraints.from_strs(provider, strs))
102
            constraints.update(dummy_cs.parse(strs))
2943
137
        self.assert_roundtrip_equal(constraints, expected)
2944
138
2945
139
    def assert_constraints_dummy(self, strss, expected):
2947
140
        expected = dict(dummy_defaults, **expected)
103
        expected = dict(dummy_defaults, **expected)
2949
141
        self.assert_constraints("dummy", strss, expected)
104
        self.assert_roundtrip_equal(dummy_cs, constraints, expected)
2950
142
105
2952
143
    def test_constraints_dummy(self):
106
    def test_constraints(self):
2953
144
        """Sane constraints dicts are generated for unknown environments"""
107
        """Sane constraints dicts are generated for unknown environments"""
2959
145
        self.assert_constraints_dummy([[]], {})
108
        self.assert_constraints([[]], {})
2960
146
        self.assert_constraints_dummy([["arch=arm"]], {"arch": "arm"})
109
        self.assert_constraints([["cpu=", "mem="]], {})
2961
147
        self.assert_constraints_dummy([["cpu=0.1"]], {"cpu": 0.1})
110
        self.assert_constraints([["arch=arm"]], {"arch": "arm"})
2962
148
        self.assert_constraints_dummy([["mem=128"]], {"mem": 128})
111
        self.assert_constraints([["cpu=0.1"]], {"cpu": 0.1})
2963
149
        self.assert_constraints_dummy(
112
        self.assert_constraints([["mem=128"]], {"mem": 128})
2964
113
        self.assert_constraints([["cpu=0"]], {"cpu": 0})
2965
114
        self.assert_constraints([["mem=0"]], {"mem": 0})
2966
115
        self.assert_constraints(
2967
150
            [["arch=amd64", "cpu=6", "mem=1.5G"]],
116
            [["arch=amd64", "cpu=6", "mem=1.5G"]],
2969
151
            {"arch": "amd64", "cpu": 6, "mem": 1536,})
117
            {"arch": "amd64", "cpu": 6, "mem": 1536})
2970
152
118
2971
153
    def test_overwriting_basic(self):
119
    def test_overwriting_basic(self):
2972
154
        """Later values shadow earlier values"""
120
        """Later values shadow earlier values"""
2974
155
        self.assert_constraints_dummy(
121
        self.assert_constraints(
2975
156
            [["cpu=4", "mem=512"], ["arch=i386", "mem=1G"]],
122
            [["cpu=4", "mem=512"], ["arch=i386", "mem=1G"]],
2976
157
            {"arch": "i386", "cpu": 4, "mem": 1024})
123
            {"arch": "i386", "cpu": 4, "mem": 1024})
2977
158
124
2978
159
    def test_reset(self):
125
    def test_reset(self):
2979
160
        """Empty string resets to juju default"""
126
        """Empty string resets to juju default"""
2981
161
        self.assert_constraints_dummy(
127
        self.assert_constraints(
2982
162
            [["arch=arm", "cpu=4", "mem=1024"], ["arch=", "cpu=", "mem="]],
128
            [["arch=arm", "cpu=4", "mem=1024"], ["arch=", "cpu=", "mem="]],
2985
163
            {"arch": None, "cpu": 1, "mem": 512})
129
            {"arch": "amd64", "cpu": 1, "mem": 512})
2986
164
        self.assert_constraints_dummy(
130
        self.assert_constraints(
2987
165
            [["arch=", "cpu=", "mem="], ["arch=arm", "cpu=4", "mem=1024"]],
131
            [["arch=", "cpu=", "mem="], ["arch=arm", "cpu=4", "mem=1024"]],
2988
166
            {"arch": "arm", "cpu": 4, "mem": 1024})
132
            {"arch": "arm", "cpu": 4, "mem": 1024})
2989
167
133
2990
168
    def assert_constraints_ec2(self, strss, expected):
2991
169
        expected = dict(ec2_defaults, **expected)
2992
170
        self.assert_constraints("ec2", strss, expected)
2993
171
2994
172
    def test_constraints_ec2(self):
2995
173
        """Sane constraints dicts are generated for ec2"""
2996
174
        self.assert_constraints_ec2([[]], {})
2997
175
        self.assert_constraints_ec2([["arch=arm"]], {"arch": "arm"})
2998
176
        self.assert_constraints_ec2([["cpu=128"]], {"cpu": 128})
2999
177
        self.assert_constraints_ec2([["mem=2G"]], {"mem": 2048})
3000
178
        self.assert_constraints_ec2([["ec2-zone=b"]], {"ec2-zone": "b"})
3001
179
        self.assert_constraints_ec2(
3002
180
            [["arch=amd64", "cpu=32", "mem=2G", "ec2-zone=b"]],
3003
181
            {"arch": "amd64", "cpu": 32, "mem": 2048, "ec2-zone": "b"})
3004
182
3005
183
    def test_overwriting_ec2_instance_type(self):
3006
184
        """ec2-instance-type interacts correctly with arch, cpu, mem"""
3007
185
        self.assert_constraints_ec2(
3008
186
            [["ec2-instance-type=t1.micro"]],
3009
187
            {"ec2-instance-type": "t1.micro", "cpu": None, "mem": None})
3010
188
        self.assert_constraints_ec2(
3011
189
            [["arch=arm", "cpu=8"], ["ec2-instance-type=t1.micro"]],
3012
190
            {"ec2-instance-type": "t1.micro", "cpu": None, "mem": None})
3013
191
        self.assert_constraints_ec2(
3014
192
            [["ec2-instance-type=t1.micro"], ["arch=arm", "cpu=8"]],
3015
193
            {"ec2-instance-type": None, "arch": "arm", "cpu": 8, "mem": None})
3016
194
3017
195
    def assert_constraints_orchestra(self, strss, expected):
3018
196
        expected = dict(orchestra_defaults, **expected)
3019
197
        self.assert_constraints("orchestra", strss, expected)
3020
198
3021
199
    def test_constraints_orchestra(self):
3022
200
        """Sane constraints dicts are generated for orchestra"""
3023
201
        self.assert_constraints_orchestra([[]], {})
3024
202
        self.assert_constraints_orchestra([["arch=arm"]], {"arch": "arm"})
3025
203
        self.assert_constraints_orchestra([["cpu=128"]], {"cpu": 128})
3026
204
        self.assert_constraints_orchestra([["mem=0.25T"]], {"mem": 262144})
3027
205
        self.assert_constraints_orchestra(
3028
206
            [["orchestra-classes=x,y"]], {"orchestra-classes": ["x", "y"]})
3029
207
        self.assert_constraints_orchestra(
3030
208
            [["arch=i386", "cpu=2", "mem=768M", "orchestra-classes=a,b"]],
3031
209
            {"arch": "i386", "cpu": 2, "mem": 768,
3032
210
                "orchestra-classes": ["a", "b"]})
3033
211
3034
212
    def test_overwriting_orchestra_name(self):
3035
213
        """orchestra-name interacts correctly with arch, cpu, mem"""
3036
214
        self.assert_constraints_orchestra(
3037
215
            [["orchestra-name=baggins"]],
3038
216
            {"orchestra-name": "baggins", "cpu": None, "mem": None})
3039
217
        self.assert_constraints_orchestra(
3040
218
            [["orchestra-name=baggins"], ["arch=arm"]],
3041
219
            {"orchestra-name": None, "arch": "arm", "cpu": None, "mem": None})
3042
220
        self.assert_constraints_orchestra(
3043
221
            [["arch=arm", "cpu=2"], ["orchestra-name=baggins"]],
3044
222
            {"orchestra-name": "baggins", "arch": None, "cpu": None,
3045
223
                "mem": None})
3046
224
3047
225
    def test_overwriting_orchestra_classes(self):
3048
226
        """orchestra-classes interacts correctly with orchestra-name"""
3049
227
        self.assert_constraints_orchestra(
3050
228
            [["orchestra-name=baggins"], ["orchestra-classes=c,d", "cpu=2"]],
3051
229
            {"orchestra-classes": ["c", "d"], "cpu": 2, "mem": None})
3052
230
        self.assert_constraints_orchestra(
3053
231
            [["orchestra-classes=zz,top", "arch=amd64", "cpu=2"],
3054
232
                ["orchestra-name=baggins"]],
3055
233
            {"orchestra-name": "baggins", "orchestra-classes": None,
3056
234
                "cpu": None, "mem": None})
3057
235
3058
236
134
3059
237
class ConstraintsFulfilmentTest(ConstraintsTestCase):
135
class ConstraintsFulfilmentTest(ConstraintsTestCase):
3060
238
136
3061
239
    def completed_constraints(self, provider="provider", series="series"):
3062
240
        return Constraints.from_strs(provider, []).with_series(series)
3063
241
3064
242
    def assert_incomparable(self, c1, c2):
3065
243
        self.assert_error(
3066
244
            "Cannot compare incomplete constraints", c1.can_satisfy, c2)
3067
245
        self.assert_error(
3068
246
            "Cannot compare incomplete constraints", c2.can_satisfy, c1)
3069
247
3070
248
    def assert_match(self, c1, c2, expected):
137
    def assert_match(self, c1, c2, expected):
3071
249
        self.assertEquals(c1.can_satisfy(c2), expected)
138
        self.assertEquals(c1.can_satisfy(c2), expected)
3072
250
        self.assertEquals(c2.can_satisfy(c1), expected)
139
        self.assertEquals(c2.can_satisfy(c1), expected)
3073
251
140
3074
252
    def test_fulfil_completeness(self):
141
    def test_fulfil_completeness(self):
3083
253
        """can_satisfy needs to be called on and with complete Constraints~s"""
142
        """
3084
254
        c1 = Constraints({"provider-type": "a"})
143
        can_satisfy needs to be called on and with complete Constraints~s to
3085
255
        c2 = Constraints({"provider-type": "a"})
144
        have any chance of working.
3086
256
        self.assert_incomparable(c1, c2)
145
        """
3087
257
        c3 = self.completed_constraints("a")
146
        good = Constraints(
3088
258
        self.assert_incomparable(c1, c3)
147
            dummy_cs, {"provider-type": "dummy", "ubuntu-series": "x"})
3089
259
        c4 = self.completed_constraints("a")
148
        self.assert_match(good, good, True)
3090
260
        self.assert_match(c3, c4, True)
149
        bad = [Constraints(dummy_cs, {}),
3091
150
               Constraints(dummy_cs, {"provider-type": "dummy"}),
3092
151
               Constraints(dummy_cs, {"ubuntu-series": "x"})]
3093
152
        for i, bad1 in enumerate(bad):
3094
153
            self.assert_match(bad1, good, False)
3095
154
            for bad2 in bad[i:]:
3096
155
                self.assert_match(bad1, bad2, False)
3097
261
156
3098
262
    def test_fulfil_matches(self):
157
    def test_fulfil_matches(self):
3099
158
        other_cs = ConstraintSet("other")
3100
159
        other_cs.register_generics([])
3101
160
        other_constraints = other_cs.parse([])
3102
263
        instances = (
161
        instances = (
3107
264
            Constraints({"provider-type": "a", "ubuntu-series": "x"}),
162
            dummy_constraints.with_series("x"),
3108
265
            Constraints({"provider-type": "a", "ubuntu-series": "y"}),
163
            dummy_constraints.with_series("y"),
3109
266
            Constraints({"provider-type": "b", "ubuntu-series": "x"}),
164
            other_constraints.with_series("x"),
3110
267
            Constraints({"provider-type": "b", "ubuntu-series": "y"}))
165
            other_constraints.with_series("y"))
3111
268
166
3112
269
        for i, c1 in enumerate(instances):
167
        for i, c1 in enumerate(instances):
3113
270
            self.assert_match(c1, c1, True)
168
            self.assert_match(c1, c1, True)
3114
@@ -272,94 +170,237 @@
3115
272
                self.assert_match(c1, c2, False)
170
                self.assert_match(c1, c2, False)
3116
273
171
3117
274
    def assert_can_satisfy(
172
    def assert_can_satisfy(
3120
275
            self, machine_strs, unit_strs, expected, provider="provider"):
173
            self, machine_strs, unit_strs, expected):
3121
276
        machine = Constraints.from_strs(provider, machine_strs)
174
        machine = dummy_cs.parse(machine_strs)
3122
277
        machine = machine.with_series("shiny")
175
        machine = machine.with_series("shiny")
3124
278
        unit = Constraints.from_strs(provider, unit_strs)
176
        unit = dummy_cs.parse(unit_strs)
3125
279
        unit = unit.with_series("shiny")
177
        unit = unit.with_series("shiny")
3126
280
        self.assertEquals(machine.can_satisfy(unit), expected)
178
        self.assertEquals(machine.can_satisfy(unit), expected)
3127
281
179
3128
282
        if provider != "provider":
3129
283
            # Check that a different provider doesn't detect any problem,
3130
284
            # because it's ignoring all off-provider constraints.
3131
285
            machine = Constraints.from_strs("provider", machine_strs)
3132
286
            machine = machine.with_series("shiny")
3133
287
            unit = Constraints.from_strs("provider", unit_strs)
3134
288
            unit = unit.with_series("shiny")
3135
289
            self.assertEquals(machine.can_satisfy(unit), True)
3136
290
3137
291
3138
292
    def test_can_satisfy(self):
180
    def test_can_satisfy(self):
3139
293
        self.assert_can_satisfy([], [], True)
181
        self.assert_can_satisfy([], [], True)
3140
294
182
3142
295
        self.assert_can_satisfy(["arch=arm"], [], True)
183
        self.assert_can_satisfy(["arch=arm"], [], False)
3143
184
        self.assert_can_satisfy(["arch=amd64"], [], True)
3144
296
        self.assert_can_satisfy([], ["arch=arm"], False)
185
        self.assert_can_satisfy([], ["arch=arm"], False)
3145
297
        self.assert_can_satisfy(["arch=i386"], ["arch=arm"], False)
186
        self.assert_can_satisfy(["arch=i386"], ["arch=arm"], False)
3146
298
        self.assert_can_satisfy(["arch=arm"], ["arch=amd64"], False)
187
        self.assert_can_satisfy(["arch=arm"], ["arch=amd64"], False)
3147
299
        self.assert_can_satisfy(["arch=amd64"], ["arch=amd64"], True)
188
        self.assert_can_satisfy(["arch=amd64"], ["arch=amd64"], True)
3148
189
        self.assert_can_satisfy(["arch=i386"], ["arch=any"], True)
3149
190
        self.assert_can_satisfy(["arch=arm"], ["arch=any"], True)
3150
191
        self.assert_can_satisfy(["arch=amd64"], ["arch=any"], True)
3151
192
        self.assert_can_satisfy(["arch=any"], ["arch=any"], True)
3152
193
        self.assert_can_satisfy(["arch=any"], ["arch=i386"], False)
3153
194
        self.assert_can_satisfy(["arch=any"], ["arch=amd64"], False)
3154
195
        self.assert_can_satisfy(["arch=any"], ["arch=arm"], False)
3155
300
196
3156
301
        self.assert_can_satisfy(["cpu=64"], [], True)
197
        self.assert_can_satisfy(["cpu=64"], [], True)
3157
302
        self.assert_can_satisfy([], ["cpu=64"], False)
198
        self.assert_can_satisfy([], ["cpu=64"], False)
3158
303
        self.assert_can_satisfy(["cpu=64"], ["cpu=32"], True)
199
        self.assert_can_satisfy(["cpu=64"], ["cpu=32"], True)
3159
304
        self.assert_can_satisfy(["cpu=32"], ["cpu=64"], False)
200
        self.assert_can_satisfy(["cpu=32"], ["cpu=64"], False)
3160
305
        self.assert_can_satisfy(["cpu=64"], ["cpu=64"], True)
201
        self.assert_can_satisfy(["cpu=64"], ["cpu=64"], True)
3161
202
        self.assert_can_satisfy(["cpu=0.01"], ["cpu=any"], True)
3162
203
        self.assert_can_satisfy(["cpu=9999"], ["cpu=any"], True)
3163
204
        self.assert_can_satisfy(["cpu=any"], ["cpu=any"], True)
3164
205
        self.assert_can_satisfy(["cpu=any"], ["cpu=0.01"], False)
3165
206
        self.assert_can_satisfy(["cpu=any"], ["cpu=9999"], False)
3166
306
207
3167
307
        self.assert_can_satisfy(["mem=8G"], [], True)
208
        self.assert_can_satisfy(["mem=8G"], [], True)
3168
308
        self.assert_can_satisfy([], ["mem=8G"], False)
209
        self.assert_can_satisfy([], ["mem=8G"], False)
3169
309
        self.assert_can_satisfy(["mem=8G"], ["mem=4G"], True)
210
        self.assert_can_satisfy(["mem=8G"], ["mem=4G"], True)
3170
310
        self.assert_can_satisfy(["mem=4G"], ["mem=8G"], False)
211
        self.assert_can_satisfy(["mem=4G"], ["mem=8G"], False)
3171
311
        self.assert_can_satisfy(["mem=8G"], ["mem=8G"], True)
212
        self.assert_can_satisfy(["mem=8G"], ["mem=8G"], True)
3226
312
213
        self.assert_can_satisfy(["mem=2M"], ["mem=any"], True)
3227
313
        self.assert_can_satisfy(
214
        self.assert_can_satisfy(["mem=256T"], ["mem=any"], True)
3228
314
            # orchestra-name clears default cpu/mem values.
215
        self.assert_can_satisfy(["mem=any"], ["mem=any"], True)
3229
315
            # This may be a problem.
216
        self.assert_can_satisfy(["mem=any"], ["mem=2M"], False)
3230
316
            ["orchestra-name=henry"], [], False, "orchestra")
217
        self.assert_can_satisfy(["mem=any"], ["mem=256T"], False)
3231
317
        self.assert_can_satisfy(
218
3232
318
            [], ["orchestra-name=henry"], False, "orchestra")
219
3233
319
        self.assert_can_satisfy(
220
class ConstraintSetTest(TestCase):
3234
320
            ["orchestra-name=henry"], ["orchestra-name=jane"], False,
221
3235
321
            "orchestra")
222
    def allow_names(self, *names):
3236
322
        self.assert_can_satisfy(
223
        all_names = ["ubuntu-series", "provider-type"]
3237
323
            ["orchestra-name=jane"], ["orchestra-name=henry"], False,
224
        all_names.extend(names)
3238
324
            "orchestra")
225
        from juju.machine import constraints
3239
325
        self.assert_can_satisfy(
226
        self.patch(constraints, "ALL_NAMES", all_names)
3240
326
            ["orchestra-name=henry"], ["orchestra-name=henry"], True,
227
3241
327
            "orchestra")
228
    def test_register_unknown_name(self):
3242
328
229
        e = self.assertRaises(
3243
329
        self.assert_can_satisfy(
230
            AssertionError, ConstraintSet("provider").register, "nonsense")
3244
330
            ["orchestra-classes=a,b"], [], True, "orchestra")
231
        self.assertEquals(str(e), "please update ALL_NAMES")
3245
331
        self.assert_can_satisfy(
232
3246
332
            [], ["orchestra-classes=a,b"], False, "orchestra")
233
    def test_register_known_names(self):
3247
333
        self.assert_can_satisfy(
234
        self.allow_names("foo", "blob")
3248
334
            ["orchestra-classes=a,b"], ["orchestra-classes=a"], True,
235
        cs = ConstraintSet("provider")
3249
335
            "orchestra")
236
        cs.register("foo")
3250
336
        self.assert_can_satisfy(
237
        cs.register("blob")
3251
337
            ["orchestra-classes=a"], ["orchestra-classes=a,b"], False,
238
        c1 = cs.parse(["foo=bar"]).with_series("series")
3252
338
            "orchestra")
239
        self.assertEquals(c1["foo"], "bar")
3253
339
        self.assert_can_satisfy(
240
        self.assertEquals(c1["blob"], None)
3254
340
            ["orchestra-classes=a,b"], ["orchestra-classes=a,b"], True,
241
        c2 = cs.parse(["foo=bar"]).with_series("series")
3255
341
            "orchestra")
242
        self.assertTrue(c1.can_satisfy(c2))
3256
342
        self.assert_can_satisfy(
243
        self.assertTrue(c2.can_satisfy(c1))
3257
343
            ["orchestra-classes=a,b"], ["orchestra-classes=a,c"], False,
244
3258
344
            "orchestra")
245
    def test_unregistered_name(self):
3259
345
246
        self.allow_names("foo", "bar", "baz")
3260
346
        self.assert_can_satisfy(["ec2-zone=a"], [], True, "ec2")
247
        cs = ConstraintSet("provider")
3261
347
        self.assert_can_satisfy([], ["ec2-zone=a"], False, "ec2")
248
        cs.register("bar")
3262
348
        self.assert_can_satisfy(["ec2-zone=a"], ["ec2-zone=b"], False, "ec2")
249
        output = self.capture_logging()
3263
349
        self.assert_can_satisfy(["ec2-zone=b"], ["ec2-zone=a"], False, "ec2")
250
        constraints = cs.parse(["foo=1", "bar=2", "baz=3"])
3264
350
        self.assert_can_satisfy(["ec2-zone=a"], ["ec2-zone=a"], True, "ec2")
251
        self.assertIn("ignored irrelevant 'foo' constraint", output.getvalue())
3265
351
252
        self.assertIn("ignored irrelevant 'baz' constraint", output.getvalue())
3266
352
        self.assert_can_satisfy(
253
        self.assertEquals(constraints["bar"], "2")
3267
353
            # ec2-instance-type clears default cpu/mem values.
254
3268
354
            # This may be a problem.
255
    def test_register_invisible(self):
3269
355
            ["ec2-instance-type=m1.small"], [], False, "ec2")
256
        self.allow_names("foo")
3270
356
        self.assert_can_satisfy([], ["ec2-instance-type=m1.small"], False, "ec2")
257
        cs = ConstraintSet("provider")
3271
357
        self.assert_can_satisfy(
258
        cs.register("foo", visible=False)
3272
358
            ["ec2-instance-type=m1.large"], ["ec2-instance-type=m1.small"],
259
        e = self.assertRaises(ConstraintError, cs.parse, ["foo=bar"])
3273
359
            False, "ec2")
260
        self.assertEquals(str(e), "Cannot set computed constraint: 'foo'")
3274
360
        self.assert_can_satisfy(
261
3275
361
            ["ec2-instance-type=m1.small"], ["ec2-instance-type=m1.large"],
262
    def test_register_comparer(self):
3276
362
            False, "ec2")
263
        self.allow_names("foo")
3277
363
        self.assert_can_satisfy(
264
        cs = ConstraintSet("provider")
3278
364
            ["ec2-instance-type=m1.small"], ["ec2-instance-type=m1.small"],
265
        cs.register("foo", comparer=operator.ne)
3279
365
            True, "ec2")
266
        c1 = cs.parse(["foo=bar"]).with_series("series")
3280
267
        c2 = cs.parse(["foo=bar"]).with_series("series")
3281
268
        self.assertFalse(c1.can_satisfy(c2))
3282
269
        self.assertFalse(c2.can_satisfy(c1))
3283
270
        c3 = cs.parse(["foo=baz"]).with_series("series")
3284
271
        self.assertTrue(c1.can_satisfy(c3))
3285
272
        self.assertTrue(c3.can_satisfy(c1))
3286
273
3287
274
    def test_register_default_and_converter(self):
3288
275
        self.allow_names("foo")
3289
276
        cs = ConstraintSet("provider")
3290
277
        cs.register("foo", default="star", converter=lambda s: "death-" + s)
3291
278
        c1 = cs.parse([])
3292
279
        self.assertEquals(c1["foo"], "death-star")
3293
280
        c1 = cs.parse(["foo=clock"])
3294
281
        self.assertEquals(c1["foo"], "death-clock")
3295
282
3296
283
    def test_convert_wraps_ValueError(self):
3297
284
        self.allow_names("foo", "bar")
3298
285
3299
286
        def raiser(e):
3300
287
            raise e
3301
288
        cs = ConstraintSet("provider")
3302
289
        cs.register("foo", converter=lambda s: raiser(ValueError(s)))
3303
290
        cs.register("bar", converter=lambda s: raiser(KeyError(s)))
3304
291
        self.assertRaises(ConstraintError, cs.parse, ["foo=1"])
3305
292
        self.assertRaises(KeyError, cs.parse, ["bar=1"])
3306
293
3307
294
    def test_register_conflicts(self):
3308
295
        self.allow_names("foo", "bar", "baz", "qux")
3309
296
        cs = ConstraintSet("provider")
3310
297
        cs.register("foo")
3311
298
        cs.register("bar")
3312
299
        cs.register("baz")
3313
300
        cs.register("qux")
3314
301
        cs.parse(["foo=1", "bar=2", "baz=3", "qux=4"])
3315
302
3316
303
        def assert_ambiguous(strs):
3317
304
            e = self.assertRaises(ConstraintError, cs.parse, strs)
3318
305
            self.assertTrue(str(e).startswith("Ambiguous constraints"))
3319
306
3320
307
        cs.register_conflicts(["foo"], ["bar", "baz", "qux"])
3321
308
        assert_ambiguous(["foo=1", "bar=2"])
3322
309
        assert_ambiguous(["foo=1", "baz=3"])
3323
310
        assert_ambiguous(["foo=1", "qux=4"])
3324
311
        cs.parse(["foo=1"])
3325
312
        cs.parse(["bar=2", "baz=3", "qux=4"])
3326
313
3327
314
        cs.register_conflicts(["bar", "baz"], ["qux"])
3328
315
        assert_ambiguous(["bar=2", "qux=4"])
3329
316
        assert_ambiguous(["baz=3", "qux=4"])
3330
317
        cs.parse(["foo=1"])
3331
318
        cs.parse(["bar=2", "baz=3"])
3332
319
        cs.parse(["qux=4"])
3333
320
3334
321
    def test_register_generics_no_instance_types(self):
3335
322
        cs = ConstraintSet("provider")
3336
323
        cs.register_generics([])
3337
324
        c1 = cs.parse([])
3338
325
        self.assertEquals(c1["arch"], "amd64")
3339
326
        self.assertEquals(c1["cpu"], 1.0)
3340
327
        self.assertEquals(c1["mem"], 512.0)
3341
328
        self.assertFalse("instance-type" in c1)
3342
329
3343
330
        c2 = cs.parse(["arch=any", "cpu=0", "mem=8G"])
3344
331
        self.assertEquals(c2["arch"], None)
3345
332
        self.assertEquals(c2["cpu"], 0.0)
3346
333
        self.assertEquals(c2["mem"], 8192.0)
3347
334
        self.assertFalse("instance-type" in c2)
3348
335
3349
336
    def test_register_generics_with_instance_types(self):
3350
337
        cs = ConstraintSet("provider")
3351
338
        cs.register_generics(["a1.big", "c7.peculiar"])
3352
339
        c1 = cs.parse([])
3353
340
        self.assertEquals(c1["arch"], "amd64")
3354
341
        self.assertEquals(c1["cpu"], 1.0)
3355
342
        self.assertEquals(c1["mem"], 512.0)
3356
343
        self.assertEquals(c1["instance-type"], None)
3357
344
3358
345
        c2 = cs.parse(["arch=any", "cpu=0", "mem=8G"])
3359
346
        self.assertEquals(c2["arch"], None)
3360
347
        self.assertEquals(c2["cpu"], 0.0)
3361
348
        self.assertEquals(c2["mem"], 8192.0)
3362
349
        self.assertEquals(c2["instance-type"], None)
3363
350
3364
351
        c3 = cs.parse(["instance-type=c7.peculiar", "arch=i386"])
3365
352
        self.assertEquals(c3["arch"], "i386")
3366
353
        self.assertEquals(c3["cpu"], None)
3367
354
        self.assertEquals(c3["mem"], None)
3368
355
        self.assertEquals(c3["instance-type"], "c7.peculiar")
3369
356
3370
357
        def assert_ambiguous(strs):
3371
358
            e = self.assertRaises(ConstraintError, cs.parse, strs)
3372
359
            self.assertTrue(str(e).startswith("Ambiguous constraints"))
3373
360
3374
361
        assert_ambiguous(["cpu=1", "instance-type=c7.peculiar"])
3375
362
        assert_ambiguous(["mem=1024", "instance-type=c7.peculiar"])
3376
363
3377
364
        c4 = cs.parse([])
3378
365
        c4.update(c2)
3379
366
        self.assertEquals(c4["arch"], None)
3380
367
        self.assertEquals(c4["cpu"], 0.0)
3381
368
        self.assertEquals(c4["mem"], 8192.0)
3382
369
        self.assertEquals(c4["instance-type"], None)
3383
370
3384
371
        c5 = cs.parse(["instance-type=a1.big"])
3385
372
        c5.update(cs.parse(["arch=i386"]))
3386
373
        self.assertEquals(c5["arch"], "i386")
3387
374
        self.assertEquals(c5["cpu"], None)
3388
375
        self.assertEquals(c5["mem"], None)
3389
376
        self.assertEquals(c5["instance-type"], "a1.big")
3390
377
3391
378
        c6 = cs.parse(["instance-type=a1.big"])
3392
379
        c6.update(cs.parse(["cpu=20"]))
3393
380
        self.assertEquals(c6["arch"], "amd64")
3394
381
        self.assertEquals(c6["cpu"], 20.0)
3395
382
        self.assertEquals(c6["mem"], None)
3396
383
        self.assertEquals(c6["instance-type"], None)
3397
384
3398
385
        c7 = cs.parse(["instance-type="])
3399
386
        self.assertEquals(c7["arch"], "amd64")
3400
387
        self.assertEquals(c7["cpu"], 1.0)
3401
388
        self.assertEquals(c7["mem"], 512.0)
3402
389
        self.assertEquals(c7["instance-type"], None)
3403
390
3404
391
        c8 = cs.parse(["instance-type=any"])
3405
392
        self.assertEquals(c8["arch"], "amd64")
3406
393
        self.assertEquals(c8["cpu"], 1.0)
3407
394
        self.assertEquals(c8["mem"], 512.0)
3408
395
        self.assertEquals(c8["instance-type"], None)
3409
396
3410
397
    def test_load_validates(self):
3411
398
        self.allow_names("foo")
3412
399
        cs = ConstraintSet("provider")
3413
400
3414
401
        def blam(s):
3415
402
            raise ValueError(s)
3416
403
3417
404
        cs.register("foo", converter=blam)
3418
405
        e = self.assertRaises(ConstraintError, cs.load, {"foo": "bar"})
3419
406
        self.assertEquals(str(e), "Bad 'foo' constraint 'bar': bar")
3420
366
407
3421
=== modified file 'juju/machine/unit.py'
3422
--- juju/machine/unit.py	2012-02-21 12:14:11 +0000
3423
+++ juju/machine/unit.py	2012-03-30 16:56:32 +0000
3424
@@ -1,6 +1,5 @@
3425
1
import os
1
import os
3426
2
import shutil
2
import shutil
3427
3
import sys
3428
4
import logging
3
import logging
3429
5
4
3430
6
import juju
5
import juju
3431
7
6
3432
=== modified file 'juju/providers/common/base.py'
3433
--- juju/providers/common/base.py	2011-11-19 05:37:09 +0000
3434
+++ juju/providers/common/base.py	2012-03-30 16:56:32 +0000
3435
@@ -1,9 +1,10 @@
3436
1
import copy
1
import copy
3437
2
from operator import itemgetter
2
from operator import itemgetter
3438
3
3
3440
4
from twisted.internet.defer import inlineCallbacks, returnValue
4
from twisted.internet.defer import inlineCallbacks, returnValue, succeed
3441
5
5
3442
6
from juju.environment.errors import EnvironmentsConfigError
6
from juju.environment.errors import EnvironmentsConfigError
3443
7
from juju.machine.constraints import ConstraintSet
3444
7
from juju.state.placement import UNASSIGNED_POLICY
8
from juju.state.placement import UNASSIGNED_POLICY
3445
8
9
3446
9
10
3447
@@ -30,10 +31,13 @@
3448
30
31
3449
31
    You may want to override the following methods, but you should be careful
32
    You may want to override the following methods, but you should be careful
3450
32
    to call :class:`MachineProviderBase`'s implementation (or be very sure you
33
    to call :class:`MachineProviderBase`'s implementation (or be very sure you
3452
33
    don't need to:
34
    don't need to):
3453
34
35
3454
35
        * :meth:`__init__`
36
        * :meth:`__init__`
3455
36
        * :meth:`get_serialization_data`
37
        * :meth:`get_serialization_data`
3456
38
        * :meth:`get_legacy_config_keys`
3457
39
        * :meth:`get_placement_policy`
3458
40
        * :meth:`get_constraint_set`
3459
37
41
3460
38
    You probably shouldn't override anything else.
42
    You probably shouldn't override anything else.
3461
39
    """
43
    """
3462
@@ -48,11 +52,16 @@
3463
48
        self.environment_name = environment_name
52
        self.environment_name = environment_name
3464
49
        self.config = config
53
        self.config = config
3465
50
54
3466
55
    def get_constraint_set(self):
3467
56
        """Return the set of constraints that are valid for this provider."""
3468
57
        return succeed(ConstraintSet(self.provider_type))
3469
58
3470
59
    def get_legacy_config_keys(self):
3471
60
        """Return any deprecated config keys that are set."""
3472
61
        return set() & set(self.config)
3473
62
3474
51
    def get_placement_policy(self):
63
    def get_placement_policy(self):
3479
52
        """Get the unit placement policy for the provider.
64
        """Get the unit placement policy for the provider."""
3476
53
3477
54
        :param preference: A user specified plcaement policy preference
3478
55
        """
3480
56
        return self.config.get("placement", UNASSIGNED_POLICY)
65
        return self.config.get("placement", UNASSIGNED_POLICY)
3481
57
66
3482
58
    def get_serialization_data(self):
67
    def get_serialization_data(self):
3483
@@ -151,9 +160,9 @@
3484
151
        """
160
        """
3485
152
        return ZookeeperConnect(self).run(share=share)
161
        return ZookeeperConnect(self).run(share=share)
3486
153
162
3488
154
    def bootstrap(self):
163
    def bootstrap(self, constraints):
3489
155
        """Bootstrap an juju server in the provider."""
164
        """Bootstrap an juju server in the provider."""
3491
156
        return Bootstrap(self).run()
165
        return Bootstrap(self, constraints).run()
3492
157
166
3493
158
    def get_machine(self, instance_id):
167
    def get_machine(self, instance_id):
3494
159
        """Retrieve a provider machine by instance id.
168
        """Retrieve a provider machine by instance id.
3495
160
169
3496
=== modified file 'juju/providers/common/bootstrap.py'
3497
--- juju/providers/common/bootstrap.py	2011-09-22 13:23:00 +0000
3498
+++ juju/providers/common/bootstrap.py	2012-03-30 16:56:32 +0000
3499
@@ -1,5 +1,7 @@
3500
1
from cStringIO import StringIO
1
from cStringIO import StringIO
3501
2
2
3502
3
from twisted.internet.defer import inlineCallbacks, returnValue
3503
4
3504
3
from juju.errors import EnvironmentNotFound, ProviderError
5
from juju.errors import EnvironmentNotFound, ProviderError
3505
4
6
3506
5
from .utils import log
7
from .utils import log
3507
@@ -10,8 +12,9 @@
3508
10
class Bootstrap(object):
12
class Bootstrap(object):
3509
11
    """Generic bootstrap operation class."""
13
    """Generic bootstrap operation class."""
3510
12
14
3512
13
    def __init__(self, provider):
15
    def __init__(self, provider, constraints):
3513
14
        self._provider = provider
16
        self._provider = provider
3514
17
        self._constraints = constraints
3515
15
18
3516
16
    def run(self):
19
    def run(self):
3517
17
        """Get an existing zookeeper, or launch a new one.
20
        """Get an existing zookeeper, or launch a new one.
3518
@@ -47,6 +50,9 @@
3519
47
            "Bootstrap aborted because file storage is not writable: %s"
50
            "Bootstrap aborted because file storage is not writable: %s"
3520
48
            % str(failure.value))
51
            % str(failure.value))
3521
49
52
3522
53
    @inlineCallbacks
3523
50
    def _launch_machine(self, unused):
54
    def _launch_machine(self, unused):
3524
51
        log.debug("Launching juju bootstrap instance.")
55
        log.debug("Launching juju bootstrap instance.")
3526
52
        return self._provider.start_machine({"machine-id": "0"}, master=True)
56
        machines = yield self._provider.start_machine(
3527
57
            {"machine-id": "0", "constraints": self._constraints}, master=True)
3528
58
        returnValue(machines)
3529
53
59
3530
=== modified file 'juju/providers/common/cloudinit.py'
3531
--- juju/providers/common/cloudinit.py	2012-02-21 19:28:28 +0000
3532
+++ juju/providers/common/cloudinit.py	2012-03-30 16:56:32 +0000
3533
@@ -1,4 +1,6 @@
3534
1
from base64 import b64encode
3535
1
from subprocess import Popen, PIPE
2
from subprocess import Popen, PIPE
3536
3
from yaml import safe_dump
3537
2
4
3538
3
from juju.errors import CloudInitError
5
from juju.errors import CloudInitError
3539
4
from juju.lib.upstart import UpstartService
6
from juju.lib.upstart import UpstartService
3540
@@ -29,14 +31,15 @@
3541
29
    return scripts
31
    return scripts
3542
30
32
3543
31
33
3545
32
def _zookeeper_scripts(instance_id, secret, provider_type):
34
def _zookeeper_scripts(instance_id, secret, constraints, provider_type):
3546
33
    return [
35
    return [
3547
34
        "juju-admin initialize"
36
        "juju-admin initialize"
3548
35
        " --instance-id=%s"
37
        " --instance-id=%s"
3549
36
        " --admin-identity=%s"
38
        " --admin-identity=%s"
3550
39
        " --constraints-data=%s"
3551
37
        " --provider-type=%s"
40
        " --provider-type=%s"
3552
38
        % (instance_id, make_identity("admin:%s" % secret),
41
        % (instance_id, make_identity("admin:%s" % secret),
3554
39
           provider_type)]
42
           b64encode(safe_dump(constraints.data)), provider_type)]
3555
40
43
3556
41
44
3557
42
def _machine_scripts(machine_id, zookeeper_hosts):
45
def _machine_scripts(machine_id, zookeeper_hosts):
3558
@@ -143,6 +146,7 @@
3559
143
        self._zookeeper = False
146
        self._zookeeper = False
3560
144
        self._zookeeper_hosts = []
147
        self._zookeeper_hosts = []
3561
145
        self._zookeeper_secret = None
148
        self._zookeeper_secret = None
3562
149
        self._constraints = None
3563
146
        self._origin, self._origin_url = get_default_origin()
150
        self._origin, self._origin_url = get_default_origin()
3564
147
151
3565
148
    def add_ssh_key(self, key):
152
    def add_ssh_key(self, key):
3566
@@ -236,6 +240,13 @@
3567
236
        """
240
        """
3568
237
        self._zookeeper_secret = secret
241
        self._zookeeper_secret = secret
3569
238
242
3570
243
    def set_constraints(self, constraints):
3571
244
        """Specify the initial machine's constraints.
3572
245
3573
246
        You only need to set this if this machine will be a zookeeper instance.
3574
247
        """
3575
248
        self._constraints = constraints
3576
249
3577
239
    def render(self):
250
    def render(self):
3578
240
        """Get content for a cloud-init file with appropriate specifications.
251
        """Get content for a cloud-init file with appropriate specifications.
3579
241
252
3580
@@ -265,6 +276,7 @@
3581
265
        if self._zookeeper:
276
        if self._zookeeper:
3582
266
            require("_instance_id", "set_instance_id_accessor")
277
            require("_instance_id", "set_instance_id_accessor")
3583
267
            require("_zookeeper_secret", "set_zookeeper_secret")
278
            require("_zookeeper_secret", "set_zookeeper_secret")
3584
279
            require("_constraints", "set_constraints")
3585
268
        else:
280
        else:
3586
269
            require("_zookeeper_hosts", "set_zookeeper_machines")
281
            require("_zookeeper_hosts", "set_zookeeper_machines")
3587
270
        if missing:
282
        if missing:
3588
@@ -299,6 +311,7 @@
3589
299
            scripts.extend(_zookeeper_scripts(
311
            scripts.extend(_zookeeper_scripts(
3590
300
                self._instance_id,
312
                self._instance_id,
3591
301
                self._zookeeper_secret,
313
                self._zookeeper_secret,
3592
314
                self._constraints,
3593
302
                self._provider_type))
315
                self._provider_type))
3594
303
        scripts.extend(_machine_scripts(
316
        scripts.extend(_machine_scripts(
3595
304
            self._machine_id, self._join_zookeeper_hosts()))
317
            self._machine_id, self._join_zookeeper_hosts()))
3596
305
318
3597
=== modified file 'juju/providers/common/launch.py'
3598
--- juju/providers/common/launch.py	2011-09-30 04:52:20 +0000
3599
+++ juju/providers/common/launch.py	2012-03-30 16:56:32 +0000
3600
@@ -1,4 +1,6 @@
3602
1
from twisted.internet.defer import inlineCallbacks, returnValue
1
from twisted.internet.defer import fail, inlineCallbacks, returnValue
3603
2
3604
3
from juju.errors import ProviderError
3605
2
4
3606
3
from .cloudinit import CloudInit
5
from .cloudinit import CloudInit
3607
4
from .utils import get_user_authorized_keys
6
from .utils import get_user_authorized_keys
3608
@@ -24,10 +26,27 @@
3609
24
    .. automethod:: _create_cloud_init
26
    .. automethod:: _create_cloud_init
3610
25
    """
27
    """
3611
26
28
3613
27
    def __init__(self, provider, master=False, constraints=None):
29
    def __init__(self, provider, constraints, master=False):
3614
28
        self._provider = provider
30
        self._provider = provider
3615
31
        self._constraints = constraints
3616
29
        self._master = master
32
        self._master = master
3618
30
        self._constraints = constraints or {}
33
3619
34
    @classmethod
3620
35
    def launch(cls, provider, machine_data, master):
3621
36
        """Create and run a machine launch operation.
3622
37
3623
38
        Exists for the convenience of the `MachineProvider` implementations
3624
39
        which actually use the "constraints" key in machine_data, which would
3625
40
        otherwise duplicate code.
3626
41
        """
3627
42
        if "machine-id" not in machine_data:
3628
43
            return fail(ProviderError(
3629
44
                "Cannot launch a machine without specifying a machine-id"))
3630
45
        if "constraints" not in machine_data:
3631
46
            return fail(ProviderError(
3632
47
                "Cannot launch a machine without specifying constraints"))
3633
48
        launcher = cls(provider, machine_data["constraints"], master)
3634
49
        return launcher.run(machine_data["machine-id"])
3635
31
50
3636
32
    @inlineCallbacks
51
    @inlineCallbacks
3637
33
    def run(self, machine_id):
52
    def run(self, machine_id):
3638
@@ -88,6 +107,7 @@
3639
88
        if self._master:
107
        if self._master:
3640
89
            cloud_init.enable_bootstrap()
108
            cloud_init.enable_bootstrap()
3641
90
            cloud_init.set_zookeeper_secret(config["admin-secret"])
109
            cloud_init.set_zookeeper_secret(config["admin-secret"])
3642
110
            cloud_init.set_constraints(self._constraints)
3643
91
        return cloud_init
111
        return cloud_init
3644
92
112
3645
93
    def _on_new_zookeepers(self, machines):
113
    def _on_new_zookeepers(self, machines):
3646
94
114
3647
=== modified file 'juju/providers/common/tests/data/cloud_init_bootstrap'
3648
--- juju/providers/common/tests/data/cloud_init_bootstrap	2012-02-21 19:28:28 +0000
3649
+++ juju/providers/common/tests/data/cloud_init_bootstrap	2012-03-30 16:56:32 +0000
3650
@@ -6,8 +6,8 @@
3651
6
output: {all: '| tee -a /var/log/cloud-init-output.log'}
6
output: {all: '| tee -a /var/log/cloud-init-output.log'}
3652
7
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
7
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
3653
8
  default-jre-headless, zookeeper, zookeeperd, juju]
8
  default-jre-headless, zookeeper, zookeeperd, juju]
3656
9
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
9
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'juju-admin initialize
3657
10
    /var/log/juju, 'juju-admin initialize --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI=
10
    --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI= --constraints-data=e2NwdTogJzIwJywgcHJvdmlkZXItdHlwZTogZHVtbXksIHVidW50dS1zZXJpZXM6IGFzdG9uaXNoaW5nfQo=
3658
11
    --provider-type=dummy', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
11
    --provider-type=dummy', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
3659
12
12
3660
13
    description "Juju machine agent"
13
    description "Juju machine agent"
3661
14
14
3662
=== modified file 'juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers'
3663
--- juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers	2012-02-21 19:28:28 +0000
3664
+++ juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers	2012-03-30 16:56:32 +0000
3665
@@ -6,8 +6,8 @@
3666
6
output: {all: '| tee -a /var/log/cloud-init-output.log'}
6
output: {all: '| tee -a /var/log/cloud-init-output.log'}
3667
7
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
7
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
3668
8
  default-jre-headless, zookeeper, zookeeperd, juju]
8
  default-jre-headless, zookeeper, zookeeperd, juju]
3671
9
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
9
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'juju-admin initialize
3672
10
    /var/log/juju, 'juju-admin initialize --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI=
10
    --instance-id=token --admin-identity=admin:19vlzY4Vc3q4Ew5OsCwKYqrq1HI= --constraints-data=e2NwdTogJzIwJywgcHJvdmlkZXItdHlwZTogZHVtbXksIHVidW50dS1zZXJpZXM6IGFzdG9uaXNoaW5nfQo=
3673
11
    --provider-type=dummy', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
11
    --provider-type=dummy', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
3674
12
12
3675
13
    description "Juju machine agent"
13
    description "Juju machine agent"
3676
14
14
3677
=== modified file 'juju/providers/common/tests/data/cloud_init_distro'
3678
--- juju/providers/common/tests/data/cloud_init_distro	2012-02-21 19:28:28 +0000
3679
+++ juju/providers/common/tests/data/cloud_init_distro	2012-03-30 16:56:32 +0000
3680
@@ -4,9 +4,10 @@
3681
4
machine-data: {juju-provider-type: dummy, juju-zookeeper-hosts: 'cotswold:2181,longleat:2181',
4
machine-data: {juju-provider-type: dummy, juju-zookeeper-hosts: 'cotswold:2181,longleat:2181',
3682
5
  machine-id: passport}
5
  machine-id: passport}
3683
6
output: {all: '| tee -a /var/log/cloud-init-output.log'}
6
output: {all: '| tee -a /var/log/cloud-init-output.log'}
3687
7
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper, juju]
7
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
3688
8
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
8
  juju]
3689
9
    /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf <<EOF
9
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf
3690
10
    <<EOF
3691
10
11
3692
11
    description "Juju machine agent"
12
    description "Juju machine agent"
3693
12
13
3694
13
14
3695
=== modified file 'juju/providers/common/tests/data/cloud_init_ppa'
3696
--- juju/providers/common/tests/data/cloud_init_ppa	2012-02-21 19:28:28 +0000
3697
+++ juju/providers/common/tests/data/cloud_init_ppa	2012-03-30 16:56:32 +0000
3698
@@ -6,9 +6,10 @@
3699
6
machine-data: {juju-provider-type: dummy, juju-zookeeper-hosts: 'cotswold:2181,longleat:2181',
6
machine-data: {juju-provider-type: dummy, juju-zookeeper-hosts: 'cotswold:2181,longleat:2181',
3700
7
  machine-id: passport}
7
  machine-id: passport}
3701
8
output: {all: '| tee -a /var/log/cloud-init-output.log'}
8
output: {all: '| tee -a /var/log/cloud-init-output.log'}
3705
9
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper, juju]
9
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
3706
10
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
10
  juju]
3707
11
    /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf <<EOF
11
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'cat >> /etc/init/juju-machine-agent.conf
3708
12
    <<EOF
3709
12
13
3710
13
    description "Juju machine agent"
14
    description "Juju machine agent"
3711
14
15
3712
15
16
3713
=== modified file 'juju/providers/common/tests/test_base.py'
3714
--- juju/providers/common/tests/test_base.py	2011-09-27 02:14:56 +0000
3715
+++ juju/providers/common/tests/test_base.py	2012-03-30 16:56:32 +0000
3716
@@ -63,6 +63,10 @@
3717
63
        self.assertEqual(
63
        self.assertEqual(
3718
64
            provider.get_placement_policy(), "local")
64
            provider.get_placement_policy(), "local")
3719
65
65
3720
66
    def test_get_legacy_config_keys(self):
3721
67
        provider = DummyProvider()
3722
68
        self.assertEqual(provider.get_legacy_config_keys(), set())
3723
69
3724
66
    def test_get_machine_error(self):
70
    def test_get_machine_error(self):
3725
67
        provider = DummyProvider()
71
        provider = DummyProvider()
3726
68
        provider.get_machines = self.mocker.mock()
72
        provider.get_machines = self.mocker.mock()
3727
69
73
3728
=== modified file 'juju/providers/common/tests/test_bootstrap.py'
3729
--- juju/providers/common/tests/test_bootstrap.py	2011-09-15 18:50:23 +0000
3730
+++ juju/providers/common/tests/test_bootstrap.py	2012-03-30 16:56:32 +0000
3731
@@ -1,10 +1,11 @@
3732
1
import logging
1
import logging
3733
2
import tempfile
2
import tempfile
3734
3
3
3736
4
from twisted.internet.defer import fail, succeed
4
from twisted.internet.defer import fail, succeed, inlineCallbacks
3737
5
5
3738
6
from juju.errors import EnvironmentNotFound, ProviderError
6
from juju.errors import EnvironmentNotFound, ProviderError
3739
7
from juju.lib.testing import TestCase
7
from juju.lib.testing import TestCase
3740
8
from juju.machine.tests.test_constraints import dummy_cs
3741
8
from juju.providers.common.base import MachineProviderBase
9
from juju.providers.common.base import MachineProviderBase
3742
9
from juju.providers.dummy import DummyMachine, FileStorage
10
from juju.providers.dummy import DummyMachine, FileStorage
3743
10
11
3744
@@ -27,7 +28,11 @@
3745
27
28
3746
28
class DummyProvider(MachineProviderBase):
29
class DummyProvider(MachineProviderBase):
3747
29
30
3749
30
    def __init__(self, file_storage, zookeeper):
31
    provider_type = "dummy"
3750
32
    config = {"default-series": "splendid"}
3751
33
3752
34
    def __init__(self, test, file_storage, zookeeper):
3753
35
        self._test = test
3754
31
        self._file_storage = file_storage
36
        self._file_storage = file_storage
3755
32
        self._zookeeper = zookeeper
37
        self._zookeeper = zookeeper
3756
33
38
3757
@@ -41,24 +46,34 @@
3758
41
            return succeed([self._zookeeper])
46
            return succeed([self._zookeeper])
3759
42
        return fail(EnvironmentNotFound())
47
        return fail(EnvironmentNotFound())
3760
43
48
3763
44
    def start_machine(self, machine_id, master=False):
49
    def start_machine(self, machine_data, master=False):
3764
45
        assert master is True
50
        self._test.assertTrue(master)
3765
51
        self._test.assertEquals(machine_data["machine-id"], "0")
3766
52
        constraints = machine_data["constraints"]
3767
53
        self._test.assertEquals(constraints["provider-type"], "dummy")
3768
54
        self._test.assertEquals(constraints["ubuntu-series"], "splendid")
3769
55
        self._test.assertEquals(constraints["arch"], "arm")
3770
46
        return [DummyMachine("i-keepzoos")]
56
        return [DummyMachine("i-keepzoos")]
3771
47
57
3772
48
58
3773
49
class BootstrapTest(TestCase):
59
class BootstrapTest(TestCase):
3774
50
60
3775
61
    @inlineCallbacks
3776
62
    def setUp(self):
3777
63
        yield super(BootstrapTest, self).setUp()
3778
64
        self.constraints = dummy_cs.parse(["arch=arm"]).with_series("splendid")
3779
65
3780
51
    def test_unknown_error(self):
66
    def test_unknown_error(self):
3783
52
        provider = DummyProvider(None, SomeError())
67
        provider = DummyProvider(self, None, SomeError())
3784
53
        d = provider.bootstrap()
68
        d = provider.bootstrap(self.constraints)
3785
54
        self.assertFailure(d, SomeError)
69
        self.assertFailure(d, SomeError)
3786
55
        return d
70
        return d
3787
56
71
3788
57
    def test_zookeeper_exists(self):
72
    def test_zookeeper_exists(self):
3789
58
        log = self.capture_logging("juju.common", level=logging.DEBUG)
73
        log = self.capture_logging("juju.common", level=logging.DEBUG)
3790
59
        provider = DummyProvider(
74
        provider = DummyProvider(
3793
60
            WorkingFileStorage(), DummyMachine("i-alreadykeepzoos"))
75
            self, WorkingFileStorage(), DummyMachine("i-alreadykeepzoos"))
3794
61
        d = provider.bootstrap()
76
        d = provider.bootstrap(self.constraints)
3795
62
77
3796
63
        def verify(machines):
78
        def verify(machines):
3797
64
            (machine,) = machines
79
            (machine,) = machines
3798
@@ -73,8 +88,8 @@
3799
73
        return d
88
        return d
3800
74
89
3801
75
    def test_bad_storage(self):
90
    def test_bad_storage(self):
3804
76
        provider = DummyProvider(UnwritableFileStorage(), None)
91
        provider = DummyProvider(self, UnwritableFileStorage(), None)
3805
77
        d = provider.bootstrap()
92
        d = provider.bootstrap(self.constraints)
3806
78
        self.assertFailure(d, ProviderError)
93
        self.assertFailure(d, ProviderError)
3807
79
94
3808
80
        def verify(error):
95
        def verify(error):
3809
@@ -87,8 +102,8 @@
3810
87
102
3811
88
    def test_create_zookeeper(self):
103
    def test_create_zookeeper(self):
3812
89
        log = self.capture_logging("juju.common", level=logging.DEBUG)
104
        log = self.capture_logging("juju.common", level=logging.DEBUG)
3815
90
        provider = DummyProvider(WorkingFileStorage(), None)
105
        provider = DummyProvider(self, WorkingFileStorage(), None)
3816
91
        d = provider.bootstrap()
106
        d = provider.bootstrap(self.constraints)
3817
92
107
3818
93
        def verify(machines):
108
        def verify(machines):
3819
94
            (machine,) = machines
109
            (machine,) = machines
3820
95
110
3821
=== modified file 'juju/providers/common/tests/test_cloudinit.py'
3822
--- juju/providers/common/tests/test_cloudinit.py	2012-02-22 09:23:16 +0000
3823
+++ juju/providers/common/tests/test_cloudinit.py	2012-03-30 16:56:32 +0000
3824
@@ -5,6 +5,7 @@
3825
5
5
3826
6
from juju.errors import CloudInitError
6
from juju.errors import CloudInitError
3827
7
from juju.lib.testing import TestCase
7
from juju.lib.testing import TestCase
3828
8
from juju.machine.tests.test_constraints import dummy_cs
3829
8
from juju.providers.common.cloudinit import (
9
from juju.providers.common.cloudinit import (
3830
9
    CloudInit, parse_juju_origin, get_default_origin)
10
    CloudInit, parse_juju_origin, get_default_origin)
3831
10
from juju.providers.dummy import DummyMachine
11
from juju.providers.dummy import DummyMachine
3832
@@ -34,6 +35,8 @@
3833
34
        cloud_init.set_provider_type("dummy")
35
        cloud_init.set_provider_type("dummy")
3834
35
        cloud_init.set_instance_id_accessor("token")
36
        cloud_init.set_instance_id_accessor("token")
3835
36
        cloud_init.set_zookeeper_secret("seekrit")
37
        cloud_init.set_zookeeper_secret("seekrit")
3836
38
        cloud_init.set_constraints(
3837
39
            dummy_cs.parse(["cpu=20"]).with_series("astonishing"))
3838
37
        cloud_init.set_juju_source(distro=True)
40
        cloud_init.set_juju_source(distro=True)
3839
38
        if with_zookeepers:
41
        if with_zookeepers:
3840
39
            cloud_init.set_zookeeper_machines([
42
            cloud_init.set_zookeeper_machines([
3841
@@ -64,7 +67,7 @@
3842
64
            str(error),
67
            str(error),
3843
65
            "Incomplete cloud-init: you need to call add_ssh_key, "
68
            "Incomplete cloud-init: you need to call add_ssh_key, "
3844
66
            "set_machine_id, set_provider_type, set_instance_id_accessor, "
69
            "set_machine_id, set_provider_type, set_instance_id_accessor, "
3846
67
            "set_zookeeper_secret")
70
            "set_zookeeper_secret, set_constraints")
3847
68
71
3848
69
    def test_source_validate(self):
72
    def test_source_validate(self):
3849
70
        bad_choices = (
73
        bad_choices = (
3850
71
74
3851
=== modified file 'juju/providers/common/tests/test_launch.py'
3852
--- juju/providers/common/tests/test_launch.py	2011-09-19 23:33:37 +0000
3853
+++ juju/providers/common/tests/test_launch.py	2012-03-30 16:56:32 +0000
3854
@@ -1,6 +1,6 @@
3855
1
import tempfile
1
import tempfile
3856
2
2
3858
3
from twisted.internet.defer import fail, succeed
3
from twisted.internet.defer import fail, succeed, inlineCallbacks, returnValue
3859
4
4
3860
5
from juju.errors import EnvironmentNotFound
5
from juju.errors import EnvironmentNotFound
3861
6
from juju.lib.testing import TestCase
6
from juju.lib.testing import TestCase
3862
@@ -9,10 +9,12 @@
3863
9
from juju.providers.dummy import DummyMachine, FileStorage
9
from juju.providers.dummy import DummyMachine, FileStorage
3864
10
10
3865
11
11
3867
12
def launch_machine(test, master, zookeeper):
12
def get_classes(test, master, machine_id, zookeeper):
3868
13
13
3869
14
    class DummyProvider(MachineProviderBase):
14
    class DummyProvider(MachineProviderBase):
3870
15
15
3871
16
        provider_type = "dummy"
3872
17
3873
16
        def __init__(self):
18
        def __init__(self):
3874
17
            self.config = {"admin-secret": "BLAH"}
19
            self.config = {"admin-secret": "BLAH"}
3875
18
            self._file_storage = FileStorage(tempfile.mkdtemp())
20
            self._file_storage = FileStorage(tempfile.mkdtemp())
3876
@@ -27,54 +29,73 @@
3877
27
29
3878
28
    class DummyLaunchMachine(LaunchMachine):
30
    class DummyLaunchMachine(LaunchMachine):
3879
29
31
3882
30
        def start_machine(self, machine_id, zookeepers):
32
        def start_machine(self, actual_machine_id, zookeepers):
3883
31
            test.assertEquals(machine_id, "1234")
33
            test.assertEquals(actual_machine_id, machine_id)
3884
32
            test.assertEquals(zookeepers, filter(None, [zookeeper]))
34
            test.assertEquals(zookeepers, filter(None, [zookeeper]))
3885
33
            test.assertEquals(self._master, master)
35
            test.assertEquals(self._master, master)
3887
34
            test.assertEquals(self._constraints, {})
36
            test.assertEquals(self._constraints, self.expect_constraints)
3888
35
            return succeed([DummyMachine("i-malive")])
37
            return succeed([DummyMachine("i-malive")])
3889
36
38
3890
39
    return DummyProvider, DummyLaunchMachine
3891
40
3892
41
3893
42
@inlineCallbacks
3894
43
def launch_machine(test, master, zookeeper):
3895
44
    DummyProvider, DummyLaunchMachine = get_classes(
3896
45
        test, master, "1234", zookeeper)
3897
46
3898
37
    provider = DummyProvider()
47
    provider = DummyProvider()
3901
38
    d = DummyLaunchMachine(provider, master).run("1234")
48
    cs = yield provider.get_constraint_set()
3902
39
    return provider, d
49
    constraints = cs.parse([])
3903
50
    launch = DummyLaunchMachine(provider, constraints, master)
3904
51
    launch.expect_constraints = constraints
3905
52
    machines = yield launch.run("1234")
3906
53
    returnValue((provider, machines))
3907
40
54
3908
41
55
3909
42
class LaunchMachineTest(TestCase):
56
class LaunchMachineTest(TestCase):
3910
43
57
3911
58
    @inlineCallbacks
3912
44
    def assert_success(self, master, zookeeper):
59
    def assert_success(self, master, zookeeper):
3922
45
        provider, d = launch_machine(self, master, zookeeper)
60
        provider, machines = yield launch_machine(self, master, zookeeper)
3923
46
61
        (machine,) = machines
3924
47
        def verify(machines):
62
        self.assertTrue(isinstance(machine, DummyMachine))
3925
48
            (machine,) = machines
63
        self.assertEquals(machine.instance_id, "i-malive")
3926
49
            self.assertTrue(isinstance(machine, DummyMachine))
64
        returnValue(provider)
3918
50
            self.assertEquals(machine.instance_id, "i-malive")
3919
51
            return provider
3920
52
        d.addCallback(verify)
3921
53
        return d
3927
54
65
3928
55
    def test_start_nonzookeeper_no_zookeepers(self):
66
    def test_start_nonzookeeper_no_zookeepers(self):
3929
56
        """Starting a non-zookeeper without a zookeeper is an error"""
67
        """Starting a non-zookeeper without a zookeeper is an error"""
3933
57
        unused, d = launch_machine(self, False, None)
68
        return self.assertFailure(
3934
58
        self.assertFailure(d, EnvironmentNotFound)
69
            launch_machine(self, False, None), EnvironmentNotFound)
3932
59
        return d
3935
60
70
3936
71
    @inlineCallbacks
3937
61
    def test_start_zookeeper_no_zookeepers(self):
72
    def test_start_zookeeper_no_zookeepers(self):
3938
62
        """A new zookeeper should be recorded in provider state"""
73
        """A new zookeeper should be recorded in provider state"""
3948
63
        d = self.assert_success(True, None)
74
        provider = yield self.assert_success(True, None)
3949
64
75
        provider_state = yield provider.load_state()
3950
65
        def verify(provider):
76
        self.assertEquals(
3951
66
            provider_state = yield provider.load_state()
77
            provider_state, {"zookeeper-instances": ["i-malive"]})
3952
67
            self.assertEquals(
78
3953
68
                provider_state, {"zookeeper-instances": ["i-malive"]})
79
    @inlineCallbacks
3945
69
        d.addCallback(verify)
3946
70
        return d
3947
71
3954
72
    def test_works_with_zookeeper(self):
80
    def test_works_with_zookeeper(self):
3955
73
        """Creating a non-zookeeper machine should not alter provider state"""
81
        """Creating a non-zookeeper machine should not alter provider state"""
3963
74
        d = self.assert_success(False, DummyMachine("i-keepzoos"))
82
        provider = yield self.assert_success(False, DummyMachine("i-keepzoos"))
3964
75
83
        provider_state = yield provider.load_state()
3965
76
        def verify(provider):
84
        self.assertEquals(provider_state, False)
3966
77
            provider_state = yield provider.load_state()
85
3967
78
            self.assertEquals(provider_state, False)
86
    @inlineCallbacks
3968
79
        d.addCallback(verify)
87
    def test_convenience_launch(self):
3969
80
        return d
88
        DummyProvider, DummyLaunchMachine = get_classes(
3970
89
            self, True, "999", None)
3971
90
3972
91
        provider = DummyProvider()
3973
92
        cs = yield provider.get_constraint_set()
3974
93
        constraints = cs.parse(["arch=arm", "mem=1G"])
3975
94
        DummyLaunchMachine.expect_constraints = constraints
3976
95
        machine_data = {
3977
96
            "machine-id": "999", "constraints": constraints}
3978
97
        machines = yield DummyLaunchMachine.launch(
3979
98
            provider, machine_data, True)
3980
99
        (machine,) = machines
3981
100
        self.assertTrue(isinstance(machine, DummyMachine))
3982
101
        self.assertEquals(machine.instance_id, "i-malive")
3983
81
102
3984
=== modified file 'juju/providers/dummy.py'
3985
--- juju/providers/dummy.py	2011-09-28 09:48:30 +0000
3986
+++ juju/providers/dummy.py	2012-03-30 16:56:32 +0000
3987
@@ -11,6 +11,7 @@
3988
11
11
3989
12
12
3990
13
from juju.machine import ProviderMachine
13
from juju.machine import ProviderMachine
3991
14
from juju.machine.constraints import ConstraintSet
3992
14
from juju.state.placement import UNASSIGNED_POLICY
15
from juju.state.placement import UNASSIGNED_POLICY
3993
15
from juju.providers.common.files import FileStorage
16
from juju.providers.common.files import FileStorage
3994
16
17
3995
@@ -34,6 +35,9 @@
3996
34
        self._state = None
35
        self._state = None
3997
35
        self._storage = None
36
        self._storage = None
3998
36
37
3999
38
    def get_legacy_config_keys(self):
4000
39
        return set(("some-legacy-key",)) & set(self.config)
4001
40
4002
37
    def get_placement_policy(self):
41
    def get_placement_policy(self):
4003
38
        """Get the unit placement policy for the provider.
42
        """Get the unit placement policy for the provider.
4004
39
43
4005
@@ -41,6 +45,11 @@
4006
41
        """
45
        """
4007
42
        return self.config.get("placement", UNASSIGNED_POLICY)
46
        return self.config.get("placement", UNASSIGNED_POLICY)
4008
43
47
4009
48
    def get_constraint_set(self):
4010
49
        cs = ConstraintSet(self.provider_type)
4011
50
        cs.register_generics([])
4012
51
        return succeed(cs)
4013
52
4014
44
    @property
53
    @property
4015
45
    def provider_type(self):
54
    def provider_type(self):
4016
46
        return "dummy"
55
        return "dummy"
4017
@@ -91,7 +100,7 @@
4018
91
                return succeed(machine)
100
                return succeed(machine)
4019
92
        return fail(MachinesNotFound([instance_id]))
101
        return fail(MachinesNotFound([instance_id]))
4020
93
102
4022
94
    def bootstrap(self):
103
    def bootstrap(self, constraints):
4023
95
        """
104
        """
4024
96
        Bootstrap juju on the machine provider.
105
        Bootstrap juju on the machine provider.
4025
97
        """
106
        """
4026
98
107
4027
=== modified file 'juju/providers/ec2/__init__.py'
4028
--- juju/providers/ec2/__init__.py	2011-09-19 17:17:00 +0000
4029
+++ juju/providers/ec2/__init__.py	2012-03-30 16:56:32 +0000
4030
@@ -1,7 +1,7 @@
4031
1
import os
1
import os
4032
2
import re
2
import re
4033
3
3
4035
4
from twisted.internet.defer import fail, inlineCallbacks, returnValue
4
from twisted.internet.defer import inlineCallbacks, returnValue
4036
5
5
4037
6
from txaws.ec2.exception import EC2Error
6
from txaws.ec2.exception import EC2Error
4038
7
from txaws.service import AWSServiceRegion
7
from txaws.service import AWSServiceRegion
4039
@@ -16,7 +16,7 @@
4040
16
from .securitygroup import (
16
from .securitygroup import (
4041
17
    open_provider_port, close_provider_port, get_provider_opened_ports,
17
    open_provider_port, close_provider_port, get_provider_opened_ports,
4042
18
    remove_security_groups, destroy_environment_security_group)
18
    remove_security_groups, destroy_environment_security_group)
4044
19
from .utils import get_region_uri
19
from .utils import convert_zone, get_region_uri, DEFAULT_REGION, INSTANCE_TYPES
4045
20
20
4046
21
21
4047
22
class MachineProvider(MachineProviderBase):
22
class MachineProvider(MachineProviderBase):
4048
@@ -26,7 +26,7 @@
4049
26
        super(MachineProvider, self).__init__(environment_name, config)
26
        super(MachineProvider, self).__init__(environment_name, config)
4050
27
27
4051
28
        if not config.get("ec2-uri"):
28
        if not config.get("ec2-uri"):
4053
29
            ec2_uri = get_region_uri(config.get("region", "us-east-1"))
29
            ec2_uri = get_region_uri(config.get("region", DEFAULT_REGION))
4054
30
        else:
30
        else:
4055
31
            ec2_uri = config.get("ec2-uri")
31
            ec2_uri = config.get("ec2-uri")
4056
32
32
4057
@@ -42,6 +42,30 @@
4058
42
    def provider_type(self):
42
    def provider_type(self):
4059
43
        return "ec2"
43
        return "ec2"
4060
44
44
4061
45
    @property
4062
46
    def using_amazon(self):
4063
47
        return "ec2-uri" not in self.config
4064
48
4065
49
    @inlineCallbacks
4066
50
    def get_constraint_set(self):
4067
51
        """Return the set of constraints that are valid for this provider."""
4068
52
        cs = yield super(MachineProvider, self).get_constraint_set()
4069
53
        if self.using_amazon:
4070
54
            # Expose EC2 instance types/zones on AWS itelf, not private clouds.
4071
55
            cs.register_generics(INSTANCE_TYPES.keys())
4072
56
            cs.register("ec2-zone", converter=convert_zone)
4073
57
        returnValue(cs)
4074
58
4075
59
    def get_legacy_config_keys(self):
4076
60
        """Return any deprecated config keys that are set"""
4077
61
        legacy = super(MachineProvider, self).get_legacy_config_keys()
4078
62
        if self.using_amazon:
4079
63
            # In the absence of a generic instance-type/image-id mechanism,
4080
64
            # these keys remain valid on private clouds.
4081
65
            amazon_legacy = set(("default-image-id", "default-instance-type"))
4082
66
            legacy.update(amazon_legacy.intersection(self.config))
4083
67
        return legacy
4084
68
4085
45
    def get_serialization_data(self):
69
    def get_serialization_data(self):
4086
46
        """Get provider configuration suitable for serialization.
70
        """Get provider configuration suitable for serialization.
4087
47
71
4088
@@ -67,12 +91,7 @@
4089
67
            and run a provisioning agent, in addition to running a machine
91
            and run a provisioning agent, in addition to running a machine
4090
68
            agent.
92
            agent.
4091
69
        """
93
        """
4098
70
        if "machine-id" not in machine_data:
94
        return EC2LaunchMachine.launch(self, machine_data, master)
4093
71
            return fail(ProviderError(
4094
72
                "Cannot launch a machine without specifying a machine-id"))
4095
73
        machine_id = machine_data["machine-id"]
4096
74
        constraints = machine_data.get("constraints", {})
4097
75
        return EC2LaunchMachine(self, master, constraints).run(machine_id)
4099
76
95
4100
77
    @inlineCallbacks
96
    @inlineCallbacks
4101
78
    def get_machines(self, instance_ids=()):
97
    def get_machines(self, instance_ids=()):
4102
79
98
4103
=== modified file 'juju/providers/ec2/launch.py'
4104
--- juju/providers/ec2/launch.py	2011-09-19 20:38:45 +0000
4105
+++ juju/providers/ec2/launch.py	2012-03-30 16:56:32 +0000
4106
@@ -6,7 +6,7 @@
4107
6
from juju.providers.common.launch import LaunchMachine
6
from juju.providers.common.launch import LaunchMachine
4108
7
7
4109
8
from .machine import machine_from_instance
8
from .machine import machine_from_instance
4111
9
from .utils import get_image_id, log
9
from .utils import get_machine_spec, log, DEFAULT_REGION
4112
10
10
4113
11
11
4114
12
class EC2LaunchMachine(LaunchMachine):
12
class EC2LaunchMachine(LaunchMachine):
4115
@@ -34,17 +34,21 @@
4116
34
            "$(curl http://169.254.169.254/1.0/meta-data/instance-id)")
34
            "$(curl http://169.254.169.254/1.0/meta-data/instance-id)")
4117
35
        user_data = cloud_init.render()
35
        user_data = cloud_init.render()
4118
36
36
4122
37
        instance_type = self._provider.config.get(
37
        availability_zone = self._constraints["ec2-zone"]
4123
38
            "default-instance-type", "m1.small")
38
        if availability_zone is not None:
4124
39
        image_id = yield get_image_id(self._provider.config, self._constraints)
39
            region = self._provider.config.get("region", DEFAULT_REGION)
4125
40
            availability_zone = region + availability_zone
4126
41
        spec = yield get_machine_spec(self._provider.config, self._constraints)
4127
40
        security_groups = yield self._ensure_groups(machine_id)
42
        security_groups = yield self._ensure_groups(machine_id)
4128
41
43
4129
44
        log.debug("Launching with machine spec %s", spec)
4130
42
        instances = yield self._provider.ec2.run_instances(
45
        instances = yield self._provider.ec2.run_instances(
4131
43
            image_id=image_id,
4132
44
            instance_type=instance_type,
4133
45
            min_count=1,
46
            min_count=1,
4134
46
            max_count=1,
47
            max_count=1,
4135
48
            image_id=spec.image_id,
4136
49
            instance_type=spec.instance_type,
4137
47
            security_groups=security_groups,
50
            security_groups=security_groups,
4138
51
            availability_zone=availability_zone,
4139
48
            user_data=user_data)
52
            user_data=user_data)
4140
49
53
4141
50
        returnValue([machine_from_instance(i) for i in instances])
54
        returnValue([machine_from_instance(i) for i in instances])
4142
51
55
4143
=== modified file 'juju/providers/ec2/tests/common.py'
4144
--- juju/providers/ec2/tests/common.py	2011-09-29 05:35:04 +0000
4145
+++ juju/providers/ec2/tests/common.py	2012-03-30 16:56:32 +0000
4146
@@ -1,6 +1,6 @@
4147
1
from yaml import dump
1
from yaml import dump
4148
2
2
4150
3
from twisted.internet.defer import fail, succeed
3
from twisted.internet.defer import fail, succeed, inlineCallbacks, returnValue
4151
4
4
4152
5
from txaws.s3.client import S3Client
5
from txaws.s3.client import S3Client
4153
6
from txaws.s3.exception import S3Error
6
from txaws.s3.exception import S3Error
4154
@@ -14,6 +14,13 @@
4155
14
14
4156
15
MATCH_GROUP = MATCH(lambda x: x.startswith("juju-moon"))
15
MATCH_GROUP = MATCH(lambda x: x.startswith("juju-moon"))
4157
16
16
4158
17
_constraints_provider = MachineProvider("", {})
4159
18
4160
19
@inlineCallbacks
4161
20
def get_constraints(strs, series="splendid"):
4162
21
    cs = yield _constraints_provider.get_constraint_set()
4163
22
    returnValue(cs.parse(strs).with_series(series))
4164
23
4165
17
24
4166
18
class EC2TestMixin(object):
25
class EC2TestMixin(object):
4167
19
26
4168
@@ -26,7 +33,8 @@
4169
26
                "admin-secret": "magic-beans",
33
                "admin-secret": "magic-beans",
4170
27
                "access-key": "0f62e973d5f8",
34
                "access-key": "0f62e973d5f8",
4171
28
                "secret-key": "3e5a7c653f59",
35
                "secret-key": "3e5a7c653f59",
4173
29
                "control-bucket": self.env_name}
36
                "control-bucket": self.env_name,
4174
37
                "default-series": "splendid"}
4175
30
38
4176
31
    def get_provider(self):
39
    def get_provider(self):
4177
32
        """Return the ec2 machine provider.
40
        """Return the ec2 machine provider.
4178
@@ -81,7 +89,7 @@
4179
81
89
4180
82
class EC2MachineLaunchMixin(object):
90
class EC2MachineLaunchMixin(object):
4181
83
91
4183
84
    def _mock_launch_utils(self, ami_name="ami-default", **get_ami_kwargs):
92
    def _mock_launch_utils(self, ami_name="ami-default", get_ami_args=()):
4184
85
        get_public_key = self.mocker.replace(
93
        get_public_key = self.mocker.replace(
4185
86
            "juju.providers.common.utils.get_user_authorized_keys")
94
            "juju.providers.common.utils.get_user_authorized_keys")
4186
87
95
4187
@@ -91,16 +99,12 @@
4188
91
        get_public_key(MATCH(match_config))
99
        get_public_key(MATCH(match_config))
4189
92
        self.mocker.result("zebra")
100
        self.mocker.result("zebra")
4190
93
101
4193
94
        if not get_ami_kwargs:
102
        get_ami_args = get_ami_args or (
4194
95
            return
103
            "splendid", "amd64", "us-east-1", False)
4195
96
        get_ami = self.mocker.replace(
104
        get_ami = self.mocker.replace(
4196
97
            "juju.providers.ec2.utils.get_current_ami")
105
            "juju.providers.ec2.utils.get_current_ami")
4203
98
        get_ami(KWARGS)
106
        get_ami(*get_ami_args)
4204
99
107
        self.mocker.result(succeed(ami_name))
4199
100
        def check_kwargs(**kwargs):
4200
101
            self.assertEquals(kwargs, get_ami_kwargs)
4201
102
            return succeed(ami_name)
4202
103
        self.mocker.call(check_kwargs)
4205
104
108
4206
105
    def _mock_create_group(self):
109
    def _mock_create_group(self):
4207
106
        group_name = "juju-%s" % self.env_name
110
        group_name = "juju-%s" % self.env_name
4208
107
111
4209
=== modified file 'juju/providers/ec2/tests/data/bootstrap_cloud_init'
4210
--- juju/providers/ec2/tests/data/bootstrap_cloud_init	2012-02-21 19:28:28 +0000
4211
+++ juju/providers/ec2/tests/data/bootstrap_cloud_init	2012-03-30 16:56:32 +0000
4212
@@ -5,10 +5,10 @@
4213
5
output: {all: '| tee -a /var/log/cloud-init-output.log'}
5
output: {all: '| tee -a /var/log/cloud-init-output.log'}
4214
6
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
6
packages: [bzr, byobu, tmux, python-setuptools, python-twisted, python-txaws, python-zookeeper,
4215
7
  default-jre-headless, zookeeper, zookeeperd, juju]
7
  default-jre-headless, zookeeper, zookeeperd, juju]
4220
8
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p
8
runcmd: [sudo mkdir -p /var/lib/juju, sudo mkdir -p /var/log/juju, 'juju-admin initialize
4221
9
    /var/log/juju, 'juju-admin initialize --instance-id=$(curl http://169.254.169.254/1.0/meta-data/instance-id)
9
    --instance-id=$(curl http://169.254.169.254/1.0/meta-data/instance-id) --admin-identity=admin:JbJ6sDGV37EHzbG9FPvttk64cmg=
4222
10
    --admin-identity=admin:JbJ6sDGV37EHzbG9FPvttk64cmg= --provider-type=ec2', 'cat
10
    --constraints-data=e2NwdTogbnVsbCwgaW5zdGFuY2UtdHlwZTogbTEuc21hbGwsIG1lbTogbnVsbCwgcHJvdmlkZXItdHlwZTogZWMyLCB1YnVudHUtc2VyaWVzOiBzcGxlbmRpZH0K
4223
11
    >> /etc/init/juju-machine-agent.conf <<EOF
11
    --provider-type=ec2', 'cat >> /etc/init/juju-machine-agent.conf <<EOF
4224
12
12
4225
13
    description "Juju machine agent"
13
    description "Juju machine agent"
4226
14
14
4227
15
15
4228
=== modified file 'juju/providers/ec2/tests/test_bootstrap.py'
4229
--- juju/providers/ec2/tests/test_bootstrap.py	2011-09-30 04:52:20 +0000
4230
+++ juju/providers/ec2/tests/test_bootstrap.py	2012-03-30 16:56:32 +0000
4231
@@ -3,7 +3,7 @@
4232
3
3
4233
4
import yaml
4
import yaml
4234
5
5
4236
6
from twisted.internet.defer import succeed
6
from twisted.internet.defer import succeed, inlineCallbacks
4237
7
7
4238
8
from txaws.ec2.model import SecurityGroup
8
from txaws.ec2.model import SecurityGroup
4239
9
9
4240
@@ -11,7 +11,7 @@
4241
11
from juju.lib.testing import TestCase
11
from juju.lib.testing import TestCase
4242
12
from juju.providers.ec2.machine import EC2ProviderMachine
12
from juju.providers.ec2.machine import EC2ProviderMachine
4243
13
13
4245
14
from .common import EC2TestMixin, EC2MachineLaunchMixin
14
from .common import EC2TestMixin, EC2MachineLaunchMixin, get_constraints
4246
15
15
4247
16
16
4248
17
DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data")
17
DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data")
4249
@@ -50,8 +50,10 @@
4250
50
            max_count=1,
50
            max_count=1,
4251
51
            min_count=1,
51
            min_count=1,
4252
52
            security_groups=["juju-moon", "juju-moon-0"],
52
            security_groups=["juju-moon", "juju-moon-0"],
4253
53
            availability_zone=None,
4254
53
            user_data=MATCH(verify_user_data))
54
            user_data=MATCH(verify_user_data))
4255
54
55
4256
56
    @inlineCallbacks
4257
55
    def test_launch_bootstrap(self):
57
    def test_launch_bootstrap(self):
4258
56
        """The provider bootstrap can launch a bootstrap/zookeeper machine."""
58
        """The provider bootstrap can launch a bootstrap/zookeeper machine."""
4259
57
59
4260
@@ -64,23 +66,20 @@
4261
64
        self.mocker.result(succeed([]))
66
        self.mocker.result(succeed([]))
4262
65
        self._mock_create_group()
67
        self._mock_create_group()
4263
66
        self._mock_create_machine_group(0)
68
        self._mock_create_machine_group(0)
4265
67
        self._mock_launch_utils(region="us-east-1")
69
        self._mock_launch_utils()
4266
68
        self._mock_launch()
70
        self._mock_launch()
4267
69
        self.mocker.result(succeed([]))
71
        self.mocker.result(succeed([]))
4268
70
        self._mock_save()
72
        self._mock_save()
4269
71
        self.mocker.replay()
73
        self.mocker.replay()
4270
72
74
4271
73
        provider = self.get_provider()
75
        provider = self.get_provider()
4282
74
        deferred = provider.bootstrap()
76
        constraints = yield get_constraints(["instance-type=m1.small"])
4283
75
77
        yield provider.bootstrap(constraints)
4284
76
        def check_log(result):
78
        log_text = log.getvalue()
4285
77
            log_text = log.getvalue()
79
        self.assertIn("Launching juju bootstrap instance", log_text)
4286
78
            self.assertIn("Launching juju bootstrap instance", log_text)
80
        self.assertNotIn("previously bootstrapped", log_text)
4287
79
            self.assertNotIn("previously bootstrapped", log_text)
81
4288
80
82
    @inlineCallbacks
4279
81
        deferred.addCallback(check_log)
4280
82
        return deferred
4281
83
4289
84
    def test_launch_bootstrap_existing_provider_group(self):
83
    def test_launch_bootstrap_existing_provider_group(self):
4290
85
        """
84
        """
4291
86
        When launching a bootstrap instance the provider will use an existing
85
        When launching a bootstrap instance the provider will use an existing
4292
@@ -94,15 +93,17 @@
4293
94
        self.mocker.result(succeed([
93
        self.mocker.result(succeed([
4294
95
            SecurityGroup("juju-%s" % self.env_name, "")]))
94
            SecurityGroup("juju-%s" % self.env_name, "")]))
4295
96
        self._mock_create_machine_group(0)
95
        self._mock_create_machine_group(0)
4297
97
        self._mock_launch_utils(region="us-east-1")
96
        self._mock_launch_utils()
4298
98
        self._mock_launch()
97
        self._mock_launch()
4299
99
        self.mocker.result(succeed([]))
98
        self.mocker.result(succeed([]))
4300
100
        self._mock_save()
99
        self._mock_save()
4301
101
        self.mocker.replay()
100
        self.mocker.replay()
4302
102
101
4303
103
        provider = self.get_provider()
102
        provider = self.get_provider()
4305
104
        return provider.bootstrap()
103
        constraints = yield get_constraints(["instance-type=m1.small"])
4306
104
        yield provider.bootstrap(constraints)
4307
105
105
4308
106
    @inlineCallbacks
4309
106
    def test_run_with_loaded_state(self):
107
    def test_run_with_loaded_state(self):
4310
107
        """
108
        """
4311
108
        If the provider bootstrap is run when there is already a running
109
        If the provider bootstrap is run when there is already a running
4312
@@ -116,21 +117,18 @@
4313
116
        self.mocker.replay()
117
        self.mocker.replay()
4314
117
118
4315
118
        log = self.capture_logging("juju.common")
119
        log = self.capture_logging("juju.common")
4316
119
4317
120
        def validate_result(result):
4318
121
            self.assertTrue(result)
4319
122
            machine = result.pop()
4320
123
            self.assertTrue(isinstance(machine, EC2ProviderMachine))
4321
124
            self.assertEqual(machine.instance_id, "i-foobar")
4322
125
            self.assertEquals(
4323
126
                log.getvalue(),
4324
127
                "juju environment previously bootstrapped.\n")
4325
128
4326
129
        provider = self.get_provider()
120
        provider = self.get_provider()
4331
130
        d = provider.bootstrap()
121
        constraints = yield get_constraints(["instance-type=m1.small"])
4332
131
        d.addCallback(validate_result)
122
        machines = yield provider.bootstrap(constraints)
4333
132
        return d
123
4334
133
124
        (machine,) = machines
4335
125
        self.assertTrue(isinstance(machine, EC2ProviderMachine))
4336
126
        self.assertEqual(machine.instance_id, "i-foobar")
4337
127
        self.assertEquals(
4338
128
            log.getvalue(),
4339
129
            "juju environment previously bootstrapped.\n")
4340
130
4341
131
    @inlineCallbacks
4342
134
    def test_run_with_launch(self):
132
    def test_run_with_launch(self):
4343
135
        """
133
        """
4344
136
        The provider bootstrap will launch an instance when run if there
134
        The provider bootstrap will launch an instance when run if there
4345
@@ -143,16 +141,14 @@
4346
143
        self.mocker.result(succeed([
141
        self.mocker.result(succeed([
4347
144
            SecurityGroup("juju-%s" % self.env_name, "")]))
142
            SecurityGroup("juju-%s" % self.env_name, "")]))
4348
145
        self._mock_create_machine_group(0)
143
        self._mock_create_machine_group(0)
4350
146
        self._mock_launch_utils(region="us-east-1")
144
        self._mock_launch_utils()
4351
147
        self._mock_launch()
145
        self._mock_launch()
4352
148
        self.mocker.result(succeed([self.get_instance("i-foobar")]))
146
        self.mocker.result(succeed([self.get_instance("i-foobar")]))
4353
149
        self._mock_save()
147
        self._mock_save()
4354
150
        self.mocker.replay()
148
        self.mocker.replay()
4355
151
149
4356
152
        def validate_result(result):
4357
153
            (machine,) = result
4358
154
            self.assert_machine(machine, "i-foobar", "")
4359
155
        provider = self.get_provider()
150
        provider = self.get_provider()
4363
156
        d = provider.bootstrap()
151
        constraints = yield get_constraints(["instance-type=m1.small"])
4364
157
        d.addCallback(validate_result)
152
        machines = yield provider.bootstrap(constraints)
4365
158
        return d
153
        (machine,) = machines
4366
154
        self.assert_machine(machine, "i-foobar", "")
4367
159
155
4368
=== modified file 'juju/providers/ec2/tests/test_launch.py'
4369
--- juju/providers/ec2/tests/test_launch.py	2011-09-28 05:22:36 +0000
4370
+++ juju/providers/ec2/tests/test_launch.py	2012-03-30 16:56:32 +0000
4371
@@ -13,15 +13,26 @@
4372
13
from juju.lib.testing import TestCase
13
from juju.lib.testing import TestCase
4373
14
from juju.lib.mocker import MATCH
14
from juju.lib.mocker import MATCH
4374
15
15
4376
16
from .common import EC2TestMixin, EC2MachineLaunchMixin
16
from .common import EC2TestMixin, EC2MachineLaunchMixin, get_constraints
4377
17
17
4378
18
DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data")
18
DATA_DIR = os.path.join(os.path.abspath(os.path.dirname(__file__)), "data")
4379
19
19
4380
20
20
4381
21
class EC2MachineLaunchTest(EC2TestMixin, EC2MachineLaunchMixin, TestCase):
21
class EC2MachineLaunchTest(EC2TestMixin, EC2MachineLaunchMixin, TestCase):
4382
22
22
4383
23
    @inlineCallbacks
4384
24
    def setUp(self):
4385
25
        yield super(EC2MachineLaunchTest, self).setUp()
4386
26
        self.constraints = yield get_constraints([])
4387
27
        self.gen_constraints = yield get_constraints(["cpu=20", "mem=7168"])
4388
28
        self.gen_constraints = self.gen_constraints.with_series("dribbly")
4389
29
        self.ec2_constraints = yield get_constraints(
4390
30
            ["instance-type=cc2.8xlarge", "ec2-zone=b"])
4391
31
        self.ec2_constraints = self.ec2_constraints.with_series("vast")
4392
32
4393
23
    def _mock_launch(self, instance, expect_ami="ami-default",
33
    def _mock_launch(self, instance, expect_ami="ami-default",
4394
24
                     expect_instance_type="m1.small",
34
                     expect_instance_type="m1.small",
4395
35
                     expect_availability_zone=None,
4396
25
                     cloud_init="launch_cloud_init"):
36
                     cloud_init="launch_cloud_init"):
4397
26
37
4398
27
        def verify_user_data(data):
38
        def verify_user_data(data):
4399
@@ -37,6 +48,7 @@
4400
37
            max_count=1,
48
            max_count=1,
4401
38
            min_count=1,
49
            min_count=1,
4402
39
            security_groups=["juju-moon", "juju-moon-1"],
50
            security_groups=["juju-moon", "juju-moon-1"],
4403
51
            availability_zone=expect_availability_zone,
4404
40
            user_data=MATCH(verify_user_data))
52
            user_data=MATCH(verify_user_data))
4405
41
53
4406
42
        self.mocker.result(succeed([instance]))
54
        self.mocker.result(succeed([instance]))
4407
@@ -62,7 +74,7 @@
4408
62
        self.mocker.result(succeed([]))
74
        self.mocker.result(succeed([]))
4409
63
        self._mock_create_group()
75
        self._mock_create_group()
4410
64
        self._mock_create_machine_group("1")
76
        self._mock_create_machine_group("1")
4412
65
        self._mock_launch_utils(region="us-east-1")
77
        self._mock_launch_utils()
4413
66
        self._mock_get_zookeeper_hosts()
78
        self._mock_get_zookeeper_hosts()
4414
67
        self._mock_launch(self.get_instance("i-foobar"))
79
        self._mock_launch(self.get_instance("i-foobar"))
4415
68
        self.mocker.replay()
80
        self.mocker.replay()
4416
@@ -71,18 +83,28 @@
4417
71
            (machine,) = result
83
            (machine,) = result
4418
72
            self.assert_machine(machine, "i-foobar", "")
84
            self.assert_machine(machine, "i-foobar", "")
4419
73
        provider = self.get_provider()
85
        provider = self.get_provider()
4421
74
        d = provider.start_machine({"machine-id": "1"})
86
        d = provider.start_machine({
4422
87
            "machine-id": "1", "constraints": self.constraints})
4423
75
        d.addCallback(verify_result)
88
        d.addCallback(verify_result)
4424
76
        return d
89
        return d
4425
77
90
4426
78
    @inlineCallbacks
91
    @inlineCallbacks
4427
92
    def test_provider_launch_requires_constraints(self):
4428
93
        self.mocker.replay()
4429
94
        provider = self.get_provider()
4430
95
        d = provider.start_machine({"machine-id": "1"})
4431
96
        e = yield self.assertFailure(d, ProviderError)
4432
97
        self.assertEquals(
4433
98
            str(e), "Cannot launch a machine without specifying constraints")
4434
99
4435
100
    @inlineCallbacks
4436
79
    def test_provider_launch_using_branch(self):
101
    def test_provider_launch_using_branch(self):
4437
80
        """Can use a juju branch to launch a machine"""
102
        """Can use a juju branch to launch a machine"""
4438
81
        self.ec2.describe_security_groups()
103
        self.ec2.describe_security_groups()
4439
82
        self.mocker.result(succeed([]))
104
        self.mocker.result(succeed([]))
4440
83
        self._mock_create_group()
105
        self._mock_create_group()
4441
84
        self._mock_create_machine_group("1")
106
        self._mock_create_machine_group("1")
4443
85
        self._mock_launch_utils(region="us-east-1")
107
        self._mock_launch_utils()
4444
86
        self._mock_get_zookeeper_hosts()
108
        self._mock_get_zookeeper_hosts()
4445
87
        self._mock_launch(
109
        self._mock_launch(
4446
88
            self.get_instance("i-foobar"),
110
            self.get_instance("i-foobar"),
4447
@@ -91,7 +113,8 @@
4448
91
113
4449
92
        provider = self.get_provider()
114
        provider = self.get_provider()
4450
93
        provider.config["juju-origin"] = "lp:~wizard/juju-juicebar"
115
        provider.config["juju-origin"] = "lp:~wizard/juju-juicebar"
4452
94
        machines = yield provider.start_machine({"machine-id": "1"})
116
        machines = yield provider.start_machine({
4453
117
            "machine-id": "1", "constraints": self.constraints})
4454
95
        self.assert_machine(machines[0], "i-foobar", "")
118
        self.assert_machine(machines[0], "i-foobar", "")
4455
96
119
4456
97
    @inlineCallbacks
120
    @inlineCallbacks
4457
@@ -101,7 +124,7 @@
4458
101
        self.mocker.result(succeed([]))
124
        self.mocker.result(succeed([]))
4459
102
        self._mock_create_group()
125
        self._mock_create_group()
4460
103
        self._mock_create_machine_group("1")
126
        self._mock_create_machine_group("1")
4462
104
        self._mock_launch_utils(region="us-east-1")
127
        self._mock_launch_utils()
4463
105
        self._mock_get_zookeeper_hosts()
128
        self._mock_get_zookeeper_hosts()
4464
106
        self._mock_launch(
129
        self._mock_launch(
4465
107
            self.get_instance("i-foobar"),
130
            self.get_instance("i-foobar"),
4466
@@ -110,7 +133,8 @@
4467
110
133
4468
111
        provider = self.get_provider()
134
        provider = self.get_provider()
4469
112
        provider.config["juju-origin"] = "ppa"
135
        provider.config["juju-origin"] = "ppa"
4471
113
        machines = yield provider.start_machine({"machine-id": "1"})
136
        machines = yield provider.start_machine({
4472
137
            "machine-id": "1", "constraints": self.constraints})
4473
114
        self.assert_machine(machines[0], "i-foobar", "")
138
        self.assert_machine(machines[0], "i-foobar", "")
4474
115
139
4475
116
    @inlineCallbacks
140
    @inlineCallbacks
4476
@@ -120,7 +144,7 @@
4477
120
        self.mocker.result(succeed([]))
144
        self.mocker.result(succeed([]))
4478
121
        self._mock_create_group()
145
        self._mock_create_group()
4479
122
        self._mock_create_machine_group("1")
146
        self._mock_create_machine_group("1")
4481
123
        self._mock_launch_utils(region="us-east-1")
147
        self._mock_launch_utils()
4482
124
        self._mock_get_zookeeper_hosts()
148
        self._mock_get_zookeeper_hosts()
4483
125
        self._mock_launch(
149
        self._mock_launch(
4484
126
            self.get_instance("i-foobar"),
150
            self.get_instance("i-foobar"),
4485
@@ -129,7 +153,8 @@
4486
129
153
4487
130
        provider = self.get_provider()
154
        provider = self.get_provider()
4488
131
        provider.config["juju-origin"] = "distro"
155
        provider.config["juju-origin"] = "distro"
4490
132
        machines = yield provider.start_machine({"machine-id": "1"})
156
        machines = yield provider.start_machine({
4491
157
            "machine-id": "1", "constraints": self.constraints})
4492
133
        self.assert_machine(machines[0], "i-foobar", "")
158
        self.assert_machine(machines[0], "i-foobar", "")
4493
134
159
4494
135
    @inlineCallbacks
160
    @inlineCallbacks
4495
@@ -141,17 +166,17 @@
4496
141
        self.ec2.describe_security_groups()
166
        self.ec2.describe_security_groups()
4497
142
        self.mocker.result(succeed([security_group]))
167
        self.mocker.result(succeed([security_group]))
4498
143
        self._mock_create_machine_group("1")
168
        self._mock_create_machine_group("1")
4500
144
        self._mock_launch_utils(region="us-east-1")
169
        self._mock_launch_utils()
4501
145
        self._mock_get_zookeeper_hosts()
170
        self._mock_get_zookeeper_hosts()
4502
146
        self._mock_launch(instance)
171
        self._mock_launch(instance)
4503
147
        self.mocker.replay()
172
        self.mocker.replay()
4504
148
173
4505
149
        provider = self.get_provider()
174
        provider = self.get_provider()
4511
150
        provided_machines = yield provider.start_machine({"machine-id": "1"})
175
        machines = yield provider.start_machine({
4512
151
        self.assertEqual(len(provided_machines), 1)
176
            "machine-id": "1", "constraints": self.constraints})
4513
152
        self.assertTrue(isinstance(provided_machines[0], EC2ProviderMachine))
177
        self.assertEqual(len(machines), 1)
4514
153
        self.assertEqual(
178
        self.assertTrue(isinstance(machines[0], EC2ProviderMachine))
4515
154
            provided_machines[0].instance_id, instance.instance_id)
179
        self.assertEqual(machines[0].instance_id, instance.instance_id)
4516
155
180
4517
156
    @inlineCallbacks
181
    @inlineCallbacks
4518
157
    def test_provider_launch_existing_machine_security_group(self):
182
    def test_provider_launch_existing_machine_security_group(self):
4519
@@ -165,17 +190,17 @@
4520
165
        self._mock_create_group()
190
        self._mock_create_group()
4521
166
        self._mock_delete_machine_group("1")  # delete existing sg
191
        self._mock_delete_machine_group("1")  # delete existing sg
4522
167
        self._mock_create_machine_group("1")  # then recreate
192
        self._mock_create_machine_group("1")  # then recreate
4524
168
        self._mock_launch_utils(region="us-east-1")
193
        self._mock_launch_utils()
4525
169
        self._mock_get_zookeeper_hosts()
194
        self._mock_get_zookeeper_hosts()
4526
170
        self._mock_launch(instance)
195
        self._mock_launch(instance)
4527
171
        self.mocker.replay()
196
        self.mocker.replay()
4528
172
197
4529
173
        provider = self.get_provider()
198
        provider = self.get_provider()
4535
174
        provided_machines = yield provider.start_machine({"machine-id": "1"})
199
        machines = yield provider.start_machine({
4536
175
        self.assertEqual(len(provided_machines), 1)
200
            "machine-id": "1", "constraints": self.constraints})
4537
176
        self.assertTrue(isinstance(provided_machines[0], EC2ProviderMachine))
201
        self.assertEqual(len(machines), 1)
4538
177
        self.assertEqual(
202
        self.assertTrue(isinstance(machines[0], EC2ProviderMachine))
4539
178
            provided_machines[0].instance_id, instance.instance_id)
203
        self.assertEqual(machines[0].instance_id, instance.instance_id)
4540
179
204
4541
180
    @inlineCallbacks
205
    @inlineCallbacks
4542
181
    def test_provider_launch_existing_machine_security_group_is_active(self):
206
    def test_provider_launch_existing_machine_security_group_is_active(self):
4543
@@ -191,13 +216,14 @@
4544
191
        self.mocker.result(succeed([machine_group]))
216
        self.mocker.result(succeed([machine_group]))
4545
192
        self._mock_create_group()
217
        self._mock_create_group()
4546
193
        self._mock_delete_machine_group_was_deleted("1")  # sg is gone!
218
        self._mock_delete_machine_group_was_deleted("1")  # sg is gone!
4548
194
        self._mock_launch_utils(region="us-east-1")
219
        self._mock_launch_utils()
4549
195
        self._mock_get_zookeeper_hosts()
220
        self._mock_get_zookeeper_hosts()
4550
196
        self.mocker.replay()
221
        self.mocker.replay()
4551
197
222
4552
198
        provider = self.get_provider()
223
        provider = self.get_provider()
4553
199
        ex = yield self.assertFailure(
224
        ex = yield self.assertFailure(
4555
200
            provider.start_machine({"machine-id": "1"}),
225
            provider.start_machine({
4556
226
                "machine-id": "1", "constraints": self.constraints}),
4557
201
            ProviderInteractionError)
227
            ProviderInteractionError)
4558
202
        self.assertEqual(
228
        self.assertEqual(
4559
203
            str(ex),
229
            str(ex),
4560
@@ -216,7 +242,8 @@
4561
216
        self.mocker.replay()
242
        self.mocker.replay()
4562
217
243
4563
218
        provider = self.get_provider()
244
        provider = self.get_provider()
4565
219
        d = provider.start_machine({"machine-id": "1"})
245
        d = provider.start_machine({
4566
246
            "machine-id": "1", "constraints": self.constraints})
4567
220
        self.assertFailure(d, EnvironmentNotFound)
247
        self.assertFailure(d, EnvironmentNotFound)
4568
221
        return d
248
        return d
4569
222
249
4570
@@ -231,65 +258,62 @@
4571
231
        self.mocker.replay()
258
        self.mocker.replay()
4572
232
259
4573
233
        provider = self.get_provider()
260
        provider = self.get_provider()
4575
234
        d = provider.start_machine({"machine-id": "1"})
261
        d = provider.start_machine({
4576
262
            "machine-id": "1", "constraints": self.constraints})
4577
235
        self.assertFailure(d, EnvironmentNotFound)
263
        self.assertFailure(d, EnvironmentNotFound)
4578
236
        return d
264
        return d
4579
237
265
4615
238
    def test_launch_options_known_instance_type(self):
266
    def test_launch_options_from_config_region(self):
4616
239
        self.ec2.describe_security_groups()
267
        self.ec2.describe_security_groups()
4617
240
        self.mocker.result(succeed([]))
268
        self.mocker.result(succeed([]))
4618
241
        self._mock_create_group()
269
        self._mock_create_group()
4619
242
        self._mock_create_machine_group("1")
270
        self._mock_create_machine_group("1")
4620
243
        self._mock_launch_utils(region="us-east-1")
271
        self._mock_launch_utils(
4621
244
        self._mock_get_zookeeper_hosts()
272
            ami_name="ami-regional",
4622
245
        self._mock_launch(
273
            get_ami_args=("splendid", "amd64", "somewhere-else-1", False))
4623
246
            self.get_instance("i-foobar"), expect_instance_type="m1.ginormous")
274
        self._mock_get_zookeeper_hosts()
4624
247
        self.mocker.replay()
275
        self._mock_launch(self.get_instance("i-foobar"), "ami-regional")
4590
248
4591
249
        provider = self.get_provider()
4592
250
        provider.config["default-instance-type"] = "m1.ginormous"
4593
251
        return provider.start_machine({"machine-id": "1"})
4594
252
4595
253
    def _mock_launch_with_ami_params(self, get_ami_kwargs, expect_ami=None):
4596
254
        expect_ami = expect_ami or "ami-default"
4597
255
        self.ec2.describe_security_groups()
4598
256
        self.mocker.result(succeed([]))
4599
257
        self._mock_create_group()
4600
258
        self._mock_create_machine_group("1")
4601
259
        self._mock_launch_utils(ami_name=expect_ami, **get_ami_kwargs)
4602
260
        self._mock_get_zookeeper_hosts()
4603
261
        self._mock_launch(self.get_instance("i-foobar"), expect_ami)
4604
262
4605
263
    def test_launch_options_known_ami(self):
4606
264
        self._mock_launch_with_ami_params({}, expect_ami="ami-different")
4607
265
        self.mocker.replay()
4608
266
4609
267
        provider = self.get_provider()
4610
268
        provider.config["default-image-id"] = "ami-different"
4611
269
        return provider.start_machine({"machine-id": "1"})
4612
270
4613
271
    def test_launch_options_region(self):
4614
272
        self._mock_launch_with_ami_params({"region": "somewhere-else-1"})
4625
273
        self.mocker.replay()
276
        self.mocker.replay()
4626
274
277
4627
275
        provider = self.get_provider()
278
        provider = self.get_provider()
4628
276
        provider.config["region"] = "somewhere-else-1"
279
        provider.config["region"] = "somewhere-else-1"
4648
277
        return provider.start_machine({"machine-id": "1"})
280
        return provider.start_machine({
4649
278
281
            "machine-id": "1", "constraints": self.constraints})
4650
279
    def test_launch_options_custom_image_options(self):
282
4651
280
        self._mock_launch_with_ami_params({
283
    def test_launch_options_ec2_constraints(self):
4652
281
            "region": "us-east-1",
284
        self.ec2.describe_security_groups()
4653
282
            "ubuntu_release": "choleric",
285
        self.mocker.result(succeed([]))
4654
283
            "architecture": "quantum86",
286
        self._mock_create_group()
4655
284
            "persistent_storage": "maybe",
287
        self._mock_create_machine_group("1")
4656
285
            "daily": "perhaps"})
288
        self._mock_launch_utils(
4657
286
        self.mocker.replay()
289
            ami_name="ami-fancy-cluster",
4658
287
290
            get_ami_args=("vast", "amd64", "us-east-1", True))
4659
288
        provider = self.get_provider()
291
        self._mock_get_zookeeper_hosts()
4660
289
        constraints = {
292
        self._mock_launch(
4661
290
            "ubuntu_release": "choleric",
293
            self.get_instance("i-foobar"), "ami-fancy-cluster",
4662
291
            "architecture": "quantum86",
294
            expect_instance_type="cc2.8xlarge",
4663
292
            "persistent_storage": "maybe",
295
            expect_availability_zone="us-east-1b")
4664
293
            "daily": "perhaps"}
296
        self.mocker.replay()
4665
294
        return provider.start_machine({"machine-id": "1",
297
4666
295
                                       "constraints": constraints})
298
        provider = self.get_provider()
4667
299
        return provider.start_machine({
4668
300
            "machine-id": "1",
4669
301
            "constraints": self.ec2_constraints})
4670
302
4671
303
    def test_launch_options_generic_constraints(self):
4672
304
        self.ec2.describe_security_groups()
4673
305
        self.mocker.result(succeed([]))
4674
306
        self._mock_create_group()
4675
307
        self._mock_create_machine_group("1")
4676
308
        self._mock_launch_utils(
4677
309
            get_ami_args=("dribbly", "amd64", "us-east-1", False))
4678
310
        self._mock_get_zookeeper_hosts()
4679
311
        self._mock_launch(
4680
312
            self.get_instance("i-foobar"), "ami-default",
4681
313
            expect_instance_type="c1.xlarge")
4682
314
        self.mocker.replay()
4683
315
4684
316
        provider = self.get_provider()
4685
317
        return provider.start_machine({
4686
318
            "machine-id": "1",
4687
319
            "constraints": self.gen_constraints})
4688
296
320
4689
=== modified file 'juju/providers/ec2/tests/test_provider.py'
4690
--- juju/providers/ec2/tests/test_provider.py	2011-09-23 19:47:01 +0000
4691
+++ juju/providers/ec2/tests/test_provider.py	2012-03-30 16:56:32 +0000
4692
@@ -1,7 +1,10 @@
4693
1
from twisted.internet.defer import inlineCallbacks
4694
2
4695
3
from juju.environment.errors import EnvironmentsConfigError
4696
4
from juju.errors import ConstraintError
4697
1
from juju.lib.testing import TestCase
5
from juju.lib.testing import TestCase
4698
2
from juju.providers.ec2.files import FileStorage
6
from juju.providers.ec2.files import FileStorage
4699
3
from juju.providers.ec2 import MachineProvider
7
from juju.providers.ec2 import MachineProvider
4700
4
from juju.environment.errors import EnvironmentsConfigError
4701
5
8
4702
6
from .common import EC2TestMixin
9
from .common import EC2TestMixin
4703
7
10
4704
@@ -117,6 +120,91 @@
4705
117
        serialized = provider.get_serialization_data()
120
        serialized = provider.get_serialization_data()
4706
118
        self.assertEqual(config, serialized)
121
        self.assertEqual(config, serialized)
4707
119
122
4708
123
    def test_get_legacy_config_keys(self):
4709
124
        provider = MachineProvider(self.env_name, {
4710
125
            # Note: these keys *will* at some stage be considered legacy keys;
4711
126
            # they're included here to make sure the tests are updated when we
4712
127
            # make that change.
4713
128
            "default-series": "foo", "placement": "bar"})
4714
129
        self.assertEquals(provider.get_legacy_config_keys(), set())
4715
130
4716
131
        # These keys are not valid on Amazon EC2...
4717
132
        provider.config.update({
4718
133
            "default-instance-type": "baz", "default-image-id": "qux"})
4719
134
        self.assertEquals(provider.get_legacy_config_keys(), set((
4720
135
            "default-instance-type", "default-image-id")))
4721
136
4722
137
        # ...but they still are when using private clouds.
4723
138
        provider.config.update({"ec2-uri": "anything"})
4724
139
        self.assertEquals(provider.get_legacy_config_keys(), set())
4725
140
4726
141
4727
142
class ProviderConstraintsTestCase(TestCase):
4728
143
4729
144
    def constraint_set(self):
4730
145
        provider = MachineProvider("some-ec2-env", {})
4731
146
        return provider.get_constraint_set()
4732
147
4733
148
    @inlineCallbacks
4734
149
    def assert_invalid(self, msg, *strs):
4735
150
        cs = yield self.constraint_set()
4736
151
        e = self.assertRaises(ConstraintError, cs.parse, strs)
4737
152
        self.assertEquals(str(e), msg)
4738
153
4739
154
    @inlineCallbacks
4740
155
    def test_constraints(self):
4741
156
        cs = yield self.constraint_set()
4742
157
        self.assertEquals(cs.parse([]), {
4743
158
            "provider-type": "ec2",
4744
159
            "ubuntu-series": None,
4745
160
            "instance-type": None,
4746
161
            "ec2-zone": None,
4747
162
            "arch": "amd64",
4748
163
            "cpu": 1.0,
4749
164
            "mem": 512.0})
4750
165
        self.assertEquals(cs.parse(["ec2-zone=X", "instance-type=m1.small"]), {
4751
166
            "provider-type": "ec2",
4752
167
            "ubuntu-series": None,
4753
168
            "instance-type": "m1.small",
4754
169
            "ec2-zone": "x",
4755
170
            "arch": "amd64",
4756
171
            "cpu": None,
4757
172
            "mem": None})
4758
173
4759
174
        yield self.assert_invalid(
4760
175
            "Bad 'ec2-zone' constraint '7': expected single ascii letter",
4761
176
            "ec2-zone=7")
4762
177
        yield self.assert_invalid(
4763
178
            "Bad 'ec2-zone' constraint 'blob': expected single ascii letter",
4764
179
            "ec2-zone=blob")
4765
180
        yield self.assert_invalid(
4766
181
            "Bad 'instance-type' constraint 'qq1.moar': unknown instance type",
4767
182
            "instance-type=qq1.moar")
4768
183
        yield self.assert_invalid(
4769
184
            "Ambiguous constraints: 'cpu' overlaps with 'instance-type'",
4770
185
            "instance-type=m1.small", "cpu=1")
4771
186
        yield self.assert_invalid(
4772
187
            "Ambiguous constraints: 'instance-type' overlaps with 'mem'",
4773
188
            "instance-type=m1.small", "mem=2G")
4774
189
4775
190
    @inlineCallbacks
4776
191
    def test_satisfy_zone_constraint(self):
4777
192
        cs = yield self.constraint_set()
4778
193
        a = cs.parse(["ec2-zone=a"]).with_series("series")
4779
194
        b = cs.parse(["ec2-zone=b"]).with_series("series")
4780
195
        self.assertTrue(a.can_satisfy(a))
4781
196
        self.assertTrue(b.can_satisfy(b))
4782
197
        self.assertFalse(a.can_satisfy(b))
4783
198
        self.assertFalse(b.can_satisfy(a))
4784
199
4785
200
    @inlineCallbacks
4786
201
    def test_non_amazon_constraints(self):
4787
202
        provider = MachineProvider("some-non-ec2-env", {"ec2-uri": "blah"})
4788
203
        cs = yield provider.get_constraint_set()
4789
204
        self.assertEquals(cs.parse([]), {
4790
205
            "provider-type": "ec2",
4791
206
            "ubuntu-series": None})
4792
207
4793
120
208
4794
121
class FailCreateTest(TestCase):
209
class FailCreateTest(TestCase):
4795
122
210
4796
123
211
4797
=== modified file 'juju/providers/ec2/tests/test_utils.py'
4798
--- juju/providers/ec2/tests/test_utils.py	2012-03-26 17:13:53 +0000
4799
+++ juju/providers/ec2/tests/test_utils.py	2012-03-30 16:56:32 +0000
4800
@@ -1,12 +1,16 @@
4801
1
import inspect
1
import inspect
4802
2
import os
2
import os
4803
3
3
4805
4
from twisted.internet.defer import fail, succeed
4
from twisted.internet.defer import fail, succeed, inlineCallbacks
4806
5
from twisted.web.error import Error
5
from twisted.web.error import Error
4807
6
6
4808
7
from juju.errors import ProviderError
4809
7
from juju.lib.testing import TestCase
8
from juju.lib.testing import TestCase
4810
8
from juju.providers import ec2
9
from juju.providers import ec2
4812
9
from juju.providers.ec2.utils import get_current_ami, get_image_id
10
from juju.providers.ec2.utils import (
4813
11
    get_current_ami, get_instance_type, get_machine_spec)
4814
12
4815
13
from .common import get_constraints
4816
10
14
4817
11
15
4818
12
IMAGE_URI_TEMPLATE = "\
16
IMAGE_URI_TEMPLATE = "\
4819
@@ -26,7 +30,7 @@
4820
26
        page(IMAGE_URI_TEMPLATE % "nutty")
30
        page(IMAGE_URI_TEMPLATE % "nutty")
4821
27
        self.mocker.result(fail(Error("404")))
31
        self.mocker.result(fail(Error("404")))
4822
28
        self.mocker.replay()
32
        self.mocker.replay()
4824
29
        d = get_current_ami(ubuntu_release="nutty")
33
        d = get_current_ami("nutty", "i386", "us-east-1", False)
4825
30
        self.failUnlessFailure(d, LookupError)
34
        self.failUnlessFailure(d, LookupError)
4826
31
        return d
35
        return d
4827
32
36
4828
@@ -39,7 +43,7 @@
4829
39
        page(IMAGE_URI_TEMPLATE % "lucid")
43
        page(IMAGE_URI_TEMPLATE % "lucid")
4830
40
        self.mocker.result(succeed(""))
44
        self.mocker.result(succeed(""))
4831
41
        self.mocker.replay()
45
        self.mocker.replay()
4833
42
        d = get_current_ami(ubuntu_release="lucid")
46
        d = get_current_ami("lucid", "i386", "us-east-1", False)
4834
43
        self.failUnlessFailure(d, LookupError)
47
        self.failUnlessFailure(d, LookupError)
4835
44
        return d
48
        return d
4836
45
49
4837
@@ -51,12 +55,20 @@
4838
51
            open(os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
55
            open(os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
4839
52
56
4840
53
        self.mocker.replay()
57
        self.mocker.replay()
4847
54
        d = get_current_ami(ubuntu_release="lucid")
58
        d = get_current_ami("lucid", "i386", "us-east-1", False)
4848
55
59
        d.addCallback(self.assertEquals, "ami-714ba518")
4849
56
        def verify_result(result):
60
        return d
4850
57
            self.assertEqual(result, "ami-714ba518")
61
4851
58
62
    def test_current_ami_by_arch(self):
4852
59
        d.addCallback(verify_result)
63
        """The current server machine image can be retrieved by arch."""
4853
64
        page = self.mocker.replace("twisted.web.client.getPage")
4854
65
        page(IMAGE_URI_TEMPLATE % "lucid")
4855
66
        self.mocker.result(
4856
67
            succeed(open(
4857
68
                os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
4858
69
        self.mocker.replay()
4859
70
        d = get_current_ami("lucid", "amd64", "us-east-1", False)
4860
71
        d.addCallback(self.assertEquals, "ami-4b4ba522")
4861
60
        return d
72
        return d
4862
61
73
4863
62
    def test_current_ami_by_region(self):
74
    def test_current_ami_by_region(self):
4864
@@ -67,75 +79,166 @@
4865
67
            succeed(open(
79
            succeed(open(
4866
68
                os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
80
                os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
4867
69
        self.mocker.replay()
81
        self.mocker.replay()
4881
70
        d = get_current_ami(ubuntu_release="lucid", region="us-west-1")
82
        d = get_current_ami("lucid", "i386", "us-west-1", False)
4882
71
83
        d.addCallback(self.assertEquals, "ami-cb97c68e")
4883
72
        def verify_result(result):
84
        return d
4884
73
            self.assertEqual(result, "ami-cb97c68e")
85
4885
74
86
    def test_current_ami_with_virtualisation_info(self):
4886
75
        d.addCallback(verify_result)
87
        """The current server machine image can be retrieved by arch."""
4887
76
        return d
88
        page = self.mocker.replace("twisted.web.client.getPage")
4888
77
89
        page(IMAGE_URI_TEMPLATE % "natty")
4889
78
    def test_current_ami_non_ebs(self):
90
        self.mocker.result(
4890
79
        """
91
            succeed(open(
4891
80
        The get_current_ami function accepts several filtering parameters
92
                os.path.join(IMAGE_DATA_DIR, "natty.txt")).read()))
4892
81
        to guide image selection.
93
        self.mocker.replay()
4893
82
        """
94
        d = get_current_ami("natty", "amd64", "us-east-1", True)
4894
95
        d.addCallback(self.assertEquals, "ami-1cad5275")
4895
96
        return d
4896
97
4897
98
    def test_hvm_request_on_old_series(self):
4898
83
        page = self.mocker.replace("twisted.web.client.getPage")
99
        page = self.mocker.replace("twisted.web.client.getPage")
4899
84
        page(IMAGE_URI_TEMPLATE % "lucid")
100
        page(IMAGE_URI_TEMPLATE % "lucid")
4902
85
        self.mocker.result(succeed(
101
        self.mocker.result(
4903
86
            open(os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
102
            succeed(open(
4904
103
                os.path.join(IMAGE_DATA_DIR, "lucid.txt")).read()))
4905
87
        self.mocker.replay()
104
        self.mocker.replay()
4912
88
        d = get_current_ami(ubuntu_release="lucid", persistent_storage=False)
105
        d = get_current_ami("lucid", "amd64", "us-east-1", True)
4913
89
106
        self.failUnlessFailure(d, LookupError)
4908
90
        def verify_result(result):
4909
91
            self.assertEqual(result, "ami-2d4aa444")
4910
92
4911
93
        d.addCallback(verify_result)
4914
94
        return d
107
        return d
4915
95
108
4916
96
109
4917
97
class GetImageIdTest(TestCase):
110
class GetImageIdTest(TestCase):
4918
98
111
4925
99
    def test_default_image_id(self):
112
    @inlineCallbacks
4926
100
        d = get_image_id({"default-image-id": "ami-burble"}, {})
113
    def assert_image_id(self, config, constraints, series, arch, region, hvm,
4927
101
        d.addCallback(self.assertEquals, "ami-burble")
114
                        instance_type):
4922
102
        return d
4923
103
4924
104
    def test_no_constraints(self):
4928
105
        get_current_ami_m = self.mocker.replace(get_current_ami)
115
        get_current_ami_m = self.mocker.replace(get_current_ami)
4930
106
        get_current_ami_m(region="us-east-1")
116
        get_current_ami_m(series, arch, region, hvm)
4931
107
        self.mocker.result(succeed("ami-giggle"))
117
        self.mocker.result(succeed("ami-giggle"))
4932
108
        self.mocker.replay()
118
        self.mocker.replay()
4933
109
119
4966
110
        d = get_image_id({}, {})
120
        spec = yield get_machine_spec(config, constraints)
4967
111
        d.addCallback(self.assertEquals, "ami-giggle")
121
        self.assertEquals(spec.image_id, "ami-giggle")
4968
112
        return d
122
        self.assertEquals(spec.instance_type, instance_type)
4969
113
123
4970
114
    def test_default_series(self):
124
    @inlineCallbacks
4971
115
        get_current_ami_m = self.mocker.replace(get_current_ami)
125
    def test_empty_config(self):
4972
116
        get_current_ami_m(region="us-east-1", ubuntu_release="puissant")
126
        constraints = yield get_constraints(["arch=i386"])
4973
117
        self.mocker.result(succeed("ami-pickle"))
127
        yield self.assert_image_id(
4974
118
        self.mocker.replay()
128
            {}, constraints,
4975
119
129
            "splendid", "i386", "us-east-1", False,
4976
120
        d = get_image_id({"default-series": "puissant"}, {})
130
            "m1.small")
4977
121
        d.addCallback(self.assertEquals, "ami-pickle")
131
4978
122
        return d
132
    @inlineCallbacks
4979
123
133
    def test_series_from_config(self):
4980
124
    def test_uses_constraints(self):
134
        config = {"default-series": "puissant"}
4981
125
        get_current_ami_m = self.mocker.replace(get_current_ami)
135
        constraints = yield get_constraints(["arch=i386"], None)
4982
126
        get_current_ami_m(ubuntu_release="serendipitous", architecture="x512",
136
        yield self.assert_image_id(
4983
127
                          daily=False, persistent_storage=True,
137
            config, constraints,
4984
128
                          region="blah-north-6")
138
            "puissant", "i386", "us-east-1", False,
4985
129
        self.mocker.result(succeed("ami-tinkle"))
139
            "m1.small")
4986
130
        self.mocker.replay()
140
4987
131
141
    @inlineCallbacks
4988
132
        constraints = {
142
    def test_arch_from_instance_constraint(self):
4989
133
            "architecture": "x512",
143
        constraints = yield get_constraints([
4990
134
            "ubuntu_release": "serendipitous",
144
            "instance-type=m1.large", "arch=any"])
4991
135
            "persistent_storage": True,
145
        yield self.assert_image_id(
4992
136
            "daily": False}
146
            {}, constraints,
4993
137
        d = get_image_id(
147
            "splendid", "amd64", "us-east-1", False,
4994
138
            {"region": "blah-north-6", "default-series": "overridden"},
148
            "m1.large")
4995
139
            constraints)
149
4996
140
        d.addCallback(self.assertEquals, "ami-tinkle")
150
    @inlineCallbacks
4997
141
        return d
151
    def test_arch_from_nothing(self):
4998
152
        constraints = yield get_constraints([
4999
153
            "arch=any", "cpu=any", "mem=any", "instance-type=any"])
5000
154
        yield self.assert_image_id(
Status:	Merged
Merge reported by:	Kapil Thangavelu
Merged at revision:	not available
Proposed branch:	lp:~fwereade/pyjuju/shadow-trunk-1204
Merge into:	lp:pyjuju
Diff against target:	7373 lines (+2733/-1538) 97 files modified docs/source/internals/constraints-notes.rst (+78/-0) juju/agents/provision.py (+3/-2) juju/agents/tests/common.py (+3/-19) juju/agents/tests/test_machine.py (+6/-14) juju/agents/tests/test_provision.py (+33/-48) juju/control/__init__.py (+2/-0) juju/control/add_unit.py (+6/-1) juju/control/bootstrap.py (+16/-2) juju/control/constraints_get.py (+75/-0) juju/control/constraints_set.py (+41/-28) juju/control/deploy.py (+13/-18) juju/control/initialize.py (+7/-1) juju/control/legacy.py (+41/-0) juju/control/terminate_machine.py (+2/-0) juju/control/tests/test_add_relation.py (+0/-7) juju/control/tests/test_add_unit.py (+44/-9) juju/control/tests/test_bootstrap.py (+33/-14) juju/control/tests/test_config_get.py (+0/-4) juju/control/tests/test_config_set.py (+0/-4) juju/control/tests/test_constraints_get.py (+116/-0) juju/control/tests/test_constraints_set.py (+28/-17) juju/control/tests/test_control.py (+5/-10) juju/control/tests/test_debug_hooks.py (+0/-9) juju/control/tests/test_debug_log.py (+1/-7) juju/control/tests/test_deploy.py (+66/-7) juju/control/tests/test_destroy_service.py (+0/-5) juju/control/tests/test_initialize.py (+26/-3) juju/control/tests/test_remove_unit.py (+0/-6) juju/control/tests/test_resolved.py (+0/-6) juju/control/tests/test_scp.py (+2/-20) juju/control/tests/test_ssh.py (+0/-16) juju/control/tests/test_status.py (+0/-8) juju/control/tests/test_terminate_machine.py (+9/-7) juju/control/tests/test_upgrade_charm.py (+0/-10) juju/control/tests/test_utils.py (+0/-6) juju/control/utils.py (+27/-0) juju/environment/config.py (+49/-55) juju/environment/tests/test_config.py (+93/-12) juju/hooks/tests/test_invoker.py (+7/-2) juju/machine/constraints.py (+241/-252) juju/machine/tests/test_constraints.py (+284/-243) juju/machine/unit.py (+0/-1) juju/providers/common/base.py (+17/-8) juju/providers/common/bootstrap.py (+8/-2) juju/providers/common/cloudinit.py (+15/-2) juju/providers/common/launch.py (+23/-3) juju/providers/common/tests/data/cloud_init_bootstrap (+2/-2) juju/providers/common/tests/data/cloud_init_bootstrap_zookeepers (+2/-2) juju/providers/common/tests/data/cloud_init_distro (+4/-3) juju/providers/common/tests/data/cloud_init_ppa (+4/-3) juju/providers/common/tests/test_base.py (+4/-0) juju/providers/common/tests/test_bootstrap.py (+27/-12) juju/providers/common/tests/test_cloudinit.py (+4/-1) juju/providers/common/tests/test_launch.py (+56/-35) juju/providers/dummy.py (+10/-1) juju/providers/ec2/__init__.py (+28/-9) juju/providers/ec2/launch.py (+10/-6) juju/providers/ec2/tests/common.py (+15/-11) juju/providers/ec2/tests/data/bootstrap_cloud_init (+4/-4) juju/providers/ec2/tests/test_bootstrap.py (+32/-36) juju/providers/ec2/tests/test_launch.py (+103/-79) juju/providers/ec2/tests/test_provider.py (+89/-1) juju/providers/ec2/tests/test_utils.py (+173/-70) juju/providers/ec2/utils.py (+122/-47) juju/providers/local/__init__.py (+3/-2) juju/providers/local/tests/test_provider.py (+7/-4) juju/providers/maas/launch.py (+1/-1) juju/providers/maas/maas.py (+5/-1) juju/providers/maas/provider.py (+17/-7) juju/providers/maas/tests/test_launch.py (+38/-5) juju/providers/maas/tests/test_maas.py (+38/-1) juju/providers/maas/tests/test_provider.py (+39/-1) juju/providers/maas/tests/testing.py (+8/-1) juju/providers/orchestra/__init__.py (+12/-6) juju/providers/orchestra/cobbler.py (+17/-7) juju/providers/orchestra/launch.py (+2/-1) juju/providers/orchestra/tests/common.py (+7/-4) juju/providers/orchestra/tests/data/bootstrap_user_data (+3/-2) juju/providers/orchestra/tests/test_bootstrap.py (+23/-14) juju/providers/orchestra/tests/test_cobbler.py (+22/-19) juju/providers/orchestra/tests/test_launch.py (+29/-10) juju/providers/orchestra/tests/test_provider.py (+32/-0) juju/providers/tests/test_dummy.py (+3/-3) juju/state/environment.py (+41/-18) juju/state/initialize.py (+19/-24) juju/state/machine.py (+9/-5) juju/state/service.py (+55/-19) juju/state/tests/common.py (+2/-2) juju/state/tests/test_environment.py (+49/-44) juju/state/tests/test_firewall.py (+5/-23) juju/state/tests/test_initialize.py (+35/-16) juju/state/tests/test_machine.py (+17/-4) juju/state/tests/test_placement.py (+9/-10) juju/state/tests/test_relation.py (+5/-8) juju/state/tests/test_service.py (+65/-20) juju/unit/tests/test_charm.py (+2/-26) juju/unit/tests/test_deploy.py (+5/-20)
To merge this branch:	bzr merge lp:~fwereade/pyjuju/shadow-trunk-1204
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju Engineering		2012-03-30	Pending
Review via email: mp+100195@code.launchpad.net