1
=== modified file 'juju/agents/provision.py'
2
--- juju/agents/provision.py	2012-03-20 10:13:22 +0000
3
+++ juju/agents/provision.py	2012-07-18 19:47:20 +0000
4
@@ -195,6 +195,7 @@
5
195
        for instance_id in unused:
195
        for instance_id in unused:
6
196
            log.info("Shutting down machine id:%s ...", instance_id)
196
            log.info("Shutting down machine id:%s ...", instance_id)
7
197
            machine = provider_machines[instance_id]
197
            machine = provider_machines[instance_id]
8
198
9
198
            try:
199
            try:
10
199
                yield self.provider.shutdown_machine(machine)
200
                yield self.provider.shutdown_machine(machine)
11
200
            except ProviderError:
201
            except ProviderError:
12
201
202
13
=== modified file 'juju/control/status.py'
14
--- juju/control/status.py	2012-05-18 21:41:15 +0000
15
+++ juju/control/status.py	2012-07-18 19:47:20 +0000
16
@@ -543,7 +543,7 @@
17
543
                        m["agent-state"] = "not-started"
543
                        m["agent-state"] = "not-started"
18
544
            except ProviderError:
544
            except ProviderError:
19
545
                # The provider doesn't have machine information
545
                # The provider doesn't have machine information
21
546
                self.log.error(
546
                self.log.exception(
22
547
                    "Machine provider information missing: machine %s" % (
547
                    "Machine provider information missing: machine %s" % (
23
548
                        machine_state.id))
548
                        machine_state.id))
24
549
549
25
550
550
26
=== modified file 'juju/environment/config.py'
27
--- juju/environment/config.py	2012-04-11 01:17:53 +0000
28
+++ juju/environment/config.py	2012-07-18 19:47:20 +0000
29
@@ -6,8 +6,8 @@
30
6
from juju.environment.errors import EnvironmentsConfigError
6
from juju.environment.errors import EnvironmentsConfigError
31
7
from juju.errors import FileAlreadyExists, FileNotFound
7
from juju.errors import FileAlreadyExists, FileNotFound
32
8
from juju.lib.schema import (
8
from juju.lib.schema import (
35
9
    Constant, Dict, KeyDict, OAuthString, OneOf, SchemaError, SelectDict,
9
    Constant, Dict, Int, KeyDict, OAuthString, OneOf, SchemaError, SelectDict,
36
10
    String)
10
    String, Bool)
37
11
11
38
12
DEFAULT_CONFIG_PATH = "~/.juju/environments.yaml"
12
DEFAULT_CONFIG_PATH = "~/.juju/environments.yaml"
39
13
13
40
@@ -23,6 +23,14 @@
41
23
23
42
24
_EITHER_PLACEMENT = OneOf(Constant("unassigned"), Constant("local"))
24
_EITHER_PLACEMENT = OneOf(Constant("unassigned"), Constant("local"))
43
25
25
44
26
# See juju.providers.openstack.credentials for definition and more details
45
27
_OPENSTACK_AUTH_MODE = OneOf(
46
28
    Constant("userpass"),
47
29
    Constant("keypair"),
48
30
    Constant("legacy"),
49
31
    Constant("rax"),
50
32
    )
51
33
52
26
SCHEMA = KeyDict({
34
SCHEMA = KeyDict({
53
27
    "default": String(),
35
    "default": String(),
54
28
    "environments": Dict(String(), SelectDict("type", {
36
    "environments": Dict(String(), SelectDict("type", {
55
@@ -49,6 +57,44 @@
56
49
            optional=[
57
            optional=[
57
50
                "access-key", "secret-key", "region", "ec2-uri", "s3-uri",
58
                "access-key", "secret-key", "region", "ec2-uri", "s3-uri",
58
51
                "placement", "ssl-hostname-verification"]),
59
                "placement", "ssl-hostname-verification"]),
59
60
        "openstack": KeyDict({
60
61
            "control-bucket": String(),
61
62
            "admin-secret": String(),
62
63
            "access-key": String(),
63
64
            "secret-key": String(),
64
65
            "default-instance-type": String(),
65
66
            "default-image-id": OneOf(String(), Int()),
66
67
            "auth-url": String(),
67
68
            "project-name": String(),
68
69
            "use-floating-ip": Bool(),
69
70
            "placement": _EITHER_PLACEMENT,
70
71
            "auth-mode": _OPENSTACK_AUTH_MODE,
71
72
            "region": String(),
72
73
            "default-series": String(),
73
74
            },
74
75
            optional=[
75
76
                "access-key", "secret-key", "auth-url", "project-name",
76
77
                "placement", "auth-mode", "region", "use-floating-ip"]),
77
78
        "openstack_s3": KeyDict({
78
79
            "control-bucket": String(),
79
80
            "admin-secret": String(),
80
81
            "access-key": String(),
81
82
            "secret-key": String(),
82
83
            "default-instance-type": String(),
83
84
            "default-image-id": OneOf(String(), Int()),
84
85
            "auth-url": String(),
85
86
            "placement": _EITHER_PLACEMENT,
86
87
            "combined-key": String(),
87
88
            "s3-uri": String(),
88
89
            "use-floating-ip": Bool(),
89
90
            "auth-mode": _OPENSTACK_AUTH_MODE,
90
91
            "region": String(),
91
92
            "default-series": String(),
92
93
            },
93
94
            optional=[
94
95
                "access-key", "secret-key", "combined-key", "auth-url",
95
96
                "s3-uri", "project-name", "placement", "auth-mode", "region",
96
97
                "use-floating-ip"]),
97
52
        "orchestra": KeyDict({
98
        "orchestra": KeyDict({
98
53
            "orchestra-server": String(),
99
            "orchestra-server": String(),
99
54
            "orchestra-user": String(),
100
            "orchestra-user": String(),
100
55
101
101
=== modified file 'juju/errors.py'
102
--- juju/errors.py	2012-03-28 07:33:22 +0000
103
+++ juju/errors.py	2012-07-18 19:47:20 +0000
104
@@ -159,7 +159,7 @@
105
159
    def __str__(self):
159
    def __str__(self):
106
160
        return "Cannot find machine%s: %s" % (
160
        return "Cannot find machine%s: %s" % (
107
161
            "" if len(self.instance_ids) == 1 else "s",
161
            "" if len(self.instance_ids) == 1 else "s",
109
162
            ", ".join(self.instance_ids))
162
            ", ".join(map(str, self.instance_ids)))
110
163
163
111
164
164
112
165
class ProviderInteractionError(ProviderError):
165
class ProviderInteractionError(ProviderError):
113
166
166
114
=== modified file 'juju/providers/common/findzookeepers.py'
115
--- juju/providers/common/findzookeepers.py	2011-09-15 18:50:23 +0000
116
+++ juju/providers/common/findzookeepers.py	2012-07-18 19:47:20 +0000
117
@@ -36,5 +36,6 @@
118
36
36
119
37
    if machines:
37
    if machines:
120
38
        returnValue(machines)
38
        returnValue(machines)
121
39
122
39
    raise EnvironmentNotFound("machines are not running (%s)"
40
    raise EnvironmentNotFound("machines are not running (%s)"
124
40
                              % ", ".join(missing_instance_ids))
41
                             % ", ".join(map(str, missing_instance_ids)))
125
41
42
126
=== modified file 'juju/providers/ec2/tests/test_launch.py'
127
--- juju/providers/ec2/tests/test_launch.py	2012-07-05 21:49:12 +0000
128
+++ juju/providers/ec2/tests/test_launch.py	2012-07-18 19:47:20 +0000
129
@@ -67,7 +67,7 @@
130
67
    def test_provider_launch(self):
67
    def test_provider_launch(self):
131
68
        """
68
        """
132
69
        The provider can be used to launch a machine with a minimal set of
69
        The provider can be used to launch a machine with a minimal set of
134
70
        required packages, repositories, and and security groups.
70
        required packages, repositories, and security groups.
135
71
        """
71
        """
136
72
        self.ec2.describe_security_groups()
72
        self.ec2.describe_security_groups()
137
73
        self.mocker.result(succeed([]))
73
        self.mocker.result(succeed([]))
138
74
74
139
=== added directory 'juju/providers/openstack'
140
=== added file 'juju/providers/openstack/__init__.py'
141
--- juju/providers/openstack/__init__.py	1970-01-01 00:00:00 +0000
142
+++ juju/providers/openstack/__init__.py	2012-07-18 19:47:20 +0000
143
@@ -0,0 +1,3 @@
144
1
"""Support for using OpenStack as a cloud provider for juju"""
145
2
146
3
from .provider import MachineProvider
147
0
4
148
=== added file 'juju/providers/openstack/client.py'
149
--- juju/providers/openstack/client.py	1970-01-01 00:00:00 +0000
150
+++ juju/providers/openstack/client.py	2012-07-18 19:47:20 +0000
151
@@ -0,0 +1,470 @@
152
1
"""Client for talking to OpenStack APIs using twisted
153
2
154
3
This is not a complete implemention of all interfaces, just what juju needs.
155
4
156
5
There is a fair bit of code cleanup and feature implementation to do here
157
6
still.
158
7
159
8
* Must check https certificates, can use code in txaws to do this.
160
9
* Must support user/password authentication with keystone as well as keypair.
161
10
* Want a ProviderInteractionError subclass that can include the extra details
162
11
  returned in json form when something goes wrong and is raised by clients.
163
12
* Request flow and json handling in general needs polish.
164
13
* Need to prevent concurrent authentication attempts.
165
14
* Need to limit concurrent http api requests to 4 or something reasonable,
166
15
  can use DeferredSemaphore for this.
167
16
* Should really have authentication retry logic in case the token expires.
168
17
* Would be nice to use Agent keep alive support that twisted 12.1.0 added.
169
18
"""
170
19
171
20
import base64
172
21
import json
173
22
import logging
174
23
import operator
175
24
import urllib
176
25
177
26
import twisted
178
27
from twisted.internet import (
179
28
    defer,
180
29
    interfaces,
181
30
    protocol,
182
31
    reactor,
183
32
    )
184
33
from twisted.web import (
185
34
    client,
186
35
    http_headers,
187
36
    )
188
37
from zope.interface import implements
189
38
190
39
from juju import errors
191
40
192
41
193
42
log = logging.getLogger("juju.openstack")
194
43
195
44
196
45
# Need the right juju version number, not exposed within python package.
197
46
_USER_AGENT = "juju/%s twisted/%s" % ("0.5", twisted.__version__)
198
47
199
48
200
49
class BytestringProducer(object):
201
50
    """Wrap basic bytestring as a needlessly fancy twisted producer."""
202
51
203
52
    implements(interfaces.IProducer)
204
53
205
54
    def __init__(self, bytestring):
206
55
        self.content = bytestring
207
56
        self.length = len(bytestring)
208
57
209
58
    def pauseProducing(self):
210
59
        """Nothing to do if production is paused"""
211
60
212
61
    def startProducing(self, consumer):
213
62
        """Write entire contents when production starts"""
214
63
        consumer.write(self.content)
215
64
        return defer.succeed(None)
216
65
217
66
    def stopProducing(self):
218
67
        """Nothing to do when production halts"""
219
68
220
69
221
70
class ResponseReader(protocol.Protocol):
222
71
    """Protocol object suitable for use with Response.deliverBody
223
72
224
73
    The 'onConnectionLost' deferred will be called back once the connection
225
74
    is shut down with all the bytes from the body collected at that point.
226
75
    """
227
76
228
77
    def __init__(self):
229
78
        self.onConnectionLost = defer.Deferred()
230
79
231
80
    def connectionMade(self):
232
81
        self.data = []
233
82
234
83
    def dataReceived(self, data):
235
84
        self.data.append(data)
236
85
237
86
    def connectionLost(self, reason):
238
87
        """Called on connection shut down
239
88
240
89
        Here 'reason' can be one of ResponseDone, PotentialDataLost, or
241
90
        ResponseFailed, but currently there is no fancy handling of these.
242
91
        """
243
92
        self.onConnectionLost.callback("".join(self.data))
244
93
245
94
246
95
@defer.inlineCallbacks
247
96
def request(method, url, extra_headers=(), body=None):
248
97
    headers = http_headers.Headers({
249
98
        # GZ 2012-07-03: Previously passed Accept: application/json header
250
99
        #                here, but not always the right thing. Bad for swift?
251
100
        "User-Agent": [_USER_AGENT],
252
101
        })
253
102
    for header, value in extra_headers:
254
103
        headers.setRawHeaders(header, [value])
255
104
    if body is not None:
256
105
        if isinstance(body, dict):
257
106
            content_type = "application/json"
258
107
            body = json.dumps(body)
259
108
        elif isinstance(body, str):
260
109
            content_type = "application/octet-stream"
261
110
        headers.setRawHeaders("Content-Type", [content_type])
262
111
        body = BytestringProducer(body)
263
112
    response = yield client.Agent(reactor).request(method, url, headers, body)
264
113
    if response.length == 0:
265
114
        defer.returnValue((response, ""))
266
115
    reader = ResponseReader()
267
116
    response.deliverBody(reader)
268
117
    body = yield reader.onConnectionLost
269
118
    defer.returnValue((response, body))
270
119
271
120
272
121
class _OpenStackClient(object):
273
122
274
123
    def __init__(self, credentials):
275
124
        self.credentials = credentials
276
125
        log.debug("openstack: using auth-mode %r with %s", credentials.mode,
277
126
            credentials.url)
278
127
        if credentials.mode == "keypair":
279
128
            self.authenticate = self.authenticate_v2_keypair
280
129
        elif credentials.mode == "legacy":
281
130
            self.authenticate = self.authenticate_v1
282
131
        elif credentials.mode == "rax":
283
132
            self.authenticate = self.authenticate_rax_auth
284
133
        else:
285
134
            self.authenticate = self.authenticate_v2_userpass
286
135
        self.token = None
287
136
288
137
    def _make_url(self, service, parts):
289
138
        """Form full url from path components to service endpoint url"""
290
139
        # GZ 2012-07-03: Need to ensure either services is populated or catch
291
140
        #                error here and propogate as one useful for users.
292
141
        endpoint = self.services[service]
293
142
        if not endpoint[-1] == "/":
294
143
            endpoint += "/"
295
144
        if isinstance(parts, str):
296
145
            return endpoint + parts
297
146
        quoted_parts = []
298
147
        for part in parts:
299
148
            if not isinstance(part, str):
300
149
                part = urllib.quote(unicode(part).encode("utf-8"), "/~")
301
150
            quoted_parts.append(part)
302
151
        url = endpoint + "/".join(quoted_parts)
303
152
        log.debug('access %s @ %s', service, url)
304
153
        return url
305
154
306
155
    @defer.inlineCallbacks
307
156
    def authenticate_v1(self):
308
157
        deferred = request(
309
158
            "GET",
310
159
            self.credentials.url,
311
160
            extra_headers=[
312
161
                ("X-Auth-User", self.credentials.username),
313
162
                ("X-Auth-Key", self.credentials.access_key),
314
163
                ],
315
164
            )
316
165
        response, body = yield deferred
317
166
        if response.code != 204:
318
167
            raise errors.ProviderInteractionError("Failed to authenticate")
319
168
        # TODO: check response has right headers
320
169
        [nova_url] = response.headers.getRawHeaders("X-Server-Management-Url")
321
170
        self.services = {"compute": self.nova_url}
322
171
        # No swift_url set as that is not supported
323
172
        [self.token] = response.headers.getRawHeaders("X-Auth-Token")
324
173
325
174
    def authenticate_v2_keypair(self):
326
175
        deferred = request(
327
176
            "POST",
328
177
            self.credentials.url + "tokens",
329
178
            body={"auth": {
330
179
                  "apiAccessKeyCredentials": {
331
180
                    "accessKey": self.credentials.access_key,
332
181
                    "secretKey": self.credentials.secret_key,
333
182
                  },
334
183
                  "tenantName": self.credentials.project_name,
335
184
                }}
336
185
            )
337
186
        return deferred.addCallback(self._handle_v2_auth)
338
187
339
188
    def authenticate_v2_userpass(self):
340
189
        deferred = request(
341
190
            "POST",
342
191
            self.credentials.url + "tokens",
343
192
            body={"auth": {
344
193
                  "passwordCredentials": {
345
194
                    "username": self.credentials.username,
346
195
                    "password": self.credentials.password,
347
196
                  },
348
197
                  "tenantName": self.credentials.project_name,
349
198
                }}
350
199
            )
351
200
        return deferred.addCallback(self._handle_v2_auth)
352
201
353
202
    def authenticate_rax_auth(self):
354
203
        # openstack is not a product, but a kit for making snowflakes.
355
204
        deferred = request(
356
205
            "POST",
357
206
            self.credentials.url + "tokens",
358
207
            body={"auth": {
359
208
                  "RAX-KSKEY:apiKeyCredentials": {
360
209
                    "username": self.credentials.username,
361
210
                    "apiKey": self.credentials.password,
362
211
                    "tenantName": self.credentials.project_name}}}
363
212
            )
364
213
        return deferred.addCallback(self._handle_v2_auth)
365
214
366
215
    def _handle_v2_auth(self, result):
367
216
        access_details = self._json(result, 200, 'access')
368
217
        token_details = access_details["token"]
369
218
        self.token = token_details["id"]
370
219
371
220
        # TODO: care about token_details["expires"]
372
221
        # Don't need to we're not preserving tokens.
373
222
        services = []
374
223
        log.debug("openstack: authenticated til %r", token_details['expires'])
375
224
        region = self.credentials.region
376
225
        # HP cloud uses both az-1.region-a.geo-1 and region-a.geo-1 forms, not
377
226
        # clear what should be in config or what the correct logic is.
378
227
        if region is not None:
379
228
            base_region = region.split('.', 1)[-1]
380
229
        # GZ: 2012-07-03: Should split extraction of endpoints, add logging,
381
230
        #                 and make more robust.
382
231
        for catalog in access_details["serviceCatalog"]:
383
232
            for endpoint in catalog["endpoints"]:
384
233
                if region is not None and region != endpoint["region"]:
385
234
                    if base_region != endpoint["region"]:
386
235
                        continue
387
236
                services.append((catalog["type"], str(endpoint["publicURL"])))
388
237
                break
389
238
390
239
        if not services:
391
240
            raise errors.ProviderInteractionError("No suitable endpoints")
392
241
393
242
        self.services = dict(services)
394
243
395
244
    def is_authenticated(self):
396
245
        return self.token is not None
397
246
398
247
    @defer.inlineCallbacks
399
248
    def authed_request(self, method, url, headers=None, body=None):
400
249
        log.debug("openstack: %s %r", method, url)
401
250
        request_headers = [("X-Auth-Token", self.token)]
402
251
        if headers:
403
252
            request_headers += headers
404
253
        response, body = yield request(method, url, request_headers, body)
405
254
        log.debug("openstack: %d %r", response.code, body)
406
255
        defer.returnValue((response, body))
407
256
408
257
    def _empty(self, result, code):
409
258
        response, body = result
410
259
        if response.code != code:
411
260
            # XXX: This is a deeply unhelpful error, need context from request
412
261
            raise errors.ProviderInteractionError("Unexpected %d: %r" % (
413
262
                response.code, body))
414
263
415
264
    def _json(self, result, code, root=None):
416
265
        response, body = result
417
266
        if response.code != code:
418
267
            raise errors.ProviderInteractionError("Unexpected %d: %r" % (
419
268
                response.code, body))
420
269
        type_headers = response.headers.getRawHeaders("Content-Type")
421
270
422
271
        found = False
423
272
        for h in type_headers:
424
273
            if 'application/json' in h:
425
274
                found = True
426
275
        if not found:
427
276
            raise errors.ProviderInteractionError(
428
277
                "Expected json response got %s" % type_headers)
429
278
430
279
        data = json.loads(body)
431
280
        if root is not None:
432
281
            return data[root]
433
282
        return data
434
283
435
284
436
285
class _NovaClient(object):
437
286
438
287
    def __init__(self, client):
439
288
        self._client = client
440
289
441
290
    @defer.inlineCallbacks
442
291
    def request(self, method, parts, headers=None, body=None):
443
292
        if not self._client.is_authenticated():
444
293
            yield self._client.authenticate()
445
294
        url = self._client._make_url("compute", parts)
446
295
        result = yield self._client.authed_request(method, url, headers, body)
447
296
        defer.returnValue(result)
448
297
449
298
    def delete(self, parts, code=202):
450
299
        deferred = self.request("DELETE", parts)
451
300
        return deferred.addCallback(self._client._empty, code)
452
301
453
302
    def get(self, parts, root, code=200):
454
303
        deferred = self.request("GET", parts)
455
304
        return deferred.addCallback(self._client._json, code, root)
456
305
457
306
    def post(self, parts, jsonobj, root, code=200):
458
307
        deferred = self.request("POST", parts, None, jsonobj)  # XXX
459
308
        return deferred.addCallback(self._client._json, code, root)
460
309
461
310
    def post_no_data(self, parts, root, code=200):
462
311
        deferred = self.request("POST", parts, None, "")  # XXX
463
312
        return deferred.addCallback(self._client._json, code, root)
464
313
465
314
    def post_no_result(self, parts, jsonobj, code=202):
466
315
        deferred = self.request("POST", parts, None, jsonobj)  # XXX
467
316
        return deferred.addCallback(self._client._empty, code)
468
317
469
318
    def list_flavors(self):
470
319
        return self.get("flavors", "flavors")
471
320
472
321
    def get_server(self, server_id):
473
322
        return self.get(["servers", server_id], "server")
474
323
475
324
    # GZ 2012-05-31: Appending detail isn't a known path for some reason.
476
325
    def get_server_detail(self, server_id):
477
326
        return self.get(["servers", server_id, "detail"], "server")
478
327
479
328
    def list_servers(self):
480
329
        return self.get(["servers"], "servers")
481
330
482
331
    def list_servers_detail(self):
483
332
        return self.get(["servers", "detail"], "servers")
484
333
485
334
    def delete_server(self, server_id):
486
335
        return self.delete(["servers", server_id], code=204)
487
336
488
337
    def run_server(self, image_id, flavor_id, name, security_group_names=None,
489
338
        user_data=None):
490
339
        server = {
491
340
            'name': name,
492
341
            'flavorRef': flavor_id,
493
342
            'imageRef': image_id,
494
343
        }
495
344
        if user_data is not None:
496
345
            server["user_data"] = base64.b64encode(user_data)
497
346
        if security_group_names is not None:
498
347
            server["security_groups"] = [{'name': n}
499
348
                for n in security_group_names]
500
349
        return self.post(["servers"], {'server': server},
501
350
            root="server", code=202)
502
351
503
352
    def get_server_security_groups(self, server_id):
504
353
        d = self.get(
505
354
            ["servers", server_id, "os-security-groups"],
506
355
            root="security_groups")
507
356
        # 2012-07-12: Workaround lack of this api in HP cloud
508
357
        d.addErrback(
509
358
            lambda f: self.get_server(server_id).addCallback(
510
359
                operator.itemgetter("security_groups")))
511
360
        return d
512
361
513
362
    def list_security_groups(self):
514
363
        return self.get(["os-security-groups"], "security_groups")
515
364
516
365
    def create_security_group(self, name, description):
517
366
        return self.post("os-security-groups", {
518
367
            'security_group': {
519
368
                'name': name,
520
369
                'description': description,
521
370
                }
522
371
            },
523
372
            root="security_group")
524
373
525
374
    def delete_security_group(self, group_id):
526
375
        return self.delete(["os-security-groups", group_id])
527
376
528
377
    def add_security_group_rule(self, parent_group_id, **kwargs):
529
378
        rule = {'parent_group_id': parent_group_id}
530
379
        using_group = "group_id" in kwargs
531
380
        if using_group:
532
381
            rule['group_id'] = kwargs['group_id']
533
382
        elif "cidr" in kwargs:
534
383
            rule['cidr'] = kwargs['cidr']
535
384
        if not using_group or "ip_protocol" in kwargs:
536
385
            rule['ip_protocol'] = kwargs['ip_protocol']
537
386
            rule['from_port'] = kwargs['from_port']
538
387
            rule['to_port'] = kwargs['to_port']
539
388
        return self.post("os-security-group-rules",
540
389
            {'security_group_rule': rule},
541
390
            root="security_group_rule")
542
391
543
392
    def delete_security_group_rule(self, rule_id):
544
393
        return self.delete(["os-security-group-rules", rule_id])
545
394
546
395
    def add_server_security_group(self, server_id, group_name):
547
396
        return self.post_no_result(["servers", server_id, "action"], {
548
397
            "addSecurityGroup": {
549
398
                "name": group_name,
550
399
            }})
551
400
552
401
    def remove_server_security_group(self, server_id, group_name):
553
402
        return self.post_no_result(["servers", server_id, "action"], {
554
403
            "removeSecurityGroup": {
555
404
                "name": group_name,
556
405
            }})
557
406
558
407
    def list_floating_ips(self):
559
408
        return self.get(["os-floating-ips"], "floating_ips")
560
409
561
410
    def get_floating_ip(self, ip_id):
562
411
        return self.get(["os-floating-ips", ip_id], "floating_ip")
563
412
564
413
    def allocate_floating_ip(self):
565
414
        return self.post_no_data(["os-floating-ips"], "floating_ip")
566
415
567
416
    def delete_floating_ip(self, ip_id):
568
417
        return self.delete(["os-floating-ips", ip_id])
569
418
570
419
    def add_floating_ip(self, server_id, addr):
571
420
        return self.post_no_result(["servers", server_id, "action"], {
572
421
            'addFloatingIp': {
573
422
                'address': addr,
574
423
            }})
575
424
576
425
    def remove_floating_ip(self, server_id, addr):
577
426
        return self.post_no_result(["servers", server_id, "action"], {
578
427
            'removeFloatingIp': {
579
428
                'address': addr,
580
429
            }})
581
430
582
431
583
432
class _SwiftClient(object):
584
433
585
434
    def __init__(self, client):
586
435
        self._client = client
587
436
588
437
    @defer.inlineCallbacks
589
438
    def request(self, method, parts, headers=None, body=None):
590
439
        if not self._client.is_authenticated():
591
440
            yield self._client.authenticate()
592
441
        url = self._client._make_url("object-store", parts)
593
442
        result = yield self._client.authed_request(method, url, headers, body)
594
443
        defer.returnValue(result)
595
444
596
445
    def public_object_url(self, container, object_name):
597
446
        if not self._client.is_authenticated():
598
447
            raise ValueError("Need to have authenticated to get object url")
599
448
        return self._client._make_url("object-store", [container, object_name])
600
449
601
450
    def put_container(self, container_name):
602
451
        # Juju expects there to be a (semi) public url for some objects. This
603
452
        # could probably be more restrictive or placed in a seperate container
604
453
        # with some refactoring, but for now just make everything public.
605
454
        read_acl_header = ("X-Container-Read", ".r:*")
606
455
        return self.request("PUT", [container_name], [read_acl_header], "")
607
456
608
457
    def delete_container(self, container_name):
609
458
        return self.request("DELETE", [container_name])
610
459
611
460
    def head_object(self, container, object_name):
612
461
        return self.request("HEAD", [container, object_name])
613
462
614
463
    def get_object(self, container, object_name):
615
464
        return self.request("GET", [container, object_name])
616
465
617
466
    def delete_object(self, container, object_name):
618
467
        return self.request("DELETE", [container, object_name])
619
468
620
469
    def put_object(self, container, object_name, bytestring):
621
470
        return self.request("PUT", [container, object_name], None, bytestring)
622
0
471
623
=== added file 'juju/providers/openstack/credentials.py'
624
--- juju/providers/openstack/credentials.py	1970-01-01 00:00:00 +0000
625
+++ juju/providers/openstack/credentials.py	2012-07-18 19:47:20 +0000
626
@@ -0,0 +1,101 @@
627
1
"""Handling of the credentials needed to authenticate with the OpenStack api
628
2
629
3
Supports several different sets of credentials different auth modes need:
630
4
* 'legacy' is built into nova and deprecated in favour of using keystone
631
5
* 'keypair' works with the HP public cloud implemention of keystone
632
6
* 'userpass' is the way keystone seems to want to do authentication generally
633
7
"""
634
8
635
9
import os
636
10
637
11
638
12
class OpenStackCredentials(object):
639
13
    """Encapsulation of credentials used to authenticate with OpenStack"""
640
14
641
15
    _config_vars = {
642
16
            'auth-url': ("OS_AUTH_URL", "NOVA_URL"),
643
17
            'username': ("OS_USERNAME", "NOVA_USERNAME"),
644
18
            'password': ("OS_PASSWORD", "NOVA_PASSWORD"),
645
19
            # HP exposes both a numeric id and a name for tenants, passed back
646
20
            # as tenantId and tenantName. Use the name only for simplicity.
647
21
            'project-name': ("OS_TENANT_NAME", "NOVA_PROJECT_NAME",
648
22
                             "NOVA_PROJECT_ID"),
649
23
            'region': ("OS_REGION_NAME", "NOVA_REGION_NAME", "NOVA_REGION"),
650
24
            # The key variables don't seem to have modern OS_ prefixed aliases
651
25
            'access-key': ("NOVA_API_KEY",),
652
26
            'secret-key': ("EC2_SECRET_KEY", "AWS_SECRET_ACCESS_KEY"),
653
27
            # A usable mode can normally be guessed, but may be configured
654
28
            'auth-mode': (),
655
29
        }
656
30
657
31
    # Really, legacy auth could pass in the project id and keystone doesn't
658
32
    # require it, but this is what the client expects for now.
659
33
    _modes = {
660
34
        'userpass': ('username', 'password', 'project-name'),
661
35
        'rax': ('username', 'password', 'project-name'),
662
36
        'keypair': ('access-key', 'secret-key', 'project-name'),
663
37
        'legacy': ('username', 'access-key'),
664
38
        }
665
39
666
40
    _version_to_mode = {
667
41
        "v2.0": 'userpass',
668
42
        "v1.1": 'legacy',
669
43
        "v1.0": 'legacy',
670
44
        }
671
45
672
46
    def __init__(self, creds_dict):
673
47
        url = creds_dict.get("auth-url")
674
48
        if not url:
675
49
            raise ValueError("Missing config 'auth-url' for OpenStack api")
676
50
        mode = creds_dict.get("auth-mode")
677
51
        if mode is None:
678
52
            mode = self._guess_auth_mode(url)
679
53
        elif mode not in self._modes:
680
54
            # The juju.environment.config layer should raise a pretty error
681
55
            raise ValueError("Unknown 'auth-mode' value %r" % (self.mode,))
682
56
        missing_keys = [key for key in self._modes[mode]
683
57
            if not creds_dict.get(key)]
684
58
        if missing_keys:
685
59
            raise ValueError("Missing config %s required for %s auth" % (
686
60
                ", ".join(map(repr, missing_keys)), mode))
687
61
        self.url = url
688
62
        self.mode = mode
689
63
        for key in self._config_vars:
690
64
            if key not in ("auth-url", "auth-mode"):
691
65
                setattr(self, key.replace("-", "_"), creds_dict.get(key))
692
66
693
67
    @classmethod
694
68
    def _guess_auth_mode(cls, url):
695
69
        """Pick a mode based on the version at the end of `url` given"""
696
70
        final_part = url.rstrip("/").rsplit("/", 1)[-1]
697
71
        try:
698
72
            return cls._version_to_mode[final_part]
699
73
        except KeyError:
700
74
            raise ValueError(
701
75
                "Missing config 'auth-mode' as unknown version"
702
76
                " in 'auth-url' given: " + url)
703
77
704
78
    @classmethod
705
79
    def _get(cls, config, key):
706
80
        """Retrieve `key` from `config` if present or in matching envvars"""
707
81
        val = config.get(key)
708
82
        if val is None:
709
83
            for env_key in cls._config_vars[key]:
710
84
711
85
                val = os.environ.get(env_key)
712
86
                if val:
713
87
                    return val
714
88
        return val
715
89
716
90
    @classmethod
717
91
    def from_environment(cls, config):
718
92
        """Create credentials from `config` falling back to environment"""
719
93
        return cls(dict((k, cls._get(config, k)) for k in cls._config_vars))
720
94
721
95
    def set_config_defaults(self, data):
722
96
        """Populate `data` with these credentials where not already set"""
723
97
        for key in self._config_vars:
724
98
            if key not in data:
725
99
                val = getattr(self, key.replace("auth-", "").replace("-", "_"))
726
100
                if val is not None:
727
101
                    data[key] = val
728
0
102
729
=== added file 'juju/providers/openstack/files.py'
730
--- juju/providers/openstack/files.py	1970-01-01 00:00:00 +0000
731
+++ juju/providers/openstack/files.py	2012-07-18 19:47:20 +0000
732
@@ -0,0 +1,84 @@
733
1
"""OpenStack provider file storage on Swift
734
2
735
3
Basically a limited wrapper around the underlying api calls, with a few added
736
4
quirks. There's some specific handling for 404 responses, raises FileNotFound
737
5
on GET, and on PUT attempts to create the container then retries.
738
6
739
7
Expects file-like objects for data. This isn't terribly useful as it doesn't
740
8
fit well with the twisted model for chunking http data and most objects are
741
9
small anyway.
742
10
743
11
The main complication is the get_url method, which requires the generation of
744
12
link that can be used by any http client to fetch a particular object without
745
13
authentication. This is not possible in the general case in swift, however
746
14
there are a few ways around the problem:
747
15
748
16
* The stub nova-objectstore service doesn't check access anyway, see lp:947374
749
17
* The tempurl swift middleware if enabled can do this with some advance setup
750
18
* A container can have a more permissive ACL applying to all objects within
751
19
752
20
All of these require touching the network to at least get the swift endpoint
753
21
from the identity service, which as get_url doesn't return a deferred is
754
22
problematic. In practice it's only used after putting an object however, so
755
23
just raising if client has not yet been authenticated is good enough.
756
24
"""
757
25
758
26
from cStringIO import StringIO
759
27
760
28
from twisted.internet import defer
761
29
762
30
from juju import errors
763
31
764
32
765
33
class FileStorage(object):
766
34
    """Swift-backed :class:`FileStorage` abstraction"""
767
35
768
36
    def __init__(self, swift, container):
769
37
        self._swift = swift
770
38
        self._container = container
771
39
772
40
    def get_url(self, name):
773
41
        return self._swift.public_object_url(self._container, name)
774
42
775
43
    @defer.inlineCallbacks
776
44
    def get(self, name):
777
45
        """Get a file object from Swift.
778
46
779
47
        :param unicode name: S3 key for the desired file
780
48
781
49
        :return: an open file object
782
50
        :rtype: :class:`twisted.internet.defer.Deferred`
783
51
784
52
        :raises: :exc:`juju.errors.FileNotFound` if the file doesn't exist
785
53
        """
786
54
        response, body = yield self._swift.get_object(self._container, name)
787
55
        if response.code == 404:
788
56
            raise errors.FileNotFound(name)
789
57
        if response.code != 200:
790
58
            raise errors.ProviderInteractionError(
791
59
                "Couldn't fetch object %r %r" % (response.code, body))
792
60
        defer.returnValue(StringIO(body))
793
61
794
62
    @defer.inlineCallbacks
795
63
    def put(self, remote_path, file_object):
796
64
        """Upload a file to Swift.
797
65
798
66
        :param unicode remote_path: key on which to store the content
799
67
800
68
        :param file_object: open file object containing the content
801
69
802
70
        :rtype: :class:`twisted.internet.defer.Deferred`
803
71
        """
804
72
        data = file_object.read()
805
73
        response, body = yield self._swift.put_object(self._container,
806
74
            remote_path, data)
807
75
        if response.code == 404:
808
76
            response, body = yield self._swift.put_container(self._container)
809
77
            if response.code != 201:
810
78
                raise errors.ProviderInteractionError(
811
79
                    "Couldn't create container %r" % (self._container,))
812
80
            response, body = yield self._swift.put_object(self._container,
813
81
                remote_path, data)
814
82
        if response.code != 201:
815
83
            raise errors.ProviderInteractionError(
816
84
                "Couldn't create object %r %r" % (response.code, remote_path))
817
0
85
818
=== added file 'juju/providers/openstack/launch.py'
819
--- juju/providers/openstack/launch.py	1970-01-01 00:00:00 +0000
820
+++ juju/providers/openstack/launch.py	2012-07-18 19:47:20 +0000
821
@@ -0,0 +1,131 @@
822
1
"""Helpers for creating servers catered to Juju needs with OpenStack
823
2
824
3
Specific notes:
825
4
* Expects a public address for each machine, as that's what EC2 promises,
826
5
  would be good to weaken this requirement.
827
6
* Creates a per-machine security group in case need to poke ports open later,
828
7
  as EC2 doesn't support changing groups later, but OpenStack does.
829
8
* Needs to tell cloud-init how to get server id, currently in essex metadata
830
9
  service gives i-08x style only, so cheat and use filestorage.
831
10
* Config must specify a flavor, as these vary between Openstack deployments.
832
11
  Working out constraints should resolve this.
833
12
* Config must specify an image id, as there's no standard way of looking up
834
13
  from distro series across clouds yet in essex.
835
14
* Would be really nice to put the service name in the server name, but it's
836
15
  not passed down into LaunchMachine currently.
837
16
838
17
There are some race issues with the current setup:
839
18
* Storing of server id needs to complete before cloud-init does the lookup.
840
19
* A floating ip may be assigned to another server before the current one
841
20
  finishes launching and can use the available ip itself.
842
21
"""
843
22
844
23
from cStringIO import StringIO
845
24
846
25
from twisted.internet import (
847
26
    defer,
848
27
    reactor,
849
28
    )
850
29
851
30
from juju.errors import ProviderError, ProviderInteractionError
852
31
from juju.lib import twistutils
853
32
from juju.providers.common.launch import LaunchMachine
854
33
855
34
from .machine import machine_from_instance, get_server_status
856
35
857
36
from .client import log
858
37
859
38
860
39
class NovaLaunchMachine(LaunchMachine):
861
40
    """OpenStack Nova operation for creating a server"""
862
41
863
42
    _DELAY_FOR_ADDRESSES = 5  # seconds
864
43
865
44
    @defer.inlineCallbacks
866
45
    def start_machine(self, machine_id, zookeepers):
867
46
        """Actually launch an instance on Nova.
868
47
869
48
        :param str machine_id: the juju machine ID to assign
870
49
871
50
        :param zookeepers: the machines currently running zookeeper, to which
872
51
            the new machine will need to connect
873
52
        :type zookeepers: list of
874
53
            :class:`juju.providers.openstack.machine.NovaProviderMachine`
875
54
876
55
        :return: a singe-entry list containing a
877
56
            :class:`juju.providers.openstack.machine.NovaProviderMachine`
878
57
            representing the newly-launched machine
879
58
        :rtype: :class:`twisted.internet.defer.Deferred`
880
59
        """
881
60
        cloud_init = self._create_cloud_init(machine_id, zookeepers)
882
61
        cloud_init.set_provider_type(self._provider.provider_type)
883
62
        filestorage = self._provider.get_file_storage()
884
63
        # Only the master is required to get its own instance id like this.
885
64
        if self._master:
886
65
            id_name = "juju_master_id"
887
66
            cloud_init.set_instance_id_accessor("$(curl %s)" % (
888
67
                filestorage.get_url(id_name),))
889
68
        user_data = cloud_init.render()
890
69
891
70
        # For openstack deployments, really need image id configured as there
892
71
        # are no standards to provide a fallback value.
893
72
        image_id = self._provider.config.get("default-image-id")
894
73
        if image_id is None:
895
74
            raise ProviderError("Need to specify a default-image-id")
896
75
897
76
        security_groups = (
898
77
            yield self._provider.port_manager.ensure_groups(machine_id))
899
78
900
79
        # Until constraints are implemented, need to a configured instance
901
80
        # type and resolve it to a flavor id here.
902
81
        flavor_name = self._provider.config.get("default-instance-type")
903
82
        if flavor_name is None:
904
83
            raise ProviderError("Need to specify a default-instance-type")
905
84
        flavors = yield self._provider.nova.list_flavors()
906
85
        flavor_map = dict((f['name'], f['id']) for f in flavors)
907
86
        if not flavor_name in flavor_map:
908
87
            ProviderError("Unknown instance type given: %r" % (flavor_name,))
909
88
910
89
        server = yield self._provider.nova.run_server(
911
90
            name="juju %s instance %s" %
912
91
                (self._provider.environment_name, machine_id,),
913
92
            image_id=image_id,
914
93
            flavor_id=flavor_map[flavor_name],
915
94
            security_group_names=security_groups,
916
95
            user_data=user_data)
917
96
918
97
        if self._master:
919
98
            yield filestorage.put(id_name, StringIO(str(server['id'])))
920
99
921
100
        # For private clouds allow an option of attaching public
922
101
        # floating ips to all the machines. None of the extant public
923
102
        # clouds need this.
924
103
        if self._provider.config.get('use-floating-ip'):
925
104
            # Not possible to attach a floating ip to a newly booted
926
105
            # server, must wait for networking to be ready when some
927
106
            # kind of address exists.
928
107
            while not server.get('addresses'):
929
108
                status = get_server_status(server)
930
109
                if status != "pending":
931
110
                    raise ProviderInteractionError(
932
111
                        "Server out of pending status "
933
112
                        "without addresses set: %r" % server)
934
113
                # Bad, bad place to be doing a wait loop directly
935
114
                yield twistutils.sleep(self._DELAY_FOR_ADDRESSES)
936
115
                log.debug("Waited for %d seconds for networking on server %r",
937
116
                          self._DELAY_FOR_ADDRESSES, server['id'])
938
117
                server = yield self._provider.nova.get_server(server['id'])
939
118
            yield _assign_floating_ip(self._provider, server['id'])
940
119
941
120
        defer.returnValue([machine_from_instance(server)])
942
121
943
122
944
123
@defer.inlineCallbacks
945
124
def _assign_floating_ip(provider, server_id):
946
125
    floating_ips = yield provider.nova.list_floating_ips()
947
126
    for floating_ip in floating_ips:
948
127
        if floating_ip['instance_id'] is None:
949
128
            break
950
129
    else:
951
130
        floating_ip = yield provider.nova.allocate_floating_ip()
952
131
    yield provider.nova.add_floating_ip(server_id, floating_ip['ip'])
953
0
132
954
=== added file 'juju/providers/openstack/machine.py'
955
--- juju/providers/openstack/machine.py	1970-01-01 00:00:00 +0000
956
+++ juju/providers/openstack/machine.py	2012-07-18 19:47:20 +0000
957
@@ -0,0 +1,68 @@
958
1
"""Helpers for mapping Nova api results to the juju machine abstraction"""
959
2
960
3
from juju.machine import ProviderMachine
961
4
962
5
963
6
_SERVER_STATE_MAP = {
964
7
    None: 'pending',
965
8
    'ACTIVE': 'running',
966
9
    'BUILD': 'pending',
967
10
    'BUILDING': 'pending',
968
11
    'REBUILDING': 'pending',
969
12
    'DELETED': 'terminated',
970
13
    'STOPPED': 'stopped',
971
14
    }
972
15
973
16
974
17
class NovaProviderMachine(ProviderMachine):
975
18
    """Nova-specific ProviderMachine implementation"""
976
19
977
20
978
21
def get_server_status(server):
979
22
    status = server.get('status')
980
23
    if status is not None and "(" in status:
981
24
        status = status.split("(", 1)[0]
982
25
    return _SERVER_STATE_MAP.get(status, 'unknown')
983
26
984
27
985
28
def get_server_addresses(server):
986
29
    private_addr = public_addr = None
987
30
    addresses = server.get("addresses")
988
31
    if addresses is not None:
989
32
        # Issue with some setups, have custom network only, use as private
990
33
        network = ()
991
34
        for name in sorted(addresses):
992
35
            if name not in ("private", "public"):
993
36
                network = addresses[name]
994
37
                if network:
995
38
                    break
996
39
        network = addresses.get("private", network)
997
40
        for address in network:
998
41
            if address.get("version", 0) == 4:
999
42
                private_addr = address['addr']
1000
43
                break
1001
44
        # Issue with HP cloud, public address is second in private network
1002
45
        network = addresses.get("public", network[1:])
1003
46
        for address in network:
1004
47
            if address.get("version", 0) == 4:
1005
48
                public_addr = address['addr']
1006
49
    return private_addr, public_addr
1007
50
1008
51
1009
52
def machine_from_instance(server):
1010
53
    """Create an :class:`NovaProviderMachine` from a server details dict
1011
54
1012
55
    :param server: a dictionary of server info as given by the Nova api
1013
56
1014
57
    :return: a matching :class:`NovaProviderMachine`
1015
58
    """
1016
59
    private_addr, public_addr = get_server_addresses(server)
1017
60
    # Juju assumes it always needs a public address and loops waiting for one.
1018
61
    # In fact a private address is generally fine provided it can be sshed to.
1019
62
    if public_addr is None and private_addr is not None:
1020
63
        public_addr = private_addr
1021
64
    return NovaProviderMachine(
1022
65
        server['id'],
1023
66
        public_addr,
1024
67
        private_addr,
1025
68
        get_server_status(server))
1026
0
69
1027
=== added file 'juju/providers/openstack/ports.py'
1028
--- juju/providers/openstack/ports.py	1970-01-01 00:00:00 +0000
1029
+++ juju/providers/openstack/ports.py	2012-07-18 19:47:20 +0000
1030
@@ -0,0 +1,179 @@
1031
1
"""Manage port access to machines using Nova security group extension
1032
2
1033
3
The mechanism is based on the existing scheme used by the EC2 provider.
1034
4
1035
5
Each machine is launched with two security groups, a juju group that is shared
1036
6
across all machines and allows access to 22/tcp for ssh, and a machine group
1037
7
just for that server so ports can be opened and closed on an individual level.
1038
8
1039
9
There is some mismatch between the port hole poking and security group models:
1040
10
* A new security group is created for every machine
1041
11
* Rules are not shared between service units but set up again each launch
1042
12
* Support for port ranges is not exposed
1043
13
1044
14
The Nova security group module follows the EC2 example quite closely, but as
1045
15
of Essex it's still under contrib and has a number of quirks:
1046
16
* To run a server with, or add or remove groups from a server, 'name' is used
1047
17
* To get details, delete, or add or remove rules from a group, 'id' is needed
1048
18
1049
19
The only way of getting 'id' if 'name' is known is by listing all groups then
1050
20
looking at the details of the one with the matching name.
1051
21
"""
1052
22
1053
23
from twisted.internet import (
1054
24
    defer,
1055
25
    )
1056
26
1057
27
from juju import errors
1058
28
1059
29
from .client import log
1060
30
1061
31
1062
32
class NovaPortManager(object):
1063
33
    """Mapping of port-based juju interface to Nova security group actions
1064
34
1065
35
    There is the potential to record some state on the instance to reduce api
1066
36
    round-trips when, for instance, launching multiple machines at once, but
1067
37
    for now
1068
38
    """
1069
39
1070
40
    def __init__(self, nova, environment_name):
1071
41
        self.nova = nova
1072
42
        self.tag = environment_name
1073
43
1074
44
    def _juju_group_name(self):
1075
45
        return "juju-%s" % (self.tag,)
1076
46
1077
47
    def _machine_group_name(self, machine_id):
1078
48
        return "juju-%s-%s" % (self.tag, machine_id)
1079
49
1080
50
    @defer.inlineCallbacks
1081
51
    def _get_machine_group(self, machine, machine_id):
1082
52
        """Get details of the machine specific security group
1083
53
1084
54
        As only the name of the group can be derived, this means listing every
1085
55
        security group for that server and seeing which has a matching name.
1086
56
        """
1087
57
        group_name = self._machine_group_name(machine_id)
1088
58
        server_id = machine.instance_id
1089
59
        groups = yield self.nova.get_server_security_groups(server_id)
1090
60
        for group in groups:
1091
61
            if group['name'] == group_name:
1092
62
                defer.returnValue(group)
1093
63
        raise errors.ProviderInteractionError(
1094
64
            "Missing security group %r for machine %r" %
1095
65
                (group_name, server_id))
1096
66
1097
67
    @defer.inlineCallbacks
1098
68
    def open_port(self, machine, machine_id, port, protocol="tcp"):
1099
69
        """Allow access to a port for the given machine only"""
1100
70
        group = yield self._get_machine_group(machine, machine_id)
1101
71
        yield self.nova.add_security_group_rule(group['id'],
1102
72
            ip_protocol=protocol, from_port=port, to_port=port)
1103
73
        log.debug("Opened %s/%s on machine %r",
1104
74
            port, protocol, machine.instance_id)
1105
75
1106
76
    @defer.inlineCallbacks
1107
77
    def close_port(self, machine, machine_id, port, protocol="tcp"):
1108
78
        """Revoke access to a port for the given machine only"""
1109
79
        group = yield self._get_machine_group(machine, machine_id)
1110
80
        for rule in group["rules"]:
1111
81
            if (port == rule["from_port"] == rule["to_port"] and
1112
82
                rule["ip_protocol"] == protocol):
1113
83
                yield self.nova.delete_security_group_rule(rule["id"])
1114
84
                log.debug("Closed %s/%s on machine %r",
1115
85
                          port, protocol, machine.instance_id)
1116
86
                return
1117
87
        raise errors.ProviderInteractionError(
1118
88
            "Couldn't close unopened %s/%s on machine %r",
1119
89
                  port, protocol, machine.instance_id)
1120
90
1121
91
    @defer.inlineCallbacks
1122
92
    def get_opened_ports(self, machine, machine_id):
1123
93
        """Get a set of opened port/protocol pairs for a machine"""
1124
94
        group = yield self._get_machine_group(machine, machine_id)
1125
95
        opened_ports = set()
1126
96
        for rule in group.get("rules", []):
1127
97
            if not rule.get("group"):
1128
98
                protocol = rule["ip_protocol"]
1129
99
                from_port = rule["from_port"]
1130
100
                to_port = rule["to_port"]
1131
101
                if from_port == to_port:
1132
102
                    opened_ports.add((from_port, protocol))
1133
103
        defer.returnValue(opened_ports)
1134
104
1135
105
    @defer.inlineCallbacks
1136
106
    def ensure_groups(self, machine_id):
1137
107
        """Get names of the security groups for a machine, creating if needed
1138
108
1139
109
        If the juju group already exists, it is assumed to be correctly set up.
1140
110
        If the machine group already exists, it is deleted then recreated.
1141
111
        """
1142
112
        security_groups = yield self.nova.list_security_groups()
1143
113
        groups_by_name = dict((sg['name'], sg['id']) for sg in security_groups)
1144
114
1145
115
        juju_group = self._juju_group_name()
1146
116
        if not juju_group in groups_by_name:
1147
117
            log.debug("Creating juju security group %s", juju_group)
1148
118
            sg = yield self.nova.create_security_group(juju_group,
1149
119
                "juju group for %s" % (self.tag,))
1150
120
            # Add external ssh access
1151
121
            yield self.nova.add_security_group_rule(sg['id'],
1152
122
                ip_protocol="tcp", from_port=22, to_port=22)
1153
123
            # Add internal group access
1154
124
            yield self.nova.add_security_group_rule(
1155
125
                parent_group_id=sg['id'], group_id=sg['id'],
1156
126
                ip_protocol="tcp", from_port=1, to_port=65535)
1157
127
1158
128
        machine_group = self._machine_group_name(machine_id)
1159
129
        if machine_group in groups_by_name:
1160
130
            yield self.nova.delete_security_group(
1161
131
                groups_by_name[machine_group])
1162
132
        log.debug("Creating machine security group %s", machine_group)
1163
133
        yield self.nova.create_security_group(machine_group,
1164
134
            "juju group for %s machine %s" % (self.tag, machine_id))
1165
135
1166
136
        defer.returnValue([juju_group, machine_group])
1167
137
1168
138
    @defer.inlineCallbacks
1169
139
    def get_machine_groups(self, machine, with_juju_group=False):
1170
140
        try:
1171
141
            ret = yield self.get_machine_groups_pure(machine, with_juju_group)
1172
142
        except errors.ProviderInteractionError, e:
1173
143
            # XXX: Need to wire up treatment of 500s properly in client
1174
144
            if getattr(e, "kind", None) == "computeError":
1175
145
                try:
1176
146
                    yield self.nova.get_server(machine.instance_id)
1177
147
                except errors.ProviderInteractionError, e:
1178
148
                    pass  # just rebinding e
1179
149
            if True or getattr(e, "kind", None) == "itemNotFound":
1180
150
                defer.returnValue(None)
1181
151
            raise
1182
152
        defer.returnValue(ret)
1183
153
1184
154
    @defer.inlineCallbacks
1185
155
    def get_machine_groups_pure(self, machine, with_juju_group=False):
1186
156
        server_id = machine.instance_id
1187
157
        groups = yield self.nova.get_server_security_groups(server_id)
1188
158
        juju_group = self._juju_group_name()
1189
159
        groups_by_name = dict((g['name'], g['id']) for g in groups
1190
160
            if g['name'].startswith(juju_group))
1191
161
        if juju_group not in groups_by_name:
1192
162
            # Not a juju machine, shouldn't touch
1193
163
            defer.returnValue(None)
1194
164
        if not with_juju_group:
1195
165
            groups_by_name.pop(juju_group)
1196
166
        # else assumption: only one remaining group, is the machine group
1197
167
        defer.returnValue(groups_by_name)
1198
168
1199
169
    @defer.inlineCallbacks
1200
170
    def delete_juju_group(self):
1201
171
        security_groups = yield self.nova.list_security_groups()
1202
172
        juju_group = self._juju_group_name()
1203
173
        for group in security_groups:
1204
174
            if group['name'] == juju_group:
1205
175
                break
1206
176
        else:
1207
177
            log.debug("Can't delete missing juju group")
1208
178
            return
1209
179
        yield self.nova.delete_security_group(group['id'])
1210
0
180
1211
=== added file 'juju/providers/openstack/provider.py'
1212
--- juju/providers/openstack/provider.py	1970-01-01 00:00:00 +0000
1213
+++ juju/providers/openstack/provider.py	2012-07-18 19:47:20 +0000
1214
@@ -0,0 +1,189 @@
1215
1
"""Provider interface implementation for OpenStack backend
1216
2
1217
3
Much of the logic is implemented in sibling modules, but the overall model is
1218
4
exposed here.
1219
5
1220
6
Still in need of work here:
1221
7
* Implement constraints using the Nova flavors api. This will always mean an
1222
8
  api call rather than hard coding values as is done with EC2. Things like
1223
9
  memory and cpu count are broadly equivalent, but there's no guarentee what
1224
10
  details are exposed and ranking by price will generally not be an option.
1225
11
"""
1226
12
1227
13
import logging
1228
14
1229
15
from twisted.internet import defer
1230
16
1231
17
from juju import errors
1232
18
from juju.providers.common.base import MachineProviderBase
1233
19
1234
20
from .client import _OpenStackClient, _NovaClient, _SwiftClient
1235
21
from . import credentials
1236
22
from .files import FileStorage
1237
23
from .launch import NovaLaunchMachine
1238
24
from .machine import (
1239
25
    NovaProviderMachine, get_server_status, machine_from_instance
1240
26
    )
1241
27
from .ports import NovaPortManager
1242
28
1243
29
1244
30
log = logging.getLogger("juju.openstack")
1245
31
1246
32
1247
33
class MachineProvider(MachineProviderBase):
1248
34
    """MachineProvider for use in an OpenStack environment"""
1249
35
1250
36
    Credentials = credentials.OpenStackCredentials
1251
37
1252
38
    def __init__(self, environment_name, config):
1253
39
        super(MachineProvider, self).__init__(environment_name, config)
1254
40
        self.credentials = self.Credentials.from_environment(config)
1255
41
        client = _OpenStackClient(self.credentials)
1256
42
        self.nova = _NovaClient(client)
1257
43
        self.swift = _SwiftClient(client)
1258
44
        self.port_manager = NovaPortManager(self.nova, environment_name)
1259
45
1260
46
    @property
1261
47
    def provider_type(self):
1262
48
        return "openstack"
1263
49
1264
50
    def get_serialization_data(self):
1265
51
        """Get provider configuration suitable for serialization.
1266
52
1267
53
        Also fills in credential information that may have earlier been
1268
54
        extracted from the environment.
1269
55
        """
1270
56
        data = super(MachineProvider, self).get_serialization_data()
1271
57
        self.credentials.set_config_defaults(data)
1272
58
        return data
1273
59
1274
60
    def get_file_storage(self):
1275
61
        """Retrieve a Swift-backed :class:`FileStorage`."""
1276
62
        return FileStorage(self.swift, self.config["control-bucket"])
1277
63
1278
64
    def start_machine(self, machine_data, master=False):
1279
65
        """Start an OpenStack machine.
1280
66
1281
67
        :param dict machine_data: desired characteristics of the new machine;
1282
68
            it must include a "machine-id" key, and may include a "constraints"
1283
69
            key to specify the underlying OS and hardware.
1284
70
1285
71
        :param bool master: if True, machine will initialize the juju admin
1286
72
            and run a provisioning agent, in addition to running a machine
1287
73
            agent.
1288
74
        """
1289
75
        return NovaLaunchMachine.launch(self, machine_data, master)
1290
76
1291
77
    @defer.inlineCallbacks
1292
78
    def get_machines(self, instance_ids=()):
1293
79
        """List machines running in the provider.
1294
80
1295
81
        :param list instance_ids: ids of instances you want to get. Leave empty
1296
82
            to list every
1297
83
            :class:`juju.providers.openstack.machine.NovaProviderMachine` owned
1298
84
            by this provider.
1299
85
1300
86
        :return: a list of
1301
87
            :class:`juju.providers.openstack.machine.NovaProviderMachine`
1302
88
            instances
1303
89
        :rtype: :class:`twisted.internet.defer.Deferred`
1304
90
1305
91
        :raises: :exc:`juju.errors.MachinesNotFound`
1306
92
        """
1307
93
        if len(instance_ids) == 1:
1308
94
            try:
1309
95
                instances = [(yield self.nova.get_server(instance_ids[0]))]
1310
96
            except errors.ProviderInteractionError, e:
1311
97
                # XXX: Need to wire up treatment of 404s properly in client
1312
98
                if True or getattr(e, "kind", None) == "itemNotFound":
1313
99
                    raise errors.MachinesNotFound(set(instance_ids))
1314
100
                raise
1315
101
            instance_ids = frozenset(instance_ids)
1316
102
        else:
1317
103
            instances = yield self.nova.list_servers()
1318
104
            if instance_ids:
1319
105
                instance_ids = frozenset(instance_ids)
1320
106
                instances = [instance for instance in instances
1321
107
                    if instance['id'] in instance_ids]
1322
108
1323
109
        # Only want to deal with servers that were created by juju, checking
1324
110
        # the name begins with the prefix launch uses is good enough.
1325
111
        name_prefix = "juju %s instance " % (self.environment_name,)
1326
112
        machines = []
1327
113
        for instance in instances:
1328
114
            if (instance['name'].startswith(name_prefix) and
1329
115
                    get_server_status(instance) in ("running", "pending")):
1330
116
                machines.append(machine_from_instance(instance))
1331
117
1332
118
        if instance_ids:
1333
119
            # We were asked for a specific list of machines, and if we can't
1334
120
            # completely fulfil that request we should blow up.
1335
121
            missing = instance_ids.difference(m.instance_id for m in machines)
1336
122
            if missing:
1337
123
                raise errors.MachinesNotFound(missing)
1338
124
1339
125
        defer.returnValue(machines)
1340
126
1341
127
    @defer.inlineCallbacks
1342
128
    def _delete_machine(self, machine, full=False):
1343
129
        server_id = machine.instance_id
1344
130
        server = yield self.nova.get_server(server_id)
1345
131
        if not server['name'].startswith(
1346
132
            "juju %s instance" % self.environment_name):
1347
133
            raise errors.MachinesNotFound(set([machine.instance_id]))
1348
134
        yield self.nova.delete_server(server_id)
1349
135
        defer.returnValue(machine)
1350
136
1351
137
    def shutdown_machine(self, machine):
1352
138
        if not isinstance(machine, NovaProviderMachine):
1353
139
            raise errors.ProviderError(
1354
140
                "Need a NovaProviderMachine to shutdown not: %r" % (machine,))
1355
141
        # EC2 provider re-gets the machine to see if it's still in existance
1356
142
        # and can be shutdown, instead just handle an error? 404-ish?
1357
143
        return self._delete_machine(machine)
1358
144
1359
145
    @defer.inlineCallbacks
1360
146
    def destroy_environment(self):
1361
147
        """Terminate all associated machines and security groups.
1362
148
1363
149
        The super defintion of this method terminates each machine in
1364
150
        the environment; this needs to be augmented here by also
1365
151
        removing the security group for the environment.
1366
152
1367
153
        :rtype: :class:`twisted.internet.defer.Deferred`
1368
154
        """
1369
155
        machines = yield self.get_machines()
1370
156
        deleted_machines = yield defer.gatherResults(
1371
157
            [self._delete_machine(m, True) for m in machines])
1372
158
        yield self.save_state({})
1373
159
        defer.returnValue(deleted_machines)
1374
160
1375
161
    def shutdown_machines(self, machines):
1376
162
        """Terminate machines associated with this provider.
1377
163
1378
164
        :param machines: machines to shut down
1379
165
        :type machines: list of
1380
166
            :class:`juju.providers.openstack.machine.NovaProviderMachine`
1381
167
1382
168
        :return: list of terminated
1383
169
            :class:`juju.providers.openstack.machine.NovaProviderMachine`
1384
170
            instances
1385
171
        :rtype: :class:`twisted.internet.defer.Deferred`
1386
172
        """
1387
173
        # XXX: need to actually handle errors as non-terminated machines
1388
174
        # and not include them in the resulting list
1389
175
        return defer.gatherResults(
1390
176
            [self.shutdown_machine(m) for m in machines], consumeErrors=True)
1391
177
1392
178
    def open_port(self, machine, machine_id, port, protocol="tcp"):
1393
179
        """Authorizes `port` using `protocol` on EC2 for `machine`."""
1394
180
        return self.port_manager.open_port(machine, machine_id, port, protocol)
1395
181
1396
182
    def close_port(self, machine, machine_id, port, protocol="tcp"):
1397
183
        """Revokes `port` using `protocol` on EC2 for `machine`."""
1398
184
        return self.port_manager.close_port(
1399
185
            machine, machine_id, port, protocol)
1400
186
1401
187
    def get_opened_ports(self, machine, machine_id):
1402
188
        """Returns a set of open (port, proto) pairs for `machine`."""
1403
189
        return self.port_manager.get_opened_ports(machine, machine_id)
1404
0
190
1405
=== added directory 'juju/providers/openstack/tests'
1406
=== added file 'juju/providers/openstack/tests/__init__.py'
1407
--- juju/providers/openstack/tests/__init__.py	1970-01-01 00:00:00 +0000
1408
+++ juju/providers/openstack/tests/__init__.py	2012-07-18 19:47:20 +0000
1409
@@ -0,0 +1,206 @@
1410
1
"""Infrastructure shared by all tests for OpenStack provider"""
1411
2
1412
3
import json
1413
4
1414
5
from twisted.internet import (
1415
6
    defer,
1416
7
    )
1417
8
from twisted.web import (
1418
9
    http,
1419
10
    http_headers,
1420
11
    )
1421
12
1422
13
from juju import errors
1423
14
from juju.lib import (
1424
15
    mocker,
1425
16
    )
1426
17
1427
18
from juju.providers.openstack import (
1428
19
    client,
1429
20
    files,
1430
21
    machine,
1431
22
    ports,
1432
23
    provider,
1433
24
    )
1434
25
1435
26
1436
27
class FakeResponse(object):
1437
28
1438
29
    def __init__(self, code):
1439
30
        if code not in http.RESPONSES:
1440
31
            raise ValueError("Unknown http code: %r" % (code,))
1441
32
        self.code = code
1442
33
        self.headers = http_headers.Headers(
1443
34
            {"Content-Type": ["application/json"]})
1444
35
1445
36
1446
37
class OpenStackTestMixin(object):
1447
38
    """Helpers for test classes that want to exercise the OpenStack APIs
1448
39
1449
40
    This goes all the way down to the http layer, which is really a little too
1450
41
    low for most of what the test cases want to assert. With some cleanups to
1451
42
    the client code, tests could instead mock out client methods.
1452
43
    """
1453
44
1454
45
    environment_name = "testing"
1455
46
    api_url = "http://test.invalid/v2.0/"
1456
47
1457
48
    def setUp(self):
1458
49
        self._mock_request = self.mocker.replace(
1459
50
            "juju.providers.openstack.client.request",
1460
51
            passthrough=False)
1461
52
        self.mocker.order()
1462
53
        self.nova_url = self.api_url + "nova"
1463
54
        self.swift_url = self.api_url + "swift"
1464
55
        self._mock_request("POST", self.api_url + "tokens", body=mocker.ANY)
1465
56
        self.mocker.result(defer.succeed((FakeResponse(200),
1466
57
            json.dumps({"access": {
1467
58
                "token": {"id": "tok", "expires": "2030-01-01T00:00:00"},
1468
59
                "serviceCatalog": [
1469
60
                    {
1470
61
                        "type": "compute",
1471
62
                        "endpoints": [{"publicURL": self.nova_url}]
1472
63
                    },
1473
64
                    {
1474
65
                        "type": "object-store",
1475
66
                        "endpoints": [{"publicURL": self.swift_url}]
1476
67
                    }
1477
68
                ]
1478
69
            }}))))
1479
70
        # Clear the environment so provider won't pick up config from envvars
1480
71
        self.change_environment()
1481
72
1482
73
    def get_config(self):
1483
74
        return {
1484
75
            "type": "openstack",
1485
76
            "admin-secret": "password",
1486
77
            "access-key": "90abcdef",
1487
78
            "secret-key": "xxxxxxxx",
1488
79
            "auth-mode": "keypair",
1489
80
            "auth-url": self.api_url,
1490
81
            "project-name": "test_project",
1491
82
            "control-bucket": self.environment_name,
1492
83
            "default-instance-type": "standard.xsmall",
1493
84
            "default-image-id": 42,
1494
85
            "use-floating-ip": True,
1495
86
            }
1496
87
1497
88
    def get_provider(self):
1498
89
        """Return the openstack machine provider.
1499
90
1500
91
        This should only be invoked after mocker is in replay mode.
1501
92
        """
1502
93
        return provider.MachineProvider(self.environment_name,
1503
94
            self.get_config())
1504
95
1505
96
    def make_server(self, server_id, name=None, status="ACTIVE"):
1506
97
        if name is None:
1507
98
            # Would be machine id rather than server id really but will do.
1508
99
            name = "juju testing instance " + str(server_id)
1509
100
        return {
1510
101
            "id": server_id,
1511
102
            "name": name,
1512
103
            "status": status,
1513
104
            "addresses": {},
1514
105
            }
1515
106
1516
107
    def assert_not_found(self, deferred, server_ids):
1517
108
        self.assertFailure(deferred, errors.MachinesNotFound)
1518
109
        return deferred.addCallback(self._check_not_found, server_ids)
1519
110
1520
111
    def _check_not_found(self, error, server_ids):
1521
112
        self.assertEqual(error.instance_ids, server_ids)
1522
113
1523
114
    def _mock_nova(self, method, path, body):
1524
115
        self._mock_request(method,
1525
116
            "%s/%s" % (self.nova_url, path),
1526
117
            [("X-Auth-Token", "tok")],
1527
118
            body)
1528
119
1529
120
    def _mock_swift(self, method, path, body, extra_headers=None):
1530
121
        headers = [("X-Auth-Token", "tok")]
1531
122
        if extra_headers is not None:
1532
123
            headers += extra_headers
1533
124
        url = "%s/%s" % (self.swift_url, path)
1534
125
        self._mock_request(method, url, headers, body)
1535
126
1536
127
    def expect_nova_get(self, path, code=200, response=""):
1537
128
        self._mock_nova("GET", path, None)
1538
129
        if not isinstance(response, str):
1539
130
            response = json.dumps(response)
1540
131
        self.mocker.result(defer.succeed((FakeResponse(code), response)))
1541
132
1542
133
    def expect_nova_post(self, path, body, code=200, response=""):
1543
134
        self._mock_nova("POST", path, body)
1544
135
        if not isinstance(response, str):
1545
136
            response = json.dumps(response)
1546
137
        self.mocker.result(defer.succeed((FakeResponse(code), response)))
1547
138
1548
139
    def expect_nova_delete(self, path, code=202, response=""):
1549
140
        self._mock_nova("DELETE", path, None)
1550
141
        self.mocker.result(defer.succeed((FakeResponse(code), response)))
1551
142
1552
143
    def expect_swift_get(self, path, code=200, response=""):
1553
144
        self._mock_swift("GET", path, None)
1554
145
        self.mocker.result(defer.succeed((FakeResponse(code), response)))
1555
146
1556
147
    def expect_swift_put(self, path, body, code=201, response=""):
1557
148
        self._mock_swift("PUT", path, body)
1558
149
        self.mocker.result(defer.succeed((FakeResponse(code), response)))
1559
150
1560
151
    def expect_swift_put_container(self, container, code=201, response=""):
1561
152
        self._mock_swift("PUT", container, "", [('X-Container-Read', '.r:*')])
1562
153
        self.mocker.result(defer.succeed((FakeResponse(code), response)))
1563
154
1564
155
1565
156
class MockedProvider(object):
1566
157
1567
158
    provider_type = "openstack"
1568
159
    environment_name = "testing"
1569
160
    api_url = "http://testing.invalid/2.0/"
1570
161
1571
162
    default_config = {
1572
163
        "type": "openstack",
1573
164
        "admin-secret": "asecret",
1574
165
        "username": "auser",
1575
166
        "password": "xxxxxxxx",
1576
167
        "auth-url": api_url,
1577
168
        "project-name": "aproject",
1578
169
        "control-bucket": environment_name,
1579
170
        "default-instance-type": "standard.xsmall",
1580
171
        "default-image-id": 42,
1581
172
        }
1582
173
1583
174
    def __init__(self, mocker, config=None):
1584
175
        if config is None:
1585
176
            config = dict(self.default_config)
1586
177
        self.config = config
1587
178
        self.nova = mocker.proxy(client._NovaClient(None), passthrough=False)
1588
179
        self.swift = mocker.proxy(client._SwiftClient(None), passthrough=False)
1589
180
        self.port_manager = mocker.proxy(
1590
181
            ports.NovaPortManager(self.nova, self.environment_name))
1591
182
        self.provider_actions = mocker.mock()
1592
183
        self.mocker = mocker
1593
184
1594
185
    def get_file_storage(self):
1595
186
        return files.FileStorage(self.swift, self.config['control-bucket'])
1596
187
1597
188
    def __getattr__(self, attr):
1598
189
        return getattr(self.provider_actions, attr)
1599
190
1600
191
    def expect_swift_public_object_url(self, object_name):
1601
192
        container_name = self.config['control-bucket']
1602
193
        event = self.swift.public_object_url(container_name, object_name)
1603
194
        self.mocker.result("%sswift/%s" % (self.api_url, object_name))
1604
195
        return event
1605
196
1606
197
    def expect_swift_put(self, object_name, body, code=201, response=""):
1607
198
        container_name = self.config['control-bucket']
1608
199
        event = self.swift.put_object(container_name, object_name, body)
1609
200
        self.mocker.result(defer.succeed((FakeResponse(code), response)))
1610
201
        return event
1611
202
1612
203
    def expect_zookeeper_machines(self, iid):
1613
204
        event = self.provider_actions.get_zookeeper_machines()
1614
205
        self.mocker.result(defer.succeed([machine.NovaProviderMachine(iid)]))
1615
206
        return event
1616
0
207
1617
=== added file 'juju/providers/openstack/tests/test_bootstrap.py'
1618
--- juju/providers/openstack/tests/test_bootstrap.py	1970-01-01 00:00:00 +0000
1619
+++ juju/providers/openstack/tests/test_bootstrap.py	2012-07-18 19:47:20 +0000
1620
@@ -0,0 +1,213 @@
1621
1
"""Tests for bootstrapping juju on openstack
1622
2
1623
3
Bootstrap touches a lot of the other parts of the provider, including machine
1624
4
launching, security groups and so on. Testing this in an end-to-end fashion as
1625
5
is done currently duplicates many checks from other more focussed tests.
1626
6
"""
1627
7
1628
8
import logging
1629
9
import yaml
1630
10
1631
11
from juju.lib import (
1632
12
    mocker,
1633
13
    testing,
1634
14
    )
1635
15
from juju.machine import constraints
1636
16
1637
17
from juju.providers.openstack.machine import NovaProviderMachine
1638
18
1639
19
from juju.providers.openstack.tests import OpenStackTestMixin
1640
20
1641
21
1642
22
class OpenStackBootstrapTest(OpenStackTestMixin, testing.TestCase):
1643
23
1644
24
    def expect_verify(self):
1645
25
        self.expect_swift_put("testing/bootstrap-verify",
1646
26
            "storage is writable")
1647
27
1648
28
    def expect_provider_state_fresh(self):
1649
29
        self.expect_swift_get("testing/provider-state")
1650
30
        self.expect_verify()
1651
31
1652
32
    def expect_create_group(self):
1653
33
        self.expect_nova_post("os-security-groups",
1654
34
            {'security_group': {
1655
35
                'name': 'juju-testing',
1656
36
                'description': 'juju group for testing',
1657
37
            }},
1658
38
            response={'security_group': {
1659
39
                'id': 1,
1660
40
            }})
1661
41
        self.expect_nova_post("os-security-group-rules",
1662
42
            {'security_group_rule': {
1663
43
                'parent_group_id': 1,
1664
44
                'ip_protocol': "tcp",
1665
45
                'from_port': 22,
1666
46
                'to_port': 22,
1667
47
            }},
1668
48
            response={'security_group_rule': {
1669
49
                'id': 144, 'parent_group_id': 1,
1670
50
            }})
1671
51
        self.expect_nova_post("os-security-group-rules",
1672
52
            {'security_group_rule': {
1673
53
                'parent_group_id': 1,
1674
54
                'group_id': 1,
1675
55
                'ip_protocol': "tcp",
1676
56
                'from_port': 1,
1677
57
                'to_port': 65535,
1678
58
            }},
1679
59
            response={'security_group_rule': {
1680
60
                'id': 145, 'parent_group_id': 1,
1681
61
            }})
1682
62
1683
63
    def expect_create_machine_group(self, machine_id):
1684
64
        machine = str(machine_id)
1685
65
        self.expect_nova_post("os-security-groups",
1686
66
            {'security_group': {
1687
67
                'name': 'juju-testing-' + machine,
1688
68
                'description': 'juju group for testing machine ' + machine,
1689
69
            }},
1690
70
            response={'security_group': {
1691
71
                'id': 2,
1692
72
            }})
1693
73
1694
74
    def _match_server(self, data):
1695
75
        userdata = data['server'].pop('user_data').decode("base64")
1696
76
        self.assertEqual("#cloud-config", userdata.split("\n", 1)[0])
1697
77
        cloud_init = yaml.load(userdata)
1698
78
        # TODO: assertions on cloud-init content
1699
79
        self.assertEqual({'server': {
1700
80
                'flavorRef': 1,
1701
81
                'imageRef': 42,
1702
82
                'name': 'juju testing instance 0',
1703
83
                'security_groups': [
1704
84
                    {'name': 'juju-testing'},
1705
85
                    {'name': 'juju-testing-0'},
1706
86
                ],
1707
87
            }},
1708
88
            data)
1709
89
        return True
1710
90
1711
91
    def expect_launch(self):
1712
92
        self.expect_nova_get("flavors",
1713
93
            response={'flavors': [{'id': 1, 'name': "standard.xsmall"}]})
1714
94
        self.expect_nova_post("servers", mocker.MATCH(self._match_server),
1715
95
            code=202, response={'server': {
1716
96
                'id': '1000',
1717
97
                'status': "PENDING",
1718
98
                'addresses': {'private': [{'version': 4, 'addr': "4.4.4.4"}]},
1719
99
            }})
1720
100
        self.expect_swift_put("testing/juju_master_id", "1000")
1721
101
        self.expect_nova_get("os-floating-ips",
1722
102
            response={'floating_ips': [
1723
103
                {'id': 80, 'instance_id': None, 'ip': "8.8.8.8"}
1724
104
            ]})
1725
105
        self.expect_nova_post("servers/1000/action",
1726
106
            {"addFloatingIp": {"address": "8.8.8.8"}}, code=202)
1727
107
        self.expect_swift_put("testing/provider-state",
1728
108
            yaml.dump({'zookeeper-instances': ['1000']}))
1729
109
1730
110
    def _check_machine(self, machine_list):
1731
111
        [machine] = machine_list
1732
112
        self.assertTrue(isinstance(machine, NovaProviderMachine))
1733
113
        self.assertEqual(machine.instance_id, '1000')
1734
114
1735
115
    def bootstrap(self):
1736
116
        provider = self.get_provider()
1737
117
        constraint_set = constraints.ConstraintSet(provider.provider_type)
1738
118
        return provider.bootstrap(constraint_set.load({}))
1739
119
1740
120
    def test_bootstrap_clean(self):
1741
121
        """Bootstrap from a clean slate makes groups and zookeeper instance"""
1742
122
        self.expect_provider_state_fresh()
1743
123
        self.expect_nova_get("os-security-groups",
1744
124
            response={'security_groups': []})
1745
125
        self.expect_create_group()
1746
126
        self.expect_create_machine_group(0)
1747
127
        self.expect_launch()
1748
128
        self.mocker.replay()
1749
129
1750
130
        log = self.capture_logging("juju.common", level=logging.DEBUG)
1751
131
        deferred = self.bootstrap()
1752
132
        deferred.addCallback(self._check_machine)
1753
133
        def check_log(_):
1754
134
            log_text = log.getvalue()
1755
135
            self.assertIn("Launching juju bootstrap instance", log_text)
1756
136
            self.assertNotIn("previously bootstrapped", log_text)
1757
137
        return deferred.addCallback(check_log)
1758
138
1759
139
    def test_bootstrap_existing_group(self):
1760
140
        """Bootstrap reuses an exisiting provider security group"""
1761
141
        self.expect_provider_state_fresh()
1762
142
        self.expect_nova_get("os-security-groups",
1763
143
            response={'security_groups': [
1764
144
                    {'name': "juju-testing", 'id': 1},
1765
145
                ]})
1766
146
        self.expect_create_machine_group(0)
1767
147
        self.expect_launch()
1768
148
        self.mocker.replay()
1769
149
        return self.bootstrap().addCallback(self._check_machine)
1770
150
1771
151
    def test_bootstrap_existing_machine_group(self):
1772
152
        """Bootstrap deletes and remakes an existing machine security group"""
1773
153
        self.expect_provider_state_fresh()
1774
154
        self.expect_nova_get("os-security-groups",
1775
155
            response={'security_groups': [
1776
156
                    {'name': "juju-testing-0", 'id': 3},
1777
157
                ]})
1778
158
        self.expect_create_group()
1779
159
        self.expect_nova_delete("os-security-groups/3")
1780
160
        self.expect_create_machine_group(0)
1781
161
        self.expect_launch()
1782
162
        self.mocker.replay()
1783
163
        return self.bootstrap().addCallback(self._check_machine)
1784
164
1785
165
    def test_existing_machine(self):
1786
166
        """A preexisting zookeeper instance is returned if present"""
1787
167
        self.expect_swift_get("testing/provider-state",
1788
168
            response=yaml.dump({'zookeeper-instances': ['1000']}))
1789
169
        self.expect_nova_get("servers/1000",
1790
170
            response={'server': {
1791
171
                'id': '1000',
1792
172
                'name': 'juju testing instance 0',
1793
173
                'state': "RUNNING"
1794
174
            }})
1795
175
        self.mocker.replay()
1796
176
1797
177
        log = self.capture_logging("juju.common")
1798
178
        self.capture_logging("juju.openstack") # Drop to avoid stderr kipple
1799
179
        deferred = self.bootstrap()
1800
180
        deferred.addCallback(self._check_machine)
1801
181
        def check_log(_):
1802
182
            self.assertEqual("juju environment previously bootstrapped.\n",
1803
183
                log.getvalue())
1804
184
        return deferred.addCallback(check_log)
1805
185
1806
186
    def test_existing_machine_missing(self):
1807
187
        """Bootstrap overwrites existing zookeeper if instance is present"""
1808
188
        self.expect_swift_get("testing/provider-state",
1809
189
            response=yaml.dump({'zookeeper-instances': [3000]}))
1810
190
        self.expect_nova_get("servers/3000", code=404,
1811
191
            response={'itemNotFound':
1812
192
                {'message': "The resource could not be found.", 'code': 404}
1813
193
            })
1814
194
        self.expect_verify()
1815
195
        self.expect_nova_get("os-security-groups",
1816
196
            response={'security_groups': [
1817
197
                    {'name': "juju-testing", 'id': 1},
1818
198
                    {'name': "juju-testing-0", 'id': 3},
1819
199
                ]})
1820
200
        self.expect_nova_delete("os-security-groups/3")
1821
201
        self.expect_create_machine_group(0)
1822
202
        self.expect_launch()
1823
203
        self.mocker.replay()
1824
204
1825
205
        log = self.capture_logging("juju.common", level=logging.DEBUG)
1826
206
        self.capture_logging("juju.openstack") # Drop to avoid stderr kipple
1827
207
        deferred = self.bootstrap()
1828
208
        deferred.addCallback(self._check_machine)
1829
209
        def check_log(_):
1830
210
            log_text = log.getvalue()
1831
211
            self.assertIn("Launching juju bootstrap instance", log_text)
1832
212
            self.assertNotIn("previously bootstrapped", log_text)
1833
213
        return deferred.addCallback(check_log)
1834
0
214
1835
=== added file 'juju/providers/openstack/tests/test_client.py'
1836
--- juju/providers/openstack/tests/test_client.py	1970-01-01 00:00:00 +0000
1837
+++ juju/providers/openstack/tests/test_client.py	2012-07-18 19:47:20 +0000
1838
@@ -0,0 +1,75 @@
1839
1
"""Tests for OpenStack API twisted client"""
1840
2
1841
3
from juju.lib import testing
1842
4
1843
5
from juju.providers.openstack import client
1844
6
1845
7
1846
8
class StubClient(client._OpenStackClient):
1847
9
1848
10
    def __init__(self):
1849
11
        self.url = "http://testing.invalid"
1850
12
1851
13
    make_url = client._OpenStackClient._make_url
1852
14
1853
15
1854
16
class TestMakeUrl(testing.TestCase):
1855
17
1856
18
    def setUp(self):
1857
19
        self.client = StubClient()
1858
20
        self.client.services = {
1859
21
            "compute": self.client.url + "/nova",
1860
22
            "object-store": self.client.url + "/swift",
1861
23
            }
1862
24
1863
25
    def test_list_str(self):
1864
26
        self.assertEqual("http://testing.invalid/nova/servers",
1865
27
            self.client.make_url("compute", ["servers"]))
1866
28
        self.assertEqual("http://testing.invalid/swift/container/object",
1867
29
            self.client.make_url("object-store", ["container", "object"]))
1868
30
1869
31
    def test_list_int(self):
1870
32
        self.assertEqual("http://testing.invalid/nova/servers/1000",
1871
33
            self.client.make_url("compute", ["servers", 1000]))
1872
34
        self.assertEqual("http://testing.invalid/nova/servers/1000/detail",
1873
35
            self.client.make_url("compute", ["servers", 1000, "detail"]))
1874
36
1875
37
    def test_list_unicode(self):
1876
38
        url = self.client.make_url("object-store", ["container", u"\xa7"])
1877
39
        self.assertIsInstance(url, str)
1878
40
        self.assertEqual("http://testing.invalid/swift/container/%C2%A7", url)
1879
41
1880
42
    def test_str(self):
1881
43
        self.assertEqual("http://testing.invalid/nova/servers",
1882
44
            self.client.make_url("compute", "servers"))
1883
45
        self.assertEqual("http://testing.invalid/swift/container/object",
1884
46
            self.client.make_url("object-store", "container/object"))
1885
47
1886
48
    def test_trailing_slash(self):
1887
49
        self.client.services["object-store"] += "/"
1888
50
        self.assertEqual("http://testing.invalid/nova/container",
1889
51
            self.client.make_url("compute", "container"))
1890
52
        self.assertEqual("http://testing.invalid/nova/container/object",
1891
53
            self.client.make_url("compute", ["container", "object"]))
1892
54
1893
55
1894
56
class TestPlan(testing.TestCase):
1895
57
    """Ideas for tests needed"""
1896
58
1897
59
    # auth request without auth
1898
60
    # get bytes, content-length 0, return ""
1899
61
    # get bytes, not ResponseDone, raise wrapped in ProviderError (with any bytes?)
1900
62
    # get bytes, type json, return bytes
1901
63
    # get json, content length 0, raise ProviderError
1902
64
    # get json, bad header (several forms), raise ProviderError (with bytes)
1903
65
    # get json, not ResponseDone, raise wrapped in ProviderError (with any bytes?)
1904
66
    # get json, undecodable, raise wrapped in ProviderError with bytes
1905
67
    # get json, mismatching root, raise ProviderError with bytes or json?
1906
68
    # wrong code, no json header, raise ProviderError with bytes
1907
69
    # wrong code, not ResponseDone, raise ProviderError from code with any bytes
1908
70
    # wrong code, undecodable, raise ProviderError from code with bytes
1909
71
    # wrong code, has mystery root, raise ProviderError from code with bytes or json?
1910
72
    # wrong code, has good root, no message
1911
73
    # wrong code, has good root, no code
1912
74
    # wrong code, has good root, differing code
1913
75
    # wrong code, has good root, message, and matching code
1914
0
76
1915
=== added file 'juju/providers/openstack/tests/test_credentials.py'
1916
--- juju/providers/openstack/tests/test_credentials.py	1970-01-01 00:00:00 +0000
1917
+++ juju/providers/openstack/tests/test_credentials.py	2012-07-18 19:47:20 +0000
1918
@@ -0,0 +1,216 @@
1919
1
"""Tests for handling of OpenStack credentials in config and environment"""
1920
2
1921
3
from juju.lib import (
1922
4
    testing,
1923
5
    )
1924
6
from juju.providers.openstack import (
1925
7
    credentials,
1926
8
    )
1927
9
1928
10
1929
11
class OpenStackCredentialsTests(testing.TestCase):
1930
12
1931
13
    def test_required_url(self):
1932
14
        e = self.assertRaises(ValueError, credentials.OpenStackCredentials, {})
1933
15
        self.assertIn("Missing config 'auth-url'", str(e))
1934
16
1935
17
    def test_required_mode_if_unguessable(self):
1936
18
        e = self.assertRaises(ValueError, credentials.OpenStackCredentials, {
1937
19
            'auth-url': "http://example.com",
1938
20
            })
1939
21
        self.assertIn("Missing config 'auth-mode'", str(e))
1940
22
1941
23
    def test_legacy(self):
1942
24
        creds = credentials.OpenStackCredentials({
1943
25
            'auth-url': "http://example.com",
1944
26
            'auth-mode': "legacy",
1945
27
            'username': "luser",
1946
28
            'access-key': "laccess",
1947
29
            })
1948
30
        self.assertEqual(creds.url, "http://example.com")
1949
31
        self.assertEqual(creds.mode, "legacy")
1950
32
        self.assertEqual(creds.username, "luser")
1951
33
        self.assertEqual(creds.access_key, "laccess")
1952
34
1953
35
    def test_legacy_required_username(self):
1954
36
        e = self.assertRaises(ValueError, credentials.OpenStackCredentials, {
1955
37
            'auth-url': "http://example.com",
1956
38
            'auth-mode': "legacy",
1957
39
            'access-key': "laccess",
1958
40
            })
1959
41
        self.assertIn("Missing config 'username'", str(e))
1960
42
1961
43
    def test_legacy_required_access_key(self):
1962
44
        e = self.assertRaises(ValueError, credentials.OpenStackCredentials, {
1963
45
            'auth-url': "http://example.com",
1964
46
            'auth-mode': "legacy",
1965
47
            'username': "luser",
1966
48
            })
1967
49
        self.assertIn("Missing config 'access-key'", str(e))
1968
50
1969
51
    # v1.0 auth is gone from the upstream codebase so maybe remove support
1970
52
    def test_legacy_guess_v1_0(self):
1971
53
        creds = credentials.OpenStackCredentials({
1972
54
            'auth-url': "http://example.com/v1.0/",
1973
55
            'username': "luser",
1974
56
            'access-key': "laccess",
1975
57
            })
1976
58
        self.assertEqual(creds.mode, "legacy")
1977
59
1978
60
    def test_legacy_guess_v1_1(self):
1979
61
        creds = credentials.OpenStackCredentials({
1980
62
            'auth-url': "http://example.com/v1.1/",
1981
63
            'username': "luser",
1982
64
            'access-key': "laccess",
1983
65
            })
1984
66
        self.assertEqual(creds.mode, "legacy")
1985
67
1986
68
    def test_userpass(self):
1987
69
        creds = credentials.OpenStackCredentials({
1988
70
            'auth-url': "http://example.com",
1989
71
            'auth-mode': "userpass",
1990
72
            'username': "uuser",
1991
73
            'password': "upass",
1992
74
            'project-name': "uproject",
1993
75
            })
1994
76
        self.assertEqual(creds.url, "http://example.com")
1995
77
        self.assertEqual(creds.mode, "userpass")
1996
78
        self.assertEqual(creds.username, "uuser")
1997
79
        self.assertEqual(creds.password, "upass")
1998
80
        self.assertEqual(creds.project_name, "uproject")
1999
81
2000
82
    def test_userpass_guess_v2_0_no_slash(self):
2001
83
        creds = credentials.OpenStackCredentials({
2002
84
            'auth-url': "http://example.com/v2.0",
2003
85
            'username': "uuser",
2004
86
            'password': "upass",
2005
87
            'project-name': "uproject",
2006
88
            })
2007
89
        self.assertEqual(creds.mode, "userpass")
2008
90
2009
91
    def test_userpass_guess_v2_0_slash(self):
2010
92
        creds = credentials.OpenStackCredentials({
2011
93
            'auth-url': "http://example.com/v2.0/",
2012
94
            'username': "uuser",
2013
95
            'password': "upass",
2014
96
            'project-name': "uproject",
2015
97
            })
2016
98
        self.assertEqual(creds.mode, "userpass")
2017
99
2018
100
    def test_keypair(self):
2019
101
        creds = credentials.OpenStackCredentials({
2020
102
            'auth-url': "http://example.com",
2021
103
            'auth-mode': "keypair",
2022
104
            'access-key': "kaccess",
2023
105
            'secret-key': "ksecret",
2024
106
            'project-name': "kproject",
2025
107
            })
2026
108
        self.assertEqual(creds.url, "http://example.com")
2027
109
        self.assertEqual(creds.mode, "keypair")
2028
110
        self.assertEqual(creds.access_key, "kaccess")
2029
111
        self.assertEqual(creds.secret_key, "ksecret")
2030
112
        self.assertEqual(creds.project_name, "kproject")
2031
113
2032
114
2033
115
class FromEnvironmentTests(testing.TestCase):
2034
116
2035
117
    def test_required_url(self):
2036
118
        self.change_environment()
2037
119
        e = self.assertRaises(ValueError,
2038
120
            credentials.OpenStackCredentials.from_environment, {})
2039
121
        self.assertIn("Missing config 'auth-url'", str(e))
2040
122
2041
123
    def test_required_mode_if_unguessable(self):
2042
124
        self.change_environment(**{"NOVA_URL": "http://example.com"})
2043
125
        e = self.assertRaises(ValueError,
2044
126
            credentials.OpenStackCredentials.from_environment, {})
2045
127
        self.assertIn("Missing config 'auth-mode'", str(e))
2046
128
2047
129
    def test_legacy(self):
2048
130
        self.change_environment(**{
2049
131
            "NOVA_URL": "http://example.com/v1.1/",
2050
132
            "NOVA_USERNAME": "euser",
2051
133
            "NOVA_API_KEY": "ekey",
2052
134
            })
2053
135
        creds = credentials.OpenStackCredentials.from_environment({})
2054
136
        self.assertEqual(creds.mode, "legacy")
2055
137
        self.assertEqual(creds.username, "euser")
2056
138
        self.assertEqual(creds.access_key, "ekey")
2057
139
2058
140
    def test_keypair(self):
2059
141
        self.change_environment(**{
2060
142
            "NOVA_URL": "http://example.com/v2.0/",
2061
143
            "NOVA_API_KEY": "eaccess",
2062
144
            "NOVA_PROJECT_NAME": "eproject",
2063
145
            "NOVA_PROJECT_ID": "349212",
2064
146
            "NOVA_REGION_NAME": "eregion",
2065
147
            "EC2_SECRET_KEY": "esecret",
2066
148
            })
2067
149
        creds = credentials.OpenStackCredentials.from_environment({
2068
150
            'auth-mode': "keypair",
2069
151
            })
2070
152
        self.assertEqual(creds.access_key, "eaccess")
2071
153
        self.assertEqual(creds.secret_key, "esecret")
2072
154
        self.assertEqual(creds.project_name, "eproject")
2073
155
        self.assertEqual(creds.region, "eregion")
2074
156
2075
157
    def test_userpass(self):
2076
158
        self.change_environment(**{
2077
159
            "OS_AUTH_URL": "http://example.com/v2.0/",
2078
160
            "OS_USERNAME": "euser",
2079
161
            "OS_PASSWORD": "epass",
2080
162
            "OS_TENANT_NAME": "eproject",
2081
163
            "OS_REGION_NAME": "eregion",
2082
164
            })
2083
165
        creds = credentials.OpenStackCredentials.from_environment({})
2084
166
        self.assertEqual(creds.mode, "userpass")
2085
167
        self.assertEqual(creds.username, "euser")
2086
168
        self.assertEqual(creds.password, "epass")
2087
169
        self.assertEqual(creds.project_name, "eproject")
2088
170
        self.assertEqual(creds.region, "eregion")
2089
171
2090
172
    def test_prefer_os_auth_url(self):
2091
173
        self.change_environment(**{
2092
174
            "NOVA_URL": "http://example.com/v1.1/",
2093
175
            "NOVA_API_KEY": "eaccess",
2094
176
            "OS_AUTH_URL": "http://example.com/v2.0/",
2095
177
            "OS_USERNAME": "euser",
2096
178
            "OS_PASSWORD": "epass",
2097
179
            "OS_TENANT_NAME": "eproject",
2098
180
            })
2099
181
        creds = credentials.OpenStackCredentials.from_environment({})
2100
182
        self.assertEqual(creds.url, "http://example.com/v2.0/")
2101
183
        self.assertEqual(creds.mode, "userpass")
2102
184
2103
185
2104
186
class SetConfigDefaultsTests(testing.TestCase):
2105
187
2106
188
    def test_set_all(self):
2107
189
        config = {
2108
190
            'auth-url': "http://example.com",
2109
191
            'auth-mode': "legacy",
2110
192
            'username': "luser",
2111
193
            'access-key': "laccess",
2112
194
            }
2113
195
        creds = credentials.OpenStackCredentials(config)
2114
196
        new_config = {}
2115
197
        creds.set_config_defaults(new_config)
2116
198
        self.assertEqual(config, new_config)
2117
199
2118
200
    def test_set_only_missing(self):
2119
201
        config = {
2120
202
            'auth-url': "http://example.com/v1.1/",
2121
203
            'username': "luser",
2122
204
            'access-key': "laccess",
2123
205
            }
2124
206
        creds = credentials.OpenStackCredentials(config)
2125
207
        new_config = {
2126
208
            'username': "nuser",
2127
209
            }
2128
210
        creds.set_config_defaults(new_config)
2129
211
        self.assertEqual({
2130
212
            'auth-url': "http://example.com/v1.1/",
2131
213
            'auth-mode': "legacy",
2132
214
            'username': "nuser",
2133
215
            'access-key': "laccess",
2134
216
            }, new_config)
2135
0
217
2136
=== added file 'juju/providers/openstack/tests/test_files.py'
2137
--- juju/providers/openstack/tests/test_files.py	1970-01-01 00:00:00 +0000
2138
+++ juju/providers/openstack/tests/test_files.py	2012-07-18 19:47:20 +0000
2139
@@ -0,0 +1,103 @@
2140
1
"""Tests for file storage backend based on Swift"""
2141
2
2142
3
from cStringIO import StringIO
2143
4
2144
5
from twisted.internet import (
2145
6
    defer,
2146
7
    )
2147
8
2148
9
from juju import errors
2149
10
from juju.lib import (
2150
11
    testing,
2151
12
    )
2152
13
from juju.providers.openstack.tests import OpenStackTestMixin
2153
14
2154
15
2155
16
class FileStorageTestCase(OpenStackTestMixin, testing.TestCase):
2156
17
2157
18
    def get_storage(self):
2158
19
        provider = self.get_provider()
2159
20
        storage = provider.get_file_storage()
2160
21
        return storage
2161
22
2162
23
    def test_put_file(self):
2163
24
        """A file can be put in the storage"""
2164
25
        content = "some text"
2165
26
        self.expect_swift_put("testing/object", content)
2166
27
        self.mocker.replay()
2167
28
        return self.get_storage().put("object", StringIO(content))
2168
29
2169
30
    def test_put_file_unicode(self):
2170
31
        """A file with a unicode name is put in UTF-8 url encoded form"""
2171
32
        content = "some text"
2172
33
        self.expect_swift_put("testing/%C2%A7", content)
2173
34
        self.mocker.replay()
2174
35
        return self.get_storage().put(u"\xa7", StringIO(content))
2175
36
2176
37
    def test_put_file_create_container(self):
2177
38
        """The container will be created if it doesn't exist yet"""
2178
39
        content = "some text"
2179
40
        self.expect_swift_put("testing/object", content, code=404)
2180
41
        self.expect_swift_put_container("testing")
2181
42
        self.expect_swift_put("testing/object", content)
2182
43
        self.mocker.replay()
2183
44
        return self.get_storage().put("object", StringIO(content))
2184
45
2185
46
    def test_put_file_unknown_error(self):
2186
47
        """Unexpected errors from client propogate"""
2187
48
        content = "some text"
2188
49
        self._mock_swift("PUT", "testing/object", content)
2189
50
        self.mocker.result(defer.fail(ValueError("Something unexpected")))
2190
51
        self.mocker.replay()
2191
52
        deferred = self.get_storage().put("object", StringIO(content))
2192
53
        return self.assertFailure(deferred, ValueError)
2193
54
2194
55
    @defer.inlineCallbacks
2195
56
    def test_get_url(self):
2196
57
        """A url can be generated for any stored file."""
2197
58
        self.mocker.replay()
2198
59
        storage = self.get_storage()
2199
60
        yield storage._swift._client.authenticate()
2200
61
        url = storage.get_url("object")
2201
62
        self.assertEqual(self.swift_url + "/testing/object", url)
2202
63
2203
64
    @defer.inlineCallbacks
2204
65
    def test_get_url_unicode(self):
2205
66
        """A url can be generated for *any* stored file."""
2206
67
        self.mocker.replay()
2207
68
        storage = self.get_storage()
2208
69
        yield storage._swift._client.authenticate()
2209
70
        url = storage.get_url(u"\xa7")
2210
71
        self.assertEqual(self.swift_url + "/testing/%C2%A7", url)
2211
72
2212
73
    @defer.inlineCallbacks
2213
74
    def test_get_file(self):
2214
75
        """Retrieving a file returns a file-like object with the content"""
2215
76
        content = "some text"
2216
77
        self.expect_swift_get("testing/object", response=content)
2217
78
        self.mocker.replay()
2218
79
        result = yield self.get_storage().get("object")
2219
80
        self.assertEqual(result.read(), content)
2220
81
2221
82
    @defer.inlineCallbacks
2222
83
    def test_get_file_unicode(self):
2223
84
        """Retrieving a file with a unicode key uses a UTF-8 url"""
2224
85
        content = "some text"
2225
86
        self.expect_swift_get(u"testing/%C2%A7", response=content)
2226
87
        self.mocker.replay()
2227
88
        result = yield self.get_storage().get(u"\xa7")
2228
89
        self.assertEqual(result.read(), content)
2229
90
2230
91
    def test_get_file_nonexistant(self):
2231
92
        """Retrieving a nonexistant file raises a file not found error."""
2232
93
        self.expect_swift_get(u"testing/missing", code=404)
2233
94
        self.mocker.replay()
2234
95
        deferred = self.get_storage().get("missing")
2235
96
        return self.assertFailure(deferred, errors.FileNotFound)
2236
97
2237
98
    def test_get_file_error(self):
2238
99
        """An error from the client results is attributed to the provider"""
2239
100
        self.expect_swift_get(u"testing/unavailable", code=500)
2240
101
        self.mocker.replay()
2241
102
        deferred = self.get_storage().get("unavailable")
2242
103
        return self.assertFailure(deferred, errors.ProviderInteractionError)
2243
0
104
2244
=== added file 'juju/providers/openstack/tests/test_getmachines.py'
2245
--- juju/providers/openstack/tests/test_getmachines.py	1970-01-01 00:00:00 +0000
2246
+++ juju/providers/openstack/tests/test_getmachines.py	2012-07-18 19:47:20 +0000
2247
@@ -0,0 +1,115 @@
2248
1
"""Tests for OpenStack provider method for listing live juju machines"""
2249
2
2250
3
from juju.lib import testing
2251
4
from juju.providers.openstack.machine import NovaProviderMachine
2252
5
from juju.providers.openstack.tests import OpenStackTestMixin
2253
6
2254
7
2255
8
class GetMachinesTests(OpenStackTestMixin, testing.TestCase):
2256
9
2257
10
    def check_machines(self, machines, expected):
2258
11
        machine_details = []
2259
12
        for m in machines:
2260
13
            self.assertTrue(isinstance(m, NovaProviderMachine))
2261
14
            machine_details.append((m.instance_id, m.state))
2262
15
        machine_details.sort()
2263
16
        expected.sort()
2264
17
        self.assertEqual(expected, machine_details)
2265
18
2266
19
    def test_all_none(self):
2267
20
        self.expect_nova_get("servers", response={"servers": []})
2268
21
        self.mocker.replay()
2269
22
        return self.get_provider().get_machines().addCallback(
2270
23
            self.check_machines, [])
2271
24
2272
25
    def test_all_single(self):
2273
26
        self.expect_nova_get("servers", response={"servers": [
2274
27
            self.make_server(1000),
2275
28
            ]})
2276
29
        self.mocker.replay()
2277
30
        return self.get_provider().get_machines().addCallback(
2278
31
            self.check_machines, [(1000, 'running')])
2279
32
2280
33
    def test_all_multiple(self):
2281
34
        self.expect_nova_get("servers", response={"servers": [
2282
35
            self.make_server(1001),
2283
36
            self.make_server(1002, status="BUILDING"),
2284
37
            ]})
2285
38
        self.mocker.replay()
2286
39
        return self.get_provider().get_machines().addCallback(
2287
40
            self.check_machines, [(1001, 'running'), (1002, 'pending')])
2288
41
2289
42
    def test_all_some_dead(self):
2290
43
        self.expect_nova_get("servers", response={"servers": [
2291
44
            self.make_server(1001, status="BUILDING"),
2292
45
            self.make_server(1002, status="DELETED"),
2293
46
            ]})
2294
47
        self.mocker.replay()
2295
48
        return self.get_provider().get_machines().addCallback(
2296
49
            self.check_machines, [(1001, 'pending')])
2297
50
2298
51
    def test_all_some_other(self):
2299
52
        self.expect_nova_get("servers", response={"servers": [
2300
53
            self.make_server(1001, name="nova started server"),
2301
54
            self.make_server(1002),
2302
55
            ]})
2303
56
        self.mocker.replay()
2304
57
        return self.get_provider().get_machines().addCallback(
2305
58
            self.check_machines, [(1002, 'running')])
2306
59
2307
60
    def test_two_none(self):
2308
61
        self.expect_nova_get("servers", response={"servers": []})
2309
62
        self.mocker.replay()
2310
63
        deferred = self.get_provider().get_machines([1001, 1002])
2311
64
        return self.assert_not_found(deferred, [1001, 1002])
2312
65
2313
66
    def test_two_some_dead(self):
2314
67
        self.expect_nova_get("servers", response={"servers": [
2315
68
            self.make_server(1001, status="BUILDING"),
2316
69
            self.make_server(1002, status="DELETED"),
2317
70
            ]})
2318
71
        self.mocker.replay()
2319
72
        deferred = self.get_provider().get_machines([1001, 1002])
2320
73
        return self.assert_not_found(deferred, [1002])
2321
74
2322
75
    def test_two_some_other(self):
2323
76
        self.expect_nova_get("servers", response={"servers": [
2324
77
            self.make_server(1001, name="nova started server"),
2325
78
            self.make_server(1002),
2326
79
            ]})
2327
80
        self.mocker.replay()
2328
81
        deferred = self.get_provider().get_machines([1001, 1002])
2329
82
        return self.assert_not_found(deferred, [1001])
2330
83
2331
84
    def test_one_running(self):
2332
85
        self.expect_nova_get("servers/1000",
2333
86
            response={"server": self.make_server(1000)})
2334
87
        self.mocker.replay()
2335
88
        deferred = self.get_provider().get_machines([1000])
2336
89
        return deferred.addCallback(self.check_machines, [(1000, 'running')])
2337
90
2338
91
    def test_one_dead(self):
2339
92
        self.expect_nova_get("servers/1000",
2340
93
            response={"server": self.make_server(1000, status="DELETED")})
2341
94
        self.mocker.replay()
2342
95
        deferred = self.get_provider().get_machines([1000])
2343
96
        return self.assert_not_found(deferred, [1000])
2344
97
2345
98
    def test_one_other(self):
2346
99
        self.expect_nova_get("servers/1000",
2347
100
            response={"server": self.make_server(1000, name="testing")})
2348
101
        self.mocker.replay()
2349
102
        deferred = self.get_provider().get_machines([1000])
2350
103
        return self.assert_not_found(deferred, [1000])
2351
104
2352
105
    def test_one_missing(self):
2353
106
        self.expect_nova_get("servers/1000",
2354
107
            code=404, response={"itemNotFound":
2355
108
                {"message": "The resource could not be found.", "code": 404}})
2356
109
        self.mocker.replay()
2357
110
        deferred = self.get_provider().get_machines([1000])
2358
111
        return self.assert_not_found(deferred, [1000])
2359
112
    # XXX: Need to do error handling properly in client still
2360
113
    test_one_missing.skip = True
2361
114
2362
115
    # XXX: EC2 also has some tests for wrapping unexpected errors from backend
2363
0
116
2364
=== added file 'juju/providers/openstack/tests/test_launch.py'
2365
--- juju/providers/openstack/tests/test_launch.py	1970-01-01 00:00:00 +0000
2366
+++ juju/providers/openstack/tests/test_launch.py	2012-07-18 19:47:20 +0000
2367
@@ -0,0 +1,113 @@
2368
1
"""Tests for launching a new server customised for juju using Nova"""
2369
2
2370
3
import logging
2371
4
2372
5
from twisted.internet import (
2373
6
    defer,
2374
7
    )
2375
8
2376
9
from juju import errors
2377
10
from juju.lib import (
2378
11
    mocker,
2379
12
    testing,
2380
13
    )
2381
14
from juju.machine import (
2382
15
    constraints,
2383
16
    )
2384
17
2385
18
from juju.providers.openstack import (
2386
19
    launch,
2387
20
    tests,
2388
21
    )
2389
22
2390
23
class MockedLaunchProvider(tests.MockedProvider):
2391
24
2392
25
    def launch(self, machine_id, master=False):
2393
26
        constraint_set = constraints.ConstraintSet(self.provider_type)
2394
27
        details = {
2395
28
            'machine-id': machine_id,
2396
29
            'constraints': constraint_set.load({}),
2397
30
            }
2398
31
        return launch.NovaLaunchMachine.launch(self, details, master)
2399
32
2400
33
    def expect_launch_setup(self, machine_id):
2401
34
        self.port_manager.ensure_groups(machine_id)
2402
35
        self.mocker.result(defer.succeed(["juju-x", "juju-y"]))
2403
36
        self.nova.list_flavors()
2404
37
        self.mocker.result(defer.succeed([
2405
38
                {'id': 1, 'name': "standard.xsmall"},
2406
39
            ]))
2407
40
2408
41
    def expect_run_server(self, machine_id, response):
2409
42
        self.nova.run_server(
2410
43
            name="juju testing instance " + machine_id,
2411
44
            image_id=42,
2412
45
            flavor_id=1,
2413
46
            security_group_names=["juju-x", "juju-y"],
2414
47
            user_data=mocker.ANY,
2415
48
            )
2416
49
        self.mocker.result(defer.succeed(response))
2417
50
2418
51
    def expect_available_floating_ip(self, server_id):
2419
52
        self.nova.list_floating_ips()
2420
53
        self.mocker.result(defer.succeed([
2421
54
            {'instance_id': None, 'ip': "198.162.1.0"},
2422
55
            ]))
2423
56
        self.nova.add_floating_ip(server_id, "198.162.1.0")
2424
57
        self.mocker.result(defer.succeed(None))
2425
58
2426
59
2427
60
class NovaLaunchMachineTests(testing.TestCase):
2428
61
2429
62
    def test_launch_requires_default_image_id(self):
2430
63
        config = dict(MockedLaunchProvider.default_config)
2431
64
        del config['default-image-id']
2432
65
        provider = MockedLaunchProvider(self.mocker, config)
2433
66
        provider.expect_zookeeper_machines(1000)
2434
67
        self.mocker.replay()
2435
68
        deferred = provider.launch("1")
2436
69
        return self.assertFailure(deferred, errors.ProviderError)
2437
70
2438
71
    def test_start_machine(self):
2439
72
        provider = MockedLaunchProvider(self.mocker)
2440
73
        provider.expect_zookeeper_machines(1000)
2441
74
        provider.expect_launch_setup("1")
2442
75
        provider.expect_run_server("1", response={
2443
76
            'id': 1001,
2444
77
            'addresses': {'public': []},
2445
78
            })
2446
79
        self.mocker.replay()
2447
80
        return provider.launch("1")
2448
81
2449
82
    def test_start_machine_delay(self):
2450
83
        provider = MockedLaunchProvider(self.mocker)
2451
84
        provider.config["use-floating-ip"] = True
2452
85
        provider.expect_zookeeper_machines(1000)
2453
86
        provider.expect_launch_setup("1")
2454
87
        provider.expect_run_server("1", response={
2455
88
            'id': 1001,
2456
89
            })
2457
90
        provider.nova.get_server(1001)
2458
91
        self.mocker.result(defer.succeed({
2459
92
            'id': 1001,
2460
93
            'addresses': {'public': []},
2461
94
            }))
2462
95
        provider.expect_available_floating_ip(1001)
2463
96
        self.mocker.result(defer.succeed(None))
2464
97
        self.mocker.replay()
2465
98
        self.patch(launch.NovaLaunchMachine, "_DELAY_FOR_ADDRESSES", 0)
2466
99
        return provider.launch("1")
2467
100
2468
101
    def test_start_machine_master(self):
2469
102
        provider = MockedLaunchProvider(self.mocker)
2470
103
        provider.expect_swift_public_object_url("juju_master_id")
2471
104
        provider.expect_launch_setup("0")
2472
105
        provider.expect_run_server("0", response={
2473
106
            'id': 1000,
2474
107
            'addresses': {'public': []},
2475
108
            })
2476
109
        provider.expect_swift_put("juju_master_id", "1000")
2477
110
        provider.provider_actions.save_state({'zookeeper-instances': [1000]})
2478
111
        self.mocker.result(defer.succeed(None))
2479
112
        self.mocker.replay()
2480
113
        return provider.launch("0", master=True)
2481
0
114
2482
=== added file 'juju/providers/openstack/tests/test_machine.py'
2483
--- juju/providers/openstack/tests/test_machine.py	1970-01-01 00:00:00 +0000
2484
+++ juju/providers/openstack/tests/test_machine.py	2012-07-18 19:47:20 +0000
2485
@@ -0,0 +1,110 @@
2486
1
"""Tests for server wrapper and helper functions"""
2487
2
2488
3
from juju.providers.openstack.machine import (
2489
4
    get_server_addresses,
2490
5
    get_server_status,
2491
6
    )
2492
7
2493
8
from juju.lib.testing import TestCase
2494
9
2495
10
2496
11
class GetServerStatusTest(TestCase):
2497
12
    """Tests for mapping of Nova status names to EC2 style names"""
2498
13
2499
14
    def test_build_schedualing(self):
2500
15
        self.assertEqual("pending",
2501
16
            get_server_status({u'status': u'BUILD(scheduling)'}))
2502
17
2503
18
    def test_build_spawning(self):
2504
19
        self.assertEqual("pending",
2505
20
            get_server_status({u'status': u'BUILD(spawning)'}))
2506
21
2507
22
    def test_active(self):
2508
23
        self.assertEqual("running",
2509
24
            get_server_status({u'status': u'ACTIVE'}))
2510
25
2511
26
    def test_no_status(self):
2512
27
        self.assertEqual("pending",
2513
28
            get_server_status({}))
2514
29
2515
30
    def test_mystery_status(self):
2516
31
        self.assertEqual("unknown",
2517
32
            get_server_status({u'status': u'NEVER_BEFORE_SEEN_MYSTERY'}))
2518
33
2519
34
2520
35
class GetServerAddressesTest(TestCase):
2521
36
    """Tests for deriving a public and private address from Nova dict"""
2522
37
2523
38
    def test_missing(self):
2524
39
        self.assertEqual((None, None), get_server_addresses({}))
2525
40
2526
41
    def test_empty(self):
2527
42
        self.assertEqual((None, None),
2528
43
            get_server_addresses({u'addresses': {}}))
2529
44
2530
45
    def test_private_only(self):
2531
46
        self.assertEqual(("127.0.0.4", None),
2532
47
            get_server_addresses({u'addresses': {
2533
48
                "private": [{"addr": "127.0.0.4", "version": 4}],
2534
49
            }}))
2535
50
2536
51
    def test_private_plus(self):
2537
52
        self.assertEqual(("127.0.0.4", "8.8.4.4"),
2538
53
            get_server_addresses({u'addresses': {
2539
54
                "private": [
2540
55
                    {"addr": "127.0.0.4", "version": 4},
2541
56
                    {"addr": "8.8.4.4", "version": 4},
2542
57
                ],
2543
58
            }}))
2544
59
2545
60
    def test_public_only(self):
2546
61
        self.assertEqual((None, "8.8.8.8"),
2547
62
            get_server_addresses({u'addresses': {
2548
63
                "public": [{"addr": "8.8.8.8", "version": 4}],
2549
64
            }}))
2550
65
2551
66
    def test_public_and_private(self):
2552
67
        self.assertEqual(("127.0.0.4", "8.8.8.8"),
2553
68
            get_server_addresses({u'addresses': {
2554
69
                "public": [{"addr": "8.8.8.8", "version": 4}],
2555
70
                "private": [{"addr": "127.0.0.4", "version": 4}],
2556
71
            }}))
2557
72
2558
73
    def test_public_and_private_plus(self):
2559
74
        self.assertEqual(("127.0.0.4", "8.8.8.8"),
2560
75
            get_server_addresses({u'addresses': {
2561
76
                "public": [{"addr": "8.8.8.8", "version": 4}],
2562
77
                "private": [
2563
78
                    {"addr": "127.0.0.4", "version": 4},
2564
79
                    {"addr": "8.8.4.4", "version": 4},
2565
80
                ],
2566
81
            }}))
2567
82
2568
83
    def test_custom_only(self):
2569
84
        self.assertEqual(("127.0.0.2", None),
2570
85
            get_server_addresses({u'addresses': {
2571
86
                "special": [{"addr": "127.0.0.2", "version": 4}],
2572
87
            }}))
2573
88
2574
89
    def test_custom_plus(self):
2575
90
        self.assertEqual(("127.0.0.2", "8.8.4.4"),
2576
91
            get_server_addresses({u'addresses': {
2577
92
                "special": [
2578
93
                    {"addr": "127.0.0.2", "version": 4},
2579
94
                    {"addr": "8.8.4.4", "version": 4},
2580
95
                ],
2581
96
            }}))
2582
97
2583
98
    def test_custom_and_private(self):
2584
99
        self.assertEqual(("127.0.0.4", None),
2585
100
            get_server_addresses({u'addresses': {
2586
101
                "special": [{"addr": "127.0.0.2", "version": 4}],
2587
102
                "private": [{"addr": "127.0.0.4", "version": 4}],
2588
103
            }}))
2589
104
2590
105
    def test_custom_and_public(self):
2591
106
        self.assertEqual(("127.0.0.2", "8.8.8.8"),
2592
107
            get_server_addresses({u'addresses': {
2593
108
                "special": [{"addr": "127.0.0.2", "version": 4}],
2594
109
                "public": [{"addr": "8.8.8.8", "version": 4}],
2595
110
            }}))
2596
0
111
2597
=== added file 'juju/providers/openstack/tests/test_ports.py'
2598
--- juju/providers/openstack/tests/test_ports.py	1970-01-01 00:00:00 +0000
2599
+++ juju/providers/openstack/tests/test_ports.py	2012-07-18 19:47:20 +0000
2600
@@ -0,0 +1,396 @@
2601
1
"""Tests for emulating port management with security groups"""
2602
2
2603
3
import logging
2604
4
2605
5
from juju import errors
2606
6
from juju.lib.testing import TestCase
2607
7
from juju.providers.openstack.machine import NovaProviderMachine
2608
8
from juju.providers.openstack.ports import NovaPortManager
2609
9
from juju.providers.openstack.tests import OpenStackTestMixin
2610
10
2611
11
2612
12
class ProviderPortMgmtTests(OpenStackTestMixin, TestCase):
2613
13
    """Tests for provider exposed port management methods"""
2614
14
2615
15
    def expect_create_rule(self, group_id, proto, port):
2616
16
        self.expect_nova_post("os-security-group-rules",
2617
17
            {'security_group_rule': {
2618
18
                'parent_group_id': group_id,
2619
19
                'ip_protocol': proto,
2620
20
                'from_port': port,
2621
21
                'to_port': port,
2622
22
            }},
2623
23
            response={'security_group_rule': {
2624
24
                'id': 144, 'parent_group_id': group_id,
2625
25
            }})
2626
26
2627
27
    def expect_existing_rule(self, rule_id, proto, port):
2628
28
        self.expect_nova_get("servers/1000/os-security-groups",
2629
29
            response={'security_groups': [
2630
30
                    {'name': "juju-testing-1", 'id': 1, 'rules': [{
2631
31
                        'id': rule_id,
2632
32
                        'parent_group_id': 1,
2633
33
                        'ip_protocol': proto,
2634
34
                        'from_port': port,
2635
35
                        'to_port': port,
2636
36
                        }]
2637
37
                    },
2638
38
                ]})
2639
39
2640
40
    def test_open_port(self):
2641
41
        """Opening a port adds the rule to the appropriate security group"""
2642
42
        self.expect_nova_get("servers/1000/os-security-groups",
2643
43
            response={'security_groups': [
2644
44
                    {'name': "juju-testing-1", 'id': 1},
2645
45
                ]})
2646
46
        self.expect_create_rule(1, "tcp", 80)
2647
47
        self.mocker.replay()
2648
48
2649
49
        log = self.capture_logging("juju.openstack", level=logging.DEBUG)
2650
50
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2651
51
        deferred = self.get_provider().open_port(machine, "1", 80)
2652
52
        def _check_log(_):
2653
53
            self.assertIn("Opened 80/tcp on machine '1000'",
2654
54
                log.getvalue())
2655
55
        return deferred.addCallback(_check_log)
2656
56
2657
57
    def test_open_port_missing_group(self):
2658
58
        """Missing security group raises an error on deleting port"""
2659
59
        self.expect_nova_get("servers/1000/os-security-groups",
2660
60
            response={'security_groups': []})
2661
61
        self.mocker.replay()
2662
62
2663
63
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2664
64
        deferred = self.get_provider().open_port(machine, "1", 80)
2665
65
        return self.assertFailure(deferred, errors.ProviderInteractionError)
2666
66
2667
67
    def test_close_port(self):
2668
68
        """Closing a port removes the matching rule from the security group"""
2669
69
        self.expect_existing_rule(12, "tcp", 80)
2670
70
        self.expect_nova_delete("os-security-group-rules/12")
2671
71
        self.mocker.replay()
2672
72
2673
73
        log = self.capture_logging("juju.openstack", level=logging.DEBUG)
2674
74
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2675
75
        deferred = self.get_provider().close_port(machine, "1", 80)
2676
76
        def _check_log(_):
2677
77
            self.assertIn("Closed 80/tcp on machine '1000'",
2678
78
                log.getvalue())
2679
79
        return deferred.addCallback(_check_log)
2680
80
2681
81
    def test_close_port_missing_group(self):
2682
82
        """Missing security group raises an error on closing port"""
2683
83
        self.expect_nova_get("servers/1000/os-security-groups",
2684
84
            response={'security_groups': []})
2685
85
        self.mocker.replay()
2686
86
2687
87
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2688
88
        deferred = self.get_provider().close_port(machine, "1", 80)
2689
89
        return self.assertFailure(deferred, errors.ProviderInteractionError)
2690
90
2691
91
    def test_close_port_missing_rule(self):
2692
92
        """Missing security group rule raises an error on closing port"""
2693
93
        self.expect_nova_get("servers/1000/os-security-groups",
2694
94
            response={'security_groups': [{
2695
95
                'name': "juju-testing-1", 'id': 1, "rules": [],
2696
96
            }]})
2697
97
        self.mocker.replay()
2698
98
2699
99
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2700
100
        deferred = self.get_provider().close_port(machine, "1", 80)
2701
101
        return self.assertFailure(deferred, errors.ProviderInteractionError)
2702
102
2703
103
    def test_close_port_mismatching_rule(self):
2704
104
        """Rule with different port raises an error on closing port"""
2705
105
        self.expect_existing_rule(12, "tcp", 8080)
2706
106
        self.mocker.replay()
2707
107
2708
108
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2709
109
        deferred = self.get_provider().close_port(machine, "1", 80)
2710
110
        return self.assertFailure(deferred, errors.ProviderInteractionError)
2711
111
2712
112
    def test_get_opened_ports_none(self):
2713
113
        """No opened ports are listed when there are no rules"""
2714
114
        self.expect_nova_get("servers/1000/os-security-groups",
2715
115
            response={'security_groups': [{
2716
116
                'name': "juju-testing-1", 'id': 1, "rules": [],
2717
117
            }]})
2718
118
        self.mocker.replay()
2719
119
2720
120
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2721
121
        deferred = self.get_provider().get_opened_ports(machine, "1")
2722
122
        return deferred.addCallback(self.assertEqual, set())
2723
123
2724
124
    def test_get_opened_ports_one(self):
2725
125
        """Opened port is listed when there is a matching rule"""
2726
126
        self.expect_existing_rule(12, "tcp", 80)
2727
127
        self.mocker.replay()
2728
128
2729
129
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2730
130
        deferred = self.get_provider().get_opened_ports(machine, "1")
2731
131
        return deferred.addCallback(self.assertEqual, set([(80, "tcp")]))
2732
132
2733
133
    def test_get_opened_ports_group_ignored(self):
2734
134
        """Opened ports exclude rules delegating to other security groups"""
2735
135
        self.expect_nova_get("servers/1000/os-security-groups",
2736
136
            response={'security_groups': [{
2737
137
                'name': "juju-testing-1", 'id': 1, "rules": [{
2738
138
                        'id': 12,
2739
139
                        'parent_group_id': 1,
2740
140
                        'ip_protocol': None,
2741
141
                        'from_port': None,
2742
142
                        'to_port': None,
2743
143
                        'group': {'name': "juju-testing"},
2744
144
                        }],
2745
145
            }]})
2746
146
        self.mocker.replay()
2747
147
2748
148
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2749
149
        deferred = self.get_provider().get_opened_ports(machine, "1")
2750
150
        return deferred.addCallback(self.assertEqual, set())
2751
151
2752
152
    def test_get_opened_ports_multiport_ignored(self):
2753
153
        """Opened ports exclude rules spanning multiple ports"""
2754
154
        self.expect_nova_get("servers/1000/os-security-groups",
2755
155
            response={'security_groups': [{
2756
156
                'name': "juju-testing-1", 'id': 1, "rules": [{
2757
157
                        'id': 12,
2758
158
                        'parent_group_id': 1,
2759
159
                        'ip_protocol': "tcp",
2760
160
                        'from_port': 8080,
2761
161
                        'to_port': 8081,
2762
162
                        }],
2763
163
            }]})
2764
164
        self.mocker.replay()
2765
165
2766
166
        machine = NovaProviderMachine('1000', "server1000.testing.invalid")
2767
167
        deferred = self.get_provider().get_opened_ports(machine, "1")
2768
168
        return deferred.addCallback(self.assertEqual, set())
2769
169
2770
170
2771
171
class PortManagerTestMixin(OpenStackTestMixin):
2772
172
2773
173
    def get_port_manager(self):
2774
174
        provider = self.get_provider()
2775
175
        return NovaPortManager(provider.nova, provider.environment_name)
2776
176
2777
177
2778
178
class EnsureGroupsTests(PortManagerTestMixin, TestCase):
2779
179
    """Tests for ensure_groups method used when launching machines"""
2780
180
2781
181
    def expect_create_juju_group(self):
2782
182
        self.expect_nova_post("os-security-groups",
2783
183
            {'security_group': {
2784
184
                'name': 'juju-testing',
2785
185
                'description': 'juju group for testing',
2786
186
            }},
2787
187
            response={'security_group': {
2788
188
                'id': 1,
2789
189
            }})
2790
190
        self.expect_nova_post("os-security-group-rules",
2791
191
            {'security_group_rule': {
2792
192
                'parent_group_id': 1,
2793
193
                'ip_protocol': "tcp",
2794
194
                'from_port': 22,
2795
195
                'to_port': 22,
2796
196
            }},
2797
197
            response={'security_group_rule': {
2798
198
                'id': 144, 'parent_group_id': 1,
2799
199
            }})
2800
200
        self.expect_nova_post("os-security-group-rules",
2801
201
            {'security_group_rule': {
2802
202
                'parent_group_id': 1,
2803
203
                'group_id': 1,
2804
204
                'ip_protocol': "tcp",
2805
205
                'from_port': 1,
2806
206
                'to_port': 65535,
2807
207
            }},
2808
208
            response={'security_group_rule': {
2809
209
                'id': 145, 'parent_group_id': 1,
2810
210
            }})
2811
211
2812
212
    def expect_create_machine_group(self, machine_id):
2813
213
        machine = str(machine_id)
2814
214
        self.expect_nova_post("os-security-groups",
2815
215
            {'security_group': {
2816
216
                'name': 'juju-testing-' + machine,
2817
217
                'description': 'juju group for testing machine ' + machine,
2818
218
            }},
2819
219
            response={'security_group': {
2820
220
                'id': 2,
2821
221
            }})
2822
222
2823
223
    def check_group_names(self, result, machine_id):
2824
224
        self.assertEqual(["juju-testing", "juju-testing-" + str(machine_id)],
2825
225
            result)
2826
226
2827
227
    def test_none_existing(self):
2828
228
        """When no groups exist juju and machine security groups are created"""
2829
229
        self.expect_nova_get("os-security-groups",
2830
230
            response={'security_groups': []})
2831
231
        self.expect_create_juju_group()
2832
232
        self.expect_create_machine_group(0)
2833
233
        self.mocker.replay()
2834
234
        deferred = self.get_port_manager().ensure_groups(0)
2835
235
        return deferred.addCallback(self.check_group_names, 0)
2836
236
2837
237
    def test_other_existing(self):
2838
238
        """Existing groups in a different environment are not affected"""
2839
239
        self.expect_nova_get("os-security-groups",
2840
240
            response={'security_groups': [
2841
241
                    {'name': "juju-testingish", 'id': 7},
2842
242
                    {'name': "juju-testingish-0", 'id': 8},
2843
243
                ]})
2844
244
        self.expect_create_juju_group()
2845
245
        self.expect_create_machine_group(0)
2846
246
        self.mocker.replay()
2847
247
        deferred = self.get_port_manager().ensure_groups(0)
2848
248
        return deferred.addCallback(self.check_group_names, 0)
2849
249
2850
250
    def test_existing_juju_group(self):
2851
251
        """An exisiting juju security group is reused"""
2852
252
        self.expect_nova_get("os-security-groups",
2853
253
            response={'security_groups': [
2854
254
                    {'name': "juju-testing", 'id': 1},
2855
255
                ]})
2856
256
        self.expect_create_machine_group(0)
2857
257
        self.mocker.replay()
2858
258
        deferred = self.get_port_manager().ensure_groups(0)
2859
259
        return deferred.addCallback(self.check_group_names, 0)
2860
260
2861
261
    def test_existing_machine_group(self):
2862
262
        """An existing machine security group is deleted and remade"""
2863
263
        self.expect_nova_get("os-security-groups",
2864
264
            response={'security_groups': [
2865
265
                    {'name': "juju-testing-6", 'id': 3},
2866
266
                ]})
2867
267
        self.expect_create_juju_group()
2868
268
        self.expect_nova_delete("os-security-groups/3")
2869
269
        self.expect_create_machine_group(6)
2870
270
        self.mocker.replay()
2871
271
        deferred = self.get_port_manager().ensure_groups(6)
2872
272
        return deferred.addCallback(self.check_group_names, 6)
2873
273
2874
274
2875
275
class GetMachineGroupsTests(PortManagerTestMixin, TestCase):
2876
276
    """Tests for get_machine_groups method needed for machine shutdown"""
2877
277
2878
278
    def test_normal(self):
2879
279
        """A standard juju machine returns the machine group name and id"""
2880
280
        self.expect_nova_get("servers/1000/os-security-groups",
2881
281
            response={'security_groups': [
2882
282
                    {'id': 7, 'name': "juju-testing"},
2883
283
                    {'id': 8, 'name': "juju-testing-0"},
2884
284
                ]})
2885
285
        self.mocker.replay()
2886
286
        machine = NovaProviderMachine(1000)
2887
287
        deferred = self.get_port_manager().get_machine_groups(machine)
2888
288
        return deferred.addCallback(self.assertEqual, {"juju-testing-0": 8})
2889
289
2890
290
    def test_normal_include_juju(self):
2891
291
        """If param with_juju_group=True the juju group is also returned"""
2892
292
        self.expect_nova_get("servers/1000/os-security-groups",
2893
293
            response={'security_groups': [
2894
294
                    {'id': 7, 'name': "juju-testing"},
2895
295
                    {'id': 8, 'name': "juju-testing-0"},
2896
296
                ]})
2897
297
        self.mocker.replay()
2898
298
        machine = NovaProviderMachine(1000)
2899
299
        deferred = self.get_port_manager().get_machine_groups(machine, True)
2900
300
        return deferred.addCallback(self.assertEqual,
2901
301
            {"juju-testing": 7, "juju-testing-0": 8})
2902
302
2903
303
    def test_extra_group(self):
2904
304
        """Additional groups not in the juju namespace are ignored"""
2905
305
        self.expect_nova_get("servers/1000/os-security-groups",
2906
306
            response={'security_groups': [
2907
307
                    {'id': 1, 'name': "default"},
2908
308
                    {'id': 7, 'name': "juju-testing"},
2909
309
                    {'id': 8, 'name': "juju-testing-0"},
2910
310
                ]})
2911
311
        self.mocker.replay()
2912
312
        machine = NovaProviderMachine(1000)
2913
313
        deferred = self.get_port_manager().get_machine_groups(machine)
2914
314
        return deferred.addCallback(self.assertEqual, {"juju-testing-0": 8})
2915
315
2916
316
    def test_other_group(self):
2917
317
        """A server not managed by juju returns nothing"""
2918
318
        self.expect_nova_get("servers/1000/os-security-groups",
2919
319
            response={'security_groups': [
2920
320
                    {'id': 1, 'name': "default"},
2921
321
                ]})
2922
322
        self.mocker.replay()
2923
323
        machine = NovaProviderMachine(1000)
2924
324
        deferred = self.get_port_manager().get_machine_groups(machine)
2925
325
        return deferred.addCallback(self.assertEqual, None)
2926
326
2927
327
    def test_missing_groups(self):
2928
328
        """A server with no groups returns nothing"""
2929
329
        self.expect_nova_get("servers/1000/os-security-groups",
2930
330
            response={'security_groups': []})
2931
331
        self.mocker.replay()
2932
332
        machine = NovaProviderMachine(1000)
2933
333
        deferred = self.get_port_manager().get_machine_groups(machine)
2934
334
        return deferred.addCallback(self.assertEqual, None)
2935
335
2936
336
    def test_error_missing_server(self):
2937
337
        """A server that doesn't exist or has been deleted returns nothing"""
2938
338
        self.expect_nova_get("servers/1000/os-security-groups",
2939
339
            code=404, response={"itemNotFound": {
2940
340
                "message": "Instance 1000 could not be found.",
2941
341
                "code": 404,
2942
342
            }})
2943
343
        self.mocker.replay()
2944
344
        machine = NovaProviderMachine(1000)
2945
345
        deferred = self.get_port_manager().get_machine_groups(machine)
2946
346
        return deferred.addCallback(self.assertEqual, None)
2947
347
    # XXX: Broken by workaround for HP not supporting this api
2948
348
    test_error_missing_server.skip = True
2949
349
2950
350
    def test_error_missing_page(self):
2951
351
        """Unexpected errors from the client are propogated"""
2952
352
        self.expect_nova_get("servers/1000/os-security-groups",
2953
353
            code=404, response="404 Not Found\n\n"
2954
354
                "The resource could not be found.\n\n   ")
2955
355
        self.mocker.replay()
2956
356
        machine = NovaProviderMachine(1000)
2957
357
        deferred = self.get_port_manager().get_machine_groups(machine)
2958
358
        return self.assertFailure(deferred, errors.ProviderInteractionError)
2959
359
    # XXX: Need implemention of fancy error to exception mapping
2960
360
    test_error_missing_page.skip = True
2961
361
2962
362
    def test_error_missing_server_fault(self):
2963
363
        "A bogus compute fault due to lp:1010486 returns nothing"""
2964
364
        self.expect_nova_get("servers/1000/os-security-groups",
2965
365
            code=500, response={"computeFault": {
2966
366
                "message": "The server has either erred or is incapable of"
2967
367
                    " performing the requested operation.",
2968
368
                "code": 500,
2969
369
            }})
2970
370
        self.expect_nova_get("servers/1000",
2971
371
            code=404, response={"itemNotFound": {
2972
372
                "message": "The resource could not be found.",
2973
373
                "code": 404,
2974
374
            }})
2975
375
        self.mocker.replay()
2976
376
        machine = NovaProviderMachine(1000)
2977
377
        deferred = self.get_port_manager().get_machine_groups(machine)
2978
378
        return deferred.addCallback(self.assertEqual, None)
2979
379
    # XXX: Need implemention of fancy error to exception mapping
2980
380
    test_error_missing_server_fault.skip = True
2981
381
2982
382
    def test_error_really_fault(self):
2983
383
        """A real compute fault is propogated"""
2984
384
        self.expect_nova_get("servers/1000/os-security-groups",
2985
385
            code=500, response={"computeFault": {
2986
386
                "message": "The server has either erred or is incapable of"
2987
387
                    " performing the requested operation.",
2988
388
                "code": 500,
2989
389
            }})
2990
390
        self.expect_nova_get("servers/1000", response={"server": {"id": 1000}})
2991
391
        self.mocker.replay()
2992
392
        machine = NovaProviderMachine(1000)
2993
393
        deferred = self.get_port_manager().get_machine_groups(machine)
2994
394
        return self.assertFailure(deferred, errors.ProviderInteractionError)
2995
395
    # XXX: Need implemention of fancy error to exception mapping
2996
396
    test_error_really_fault.skip = True
2997
0
397
2998
=== added file 'juju/providers/openstack/tests/test_provider.py'
2999
--- juju/providers/openstack/tests/test_provider.py	1970-01-01 00:00:00 +0000
3000
+++ juju/providers/openstack/tests/test_provider.py	2012-07-18 19:47:20 +0000
3001
@@ -0,0 +1,116 @@
3002
1
"""Testing for the OpenStack provider interface"""
3003
2
3004
3
from juju.lib.testing import TestCase
3005
4
from juju.environment.errors import EnvironmentsConfigError
3006
5
3007
6
from juju.providers.openstack.files import FileStorage
3008
7
from juju.providers.openstack.provider import MachineProvider
3009
8
3010
9
3011
10
class ProviderTestCase(TestCase):
3012
11
3013
12
    environment_name = "testing"
3014
13
3015
14
    _test_environ = {
3016
15
        "NOVA_URL": "http://environ.invalid",
3017
16
        "NOVA_API_KEY": "env-key",
3018
17
        "EC2_SECRET_KEY": "env-xxxx",
3019
18
        "NOVA_PROJECT_ID": "env-project",
3020
19
        }
3021
20
3022
21
    def get_config(self):
3023
22
        return {
3024
23
            "type": "openstack",
3025
24
            "auth-mode": "keypair",
3026
25
            "access-key": "key",
3027
26
            "secret-key": "xxxxxxxx",
3028
27
            "auth-url": "http://testing.invalid",
3029
28
            "project-name": "project",
3030
29
            "control-bucket": self.environment_name,
3031
30
            }
3032
31
3033
32
    def test_empty_config_raises(self):
3034
33
        """Passing no config raises an exception about lacking credentials"""
3035
34
        self.change_environment()
3036
35
        # XXX: Should this raise EnvironmentsConfigError instead?
3037
36
        self.assertRaises(ValueError,
3038
37
            MachineProvider, self.environment_name, {})
3039
38
3040
39
    def test_client_params(self):
3041
40
        """Config details get passed through to OpenStack client correctly"""
3042
41
        config = self.get_config()
3043
42
        provider = MachineProvider(self.environment_name, config)
3044
43
        creds = provider.credentials
3045
44
        self.assertEquals("key", creds.access_key)
3046
45
        self.assertEquals("xxxxxxxx", creds.secret_key)
3047
46
        self.assertEquals("http://testing.invalid", creds.url)
3048
47
        self.assertEquals("project", creds.project_name)
3049
48
        self.assertIs(creds, provider.nova._client.credentials)
3050
49
        self.assertIs(creds, provider.swift._client.credentials)
3051
50
3052
51
    def test_provider_attributes(self):
3053
52
        """
3054
53
        The provider environment name and config should be available as
3055
54
        parameters in the provider.
3056
55
        """
3057
56
        provider = MachineProvider(self.environment_name, self.get_config())
3058
57
        self.assertEqual(provider.environment_name, self.environment_name)
3059
58
        self.assertEqual(provider.config.get("type"), "openstack")
3060
59
        self.assertEqual(provider.provider_type, "openstack")
3061
60
3062
61
    def test_get_file_storage(self):
3063
62
        """The file storage is accessible via the machine provider."""
3064
63
        provider = MachineProvider(self.environment_name, self.get_config())
3065
64
        storage = provider.get_file_storage()
3066
65
        self.assertTrue(isinstance(storage, FileStorage))
3067
66
3068
67
    def test_config_serialization(self):
3069
68
        """
3070
69
        The provider configuration can be serialized to yaml.
3071
70
        """
3072
71
        self.change_environment()
3073
72
        config = self.get_config()
3074
73
        expected = config.copy()
3075
74
        config["authorized-keys-path"] = self.makeFile("key contents")
3076
75
        expected["authorized-keys"] = "key contents"
3077
76
        provider = MachineProvider(self.environment_name, config)
3078
77
        self.assertEqual(expected, provider.get_serialization_data())
3079
78
3080
79
    def test_config_environment_extraction(self):
3081
80
        """
3082
81
        The provider serialization loads keys as needed from the environment.
3083
82
3084
83
        Variables from the configuration take precendence over those from
3085
84
        the environment, when serializing.
3086
85
        """
3087
86
        self.change_environment(**self._test_environ)
3088
87
        provider = MachineProvider(self.environment_name, {
3089
88
            "auth-mode": "keypair",
3090
89
            "project-name": "other-project",
3091
90
            "authorized-keys": "key-data",
3092
91
            })
3093
92
        serialized = provider.get_serialization_data()
3094
93
        expected = {
3095
94
            "auth-mode": "keypair",
3096
95
            "access-key": "env-key",
3097
96
            "secret-key": "env-xxxx",
3098
97
            "auth-url": "http://environ.invalid",
3099
98
            "project-name": "other-project",
3100
99
            "authorized-keys": "key-data",
3101
100
            }
3102
101
        self.assertEqual(expected, serialized)
3103
102
3104
103
    def test_conflicting_authorized_keys_options(self):
3105
104
        """
3106
105
        We can't handle two different authorized keys options, so deny
3107
106
        constructing an environment that way.
3108
107
        """
3109
108
        config = self.get_config()
3110
109
        config["authorized-keys"] = "File content"
3111
110
        config["authorized-keys-path"] = "File path"
3112
111
        error = self.assertRaises(EnvironmentsConfigError,
3113
112
            MachineProvider, self.environment_name, config)
3114
113
        self.assertEquals(
3115
114
            str(error),
3116
115
            "Environment config cannot define both authorized-keys and "
3117
116
            "authorized-keys-path. Pick one!")
3118
0
117
3119
=== added file 'juju/providers/openstack/tests/test_shutdown.py'
3120
--- juju/providers/openstack/tests/test_shutdown.py	1970-01-01 00:00:00 +0000
3121
+++ juju/providers/openstack/tests/test_shutdown.py	2012-07-18 19:47:20 +0000
3122
@@ -0,0 +1,130 @@
3123
1
"""Tests for terminating machines and cleaning up the environment"""
3124
2
3125
3
from juju import errors
3126
4
from juju.lib import testing
3127
5
from juju.machine import ProviderMachine
3128
6
from juju.providers.openstack.machine import NovaProviderMachine
3129
7
from juju.providers.openstack.tests import OpenStackTestMixin
3130
8
3131
9
3132
10
class ShutdownMachineTests(OpenStackTestMixin, testing.TestCase):
3133
11
3134
12
    def test_shutdown_single(self):
3135
13
        self.expect_nova_get("servers/1000",
3136
14
            response={"server": {
3137
15
                'name': "juju testing instance 0",
3138
16
            }})
3139
17
        self.expect_nova_delete("servers/1000", code=204)
3140
18
        self.mocker.replay()
3141
19
        machine = NovaProviderMachine(1000)
3142
20
        deferred = self.get_provider().shutdown_machine(machine)
3143
21
        deferred.addCallback(self.assertIs, machine)
3144
22
3145
23
    def test_shutdown_single_other(self):
3146
24
        self.expect_nova_get("servers/1000",
3147
25
            response={"server": {
3148
26
                'name': "some other instance",
3149
27
            }})
3150
28
        self.mocker.replay()
3151
29
        machine = NovaProviderMachine(1000)
3152
30
        deferred = self.get_provider().shutdown_machine(machine)
3153
31
        return self.assert_not_found(deferred, [1000])
3154
32
3155
33
    def test_shutdown_single_wrong_machine(self):
3156
34
        self.mocker.reset()
3157
35
        machine = ProviderMachine("i-000003E8")
3158
36
        e = self.assertRaises(errors.ProviderError,
3159
37
            self.get_provider().shutdown_machine, machine)
3160
38
        self.assertIn("Need a NovaProviderMachine to shutdown", str(e))
3161
39
3162
40
    def test_shutdown_multi_none(self):
3163
41
        self.mocker.reset()
3164
42
        deferred = self.get_provider().shutdown_machines([])
3165
43
        return deferred.addCallback(self.assertEqual, [])
3166
44
3167
45
    def test_shutdown_multi_some_invalid(self):
3168
46
        """No machines are shutdown if some are invalid"""
3169
47
        self.mocker.unorder()
3170
48
        self.expect_nova_get("servers/1001",
3171
49
            response={"server": {
3172
50
                'name': "juju testing instance 1",
3173
51
            }})
3174
52
        self.expect_nova_get("servers/1002",
3175
53
            response={"server": {
3176
54
                'name': "some other instance",
3177
55
            }})
3178
56
        self.mocker.replay()
3179
57
        machines = [NovaProviderMachine(1001), NovaProviderMachine(1002)]
3180
58
        deferred = self.get_provider().shutdown_machines(machines)
3181
59
        return self.assert_not_found(deferred, [1002])
3182
60
    # XXX: dumb requirement to keep all running if some invalid, drop this
3183
61
    test_shutdown_multi_some_invalid.skip = True
3184
62
3185
63
    # GZ 2012-06-11: Corner case difference, EC2 rechecks machine statuses and
3186
64
    #                group membership on shutdown.
3187
65
3188
66
    def test_shutdown_multi_success(self):
3189
67
        """Machines are shutdown and groups except juju group are deleted"""
3190
68
        self.mocker.unorder()
3191
69
        self.expect_nova_get("servers/1001",
3192
70
            response={"server": {
3193
71
                'name': "juju testing instance 1",
3194
72
            }})
3195
73
        self.expect_nova_get("servers/1002",
3196
74
            response={"server": {
3197
75
                'name': "juju testing instance 2",
3198
76
            }})
3199
77
        self.expect_nova_delete("servers/1001", code=204)
3200
78
        self.expect_nova_delete("servers/1002", code=204)
3201
79
        self.mocker.replay()
3202
80
        machines = [NovaProviderMachine(1001), NovaProviderMachine(1002)]
3203
81
        deferred = self.get_provider().shutdown_machines(machines)
3204
82
        return deferred
3205
83
3206
84
3207
85
class DestroyEnvironmentTests(OpenStackTestMixin, testing.TestCase):
3208
86
3209
87
    def check_machine_ids(self, machines, server_ids):
3210
88
        self.assertEqual(set(m.instance_id for m in machines), set(server_ids))
3211
89
3212
90
    def test_destroy_environment(self):
3213
91
        self.mocker.unorder()
3214
92
        self.expect_swift_put("testing/provider-state", "{}\n")
3215
93
        self.expect_nova_get("servers", response={"servers": [
3216
94
            self.make_server(1001),
3217
95
            self.make_server(1002),
3218
96
            ]})
3219
97
        self.expect_nova_get("servers/1001",
3220
98
            response={"server": {
3221
99
                'name': "juju testing instance 1",
3222
100
            }})
3223
101
        self.expect_nova_get("servers/1002",
3224
102
            response={"server": {
3225
103
                'name': "juju testing instance 2",
3226
104
            }})
3227
105
        self.expect_nova_delete("servers/1001", code=204)
3228
106
        self.expect_nova_delete("servers/1002", code=204)
3229
107
        self.mocker.replay()
3230
108
        deferred = self.get_provider().destroy_environment()
3231
109
        return deferred.addCallback(self.check_machine_ids, [1001, 1002])
3232
110
3233
111
    def test_s3_failure(self):
3234
112
        self.mocker.unorder()
3235
113
        self.expect_swift_put("testing/provider-state", "{}\n",
3236
114
            code=500, response="Server unavailable or something")
3237
115
        # XXX: normal server shutdown should be expected here
3238
116
        self.mocker.replay()
3239
117
        deferred = self.get_provider().destroy_environment()
3240
118
        return deferred.addCallback(self.assertEqual, [])
3241
119
    # XXX: Need to bolster swift robustness in response to api errors
3242
120
    test_s3_failure.skip = True
3243
121
3244
122
    # GZ 2012-06-15: Always tries removing juju group unlike EC2 currently
3245
123
    def test_shutdown_no_instances(self):
3246
124
        """With no instances no shutdowns are attempted"""
3247
125
        self.mocker.unorder()
3248
126
        self.expect_swift_put("testing/provider-state", "{}\n")
3249
127
        self.expect_nova_get("servers", response={"servers": []})
3250
128
        self.mocker.replay()
3251
129
        deferred = self.get_provider().destroy_environment()
3252
130
        return deferred.addCallback(self.assertEqual, [])
3253
0
131
3254
=== added file 'juju/providers/openstack/tests/test_state.py'
3255
--- juju/providers/openstack/tests/test_state.py	1970-01-01 00:00:00 +0000
3256
+++ juju/providers/openstack/tests/test_state.py	2012-07-18 19:47:20 +0000
3257
@@ -0,0 +1,58 @@
3258
1
"""Tests for the common state interface over the the Openstack provider
3259
2
3260
3
The testcases here largely duplicate those in openstack.tests.test_files as
3261
4
state handling is a pretty thin layer over the file storage.
3262
5
"""
3263
6
3264
7
import yaml
3265
8
3266
9
from juju.lib.testing import TestCase
3267
10
from juju.providers.openstack.tests import OpenStackTestMixin
3268
11
3269
12
3270
13
class OpenStackStateTest(OpenStackTestMixin, TestCase):
3271
14
3272
15
    def test_save(self):
3273
16
        """Saving a dict puts yaml serialized bytes in provider-state"""
3274
17
        state = {"zookeeper-instances": [
3275
18
             [1000, "x1.example.com"],
3276
19
             ]}
3277
20
        self.expect_swift_put("testing/provider-state", yaml.dump(state))
3278
21
        self.mocker.replay()
3279
22
        return self.get_provider().save_state(state)
3280
23
3281
24
    def test_save_missing_container(self):
3282
25
        """Saving will create the container when it does not exist already"""
3283
26
        state = {"zookeeper-instances": [
3284
27
             [1000, "x1.example.com"],
3285
28
             ]}
3286
29
        state_bytes = yaml.dump(state)
3287
30
        self.expect_swift_put("testing/provider-state", state_bytes, code=404)
3288
31
        self.expect_swift_put_container("testing")
3289
32
        self.expect_swift_put("testing/provider-state", state_bytes)
3290
33
        self.mocker.replay()
3291
34
        return self.get_provider().save_state(state)
3292
35
3293
36
    def test_load(self):
3294
37
        """Loading deserializes yaml from provider-state to a python dict"""
3295
38
        state = {"zookeeper-instances": []}
3296
39
        self.expect_swift_get("testing/provider-state",
3297
40
            response=yaml.dump(state))
3298
41
        self.mocker.replay()
3299
42
        deferred = self.get_provider().load_state()
3300
43
        return deferred.addCallback(self.assertEqual, state)
3301
44
3302
45
    def test_load_missing(self):
3303
46
        """Loading returns False if provider-state does not exist"""
3304
47
        self.expect_swift_get("testing/provider-state", code=404,
3305
48
            response={})
3306
49
        self.mocker.replay()
3307
50
        deferred = self.get_provider().load_state()
3308
51
        return deferred.addCallback(self.assertIs, False)
3309
52
3310
53
    def test_load_no_content(self):
3311
54
        """Loading returns False if provider-state is empty"""
3312
55
        self.expect_swift_get("testing/provider-state", response="")
3313
56
        self.mocker.replay()
3314
57
        deferred = self.get_provider().load_state()
3315
58
        return deferred.addCallback(self.assertIs, False)
3316
0
59
3317
=== added directory 'juju/providers/openstack_s3'
3318
=== added file 'juju/providers/openstack_s3/__init__.py'
3319
--- juju/providers/openstack_s3/__init__.py	1970-01-01 00:00:00 +0000
3320
+++ juju/providers/openstack_s3/__init__.py	2012-07-18 19:47:20 +0000
3321
@@ -0,0 +1,48 @@
3322
1
"""Provider interface implementation for Openstack with S3 storage"""
3323
2
3324
3
import os
3325
4
3326
5
from txaws.service import AWSServiceRegion
3327
6
3328
7
from juju.providers.openstack import provider as os_provider
3329
8
from juju.providers.openstack import credentials
3330
9
from juju.providers.ec2 import files as s3_files
3331
10
3332
11
3333
12
class HybridCredentials(credentials.OpenStackCredentials):
3334
13
    """Encapsulation of credentials with S3 required values included"""
3335
14
3336
15
    _config_vars = {
3337
16
        'combined-key':  ("EC2_ACCESS_KEY", "AWS_ACCESS_KEY_ID"),
3338
17
        's3-uri': ("S3_URL",),
3339
18
    }
3340
19
    _config_vars.update(credentials.OpenStackCredentials._config_vars)
3341
20
3342
21
3343
22
class MachineProvider(os_provider.MachineProvider):
3344
23
    """MachineProvider for use in Openstack environment but with S3 API"""
3345
24
3346
25
    Credentials = HybridCredentials
3347
26
3348
27
    def __init__(self, environment_name, config):
3349
28
        super(MachineProvider, self).__init__(environment_name, config)
3350
29
3351
30
        del self.swift
3352
31
3353
32
        # If access or secret keys are still blank, inside txaws environment
3354
33
        # a ValueError will be raised after rechecking the environment.
3355
34
        self._aws_service = AWSServiceRegion(
3356
35
            access_key=self.credentials.combined_key,
3357
36
            secret_key=self.credentials.secret_key,
3358
37
            ec2_uri="", # The EC2 client will not be used
3359
38
            s3_uri=self.credentials.s3_uri)
3360
39
3361
40
        self.s3 = self._aws_service.get_s3_client()
3362
41
3363
42
    @property
3364
43
    def provider_type(self):
3365
44
        return "openstack_s3"
3366
45
3367
46
    def get_file_storage(self):
3368
47
        """Retrieve a S3 API compatible backend FileStorage class"""
3369
48
        return s3_files.FileStorage(self.s3, self.config["control-bucket"])
3370
0
49
3371
=== added directory 'juju/providers/openstack_s3/tests'
3372
=== added file 'juju/providers/openstack_s3/tests/__init__.py'
3373
=== added file 'juju/providers/openstack_s3/tests/test_provider.py'
3374
--- juju/providers/openstack_s3/tests/test_provider.py	1970-01-01 00:00:00 +0000
3375
+++ juju/providers/openstack_s3/tests/test_provider.py	2012-07-18 19:47:20 +0000
3376
@@ -0,0 +1,122 @@
3377
1
"""Testing for the OpenStack provider interface"""
3378
2
3379
3
from juju.lib.testing import TestCase
3380
4
from juju.environment.errors import EnvironmentsConfigError
3381
5
3382
6
from juju.providers.ec2.files import FileStorage
3383
7
from juju.providers.openstack_s3 import MachineProvider
3384
8
3385
9
3386
10
class ProviderTestCase(TestCase):
3387
11
3388
12
    environment_name = "testing"
3389
13
3390
14
    _test_environ = {
3391
15
        "NOVA_URL": "http://environ.invalid",
3392
16
        "NOVA_API_KEY": "env-key",
3393
17
        "EC2_ACCESS_KEY": "env-key:env-project",
3394
18
        "EC2_SECRET_KEY": "env-xxxx",
3395
19
        "NOVA_PROJECT_ID": "env-project",
3396
20
        "S3_URL": "http://environ.invalid:3333",
3397
21
        }
3398
22
3399
23
    def get_config(self):
3400
24
        return {
3401
25
            "type": "openstack_s3",
3402
26
            "auth-mode": "keypair",
3403
27
            "access-key": "key",
3404
28
            "secret-key": "xxxxxxxx",
3405
29
            "auth-url": "http://testing.invalid",
3406
30
            "project-name": "project",
3407
31
            "control-bucket": self.environment_name,
3408
32
            "combined-key": "key:project",
3409
33
            "s3-uri": "http://testing.invalid:3333",
3410
34
            }
3411
35
3412
36
    def test_client_params(self):
3413
37
        """Config details get passed through to OpenStack client correctly"""
3414
38
        config = self.get_config()
3415
39
        provider = MachineProvider(self.environment_name, config)
3416
40
        creds = provider.credentials
3417
41
        self.assertEquals("key", creds.access_key)
3418
42
        self.assertEquals("xxxxxxxx", creds.secret_key)
3419
43
        self.assertEquals("http://testing.invalid", creds.url)
3420
44
        self.assertEquals("project", creds.project_name)
3421
45
        self.assertIs(creds, provider.nova._client.credentials)
3422
46
3423
47
    def test_s3_params(self):
3424
48
        """Config details get passed through to txaws S3 client correctly"""
3425
49
        config = self.get_config()
3426
50
        s3 = MachineProvider(self.environment_name, config).s3
3427
51
        self.assertEquals("http://testing.invalid:3333/", s3.endpoint.get_uri())
3428
52
        self.assertEquals("key:project", s3.creds.access_key)
3429
53
        self.assertEquals("xxxxxxxx", s3.creds.secret_key)
3430
54
3431
55
    def test_provider_attributes(self):
3432
56
        """
3433
57
        The provider environment name and config should be available as
3434
58
        parameters in the provider.
3435
59
        """
3436
60
        provider = MachineProvider(self.environment_name, self.get_config())
3437
61
        self.assertEqual(provider.environment_name, self.environment_name)
3438
62
        self.assertEqual(provider.config.get("type"), "openstack_s3")
3439
63
        self.assertEqual(provider.provider_type, "openstack_s3")
3440
64
3441
65
    def test_get_file_storage(self):
3442
66
        """The file storage is accessible via the machine provider."""
3443
67
        provider = MachineProvider(self.environment_name, self.get_config())
3444
68
        storage = provider.get_file_storage()
3445
69
        self.assertTrue(isinstance(storage, FileStorage))
3446
70
3447
71
    def test_config_serialization(self):
3448
72
        """
3449
73
        The provider configuration can be serialized to yaml.
3450
74
        """
3451
75
        self.change_environment()
3452
76
        config = self.get_config()
3453
77
        expected = config.copy()
3454
78
        config["authorized-keys-path"] = self.makeFile("key contents")
3455
79
        expected["authorized-keys"] = "key contents"
3456
80
        provider = MachineProvider(self.environment_name, config)
3457
81
        self.assertEqual(expected, provider.get_serialization_data())
3458
82
3459
83
    def test_config_environment_extraction(self):
3460
84
        """
3461
85
        The provider serialization loads keys as needed from the environment.
3462
86
3463
87
        Variables from the configuration take precendence over those from
3464
88
        the environment, when serializing.
3465
89
        """
3466
90
        self.change_environment(**self._test_environ)
3467
91
        provider = MachineProvider(self.environment_name, {
3468
92
            "auth-mode": "keypair",
3469
93
            "project-name": "other-project",
3470
94
            "authorized-keys": "key-data",
3471
95
            })
3472
96
        serialized = provider.get_serialization_data()
3473
97
        expected = {
3474
98
            "auth-mode": "keypair",
3475
99
            "access-key": "env-key",
3476
100
            "secret-key": "env-xxxx",
3477
101
            "auth-url": "http://environ.invalid",
3478
102
            "project-name": "other-project",
3479
103
            "authorized-keys": "key-data",
3480
104
            "combined-key": "env-key:env-project",
3481
105
            "s3-uri": "http://environ.invalid:3333",
3482
106
            }
3483
107
        self.assertEqual(expected, serialized)
3484
108
3485
109
    def test_conflicting_authorized_keys_options(self):
3486
110
        """
3487
111
        We can't handle two different authorized keys options, so deny
3488
112
        constructing an environment that way.
3489
113
        """
3490
114
        config = self.get_config()
3491
115
        config["authorized-keys"] = "File content"
3492
116
        config["authorized-keys-path"] = "File path"
3493
117
        error = self.assertRaises(EnvironmentsConfigError,
3494
118
            MachineProvider, self.environment_name, config)
3495
119
        self.assertEquals(
3496
120
            str(error),
3497
121
            "Environment config cannot define both authorized-keys and "
3498
122
            "authorized-keys-path. Pick one!")
3499
0
123
3500
=== modified file 'juju/state/initialize.py'
3501
--- juju/state/initialize.py	2012-03-29 01:37:57 +0000
3502
+++ juju/state/initialize.py	2012-07-18 19:47:20 +0000
3503
@@ -30,7 +30,10 @@
3504
30
        """
30
        """
3505
31
        self.client = client
31
        self.client = client
3506
32
        self.admin_identity = admin_identity
32
        self.admin_identity = admin_identity
3507
33
        if instance_id.isdigit():
3508
34
            instance_id = int(instance_id)
3509
33
        self.instance_id = instance_id
35
        self.instance_id = instance_id
3510
36
3511
34
        self.constraints_data = constraints_data
37
        self.constraints_data = constraints_data
3512
35
        self.provider_type = provider_type
38
        self.provider_type = provider_type
3513
36
39
3514
@@ -57,6 +60,7 @@
3515
57
        # Poke constraints data into a machine state to represent this machine.
60
        # Poke constraints data into a machine state to represent this machine.
3516
58
        manager = MachineStateManager(self.client)
61
        manager = MachineStateManager(self.client)
3517
59
        machine_state = yield manager.add_machine_state(constraints)
62
        machine_state = yield manager.add_machine_state(constraints)
3518
63
3519
60
        yield machine_state.set_instance_id(self.instance_id)
64
        yield machine_state.set_instance_id(self.instance_id)
3520
61
65
3521
62
        # Set up environment constraints similarly.
66
        # Set up environment constraints similarly.
3522
63
67
3523
=== modified file 'juju/unit/address.py'
3524
--- juju/unit/address.py	2012-03-22 09:08:12 +0000
3525
+++ juju/unit/address.py	2012-07-18 19:47:20 +0000
3526
@@ -16,6 +16,8 @@
3527
16
    provider_type = yield settings.get_provider_type()
16
    provider_type = yield settings.get_provider_type()
3528
17
    if provider_type == "ec2":
17
    if provider_type == "ec2":
3529
18
        returnValue(EC2UnitAddress())
18
        returnValue(EC2UnitAddress())
3530
19
    if provider_type in ("openstack", "openstack_s3"):
3531
20
        returnValue(OpenStackUnitAddress())
3532
19
    elif provider_type == "local":
21
    elif provider_type == "local":
3533
20
        returnValue(LocalUnitAddress())
22
        returnValue(LocalUnitAddress())
3534
21
    elif provider_type == "orchestra":
23
    elif provider_type == "orchestra":
3535
@@ -24,7 +26,6 @@
3536
24
        returnValue(DummyUnitAddress())
26
        returnValue(DummyUnitAddress())
3537
25
    elif provider_type == "maas":
27
    elif provider_type == "maas":
3538
26
        returnValue(MAASUnitAddress())
28
        returnValue(MAASUnitAddress())
3539
27
3540
28
    raise JujuError(
29
    raise JujuError(
3541
29
        "Unknown provider type: %r, unit addresses unknown." % provider_type)
30
        "Unknown provider type: %r, unit addresses unknown." % provider_type)
3542
30
31
3543
@@ -32,10 +33,10 @@
3544
32
class UnitAddress(object):
33
class UnitAddress(object):
3545
33
34
3546
34
    def get_private_address(self):
35
    def get_private_address(self):
3548
35
        raise NotImplemented()
36
        raise NotImplementedError(self.get_private_address)
3549
36
37
3550
37
    def get_public_address(self):
38
    def get_public_address(self):
3552
38
        raise NotImplemented()
39
        raise NotImplementedError(self.get_public_address)
3553
39
40
3554
40
41
3555
41
class DummyUnitAddress(UnitAddress):
42
class DummyUnitAddress(UnitAddress):
3556
@@ -62,6 +63,27 @@
3557
62
        returnValue(content.strip())
63
        returnValue(content.strip())
3558
63
64
3559
64
65
3560
66
class OpenStackUnitAddress(UnitAddress):
3561
67
    """Address determination of a service unit on an OpenStack server
3562
68
3563
69
    Unlike EC2 there are no promises that an instance will have a resolvable
3564
70
    hostname, or for that matter a public ip address.
3565
71
    """
3566
72
3567
73
    def _get_metadata_string(self, key):
3568
74
        return client.getPage("http://169.254.169.254/1.0/meta-data/" + key)
3569
75
3570
76
    def get_private_address(self):
3571
77
        return self._get_metadata_string("local-ipv4")
3572
78
3573
79
    @inlineCallbacks
3574
80
    def get_public_address(self):
3575
81
        address = yield self._get_metadata_string("public-ipv4")
3576
82
        if not address:
3577
83
            address = yield self.get_private_address()
3578
84
        returnValue(address)
3579
85
3580
86
3581
65
class LocalUnitAddress(UnitAddress):
87
class LocalUnitAddress(UnitAddress):
3582
66
88
3583
67
    def get_private_address(self):
89
    def get_private_address(self):
3584
@@ -87,6 +109,7 @@
3585
87
        output = subprocess.check_output(["hostname", "-f"])
109
        output = subprocess.check_output(["hostname", "-f"])
3586
88
        return output.strip()
110
        return output.strip()
3587
89
111
3588
112
3589
90
class MAASUnitAddress(UnitAddress):
113
class MAASUnitAddress(UnitAddress):
3590
91
114
3591
92
    def get_private_address(self):
115
    def get_private_address(self):
3592
93
116
3593
=== modified file 'juju/unit/tests/test_address.py'
3594
--- juju/unit/tests/test_address.py	2012-03-22 09:08:12 +0000
3595
+++ juju/unit/tests/test_address.py	2012-07-18 19:47:20 +0000
3596
@@ -8,7 +8,7 @@
3597
8
from juju.lib.testing import TestCase
8
from juju.lib.testing import TestCase
3598
9
from juju.unit.address import (
9
from juju.unit.address import (
3599
10
    EC2UnitAddress, LocalUnitAddress, OrchestraUnitAddress, DummyUnitAddress,
10
    EC2UnitAddress, LocalUnitAddress, OrchestraUnitAddress, DummyUnitAddress,
3601
11
    MAASUnitAddress, get_unit_address)
11
    MAASUnitAddress, OpenStackUnitAddress, UnitAddress, get_unit_address)
3602
12
from juju.state.environment import GlobalSettingsStateManager
12
from juju.state.environment import GlobalSettingsStateManager
3603
13
13
3604
14
14
3605
@@ -32,6 +32,16 @@
3606
32
        self.assertTrue(isinstance(address, EC2UnitAddress))
32
        self.assertTrue(isinstance(address, EC2UnitAddress))
3607
33
33
3608
34
    @inlineCallbacks
34
    @inlineCallbacks
3609
35
    def test_get_openstack_address(self):
3610
36
        address = yield self.get_address_for("openstack")
3611
37
        self.assertTrue(isinstance(address, OpenStackUnitAddress))
3612
38
3613
39
    @inlineCallbacks
3614
40
    def test_get_openstack_s3_address(self):
3615
41
        address = yield self.get_address_for("openstack_s3")
3616
42
        self.assertTrue(isinstance(address, OpenStackUnitAddress))
3617
43
3618
44
    @inlineCallbacks
3619
35
    def test_get_local_address(self):
45
    def test_get_local_address(self):
3620
36
        address = yield self.get_address_for("local")
46
        address = yield self.get_address_for("local")
3621
37
        self.assertTrue(isinstance(address, LocalUnitAddress))
47
        self.assertTrue(isinstance(address, LocalUnitAddress))
3622
@@ -55,6 +65,22 @@
3623
55
        return self.assertFailure(self.get_address_for("foobar"), JujuError)
65
        return self.assertFailure(self.get_address_for("foobar"), JujuError)
3624
56
66
3625
57
67
3626
68
class SubclassAddressTest(TestCase):
3627
69
3628
70
    class TestingAddress(UnitAddress):
3629
71
        """An address class that neglects to implement the required methods"""
3630
72
3631
73
    def test_get_public_address(self):
3632
74
        err = self.assertRaises(NotImplementedError,
3633
75
            self.TestingAddress().get_public_address)
3634
76
        self.assertIn("TestingAddress.get_public_address", str(err))
3635
77
3636
78
    def test_get_private_address(self):
3637
79
        err = self.assertRaises(NotImplementedError,
3638
80
            self.TestingAddress().get_private_address)
3639
81
        self.assertIn("TestingAddress.get_private_address", str(err))
3640
82
3641
83
3642
58
class DummyAddressTest(TestCase):
84
class DummyAddressTest(TestCase):
3643
59
85
3644
60
    def setUp(self):
86
    def setUp(self):
3645
@@ -93,6 +119,35 @@
3646
93
            (yield self.address.get_public_address()), "foobar")
119
            (yield self.address.get_public_address()), "foobar")
3647
94
120
3648
95
121
3649
122
class OpenStackAddressTest(TestCase):
3650
123
3651
124
    def setUp(self):
3652
125
        self.address = OpenStackUnitAddress()
3653
126
        self.patch(client, "getPage", self._fetch_metadata)
3654
127
3655
128
    def _fetch_metadata(self, url):
3656
129
        head, tail = url.rsplit("/", 1)
3657
130
        self.assertEqual("http://169.254.169.254/1.0/meta-data", head)
3658
131
        return succeed(self.meta.pop(tail))
3659
132
3660
133
    @inlineCallbacks
3661
134
    def test_get_private_address(self):
3662
135
        self.meta = {"local-ipv4": "192.168.0.2"}
3663
136
        self.assertEqual("192.168.0.2",
3664
137
            (yield self.address.get_private_address()))
3665
138
3666
139
    @inlineCallbacks
3667
140
    def test_get_public_address_present(self):
3668
141
        self.meta = {"public-ipv4": "8.8.8.8"}
3669
142
        self.assertEqual("8.8.8.8", (yield self.address.get_public_address()))
3670
143
3671
144
    @inlineCallbacks
3672
145
    def test_get_public_address_missing(self):
3673
146
        self.meta = {"public-ipv4": "", "local-ipv4": "192.168.0.2"}
3674
147
        self.assertEqual("192.168.0.2",
3675
148
            (yield self.address.get_public_address()))
3676
149
3677
150
3678
96
class LocalAddressTest(TestCase):
151
class LocalAddressTest(TestCase):
3679
97
152
3680
98
    def setUp(self):
153
    def setUp(self):
Status:	Merged
Approved by:	Kapil Thangavelu on 2012-07-18
Approved revision:	539
Merged at revision:	557
Proposed branch:	lp:~gz/pyjuju/openstack_provider
Merge into:	lp:pyjuju
Diff against target:	3680 lines (+3386/-10) 31 files modified juju/agents/provision.py (+1/-0) juju/control/status.py (+1/-1) juju/environment/config.py (+48/-2) juju/errors.py (+1/-1) juju/providers/common/findzookeepers.py (+2/-1) juju/providers/ec2/tests/test_launch.py (+1/-1) juju/providers/openstack/__init__.py (+3/-0) juju/providers/openstack/client.py (+470/-0) juju/providers/openstack/credentials.py (+101/-0) juju/providers/openstack/files.py (+84/-0) juju/providers/openstack/launch.py (+131/-0) juju/providers/openstack/machine.py (+68/-0) juju/providers/openstack/ports.py (+179/-0) juju/providers/openstack/provider.py (+189/-0) juju/providers/openstack/tests/__init__.py (+206/-0) juju/providers/openstack/tests/test_bootstrap.py (+213/-0) juju/providers/openstack/tests/test_client.py (+75/-0) juju/providers/openstack/tests/test_credentials.py (+216/-0) juju/providers/openstack/tests/test_files.py (+103/-0) juju/providers/openstack/tests/test_getmachines.py (+115/-0) juju/providers/openstack/tests/test_launch.py (+113/-0) juju/providers/openstack/tests/test_machine.py (+110/-0) juju/providers/openstack/tests/test_ports.py (+396/-0) juju/providers/openstack/tests/test_provider.py (+116/-0) juju/providers/openstack/tests/test_shutdown.py (+130/-0) juju/providers/openstack/tests/test_state.py (+58/-0) juju/providers/openstack_s3/__init__.py (+48/-0) juju/providers/openstack_s3/tests/test_provider.py (+122/-0) juju/state/initialize.py (+4/-0) juju/unit/address.py (+26/-3) juju/unit/tests/test_address.py (+56/-1)
To merge this branch:	bzr merge lp:~gz/pyjuju/openstack_provider
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Kapil Thangavelu (community)		2012-06-18	Approve on 2012-07-18
Review via email: mp+110860@code.launchpad.net