1
=== modified file 'Makefile'
2
--- Makefile	2015-04-20 11:13:39 +0000
3
+++ Makefile	2015-09-01 02:46:36 +0000
4
@@ -29,14 +29,15 @@
5
29
	@$(PYTHON) bin/charm_helpers_sync.py -c charm-helpers.yaml
29
	@$(PYTHON) bin/charm_helpers_sync.py -c charm-helpers.yaml
6
30
	@$(PYTHON) bin/charm_helpers_sync.py -c charm-helpers-tests.yaml
30
	@$(PYTHON) bin/charm_helpers_sync.py -c charm-helpers-tests.yaml
7
31
31
9
32
publish: lint
32
publish: lint test
10
33
	bzr push lp:charms/rabbitmq-server
33
	bzr push lp:charms/rabbitmq-server
11
34
	bzr push lp:charms/trusty/rabbitmq-server
34
	bzr push lp:charms/trusty/rabbitmq-server
12
35
35
14
36
unit_test: .venv
36
test: .venv
15
37
	@echo Starting tests...
37
	@echo Starting tests...
17
38
	env CHARM_DIR=$(CHARM_DIR) $(TEST_PREFIX) .venv/bin/nosetests unit_tests/
38
	env CHARM_DIR=$(CHARM_DIR) $(TEST_PREFIX) .venv/bin/nosetests \
18
39
        --nologcapture --with-coverage unit_tests/
19
39
40
20
40
functional_test:
41
functional_test:
21
41
	@echo Starting amulet tests...
42
	@echo Starting amulet tests...
23
42
	@juju test -v -p AMULET_HTTP_PROXY,OS_USERNAME,OS_TENANT_NAME,OS_REGION_NAME,OS_PASSWORD,OS_AUTH_URL --timeout 900
43
	@juju test -v -p AMULET_HTTP_PROXY,AMULET_OS_VIP --timeout 2700
24
43
44
25
=== modified file 'charm-helpers-tests.yaml'
26
--- charm-helpers-tests.yaml	2015-07-31 22:00:49 +0000
27
+++ charm-helpers-tests.yaml	2015-09-01 02:46:36 +0000
28
@@ -1,6 +1,5 @@
29
1
destination: tests/charmhelpers
1
destination: tests/charmhelpers
30
2
branch: lp:charm-helpers
2
branch: lp:charm-helpers
31
3
include:
3
include:
35
4
    - core
4
    - contrib.amulet
36
5
    - cli
5
    - contrib.openstack.amulet
34
6
    - contrib.ssl
37
7
6
38
=== modified file 'hooks/rabbitmq_server_relations.py'
39
--- hooks/rabbitmq_server_relations.py	2015-09-01 00:54:12 +0000
40
+++ hooks/rabbitmq_server_relations.py	2015-09-01 02:46:36 +0000
41
@@ -326,6 +326,7 @@
42
326
        log('cluster_joined: cookie not yet set.', level=INFO)
326
        log('cluster_joined: cookie not yet set.', level=INFO)
43
327
        return
327
        return
44
328
328
45
329
<<<<<<< TREE
46
329
    rdata = relation_get()
330
    rdata = relation_get()
47
330
    hostname = rdata.get('hostname', None)
331
    hostname = rdata.get('hostname', None)
48
331
    private_address = rdata.get('private-address', None)
332
    private_address = rdata.get('private-address', None)
49
@@ -343,6 +344,23 @@
50
343
344
51
344
    if hostname and private_address:
345
    if hostname and private_address:
52
345
        rabbit.update_hosts_file({private_address: hostname})
346
        rabbit.update_hosts_file({private_address: hostname})
53
347
=======
54
348
    # If called from leader-settings-changed we are not in a hook env
55
349
    if not in_relation_hook():
56
350
        rid = relation_ids('cluster')[0]
57
351
        for unit in related_units(rid):
58
352
            rdata = relation_get(rid=rid, unit=unit)
59
353
            if rdata:
60
354
                break;
61
355
    else:
62
356
        rdata = relation_get()
63
357
64
358
    if config('prefer-ipv6') and rdata.get('hostname'):
65
359
        private_address = rdata['private-address']
66
360
        hostname = rdata['hostname']
67
361
        if hostname:
68
362
            rabbit.update_hosts_file({private_address: hostname})
69
363
>>>>>>> MERGE-SOURCE
70
346
364
71
347
    # sync passwords
365
    # sync passwords
72
348
    blacklist = ['hostname', 'private-address', 'public-address']
366
    blacklist = ['hostname', 'private-address', 'public-address']
73
349
367
74
=== modified file 'metadata.yaml'
75
--- metadata.yaml	2013-11-15 19:15:16 +0000
76
+++ metadata.yaml	2015-09-01 02:46:36 +0000
77
@@ -5,7 +5,10 @@
78
5
 RabbitMQ is an implementation of AMQP, the emerging standard for high
5
 RabbitMQ is an implementation of AMQP, the emerging standard for high
79
6
 performance enterprise messaging. The RabbitMQ server is a robust and
6
 performance enterprise messaging. The RabbitMQ server is a robust and
80
7
 scalable implementation of an AMQP broker.
7
 scalable implementation of an AMQP broker.
82
8
categories: ["misc"]
8
tags:
83
9
  - openstack
84
10
  - amqp
85
11
  - misc
86
9
provides:
12
provides:
87
10
  amqp:
13
  amqp:
88
11
    interface: rabbitmq
14
    interface: rabbitmq
89
12
15
90
=== added file 'tests/00-setup'
91
--- tests/00-setup	1970-01-01 00:00:00 +0000
92
+++ tests/00-setup	2015-09-01 02:46:36 +0000
93
@@ -0,0 +1,16 @@
94
1
#!/bin/bash
95
2
96
3
set -ex
97
4
98
5
sudo add-apt-repository --yes ppa:juju/stable
99
6
sudo apt-get update --yes
100
7
sudo apt-get install --yes python-amulet \
101
8
                           python-cinderclient \
102
9
                           python-distro-info \
103
10
                           python-glanceclient \
104
11
                           python-heatclient \
105
12
                           python-keystoneclient \
106
13
                           python-neutronclient \
107
14
                           python-novaclient \
108
15
                           python-pika \
109
16
                           python-swiftclient
110
0
17
111
=== added file 'tests/014-basic-precise-icehouse'
112
--- tests/014-basic-precise-icehouse	1970-01-01 00:00:00 +0000
113
+++ tests/014-basic-precise-icehouse	2015-09-01 02:46:36 +0000
114
@@ -0,0 +1,11 @@
115
1
#!/usr/bin/python
116
2
117
3
"""Amulet tests on a basic rabbitmq-server deployment on precise-icehouse."""
118
4
119
5
from basic_deployment import RmqBasicDeployment
120
6
121
7
if __name__ == '__main__':
122
8
    deployment = RmqBasicDeployment(series='precise',
123
9
                                    openstack='cloud:precise-icehouse',
124
10
                                    source='cloud:precise-updates/icehouse')
125
11
    deployment.run_tests()
126
0
12
127
=== added file 'tests/015-basic-trusty-icehouse'
128
--- tests/015-basic-trusty-icehouse	1970-01-01 00:00:00 +0000
129
+++ tests/015-basic-trusty-icehouse	2015-09-01 02:46:36 +0000
130
@@ -0,0 +1,9 @@
131
1
#!/usr/bin/python
132
2
133
3
"""Amulet tests on a basic rabbitmq-server deployment on trusty-icehouse."""
134
4
135
5
from basic_deployment import RmqBasicDeployment
136
6
137
7
if __name__ == '__main__':
138
8
    deployment = RmqBasicDeployment(series='trusty')
139
9
    deployment.run_tests()
140
0
10
141
=== added file 'tests/016-basic-trusty-juno'
142
--- tests/016-basic-trusty-juno	1970-01-01 00:00:00 +0000
143
+++ tests/016-basic-trusty-juno	2015-09-01 02:46:36 +0000
144
@@ -0,0 +1,11 @@
145
1
#!/usr/bin/python
146
2
147
3
"""Amulet tests on a basic rabbitmq-server deployment on trusty-juno."""
148
4
149
5
from basic_deployment import RmqBasicDeployment
150
6
151
7
if __name__ == '__main__':
152
8
    deployment = RmqBasicDeployment(series='trusty',
153
9
                                    openstack='cloud:trusty-juno',
154
10
                                    source='cloud:trusty-updates/juno')
155
11
    deployment.run_tests()
156
0
12
157
=== added file 'tests/017-basic-trusty-kilo'
158
--- tests/017-basic-trusty-kilo	1970-01-01 00:00:00 +0000
159
+++ tests/017-basic-trusty-kilo	2015-09-01 02:46:36 +0000
160
@@ -0,0 +1,11 @@
161
1
#!/usr/bin/python
162
2
163
3
"""Amulet tests on a basic rabbitmq-server deployment on trusty-kilo."""
164
4
165
5
from basic_deployment import RmqBasicDeployment
166
6
167
7
if __name__ == '__main__':
168
8
    deployment = RmqBasicDeployment(series='trusty',
169
9
                                    openstack='cloud:trusty-kilo',
170
10
                                    source='cloud:trusty-updates/kilo')
171
11
    deployment.run_tests()
172
0
12
173
=== added file 'tests/019-basic-vivid-kilo'
174
--- tests/019-basic-vivid-kilo	1970-01-01 00:00:00 +0000
175
+++ tests/019-basic-vivid-kilo	2015-09-01 02:46:36 +0000
176
@@ -0,0 +1,9 @@
177
1
#!/usr/bin/python
178
2
179
3
"""Amulet tests on a basic rabbitmq-server deployment on vivid-kilo."""
180
4
181
5
from basic_deployment import RmqBasicDeployment
182
6
183
7
if __name__ == '__main__':
184
8
    deployment = RmqBasicDeployment(series='vivid')
185
9
    deployment.run_tests()
186
0
10
187
=== added file 'tests/020-basic-trusty-liberty'
188
--- tests/020-basic-trusty-liberty	1970-01-01 00:00:00 +0000
189
+++ tests/020-basic-trusty-liberty	2015-09-01 02:46:36 +0000
190
@@ -0,0 +1,11 @@
191
1
#!/usr/bin/python
192
2
193
3
"""Amulet tests on a basic rabbitmq-server deployment on trusty-liberty."""
194
4
195
5
from basic_deployment import RmqBasicDeployment
196
6
197
7
if __name__ == '__main__':
198
8
    deployment = RmqBasicDeployment(series='trusty',
199
9
                                    openstack='cloud:trusty-liberty',
200
10
                                    source='cloud:trusty-updates/liberty')
201
11
    deployment.run_tests()
202
0
12
203
=== added file 'tests/021-basic-wily-liberty'
204
--- tests/021-basic-wily-liberty	1970-01-01 00:00:00 +0000
205
+++ tests/021-basic-wily-liberty	2015-09-01 02:46:36 +0000
206
@@ -0,0 +1,9 @@
207
1
#!/usr/bin/python
208
2
209
3
"""Amulet tests on a basic rabbitmq-server deployment on wily-liberty."""
210
4
211
5
from basic_deployment import RmqBasicDeployment
212
6
213
7
if __name__ == '__main__':
214
8
    deployment = RmqBasicDeployment(series='wily')
215
9
    deployment.run_tests()
216
0
10
217
=== added file 'tests/basic_deployment.py'
218
--- tests/basic_deployment.py	1970-01-01 00:00:00 +0000
219
+++ tests/basic_deployment.py	2015-09-01 02:46:36 +0000
220
@@ -0,0 +1,492 @@
221
1
#!/usr/bin/python
222
2
"""
223
3
Basic 3-node rabbitmq-server native cluster + nrpe functional tests
224
4
225
5
Cinder is present to exercise and inspect amqp relation functionality.
226
6
227
7
Each individual test is idempotent, in that it creates/deletes
228
8
a rmq test user, enables or disables ssl as needed.
229
9
230
10
Test order is not required, however tests are numbered to keep
231
11
relevant tests grouped together in run order.
232
12
"""
233
13
234
14
import amulet
235
15
import time
236
16
237
17
from charmhelpers.contrib.openstack.amulet.deployment import (
238
18
    OpenStackAmuletDeployment
239
19
)
240
20
241
21
from charmhelpers.contrib.openstack.amulet.utils import (
242
22
    OpenStackAmuletUtils,
243
23
    DEBUG,
244
24
    # ERROR
245
25
)
246
26
247
27
# Use DEBUG to turn on debug logging
248
28
u = OpenStackAmuletUtils(DEBUG)
249
29
250
30
251
31
class RmqBasicDeployment(OpenStackAmuletDeployment):
252
32
    """Amulet tests on a basic rabbitmq cluster deployment. Verify
253
33
       relations, service status, users and endpoint service catalog."""
254
34
255
35
    def __init__(self, series=None, openstack=None, source=None, stable=False):
256
36
        """Deploy the entire test environment."""
257
37
        super(RmqBasicDeployment, self).__init__(series, openstack, source,
258
38
                                                 stable)
259
39
        self._add_services()
260
40
        self._add_relations()
261
41
        self._configure_services()
262
42
        self._deploy()
263
43
        self._initialize_tests()
264
44
265
45
    def _add_services(self):
266
46
        """Add services
267
47
268
48
           Add the services that we're testing, where rmq is local,
269
49
           and the rest of the service are from lp branches that are
270
50
           compatible with the local charm (e.g. stable or next).
271
51
           """
272
52
        this_service = {
273
53
            'name': 'rabbitmq-server',
274
54
            'units': 3
275
55
        }
276
56
        other_services = [{'name': 'cinder'},
277
57
                          {'name': 'nrpe'}]
278
58
279
59
        super(RmqBasicDeployment, self)._add_services(this_service,
280
60
                                                      other_services)
281
61
282
62
    def _add_relations(self):
283
63
        """Add relations for the services."""
284
64
        relations = {'cinder:amqp': 'rabbitmq-server:amqp',
285
65
                     'nrpe:nrpe-external-master':
286
66
                     'rabbitmq-server:nrpe-external-master'}
287
67
288
68
        super(RmqBasicDeployment, self)._add_relations(relations)
289
69
290
70
    def _configure_services(self):
291
71
        """Configure all of the services."""
292
72
        rmq_config = {
293
73
            'min-cluster-size': '3',
294
74
            'max-cluster-tries': '6',
295
75
            'ssl': 'off',
296
76
            'management_plugin': 'False',
297
77
            'stats_cron_schedule': '*/1 * * * *'
298
78
        }
299
79
        cinder_config = {}
300
80
        configs = {'rabbitmq-server': rmq_config,
301
81
                   'cinder': cinder_config}
302
82
        super(RmqBasicDeployment, self)._configure_services(configs)
303
83
304
84
    def _initialize_tests(self):
305
85
        """Perform final initialization before tests get run."""
306
86
        # Access the sentries for inspecting service units
307
87
        self.rmq0_sentry = self.d.sentry.unit['rabbitmq-server/0']
308
88
        self.rmq1_sentry = self.d.sentry.unit['rabbitmq-server/1']
309
89
        self.rmq2_sentry = self.d.sentry.unit['rabbitmq-server/2']
310
90
        self.cinder_sentry = self.d.sentry.unit['cinder/0']
311
91
        self.nrpe_sentry = self.d.sentry.unit['nrpe/0']
312
92
        u.log.debug('openstack release val: {}'.format(
313
93
            self._get_openstack_release()))
314
94
        u.log.debug('openstack release str: {}'.format(
315
95
            self._get_openstack_release_string()))
316
96
317
97
        # Let things settle a bit before moving forward
318
98
        time.sleep(30)
319
99
320
100
    def _get_rmq_sentry_units(self):
321
101
        """Local helper specific to this 3-node rmq series of tests."""
322
102
        return [self.rmq0_sentry,
323
103
                self.rmq1_sentry,
324
104
                self.rmq2_sentry]
325
105
326
106
    def _test_rmq_amqp_messages_all_units(self, sentry_units,
327
107
                                          ssl=False, port=None):
328
108
        """Reusable test to send amqp messages to every listed rmq unit
329
109
        and check every listed rmq unit for messages.
330
110
331
111
        :param sentry_units: list of sentry units
332
112
        :returns: None if successful.  Raise on error.
333
113
        """
334
114
335
115
        # Add test user if it does not already exist
336
116
        u.add_rmq_test_user(sentry_units)
337
117
338
118
        # Handle ssl
339
119
        if ssl:
340
120
            u.configure_rmq_ssl_on(sentry_units, self.d, port=port)
341
121
        else:
342
122
            u.configure_rmq_ssl_off(sentry_units, self.d)
343
123
344
124
        # Publish and get amqp messages in all possible unit combinations.
345
125
        # Qty of checks == (qty of units) ^ 2
346
126
        amqp_msg_counter = 1
347
127
        host_names = u.get_unit_hostnames(sentry_units)
348
128
349
129
        for dest_unit in sentry_units:
350
130
            dest_unit_name = dest_unit.info['unit_name']
351
131
            dest_unit_host = dest_unit.info['public-address']
352
132
            dest_unit_host_name = host_names[dest_unit_name]
353
133
354
134
            for check_unit in sentry_units:
355
135
                check_unit_name = check_unit.info['unit_name']
356
136
                check_unit_host = check_unit.info['public-address']
357
137
                check_unit_host_name = host_names[check_unit_name]
358
138
359
139
                amqp_msg_stamp = u.get_uuid_epoch_stamp()
360
140
                amqp_msg = ('Message {}@{} {}'.format(amqp_msg_counter,
361
141
                                                      dest_unit_host,
362
142
                                                      amqp_msg_stamp)).upper()
363
143
                # Publish amqp message
364
144
                u.log.debug('Publish message to: {} '
365
145
                            '({} {})'.format(dest_unit_host,
366
146
                                             dest_unit_name,
367
147
                                             dest_unit_host_name))
368
148
369
149
                u.publish_amqp_message_by_unit(dest_unit,
370
150
                                               amqp_msg, ssl=ssl,
371
151
                                               port=port)
372
152
373
153
                # Wait a bit before checking for message
374
154
                time.sleep(2)
375
155
376
156
                # Get amqp message
377
157
                u.log.debug('Get message from:   {} '
378
158
                            '({} {})'.format(check_unit_host,
379
159
                                             check_unit_name,
380
160
                                             check_unit_host_name))
381
161
382
162
                amqp_msg_rcvd = u.get_amqp_message_by_unit(check_unit,
383
163
                                                           ssl=ssl,
384
164
                                                           port=port)
385
165
386
166
                # Validate amqp message content
387
167
                if amqp_msg == amqp_msg_rcvd:
388
168
                    u.log.debug('Message {} received '
389
169
                                'OK.'.format(amqp_msg_counter))
390
170
                else:
391
171
                    u.log.error('Expected: {}'.format(amqp_msg))
392
172
                    u.log.error('Actual:   {}'.format(amqp_msg_rcvd))
393
173
                    msg = 'Message {} mismatch.'.format(amqp_msg_counter)
394
174
                    amulet.raise_status(amulet.FAIL, msg)
395
175
396
176
                amqp_msg_counter += 1
397
177
398
178
        # Delete the test user
399
179
        u.delete_rmq_test_user(sentry_units)
400
180
401
181
    def test_100_rmq_processes(self):
402
182
        """Verify that the expected service processes are running
403
183
        on each rabbitmq-server unit."""
404
184
405
185
        # Beam and epmd sometimes briefly have more than one PID,
406
186
        # True checks for at least 1.
407
187
        rmq_processes = {
408
188
            'beam': True,
409
189
            'epmd': True,
410
190
        }
411
191
412
192
        # Units with process names and PID quantities expected
413
193
        expected_processes = {
414
194
            self.rmq0_sentry: rmq_processes,
415
195
            self.rmq1_sentry: rmq_processes,
416
196
            self.rmq2_sentry: rmq_processes
417
197
        }
418
198
419
199
        actual_pids = u.get_unit_process_ids(expected_processes)
420
200
        ret = u.validate_unit_process_ids(expected_processes, actual_pids)
421
201
        if ret:
422
202
            amulet.raise_status(amulet.FAIL, msg=ret)
423
203
424
204
        u.log.info('OK\n')
425
205
426
206
    def test_102_services(self):
427
207
        """Verify that the expected services are running on the
428
208
           corresponding service units."""
429
209
        services = {
430
210
            self.rmq0_sentry: ['rabbitmq-server'],
431
211
            self.rmq1_sentry: ['rabbitmq-server'],
432
212
            self.rmq2_sentry: ['rabbitmq-server'],
433
213
            self.cinder_sentry: ['cinder-api',
434
214
                                 'cinder-scheduler',
435
215
                                 'cinder-volume'],
436
216
        }
437
217
        ret = u.validate_services_by_name(services)
438
218
        if ret:
439
219
            amulet.raise_status(amulet.FAIL, msg=ret)
440
220
441
221
        u.log.info('OK\n')
442
222
443
223
    def test_200_rmq_cinder_amqp_relation(self):
444
224
        """Verify the rabbitmq-server:cinder amqp relation data"""
445
225
        u.log.debug('Checking rmq:cinder amqp relation data...')
446
226
        unit = self.rmq0_sentry
447
227
        relation = ['amqp', 'cinder:amqp']
448
228
        expected = {
449
229
            'private-address': u.valid_ip,
450
230
            'password': u.not_null,
451
231
            'hostname': u.valid_ip
452
232
        }
453
233
        ret = u.validate_relation_data(unit, relation, expected)
454
234
        if ret:
455
235
            msg = u.relation_error('amqp cinder', ret)
456
236
            amulet.raise_status(amulet.FAIL, msg=msg)
457
237
458
238
        u.log.info('OK\n')
459
239
460
240
    def test_201_cinder_rmq_amqp_relation(self):
461
241
        """Verify the cinder:rabbitmq-server amqp relation data"""
462
242
        u.log.debug('Checking cinder:rmq amqp relation data...')
463
243
        unit = self.cinder_sentry
464
244
        relation = ['amqp', 'rabbitmq-server:amqp']
465
245
        expected = {
466
246
            'private-address': u.valid_ip,
467
247
            'vhost': 'openstack',
468
248
            'username': u.not_null
469
249
        }
470
250
        ret = u.validate_relation_data(unit, relation, expected)
471
251
        if ret:
472
252
            msg = u.relation_error('cinder amqp', ret)
473
253
            amulet.raise_status(amulet.FAIL, msg=msg)
474
254
475
255
        u.log.info('OK\n')
476
256
477
257
    def test_202_rmq_nrpe_ext_master_relation(self):
478
258
        """Verify rabbitmq-server:nrpe nrpe-external-master relation data"""
479
259
        u.log.debug('Checking rmq:nrpe external master relation data...')
480
260
        unit = self.rmq0_sentry
481
261
        relation = ['nrpe-external-master',
482
262
                    'nrpe:nrpe-external-master']
483
263
484
264
        mon_sub = ('monitors:\n  remote:\n    nrpe:\n      rabbitmq: '
485
265
                   '{command: check_rabbitmq}\n      rabbitmq_queue: '
486
266
                   '{command: check_rabbitmq_queue}\n')
487
267
488
268
        expected = {
489
269
            'private-address': u.valid_ip,
490
270
            'monitors': mon_sub
491
271
        }
492
272
493
273
        ret = u.validate_relation_data(unit, relation, expected)
494
274
        if ret:
495
275
            msg = u.relation_error('amqp nrpe', ret)
496
276
            amulet.raise_status(amulet.FAIL, msg=msg)
497
277
498
278
        u.log.info('OK\n')
499
279
500
280
    def test_203_nrpe_rmq_ext_master_relation(self):
501
281
        """Verify nrpe:rabbitmq-server nrpe-external-master relation data"""
502
282
        u.log.debug('Checking nrpe:rmq external master relation data...')
503
283
        unit = self.nrpe_sentry
504
284
        relation = ['nrpe-external-master',
505
285
                    'rabbitmq-server:nrpe-external-master']
506
286
507
287
        expected = {
508
288
            'private-address': u.valid_ip
509
289
        }
510
290
511
291
        ret = u.validate_relation_data(unit, relation, expected)
512
292
        if ret:
513
293
            msg = u.relation_error('nrpe amqp', ret)
514
294
            amulet.raise_status(amulet.FAIL, msg=msg)
515
295
516
296
        u.log.info('OK\n')
517
297
518
298
    def test_300_rmq_config(self):
519
299
        """Verify the data in the rabbitmq conf file."""
520
300
        conf = '/etc/rabbitmq/rabbitmq-env.conf'
521
301
        sentry_units = self._get_rmq_sentry_units()
522
302
        for unit in sentry_units:
523
303
            host_name = unit.file_contents('/etc/hostname').strip()
524
304
            u.log.debug('Checking rabbitmq config file data on '
525
305
                        '{} ({})...'.format(unit.info['unit_name'],
526
306
                                            host_name))
527
307
            expected = {
528
308
                'RABBITMQ_NODENAME': 'rabbit@{}'.format(host_name)
529
309
            }
530
310
531
311
            file_contents = unit.file_contents(conf)
532
312
            u.validate_sectionless_conf(file_contents, expected)
533
313
534
314
        u.log.info('OK\n')
535
315
536
316
    def test_400_rmq_cluster_running_nodes(self):
537
317
        """Verify that cluster status from each rmq juju unit shows
538
318
        every cluster node as a running member in that cluster."""
539
319
        u.log.debug('Checking that all units are in cluster_status '
540
320
                    'running nodes...')
541
321
542
322
        sentry_units = self._get_rmq_sentry_units()
543
323
544
324
        ret = u.validate_rmq_cluster_running_nodes(sentry_units)
545
325
        if ret:
546
326
            amulet.raise_status(amulet.FAIL, msg=ret)
547
327
548
328
        u.log.info('OK\n')
549
329
550
330
    def test_402_rmq_connect_with_ssl_off(self):
551
331
        """Verify successful non-ssl amqp connection to all units when
552
332
        charm config option for ssl is set False."""
553
333
        u.log.debug('Confirming that non-ssl connection succeeds when '
554
334
                    'ssl config is off...')
555
335
        sentry_units = self._get_rmq_sentry_units()
556
336
        u.add_rmq_test_user(sentry_units)
557
337
        u.configure_rmq_ssl_off(sentry_units, self.d)
558
338
559
339
        # Check amqp connection for all units, expect connections to succeed
560
340
        for unit in sentry_units:
561
341
            connection = u.connect_amqp_by_unit(unit, ssl=False, fatal=False)
562
342
            connection.close()
563
343
564
344
        u.delete_rmq_test_user(sentry_units)
565
345
        u.log.info('OK\n')
566
346
567
347
    def test_404_rmq_ssl_connect_with_ssl_off(self):
568
348
        """Verify unsuccessful ssl amqp connection to all units when
569
349
        charm config option for ssl is set False."""
570
350
        u.log.debug('Confirming that ssl connection fails when ssl '
571
351
                    'config is off...')
572
352
        sentry_units = self._get_rmq_sentry_units()
573
353
        u.add_rmq_test_user(sentry_units)
574
354
        u.configure_rmq_ssl_off(sentry_units, self.d)
575
355
576
356
        # Check ssl amqp connection for all units, expect connections to fail
577
357
        for unit in sentry_units:
578
358
            connection = u.connect_amqp_by_unit(unit, ssl=True,
579
359
                                                port=5971, fatal=False)
580
360
            if connection:
581
361
                connection.close()
582
362
                msg = 'SSL connection unexpectedly succeeded with ssl=off'
583
363
                amulet.raise_status(amulet.FAIL, msg)
584
364
585
365
        u.delete_rmq_test_user(sentry_units)
586
366
        u.log.info('OK - Confirmed that ssl connection attempt fails '
587
367
                   'when ssl config is off.')
588
368
589
369
    def test_406_rmq_amqp_messages_all_units_ssl_off(self):
590
370
        """Send amqp messages to every rmq unit and check every rmq unit
591
371
        for messages.  Standard amqp tcp port, no ssl."""
592
372
        u.log.debug('Checking amqp message publish/get on all units '
593
373
                    '(ssl off)...')
594
374
595
375
        sentry_units = self._get_rmq_sentry_units()
596
376
        self._test_rmq_amqp_messages_all_units(sentry_units, ssl=False)
597
377
        u.log.info('OK\n')
598
378
599
379
    def test_408_rmq_amqp_messages_all_units_ssl_on(self):
600
380
        """Send amqp messages with ssl enabled, to every rmq unit and
601
381
        check every rmq unit for messages.  Standard ssl tcp port."""
602
382
        u.log.debug('Checking amqp message publish/get on all units '
603
383
                    '(ssl on)...')
604
384
605
385
        sentry_units = self._get_rmq_sentry_units()
606
386
        self._test_rmq_amqp_messages_all_units(sentry_units,
607
387
                                               ssl=True, port=5671)
608
388
        u.log.info('OK\n')
609
389
610
390
    def test_410_rmq_amqp_messages_all_units_ssl_alt_port(self):
611
391
        """Send amqp messages with ssl on, to every rmq unit and check
612
392
        every rmq unit for messages.  Custom ssl tcp port."""
613
393
        u.log.debug('Checking amqp message publish/get on all units '
614
394
                    '(ssl on)...')
615
395
616
396
        sentry_units = self._get_rmq_sentry_units()
617
397
        self._test_rmq_amqp_messages_all_units(sentry_units,
618
398
                                               ssl=True, port=5999)
619
399
        u.log.info('OK\n')
620
400
621
401
    def test_412_rmq_management_plugin(self):
622
402
        """Enable and check management plugin."""
623
403
        u.log.debug('Checking tcp socket connect to management plugin '
624
404
                    'port on all rmq units...')
625
405
626
406
        sentry_units = self._get_rmq_sentry_units()
627
407
        mgmt_port = 15672
628
408
629
409
        # Enable management plugin
630
410
        u.log.debug('Enabling management_plugin charm config option...')
631
411
        config = {'management_plugin': 'True'}
632
412
        self.d.configure('rabbitmq-server', config)
633
413
634
414
        # Check tcp connect to management plugin port
635
415
        max_wait = 120
636
416
        tries = 0
637
417
        ret = u.port_knock_units(sentry_units, mgmt_port)
638
418
        while ret and tries < (max_wait / 12):
639
419
            time.sleep(12)
640
420
            u.log.debug('Attempt {}: {}'.format(tries, ret))
641
421
            ret = u.port_knock_units(sentry_units, mgmt_port)
642
422
            tries += 1
643
423
644
424
        if ret:
645
425
            amulet.raise_status(amulet.FAIL, ret)
646
426
        else:
647
427
            u.log.debug('Connect to all units (OK)\n')
648
428
649
429
        # Disable management plugin
650
430
        u.log.debug('Disabling management_plugin charm config option...')
651
431
        config = {'management_plugin': 'False'}
652
432
        self.d.configure('rabbitmq-server', config)
653
433
654
434
        # Negative check - tcp connect to management plugin port
655
435
        u.log.info('Expect tcp connect fail since charm config '
656
436
                   'option is disabled.')
657
437
        tries = 0
658
438
        ret = u.port_knock_units(sentry_units, mgmt_port, expect_success=False)
659
439
        while ret and tries < (max_wait / 12):
660
440
            time.sleep(12)
661
441
            u.log.debug('Attempt {}: {}'.format(tries, ret))
662
442
            ret = u.port_knock_units(sentry_units, mgmt_port,
663
443
                                     expect_success=False)
664
444
            tries += 1
665
445
666
446
        if ret:
667
447
            amulet.raise_status(amulet.FAIL, ret)
668
448
        else:
669
449
            u.log.info('Confirm mgmt port closed on all units (OK)\n')
670
450
671
451
    def test_414_rmq_nrpe_monitors(self):
672
452
        """Check rabbimq-server nrpe monitor basic functionality."""
673
453
        sentry_units = self._get_rmq_sentry_units()
674
454
        host_names = u.get_unit_hostnames(sentry_units)
675
455
676
456
        # check_rabbitmq monitor
677
457
        u.log.debug('Checking nrpe check_rabbitmq on units...')
678
458
        cmds = ['egrep -oh /usr/local.* /etc/nagios/nrpe.d/'
679
459
                'check_rabbitmq.cfg']
680
460
        ret = u.check_commands_on_units(cmds, sentry_units)
681
461
        if ret:
682
462
            amulet.raise_status(amulet.FAIL, msg=ret)
683
463
684
464
        u.log.debug('Sleeping 70s for 1m cron job to run...')
685
465
        time.sleep(70)
686
466
687
467
        # check_rabbitmq_queue monitor
688
468
        u.log.debug('Checking nrpe check_rabbitmq_queue on units...')
689
469
        cmds = ['egrep -oh /usr/local.* /etc/nagios/nrpe.d/'
690
470
                'check_rabbitmq_queue.cfg']
691
471
        ret = u.check_commands_on_units(cmds, sentry_units)
692
472
        if ret:
693
473
            amulet.raise_status(amulet.FAIL, msg=ret)
694
474
695
475
        # check dat file existence
696
476
        u.log.debug('Checking nrpe dat file existence on units...')
697
477
        for sentry_unit in sentry_units:
698
478
            unit_name = sentry_unit.info['unit_name']
699
479
            unit_host_name = host_names[unit_name]
700
480
701
481
            cmds = [
702
482
                'stat /var/lib/rabbitmq/data/{}_general_stats.dat'.format(
703
483
                    unit_host_name),
704
484
                'stat /var/lib/rabbitmq/data/{}_queue_stats.dat'.format(
705
485
                    unit_host_name)
706
486
            ]
707
487
708
488
            ret = u.check_commands_on_units(cmds, [sentry_unit])
709
489
            if ret:
710
490
                amulet.raise_status(amulet.FAIL, msg=ret)
711
491
712
492
        u.log.info('OK\n')
713
0
493
714
=== added directory 'tests/charmhelpers'
715
=== removed directory 'tests/charmhelpers'
716
=== added file 'tests/charmhelpers/__init__.py'
717
--- tests/charmhelpers/__init__.py	1970-01-01 00:00:00 +0000
718
+++ tests/charmhelpers/__init__.py	2015-09-01 02:46:36 +0000
719
@@ -0,0 +1,38 @@
720
1
# Copyright 2014-2015 Canonical Limited.
721
2
#
722
3
# This file is part of charm-helpers.
723
4
#
724
5
# charm-helpers is free software: you can redistribute it and/or modify
725
6
# it under the terms of the GNU Lesser General Public License version 3 as
726
7
# published by the Free Software Foundation.
727
8
#
728
9
# charm-helpers is distributed in the hope that it will be useful,
729
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
730
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
731
12
# GNU Lesser General Public License for more details.
732
13
#
733
14
# You should have received a copy of the GNU Lesser General Public License
734
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
735
16
736
17
# Bootstrap charm-helpers, installing its dependencies if necessary using
737
18
# only standard libraries.
738
19
import subprocess
739
20
import sys
740
21
741
22
try:
742
23
    import six  # flake8: noqa
743
24
except ImportError:
744
25
    if sys.version_info.major == 2:
745
26
        subprocess.check_call(['apt-get', 'install', '-y', 'python-six'])
746
27
    else:
747
28
        subprocess.check_call(['apt-get', 'install', '-y', 'python3-six'])
748
29
    import six  # flake8: noqa
749
30
750
31
try:
751
32
    import yaml  # flake8: noqa
752
33
except ImportError:
753
34
    if sys.version_info.major == 2:
754
35
        subprocess.check_call(['apt-get', 'install', '-y', 'python-yaml'])
755
36
    else:
756
37
        subprocess.check_call(['apt-get', 'install', '-y', 'python3-yaml'])
757
38
    import yaml  # flake8: noqa
758
0
39
759
=== removed file 'tests/charmhelpers/__init__.py'
760
--- tests/charmhelpers/__init__.py	2015-04-13 22:11:34 +0000
761
+++ tests/charmhelpers/__init__.py	1970-01-01 00:00:00 +0000
762
@@ -1,38 +0,0 @@
763
1
# Copyright 2014-2015 Canonical Limited.
764
2
#
765
3
# This file is part of charm-helpers.
766
4
#
767
5
# charm-helpers is free software: you can redistribute it and/or modify
768
6
# it under the terms of the GNU Lesser General Public License version 3 as
769
7
# published by the Free Software Foundation.
770
8
#
771
9
# charm-helpers is distributed in the hope that it will be useful,
772
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
773
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
774
12
# GNU Lesser General Public License for more details.
775
13
#
776
14
# You should have received a copy of the GNU Lesser General Public License
777
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
778
16
779
17
# Bootstrap charm-helpers, installing its dependencies if necessary using
780
18
# only standard libraries.
781
19
import subprocess
782
20
import sys
783
21
784
22
try:
785
23
    import six  # flake8: noqa
786
24
except ImportError:
787
25
    if sys.version_info.major == 2:
788
26
        subprocess.check_call(['apt-get', 'install', '-y', 'python-six'])
789
27
    else:
790
28
        subprocess.check_call(['apt-get', 'install', '-y', 'python3-six'])
791
29
    import six  # flake8: noqa
792
30
793
31
try:
794
32
    import yaml  # flake8: noqa
795
33
except ImportError:
796
34
    if sys.version_info.major == 2:
797
35
        subprocess.check_call(['apt-get', 'install', '-y', 'python-yaml'])
798
36
    else:
799
37
        subprocess.check_call(['apt-get', 'install', '-y', 'python3-yaml'])
800
38
    import yaml  # flake8: noqa
801
39
0
802
=== removed directory 'tests/charmhelpers/cli'
803
=== removed file 'tests/charmhelpers/cli/__init__.py'
804
--- tests/charmhelpers/cli/__init__.py	2015-08-19 13:49:53 +0000
805
+++ tests/charmhelpers/cli/__init__.py	1970-01-01 00:00:00 +0000
806
@@ -1,191 +0,0 @@
807
1
# Copyright 2014-2015 Canonical Limited.
808
2
#
809
3
# This file is part of charm-helpers.
810
4
#
811
5
# charm-helpers is free software: you can redistribute it and/or modify
812
6
# it under the terms of the GNU Lesser General Public License version 3 as
813
7
# published by the Free Software Foundation.
814
8
#
815
9
# charm-helpers is distributed in the hope that it will be useful,
816
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
817
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
818
12
# GNU Lesser General Public License for more details.
819
13
#
820
14
# You should have received a copy of the GNU Lesser General Public License
821
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
822
16
823
17
import inspect
824
18
import argparse
825
19
import sys
826
20
827
21
from six.moves import zip
828
22
829
23
from charmhelpers.core import unitdata
830
24
831
25
832
26
class OutputFormatter(object):
833
27
    def __init__(self, outfile=sys.stdout):
834
28
        self.formats = (
835
29
            "raw",
836
30
            "json",
837
31
            "py",
838
32
            "yaml",
839
33
            "csv",
840
34
            "tab",
841
35
        )
842
36
        self.outfile = outfile
843
37
844
38
    def add_arguments(self, argument_parser):
845
39
        formatgroup = argument_parser.add_mutually_exclusive_group()
846
40
        choices = self.supported_formats
847
41
        formatgroup.add_argument("--format", metavar='FMT',
848
42
                                 help="Select output format for returned data, "
849
43
                                      "where FMT is one of: {}".format(choices),
850
44
                                 choices=choices, default='raw')
851
45
        for fmt in self.formats:
852
46
            fmtfunc = getattr(self, fmt)
853
47
            formatgroup.add_argument("-{}".format(fmt[0]),
854
48
                                     "--{}".format(fmt), action='store_const',
855
49
                                     const=fmt, dest='format',
856
50
                                     help=fmtfunc.__doc__)
857
51
858
52
    @property
859
53
    def supported_formats(self):
860
54
        return self.formats
861
55
862
56
    def raw(self, output):
863
57
        """Output data as raw string (default)"""
864
58
        if isinstance(output, (list, tuple)):
865
59
            output = '\n'.join(map(str, output))
866
60
        self.outfile.write(str(output))
867
61
868
62
    def py(self, output):
869
63
        """Output data as a nicely-formatted python data structure"""
870
64
        import pprint
871
65
        pprint.pprint(output, stream=self.outfile)
872
66
873
67
    def json(self, output):
874
68
        """Output data in JSON format"""
875
69
        import json
876
70
        json.dump(output, self.outfile)
877
71
878
72
    def yaml(self, output):
879
73
        """Output data in YAML format"""
880
74
        import yaml
881
75
        yaml.safe_dump(output, self.outfile)
882
76
883
77
    def csv(self, output):
884
78
        """Output data as excel-compatible CSV"""
885
79
        import csv
886
80
        csvwriter = csv.writer(self.outfile)
887
81
        csvwriter.writerows(output)
888
82
889
83
    def tab(self, output):
890
84
        """Output data in excel-compatible tab-delimited format"""
891
85
        import csv
892
86
        csvwriter = csv.writer(self.outfile, dialect=csv.excel_tab)
893
87
        csvwriter.writerows(output)
894
88
895
89
    def format_output(self, output, fmt='raw'):
896
90
        fmtfunc = getattr(self, fmt)
897
91
        fmtfunc(output)
898
92
899
93
900
94
class CommandLine(object):
901
95
    argument_parser = None
902
96
    subparsers = None
903
97
    formatter = None
904
98
    exit_code = 0
905
99
906
100
    def __init__(self):
907
101
        if not self.argument_parser:
908
102
            self.argument_parser = argparse.ArgumentParser(description='Perform common charm tasks')
909
103
        if not self.formatter:
910
104
            self.formatter = OutputFormatter()
911
105
            self.formatter.add_arguments(self.argument_parser)
912
106
        if not self.subparsers:
913
107
            self.subparsers = self.argument_parser.add_subparsers(help='Commands')
914
108
915
109
    def subcommand(self, command_name=None):
916
110
        """
917
111
        Decorate a function as a subcommand. Use its arguments as the
918
112
        command-line arguments"""
919
113
        def wrapper(decorated):
920
114
            cmd_name = command_name or decorated.__name__
921
115
            subparser = self.subparsers.add_parser(cmd_name,
922
116
                                                   description=decorated.__doc__)
923
117
            for args, kwargs in describe_arguments(decorated):
924
118
                subparser.add_argument(*args, **kwargs)
925
119
            subparser.set_defaults(func=decorated)
926
120
            return decorated
927
121
        return wrapper
928
122
929
123
    def test_command(self, decorated):
930
124
        """
931
125
        Subcommand is a boolean test function, so bool return values should be
932
126
        converted to a 0/1 exit code.
933
127
        """
934
128
        decorated._cli_test_command = True
935
129
        return decorated
936
130
937
131
    def no_output(self, decorated):
938
132
        """
939
133
        Subcommand is not expected to return a value, so don't print a spurious None.
940
134
        """
941
135
        decorated._cli_no_output = True
942
136
        return decorated
943
137
944
138
    def subcommand_builder(self, command_name, description=None):
945
139
        """
946
140
        Decorate a function that builds a subcommand. Builders should accept a
947
141
        single argument (the subparser instance) and return the function to be
948
142
        run as the command."""
949
143
        def wrapper(decorated):
950
144
            subparser = self.subparsers.add_parser(command_name)
951
145
            func = decorated(subparser)
952
146
            subparser.set_defaults(func=func)
953
147
            subparser.description = description or func.__doc__
954
148
        return wrapper
955
149
956
150
    def run(self):
957
151
        "Run cli, processing arguments and executing subcommands."
958
152
        arguments = self.argument_parser.parse_args()
959
153
        argspec = inspect.getargspec(arguments.func)
960
154
        vargs = []
961
155
        for arg in argspec.args:
962
156
            vargs.append(getattr(arguments, arg))
963
157
        if argspec.varargs:
964
158
            vargs.extend(getattr(arguments, argspec.varargs))
965
159
        output = arguments.func(*vargs)
966
160
        if getattr(arguments.func, '_cli_test_command', False):
967
161
            self.exit_code = 0 if output else 1
968
162
            output = ''
969
163
        if getattr(arguments.func, '_cli_no_output', False):
970
164
            output = ''
971
165
        self.formatter.format_output(output, arguments.format)
972
166
        if unitdata._KV:
973
167
            unitdata._KV.flush()
974
168
975
169
976
170
cmdline = CommandLine()
977
171
978
172
979
173
def describe_arguments(func):
980
174
    """
981
175
    Analyze a function's signature and return a data structure suitable for
982
176
    passing in as arguments to an argparse parser's add_argument() method."""
983
177
984
178
    argspec = inspect.getargspec(func)
985
179
    # we should probably raise an exception somewhere if func includes **kwargs
986
180
    if argspec.defaults:
987
181
        positional_args = argspec.args[:-len(argspec.defaults)]
988
182
        keyword_names = argspec.args[-len(argspec.defaults):]
989
183
        for arg, default in zip(keyword_names, argspec.defaults):
990
184
            yield ('--{}'.format(arg),), {'default': default}
991
185
    else:
992
186
        positional_args = argspec.args
993
187
994
188
    for arg in positional_args:
995
189
        yield (arg,), {}
996
190
    if argspec.varargs:
997
191
        yield (argspec.varargs,), {'nargs': '*'}
998
192
0
999
=== removed file 'tests/charmhelpers/cli/benchmark.py'
1000
--- tests/charmhelpers/cli/benchmark.py	2015-07-31 22:00:49 +0000
1001
+++ tests/charmhelpers/cli/benchmark.py	1970-01-01 00:00:00 +0000
1002
@@ -1,36 +0,0 @@
1003
1
# Copyright 2014-2015 Canonical Limited.
1004
2
#
1005
3
# This file is part of charm-helpers.
1006
4
#
1007
5
# charm-helpers is free software: you can redistribute it and/or modify
1008
6
# it under the terms of the GNU Lesser General Public License version 3 as
1009
7
# published by the Free Software Foundation.
1010
8
#
1011
9
# charm-helpers is distributed in the hope that it will be useful,
1012
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1013
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1014
12
# GNU Lesser General Public License for more details.
1015
13
#
1016
14
# You should have received a copy of the GNU Lesser General Public License
1017
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1018
16
1019
17
from . import cmdline
1020
18
from charmhelpers.contrib.benchmark import Benchmark
1021
19
1022
20
1023
21
@cmdline.subcommand(command_name='benchmark-start')
1024
22
def start():
1025
23
    Benchmark.start()
1026
24
1027
25
1028
26
@cmdline.subcommand(command_name='benchmark-finish')
1029
27
def finish():
1030
28
    Benchmark.finish()
1031
29
1032
30
1033
31
@cmdline.subcommand_builder('benchmark-composite', description="Set the benchmark composite score")
1034
32
def service(subparser):
1035
33
    subparser.add_argument("value", help="The composite score.")
1036
34
    subparser.add_argument("units", help="The units the composite score represents, i.e., 'reads/sec'.")
1037
35
    subparser.add_argument("direction", help="'asc' if a lower score is better, 'desc' if a higher score is better.")
1038
36
    return Benchmark.set_composite_score
1039
37
0
1040
=== removed file 'tests/charmhelpers/cli/commands.py'
1041
--- tests/charmhelpers/cli/commands.py	2015-08-19 13:49:53 +0000
1042
+++ tests/charmhelpers/cli/commands.py	1970-01-01 00:00:00 +0000
1043
@@ -1,32 +0,0 @@
1044
1
# Copyright 2014-2015 Canonical Limited.
1045
2
#
1046
3
# This file is part of charm-helpers.
1047
4
#
1048
5
# charm-helpers is free software: you can redistribute it and/or modify
1049
6
# it under the terms of the GNU Lesser General Public License version 3 as
1050
7
# published by the Free Software Foundation.
1051
8
#
1052
9
# charm-helpers is distributed in the hope that it will be useful,
1053
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1054
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1055
12
# GNU Lesser General Public License for more details.
1056
13
#
1057
14
# You should have received a copy of the GNU Lesser General Public License
1058
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1059
16
1060
17
"""
1061
18
This module loads sub-modules into the python runtime so they can be
1062
19
discovered via the inspect module. In order to prevent flake8 from (rightfully)
1063
20
telling us these are unused modules, throw a ' # noqa' at the end of each import
1064
21
so that the warning is suppressed.
1065
22
"""
1066
23
1067
24
from . import CommandLine  # noqa
1068
25
1069
26
"""
1070
27
Import the sub-modules which have decorated subcommands to register with chlp.
1071
28
"""
1072
29
from . import host  # noqa
1073
30
from . import benchmark  # noqa
1074
31
from . import unitdata  # noqa
1075
32
from . import hookenv  # noqa
1076
33
0
1077
=== removed file 'tests/charmhelpers/cli/hookenv.py'
1078
--- tests/charmhelpers/cli/hookenv.py	2015-08-19 13:49:53 +0000
1079
+++ tests/charmhelpers/cli/hookenv.py	1970-01-01 00:00:00 +0000
1080
@@ -1,23 +0,0 @@
1081
1
# Copyright 2014-2015 Canonical Limited.
1082
2
#
1083
3
# This file is part of charm-helpers.
1084
4
#
1085
5
# charm-helpers is free software: you can redistribute it and/or modify
1086
6
# it under the terms of the GNU Lesser General Public License version 3 as
1087
7
# published by the Free Software Foundation.
1088
8
#
1089
9
# charm-helpers is distributed in the hope that it will be useful,
1090
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1091
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1092
12
# GNU Lesser General Public License for more details.
1093
13
#
1094
14
# You should have received a copy of the GNU Lesser General Public License
1095
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1096
16
1097
17
from . import cmdline
1098
18
from charmhelpers.core import hookenv
1099
19
1100
20
1101
21
cmdline.subcommand('relation-id')(hookenv.relation_id._wrapped)
1102
22
cmdline.subcommand('service-name')(hookenv.service_name)
1103
23
cmdline.subcommand('remote-service-name')(hookenv.remote_service_name._wrapped)
1104
24
0
1105
=== removed file 'tests/charmhelpers/cli/host.py'
1106
--- tests/charmhelpers/cli/host.py	2015-07-31 22:00:49 +0000
1107
+++ tests/charmhelpers/cli/host.py	1970-01-01 00:00:00 +0000
1108
@@ -1,31 +0,0 @@
1109
1
# Copyright 2014-2015 Canonical Limited.
1110
2
#
1111
3
# This file is part of charm-helpers.
1112
4
#
1113
5
# charm-helpers is free software: you can redistribute it and/or modify
1114
6
# it under the terms of the GNU Lesser General Public License version 3 as
1115
7
# published by the Free Software Foundation.
1116
8
#
1117
9
# charm-helpers is distributed in the hope that it will be useful,
1118
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1119
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1120
12
# GNU Lesser General Public License for more details.
1121
13
#
1122
14
# You should have received a copy of the GNU Lesser General Public License
1123
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1124
16
1125
17
from . import cmdline
1126
18
from charmhelpers.core import host
1127
19
1128
20
1129
21
@cmdline.subcommand()
1130
22
def mounts():
1131
23
    "List mounts"
1132
24
    return host.mounts()
1133
25
1134
26
1135
27
@cmdline.subcommand_builder('service', description="Control system services")
1136
28
def service(subparser):
1137
29
    subparser.add_argument("action", help="The action to perform (start, stop, etc...)")
1138
30
    subparser.add_argument("service_name", help="Name of the service to control")
1139
31
    return host.service
1140
32
0
1141
=== removed file 'tests/charmhelpers/cli/unitdata.py'
1142
--- tests/charmhelpers/cli/unitdata.py	2015-07-31 22:00:49 +0000
1143
+++ tests/charmhelpers/cli/unitdata.py	1970-01-01 00:00:00 +0000
1144
@@ -1,39 +0,0 @@
1145
1
# Copyright 2014-2015 Canonical Limited.
1146
2
#
1147
3
# This file is part of charm-helpers.
1148
4
#
1149
5
# charm-helpers is free software: you can redistribute it and/or modify
1150
6
# it under the terms of the GNU Lesser General Public License version 3 as
1151
7
# published by the Free Software Foundation.
1152
8
#
1153
9
# charm-helpers is distributed in the hope that it will be useful,
1154
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1155
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1156
12
# GNU Lesser General Public License for more details.
1157
13
#
1158
14
# You should have received a copy of the GNU Lesser General Public License
1159
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1160
16
1161
17
from . import cmdline
1162
18
from charmhelpers.core import unitdata
1163
19
1164
20
1165
21
@cmdline.subcommand_builder('unitdata', description="Store and retrieve data")
1166
22
def unitdata_cmd(subparser):
1167
23
    nested = subparser.add_subparsers()
1168
24
    get_cmd = nested.add_parser('get', help='Retrieve data')
1169
25
    get_cmd.add_argument('key', help='Key to retrieve the value of')
1170
26
    get_cmd.set_defaults(action='get', value=None)
1171
27
    set_cmd = nested.add_parser('set', help='Store data')
1172
28
    set_cmd.add_argument('key', help='Key to set')
1173
29
    set_cmd.add_argument('value', help='Value to store')
1174
30
    set_cmd.set_defaults(action='set')
1175
31
1176
32
    def _unitdata_cmd(action, key, value):
1177
33
        if action == 'get':
1178
34
            return unitdata.kv().get(key)
1179
35
        elif action == 'set':
1180
36
            unitdata.kv().set(key, value)
1181
37
            unitdata.kv().flush()
1182
38
            return ''
1183
39
    return _unitdata_cmd
1184
40
0
1185
=== added directory 'tests/charmhelpers/contrib'
1186
=== removed directory 'tests/charmhelpers/contrib'
1187
=== added file 'tests/charmhelpers/contrib/__init__.py'
1188
--- tests/charmhelpers/contrib/__init__.py	1970-01-01 00:00:00 +0000
1189
+++ tests/charmhelpers/contrib/__init__.py	2015-09-01 02:46:36 +0000
1190
@@ -0,0 +1,15 @@
1191
1
# Copyright 2014-2015 Canonical Limited.
1192
2
#
1193
3
# This file is part of charm-helpers.
1194
4
#
1195
5
# charm-helpers is free software: you can redistribute it and/or modify
1196
6
# it under the terms of the GNU Lesser General Public License version 3 as
1197
7
# published by the Free Software Foundation.
1198
8
#
1199
9
# charm-helpers is distributed in the hope that it will be useful,
1200
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1201
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1202
12
# GNU Lesser General Public License for more details.
1203
13
#
1204
14
# You should have received a copy of the GNU Lesser General Public License
1205
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1206
0
16
1207
=== removed file 'tests/charmhelpers/contrib/__init__.py'
1208
--- tests/charmhelpers/contrib/__init__.py	2015-04-13 22:11:34 +0000
1209
+++ tests/charmhelpers/contrib/__init__.py	1970-01-01 00:00:00 +0000
1210
@@ -1,15 +0,0 @@
1211
1
# Copyright 2014-2015 Canonical Limited.
1212
2
#
1213
3
# This file is part of charm-helpers.
1214
4
#
1215
5
# charm-helpers is free software: you can redistribute it and/or modify
1216
6
# it under the terms of the GNU Lesser General Public License version 3 as
1217
7
# published by the Free Software Foundation.
1218
8
#
1219
9
# charm-helpers is distributed in the hope that it will be useful,
1220
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1221
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1222
12
# GNU Lesser General Public License for more details.
1223
13
#
1224
14
# You should have received a copy of the GNU Lesser General Public License
1225
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1226
16
0
1227
=== added directory 'tests/charmhelpers/contrib/amulet'
1228
=== added file 'tests/charmhelpers/contrib/amulet/__init__.py'
1229
--- tests/charmhelpers/contrib/amulet/__init__.py	1970-01-01 00:00:00 +0000
1230
+++ tests/charmhelpers/contrib/amulet/__init__.py	2015-09-01 02:46:36 +0000
1231
@@ -0,0 +1,15 @@
1232
1
# Copyright 2014-2015 Canonical Limited.
1233
2
#
1234
3
# This file is part of charm-helpers.
1235
4
#
1236
5
# charm-helpers is free software: you can redistribute it and/or modify
1237
6
# it under the terms of the GNU Lesser General Public License version 3 as
1238
7
# published by the Free Software Foundation.
1239
8
#
1240
9
# charm-helpers is distributed in the hope that it will be useful,
1241
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1242
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1243
12
# GNU Lesser General Public License for more details.
1244
13
#
1245
14
# You should have received a copy of the GNU Lesser General Public License
1246
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1247
0
16
1248
=== added file 'tests/charmhelpers/contrib/amulet/deployment.py'
1249
--- tests/charmhelpers/contrib/amulet/deployment.py	1970-01-01 00:00:00 +0000
1250
+++ tests/charmhelpers/contrib/amulet/deployment.py	2015-09-01 02:46:36 +0000
1251
@@ -0,0 +1,93 @@
1252
1
# Copyright 2014-2015 Canonical Limited.
1253
2
#
1254
3
# This file is part of charm-helpers.
1255
4
#
1256
5
# charm-helpers is free software: you can redistribute it and/or modify
1257
6
# it under the terms of the GNU Lesser General Public License version 3 as
1258
7
# published by the Free Software Foundation.
1259
8
#
1260
9
# charm-helpers is distributed in the hope that it will be useful,
1261
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1262
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1263
12
# GNU Lesser General Public License for more details.
1264
13
#
1265
14
# You should have received a copy of the GNU Lesser General Public License
1266
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1267
16
1268
17
import amulet
1269
18
import os
1270
19
import six
1271
20
1272
21
1273
22
class AmuletDeployment(object):
1274
23
    """Amulet deployment.
1275
24
1276
25
       This class provides generic Amulet deployment and test runner
1277
26
       methods.
1278
27
       """
1279
28
1280
29
    def __init__(self, series=None):
1281
30
        """Initialize the deployment environment."""
1282
31
        self.series = None
1283
32
1284
33
        if series:
1285
34
            self.series = series
1286
35
            self.d = amulet.Deployment(series=self.series)
1287
36
        else:
1288
37
            self.d = amulet.Deployment()
1289
38
1290
39
    def _add_services(self, this_service, other_services):
1291
40
        """Add services.
1292
41
1293
42
           Add services to the deployment where this_service is the local charm
1294
43
           that we're testing and other_services are the other services that
1295
44
           are being used in the local amulet tests.
1296
45
           """
1297
46
        if this_service['name'] != os.path.basename(os.getcwd()):
1298
47
            s = this_service['name']
1299
48
            msg = "The charm's root directory name needs to be {}".format(s)
1300
49
            amulet.raise_status(amulet.FAIL, msg=msg)
1301
50
1302
51
        if 'units' not in this_service:
1303
52
            this_service['units'] = 1
1304
53
1305
54
        self.d.add(this_service['name'], units=this_service['units'])
1306
55
1307
56
        for svc in other_services:
1308
57
            if 'location' in svc:
1309
58
                branch_location = svc['location']
1310
59
            elif self.series:
1311
60
                branch_location = 'cs:{}/{}'.format(self.series, svc['name']),
1312
61
            else:
1313
62
                branch_location = None
1314
63
1315
64
            if 'units' not in svc:
1316
65
                svc['units'] = 1
1317
66
1318
67
            self.d.add(svc['name'], charm=branch_location, units=svc['units'])
1319
68
1320
69
    def _add_relations(self, relations):
1321
70
        """Add all of the relations for the services."""
1322
71
        for k, v in six.iteritems(relations):
1323
72
            self.d.relate(k, v)
1324
73
1325
74
    def _configure_services(self, configs):
1326
75
        """Configure all of the services."""
1327
76
        for service, config in six.iteritems(configs):
1328
77
            self.d.configure(service, config)
1329
78
1330
79
    def _deploy(self):
1331
80
        """Deploy environment and wait for all hooks to finish executing."""
1332
81
        try:
1333
82
            self.d.setup(timeout=900)
1334
83
            self.d.sentry.wait(timeout=900)
1335
84
        except amulet.helpers.TimeoutError:
1336
85
            amulet.raise_status(amulet.FAIL, msg="Deployment timed out")
1337
86
        except Exception:
1338
87
            raise
1339
88
1340
89
    def run_tests(self):
1341
90
        """Run all of the methods that are prefixed with 'test_'."""
1342
91
        for test in dir(self):
1343
92
            if test.startswith('test_'):
1344
93
                getattr(self, test)()
1345
0
94
1346
=== added file 'tests/charmhelpers/contrib/amulet/utils.py'
1347
--- tests/charmhelpers/contrib/amulet/utils.py	1970-01-01 00:00:00 +0000
1348
+++ tests/charmhelpers/contrib/amulet/utils.py	2015-09-01 02:46:36 +0000
1349
@@ -0,0 +1,771 @@
1350
1
# Copyright 2014-2015 Canonical Limited.
1351
2
#
1352
3
# This file is part of charm-helpers.
1353
4
#
1354
5
# charm-helpers is free software: you can redistribute it and/or modify
1355
6
# it under the terms of the GNU Lesser General Public License version 3 as
1356
7
# published by the Free Software Foundation.
1357
8
#
1358
9
# charm-helpers is distributed in the hope that it will be useful,
1359
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1360
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1361
12
# GNU Lesser General Public License for more details.
1362
13
#
1363
14
# You should have received a copy of the GNU Lesser General Public License
1364
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1365
16
1366
17
import io
1367
18
import json
1368
19
import logging
1369
20
import os
1370
21
import re
1371
22
import socket
1372
23
import subprocess
1373
24
import sys
1374
25
import time
1375
26
import uuid
1376
27
1377
28
import amulet
1378
29
import distro_info
1379
30
import six
1380
31
from six.moves import configparser
1381
32
if six.PY3:
1382
33
    from urllib import parse as urlparse
1383
34
else:
1384
35
    import urlparse
1385
36
1386
37
1387
38
class AmuletUtils(object):
1388
39
    """Amulet utilities.
1389
40
1390
41
       This class provides common utility functions that are used by Amulet
1391
42
       tests.
1392
43
       """
1393
44
1394
45
    def __init__(self, log_level=logging.ERROR):
1395
46
        self.log = self.get_logger(level=log_level)
1396
47
        self.ubuntu_releases = self.get_ubuntu_releases()
1397
48
1398
49
    def get_logger(self, name="amulet-logger", level=logging.DEBUG):
1399
50
        """Get a logger object that will log to stdout."""
1400
51
        log = logging
1401
52
        logger = log.getLogger(name)
1402
53
        fmt = log.Formatter("%(asctime)s %(funcName)s "
1403
54
                            "%(levelname)s: %(message)s")
1404
55
1405
56
        handler = log.StreamHandler(stream=sys.stdout)
1406
57
        handler.setLevel(level)
1407
58
        handler.setFormatter(fmt)
1408
59
1409
60
        logger.addHandler(handler)
1410
61
        logger.setLevel(level)
1411
62
1412
63
        return logger
1413
64
1414
65
    def valid_ip(self, ip):
1415
66
        if re.match(r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$", ip):
1416
67
            return True
1417
68
        else:
1418
69
            return False
1419
70
1420
71
    def valid_url(self, url):
1421
72
        p = re.compile(
1422
73
            r'^(?:http|ftp)s?://'
1423
74
            r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|'  # noqa
1424
75
            r'localhost|'
1425
76
            r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'
1426
77
            r'(?::\d+)?'
1427
78
            r'(?:/?|[/?]\S+)$',
1428
79
            re.IGNORECASE)
1429
80
        if p.match(url):
1430
81
            return True
1431
82
        else:
1432
83
            return False
1433
84
1434
85
    def get_ubuntu_release_from_sentry(self, sentry_unit):
1435
86
        """Get Ubuntu release codename from sentry unit.
1436
87
1437
88
        :param sentry_unit: amulet sentry/service unit pointer
1438
89
        :returns: list of strings - release codename, failure message
1439
90
        """
1440
91
        msg = None
1441
92
        cmd = 'lsb_release -cs'
1442
93
        release, code = sentry_unit.run(cmd)
1443
94
        if code == 0:
1444
95
            self.log.debug('{} lsb_release: {}'.format(
1445
96
                sentry_unit.info['unit_name'], release))
1446
97
        else:
1447
98
            msg = ('{} `{}` returned {} '
1448
99
                   '{}'.format(sentry_unit.info['unit_name'],
1449
100
                               cmd, release, code))
1450
101
        if release not in self.ubuntu_releases:
1451
102
            msg = ("Release ({}) not found in Ubuntu releases "
1452
103
                   "({})".format(release, self.ubuntu_releases))
1453
104
        return release, msg
1454
105
1455
106
    def validate_services(self, commands):
1456
107
        """Validate that lists of commands succeed on service units.  Can be
1457
108
           used to verify system services are running on the corresponding
1458
109
           service units.
1459
110
1460
111
        :param commands: dict with sentry keys and arbitrary command list vals
1461
112
        :returns: None if successful, Failure string message otherwise
1462
113
        """
1463
114
        self.log.debug('Checking status of system services...')
1464
115
1465
116
        # /!\ DEPRECATION WARNING (beisner):
1466
117
        # New and existing tests should be rewritten to use
1467
118
        # validate_services_by_name() as it is aware of init systems.
1468
119
        self.log.warn('/!\\ DEPRECATION WARNING:  use '
1469
120
                      'validate_services_by_name instead of validate_services '
1470
121
                      'due to init system differences.')
1471
122
1472
123
        for k, v in six.iteritems(commands):
1473
124
            for cmd in v:
1474
125
                output, code = k.run(cmd)
1475
126
                self.log.debug('{} `{}` returned '
1476
127
                               '{}'.format(k.info['unit_name'],
1477
128
                                           cmd, code))
1478
129
                if code != 0:
1479
130
                    return "command `{}` returned {}".format(cmd, str(code))
1480
131
        return None
1481
132
1482
133
    def validate_services_by_name(self, sentry_services):
1483
134
        """Validate system service status by service name, automatically
1484
135
           detecting init system based on Ubuntu release codename.
1485
136
1486
137
        :param sentry_services: dict with sentry keys and svc list values
1487
138
        :returns: None if successful, Failure string message otherwise
1488
139
        """
1489
140
        self.log.debug('Checking status of system services...')
1490
141
1491
142
        # Point at which systemd became a thing
1492
143
        systemd_switch = self.ubuntu_releases.index('vivid')
1493
144
1494
145
        for sentry_unit, services_list in six.iteritems(sentry_services):
1495
146
            # Get lsb_release codename from unit
1496
147
            release, ret = self.get_ubuntu_release_from_sentry(sentry_unit)
1497
148
            if ret:
1498
149
                return ret
1499
150
1500
151
            for service_name in services_list:
1501
152
                if (self.ubuntu_releases.index(release) >= systemd_switch or
1502
153
                        service_name in ['rabbitmq-server', 'apache2']):
1503
154
                    # init is systemd (or regular sysv)
1504
155
                    cmd = 'sudo service {} status'.format(service_name)
1505
156
                    output, code = sentry_unit.run(cmd)
1506
157
                    service_running = code == 0
1507
158
                elif self.ubuntu_releases.index(release) < systemd_switch:
1508
159
                    # init is upstart
1509
160
                    cmd = 'sudo status {}'.format(service_name)
1510
161
                    output, code = sentry_unit.run(cmd)
1511
162
                    service_running = code == 0 and "start/running" in output
1512
163
1513
164
                self.log.debug('{} `{}` returned '
1514
165
                               '{}'.format(sentry_unit.info['unit_name'],
1515
166
                                           cmd, code))
1516
167
                if not service_running:
1517
168
                    return u"command `{}` returned {} {}".format(
1518
169
                        cmd, output, str(code))
1519
170
        return None
1520
171
1521
172
    def _get_config(self, unit, filename):
1522
173
        """Get a ConfigParser object for parsing a unit's config file."""
1523
174
        file_contents = unit.file_contents(filename)
1524
175
1525
176
        # NOTE(beisner):  by default, ConfigParser does not handle options
1526
177
        # with no value, such as the flags used in the mysql my.cnf file.
1527
178
        # https://bugs.python.org/issue7005
1528
179
        config = configparser.ConfigParser(allow_no_value=True)
1529
180
        config.readfp(io.StringIO(file_contents))
1530
181
        return config
1531
182
1532
183
    def validate_config_data(self, sentry_unit, config_file, section,
1533
184
                             expected):
1534
185
        """Validate config file data.
1535
186
1536
187
           Verify that the specified section of the config file contains
1537
188
           the expected option key:value pairs.
1538
189
1539
190
           Compare expected dictionary data vs actual dictionary data.
1540
191
           The values in the 'expected' dictionary can be strings, bools, ints,
1541
192
           longs, or can be a function that evaluates a variable and returns a
1542
193
           bool.
1543
194
           """
1544
195
        self.log.debug('Validating config file data ({} in {} on {})'
1545
196
                       '...'.format(section, config_file,
1546
197
                                    sentry_unit.info['unit_name']))
1547
198
        config = self._get_config(sentry_unit, config_file)
1548
199
1549
200
        if section != 'DEFAULT' and not config.has_section(section):
1550
201
            return "section [{}] does not exist".format(section)
1551
202
1552
203
        for k in expected.keys():
1553
204
            if not config.has_option(section, k):
1554
205
                return "section [{}] is missing option {}".format(section, k)
1555
206
1556
207
            actual = config.get(section, k)
1557
208
            v = expected[k]
1558
209
            if (isinstance(v, six.string_types) or
1559
210
                    isinstance(v, bool) or
1560
211
                    isinstance(v, six.integer_types)):
1561
212
                # handle explicit values
1562
213
                if actual != v:
1563
214
                    return "section [{}] {}:{} != expected {}:{}".format(
1564
215
                           section, k, actual, k, expected[k])
1565
216
            # handle function pointers, such as not_null or valid_ip
1566
217
            elif not v(actual):
1567
218
                return "section [{}] {}:{} != expected {}:{}".format(
1568
219
                       section, k, actual, k, expected[k])
1569
220
        return None
1570
221
1571
222
    def _validate_dict_data(self, expected, actual):
1572
223
        """Validate dictionary data.
1573
224
1574
225
           Compare expected dictionary data vs actual dictionary data.
1575
226
           The values in the 'expected' dictionary can be strings, bools, ints,
1576
227
           longs, or can be a function that evaluates a variable and returns a
1577
228
           bool.
1578
229
           """
1579
230
        self.log.debug('actual: {}'.format(repr(actual)))
1580
231
        self.log.debug('expected: {}'.format(repr(expected)))
1581
232
1582
233
        for k, v in six.iteritems(expected):
1583
234
            if k in actual:
1584
235
                if (isinstance(v, six.string_types) or
1585
236
                        isinstance(v, bool) or
1586
237
                        isinstance(v, six.integer_types)):
1587
238
                    # handle explicit values
1588
239
                    if v != actual[k]:
1589
240
                        return "{}:{}".format(k, actual[k])
1590
241
                # handle function pointers, such as not_null or valid_ip
1591
242
                elif not v(actual[k]):
1592
243
                    return "{}:{}".format(k, actual[k])
1593
244
            else:
1594
245
                return "key '{}' does not exist".format(k)
1595
246
        return None
1596
247
1597
248
    def validate_relation_data(self, sentry_unit, relation, expected):
1598
249
        """Validate actual relation data based on expected relation data."""
1599
250
        actual = sentry_unit.relation(relation[0], relation[1])
1600
251
        return self._validate_dict_data(expected, actual)
1601
252
1602
253
    def _validate_list_data(self, expected, actual):
1603
254
        """Compare expected list vs actual list data."""
1604
255
        for e in expected:
1605
256
            if e not in actual:
1606
257
                return "expected item {} not found in actual list".format(e)
1607
258
        return None
1608
259
1609
260
    def not_null(self, string):
1610
261
        if string is not None:
1611
262
            return True
1612
263
        else:
1613
264
            return False
1614
265
1615
266
    def _get_file_mtime(self, sentry_unit, filename):
1616
267
        """Get last modification time of file."""
1617
268
        return sentry_unit.file_stat(filename)['mtime']
1618
269
1619
270
    def _get_dir_mtime(self, sentry_unit, directory):
1620
271
        """Get last modification time of directory."""
1621
272
        return sentry_unit.directory_stat(directory)['mtime']
1622
273
1623
274
    def _get_proc_start_time(self, sentry_unit, service, pgrep_full=False):
1624
275
        """Get process' start time.
1625
276
1626
277
           Determine start time of the process based on the last modification
1627
278
           time of the /proc/pid directory. If pgrep_full is True, the process
1628
279
           name is matched against the full command line.
1629
280
           """
1630
281
        if pgrep_full:
1631
282
            cmd = 'pgrep -o -f {}'.format(service)
1632
283
        else:
1633
284
            cmd = 'pgrep -o {}'.format(service)
1634
285
        cmd = cmd + '  | grep  -v pgrep || exit 0'
1635
286
        cmd_out = sentry_unit.run(cmd)
1636
287
        self.log.debug('CMDout: ' + str(cmd_out))
1637
288
        if cmd_out[0]:
1638
289
            self.log.debug('Pid for %s %s' % (service, str(cmd_out[0])))
1639
290
            proc_dir = '/proc/{}'.format(cmd_out[0].strip())
1640
291
            return self._get_dir_mtime(sentry_unit, proc_dir)
1641
292
1642
293
    def service_restarted(self, sentry_unit, service, filename,
1643
294
                          pgrep_full=None, sleep_time=20):
1644
295
        """Check if service was restarted.
1645
296
1646
297
           Compare a service's start time vs a file's last modification time
1647
298
           (such as a config file for that service) to determine if the service
1648
299
           has been restarted.
1649
300
           """
1650
301
        # /!\ DEPRECATION WARNING (beisner):
1651
302
        # This is prone to races in that no before-time is known.
1652
303
        # Use validate_service_config_changed instead.
1653
304
1654
305
        # NOTE(beisner) pgrep_full is no longer implemented, as pidof is now
1655
306
        # used instead of pgrep.  pgrep_full is still passed through to ensure
1656
307
        # deprecation WARNS.  lp1474030
1657
308
1658
309
        self.log.warn('/!\\ DEPRECATION WARNING:  use '
1659
310
                      'validate_service_config_changed instead of '
1660
311
                      'service_restarted due to known races.')
1661
312
1662
313
        time.sleep(sleep_time)
1663
314
        if (self._get_proc_start_time(sentry_unit, service, pgrep_full) >=
1664
315
                self._get_file_mtime(sentry_unit, filename)):
1665
316
            return True
1666
317
        else:
1667
318
            return False
1668
319
1669
320
    def service_restarted_since(self, sentry_unit, mtime, service,
1670
321
                                pgrep_full=None, sleep_time=20,
1671
322
                                retry_count=2, retry_sleep_time=30):
1672
323
        """Check if service was been started after a given time.
1673
324
1674
325
        Args:
1675
326
          sentry_unit (sentry): The sentry unit to check for the service on
1676
327
          mtime (float): The epoch time to check against
1677
328
          service (string): service name to look for in process table
1678
329
          pgrep_full: No longer implemented, passed for WARNs
1679
330
          sleep_time (int): Seconds to sleep before looking for process
1680
331
          retry_count (int): If service is not found, how many times to retry
1681
332
1682
333
        Returns:
1683
334
          bool: True if service found and its start time it newer than mtime,
1684
335
                False if service is older than mtime or if service was
1685
336
                not found.
1686
337
        """
1687
338
        # NOTE(beisner) pgrep_full is no longer implemented, as pidof is now
1688
339
        # used instead of pgrep.  pgrep_full is still passed through to ensure
1689
340
        # deprecation WARNS.  lp1474030
1690
341
1691
342
        unit_name = sentry_unit.info['unit_name']
1692
343
        self.log.debug('Checking that %s service restarted since %s on '
1693
344
                       '%s' % (service, mtime, unit_name))
1694
345
        time.sleep(sleep_time)
1695
346
        proc_start_time = None
1696
347
        tries = 0
1697
348
        while tries <= retry_count and not proc_start_time:
1698
349
            try:
1699
350
                proc_start_time = self._get_proc_start_time(sentry_unit,
1700
351
                                                            service,
1701
352
                                                            pgrep_full)
1702
353
                self.log.debug('Attempt {} to get {} proc start time on {} '
1703
354
                               'OK'.format(tries, service, unit_name))
1704
355
            except IOError:
1705
356
                # NOTE(beisner) - race avoidance, proc may not exist yet.
1706
357
                # https://bugs.launchpad.net/charm-helpers/+bug/1474030
1707
358
                self.log.debug('Attempt {} to get {} proc start time on {} '
1708
359
                               'failed'.format(tries, service, unit_name))
1709
360
                time.sleep(retry_sleep_time)
1710
361
                tries += 1
1711
362
1712
363
        if not proc_start_time:
1713
364
            self.log.warn('No proc start time found, assuming service did '
1714
365
                          'not start')
1715
366
            return False
1716
367
        if proc_start_time >= mtime:
1717
368
            self.log.debug('Proc start time is newer than provided mtime'
1718
369
                           '(%s >= %s) on %s (OK)' % (proc_start_time,
1719
370
                                                      mtime, unit_name))
1720
371
            return True
1721
372
        else:
1722
373
            self.log.warn('Proc start time (%s) is older than provided mtime '
1723
374
                          '(%s) on %s, service did not '
1724
375
                          'restart' % (proc_start_time, mtime, unit_name))
1725
376
            return False
1726
377
1727
378
    def config_updated_since(self, sentry_unit, filename, mtime,
1728
379
                             sleep_time=20):
1729
380
        """Check if file was modified after a given time.
1730
381
1731
382
        Args:
1732
383
          sentry_unit (sentry): The sentry unit to check the file mtime on
1733
384
          filename (string): The file to check mtime of
1734
385
          mtime (float): The epoch time to check against
1735
386
          sleep_time (int): Seconds to sleep before looking for process
1736
387
1737
388
        Returns:
1738
389
          bool: True if file was modified more recently than mtime, False if
1739
390
                file was modified before mtime,
1740
391
        """
1741
392
        self.log.debug('Checking %s updated since %s' % (filename, mtime))
1742
393
        time.sleep(sleep_time)
1743
394
        file_mtime = self._get_file_mtime(sentry_unit, filename)
1744
395
        if file_mtime >= mtime:
1745
396
            self.log.debug('File mtime is newer than provided mtime '
1746
397
                           '(%s >= %s)' % (file_mtime, mtime))
1747
398
            return True
1748
399
        else:
1749
400
            self.log.warn('File mtime %s is older than provided mtime %s'
1750
401
                          % (file_mtime, mtime))
1751
402
            return False
1752
403
1753
404
    def validate_service_config_changed(self, sentry_unit, mtime, service,
1754
405
                                        filename, pgrep_full=None,
1755
406
                                        sleep_time=20, retry_count=2,
1756
407
                                        retry_sleep_time=30):
1757
408
        """Check service and file were updated after mtime
1758
409
1759
410
        Args:
1760
411
          sentry_unit (sentry): The sentry unit to check for the service on
1761
412
          mtime (float): The epoch time to check against
1762
413
          service (string): service name to look for in process table
1763
414
          filename (string): The file to check mtime of
1764
415
          pgrep_full: No longer implemented, passed for WARNs
1765
416
          sleep_time (int): Initial sleep in seconds to pass to test helpers
1766
417
          retry_count (int): If service is not found, how many times to retry
1767
418
          retry_sleep_time (int): Time in seconds to wait between retries
1768
419
1769
420
        Typical Usage:
1770
421
            u = OpenStackAmuletUtils(ERROR)
1771
422
            ...
1772
423
            mtime = u.get_sentry_time(self.cinder_sentry)
1773
424
            self.d.configure('cinder', {'verbose': 'True', 'debug': 'True'})
1774
425
            if not u.validate_service_config_changed(self.cinder_sentry,
1775
426
                                                     mtime,
1776
427
                                                     'cinder-api',
1777
428
                                                     '/etc/cinder/cinder.conf')
1778
429
                amulet.raise_status(amulet.FAIL, msg='update failed')
1779
430
        Returns:
1780
431
          bool: True if both service and file where updated/restarted after
1781
432
                mtime, False if service is older than mtime or if service was
1782
433
                not found or if filename was modified before mtime.
1783
434
        """
1784
435
1785
436
        # NOTE(beisner) pgrep_full is no longer implemented, as pidof is now
1786
437
        # used instead of pgrep.  pgrep_full is still passed through to ensure
1787
438
        # deprecation WARNS.  lp1474030
1788
439
1789
440
        service_restart = self.service_restarted_since(
1790
441
            sentry_unit, mtime,
1791
442
            service,
1792
443
            pgrep_full=pgrep_full,
1793
444
            sleep_time=sleep_time,
1794
445
            retry_count=retry_count,
1795
446
            retry_sleep_time=retry_sleep_time)
1796
447
1797
448
        config_update = self.config_updated_since(
1798
449
            sentry_unit,
1799
450
            filename,
1800
451
            mtime,
1801
452
            sleep_time=0)
1802
453
1803
454
        return service_restart and config_update
1804
455
1805
456
    def get_sentry_time(self, sentry_unit):
1806
457
        """Return current epoch time on a sentry"""
1807
458
        cmd = "date +'%s'"
1808
459
        return float(sentry_unit.run(cmd)[0])
1809
460
1810
461
    def relation_error(self, name, data):
1811
462
        return 'unexpected relation data in {} - {}'.format(name, data)
1812
463
1813
464
    def endpoint_error(self, name, data):
1814
465
        return 'unexpected endpoint data in {} - {}'.format(name, data)
1815
466
1816
467
    def get_ubuntu_releases(self):
1817
468
        """Return a list of all Ubuntu releases in order of release."""
1818
469
        _d = distro_info.UbuntuDistroInfo()
1819
470
        _release_list = _d.all
1820
471
        return _release_list
1821
472
1822
473
    def file_to_url(self, file_rel_path):
1823
474
        """Convert a relative file path to a file URL."""
1824
475
        _abs_path = os.path.abspath(file_rel_path)
1825
476
        return urlparse.urlparse(_abs_path, scheme='file').geturl()
1826
477
1827
478
    def check_commands_on_units(self, commands, sentry_units):
1828
479
        """Check that all commands in a list exit zero on all
1829
480
        sentry units in a list.
1830
481
1831
482
        :param commands:  list of bash commands
1832
483
        :param sentry_units:  list of sentry unit pointers
1833
484
        :returns: None if successful; Failure message otherwise
1834
485
        """
1835
486
        self.log.debug('Checking exit codes for {} commands on {} '
1836
487
                       'sentry units...'.format(len(commands),
1837
488
                                                len(sentry_units)))
1838
489
        for sentry_unit in sentry_units:
1839
490
            for cmd in commands:
1840
491
                output, code = sentry_unit.run(cmd)
1841
492
                if code == 0:
1842
493
                    self.log.debug('{} `{}` returned {} '
1843
494
                                   '(OK)'.format(sentry_unit.info['unit_name'],
1844
495
                                                 cmd, code))
1845
496
                else:
1846
497
                    return ('{} `{}` returned {} '
1847
498
                            '{}'.format(sentry_unit.info['unit_name'],
1848
499
                                        cmd, code, output))
1849
500
        return None
1850
501
1851
502
    def get_process_id_list(self, sentry_unit, process_name,
1852
503
                            expect_success=True):
1853
504
        """Get a list of process ID(s) from a single sentry juju unit
1854
505
        for a single process name.
1855
506
1856
507
        :param sentry_unit: Amulet sentry instance (juju unit)
1857
508
        :param process_name: Process name
1858
509
        :param expect_success: If False, expect the PID to be missing,
1859
510
            raise if it is present.
1860
511
        :returns: List of process IDs
1861
512
        """
1862
513
        cmd = 'pidof -x {}'.format(process_name)
1863
514
        if not expect_success:
1864
515
            cmd += " || exit 0 && exit 1"
1865
516
        output, code = sentry_unit.run(cmd)
1866
517
        if code != 0:
1867
518
            msg = ('{} `{}` returned {} '
1868
519
                   '{}'.format(sentry_unit.info['unit_name'],
1869
520
                               cmd, code, output))
1870
521
            amulet.raise_status(amulet.FAIL, msg=msg)
1871
522
        return str(output).split()
1872
523
1873
524
    def get_unit_process_ids(self, unit_processes, expect_success=True):
1874
525
        """Construct a dict containing unit sentries, process names, and
1875
526
        process IDs.
1876
527
1877
528
        :param unit_processes: A dictionary of Amulet sentry instance
1878
529
            to list of process names.
1879
530
        :param expect_success: if False expect the processes to not be
1880
531
            running, raise if they are.
1881
532
        :returns: Dictionary of Amulet sentry instance to dictionary
1882
533
            of process names to PIDs.
1883
534
        """
1884
535
        pid_dict = {}
1885
536
        for sentry_unit, process_list in six.iteritems(unit_processes):
1886
537
            pid_dict[sentry_unit] = {}
1887
538
            for process in process_list:
1888
539
                pids = self.get_process_id_list(
1889
540
                    sentry_unit, process, expect_success=expect_success)
1890
541
                pid_dict[sentry_unit].update({process: pids})
1891
542
        return pid_dict
1892
543
1893
544
    def validate_unit_process_ids(self, expected, actual):
1894
545
        """Validate process id quantities for services on units."""
1895
546
        self.log.debug('Checking units for running processes...')
1896
547
        self.log.debug('Expected PIDs: {}'.format(expected))
1897
548
        self.log.debug('Actual PIDs: {}'.format(actual))
1898
549
1899
550
        if len(actual) != len(expected):
1900
551
            return ('Unit count mismatch.  expected, actual: {}, '
1901
552
                    '{} '.format(len(expected), len(actual)))
1902
553
1903
554
        for (e_sentry, e_proc_names) in six.iteritems(expected):
1904
555
            e_sentry_name = e_sentry.info['unit_name']
1905
556
            if e_sentry in actual.keys():
1906
557
                a_proc_names = actual[e_sentry]
1907
558
            else:
1908
559
                return ('Expected sentry ({}) not found in actual dict data.'
1909
560
                        '{}'.format(e_sentry_name, e_sentry))
1910
561
1911
562
            if len(e_proc_names.keys()) != len(a_proc_names.keys()):
1912
563
                return ('Process name count mismatch.  expected, actual: {}, '
1913
564
                        '{}'.format(len(expected), len(actual)))
1914
565
1915
566
            for (e_proc_name, e_pids_length), (a_proc_name, a_pids) in \
1916
567
                    zip(e_proc_names.items(), a_proc_names.items()):
1917
568
                if e_proc_name != a_proc_name:
1918
569
                    return ('Process name mismatch.  expected, actual: {}, '
1919
570
                            '{}'.format(e_proc_name, a_proc_name))
1920
571
1921
572
                a_pids_length = len(a_pids)
1922
573
                fail_msg = ('PID count mismatch. {} ({}) expected, actual: '
1923
574
                            '{}, {} ({})'.format(e_sentry_name, e_proc_name,
1924
575
                                                 e_pids_length, a_pids_length,
1925
576
                                                 a_pids))
1926
577
1927
578
                # If expected is not bool, ensure PID quantities match
1928
579
                if not isinstance(e_pids_length, bool) and \
1929
580
                        a_pids_length != e_pids_length:
1930
581
                    return fail_msg
1931
582
                # If expected is bool True, ensure 1 or more PIDs exist
1932
583
                elif isinstance(e_pids_length, bool) and \
1933
584
                        e_pids_length is True and a_pids_length < 1:
1934
585
                    return fail_msg
1935
586
                # If expected is bool False, ensure 0 PIDs exist
1936
587
                elif isinstance(e_pids_length, bool) and \
1937
588
                        e_pids_length is False and a_pids_length != 0:
1938
589
                    return fail_msg
1939
590
                else:
1940
591
                    self.log.debug('PID check OK: {} {} {}: '
1941
592
                                   '{}'.format(e_sentry_name, e_proc_name,
1942
593
                                               e_pids_length, a_pids))
1943
594
        return None
1944
595
1945
596
    def validate_list_of_identical_dicts(self, list_of_dicts):
1946
597
        """Check that all dicts within a list are identical."""
1947
598
        hashes = []
1948
599
        for _dict in list_of_dicts:
1949
600
            hashes.append(hash(frozenset(_dict.items())))
1950
601
1951
602
        self.log.debug('Hashes: {}'.format(hashes))
1952
603
        if len(set(hashes)) == 1:
1953
604
            self.log.debug('Dicts within list are identical')
1954
605
        else:
1955
606
            return 'Dicts within list are not identical'
1956
607
1957
608
        return None
1958
609
1959
610
    def validate_sectionless_conf(self, file_contents, expected):
1960
611
        """A crude conf parser.  Useful to inspect configuration files which
1961
612
        do not have section headers (as would be necessary in order to use
1962
613
        the configparser).  Such as openstack-dashboard or rabbitmq confs."""
1963
614
        for line in file_contents.split('\n'):
1964
615
            if '=' in line:
1965
616
                args = line.split('=')
1966
617
                if len(args) <= 1:
1967
618
                    continue
1968
619
                key = args[0].strip()
1969
620
                value = args[1].strip()
1970
621
                if key in expected.keys():
1971
622
                    if expected[key] != value:
1972
623
                        msg = ('Config mismatch.  Expected, actual:  {}, '
1973
624
                               '{}'.format(expected[key], value))
1974
625
                        amulet.raise_status(amulet.FAIL, msg=msg)
1975
626
1976
627
    def get_unit_hostnames(self, units):
1977
628
        """Return a dict of juju unit names to hostnames."""
1978
629
        host_names = {}
1979
630
        for unit in units:
1980
631
            host_names[unit.info['unit_name']] = \
1981
632
                str(unit.file_contents('/etc/hostname').strip())
1982
633
        self.log.debug('Unit host names: {}'.format(host_names))
1983
634
        return host_names
1984
635
1985
636
    def run_cmd_unit(self, sentry_unit, cmd):
1986
637
        """Run a command on a unit, return the output and exit code."""
1987
638
        output, code = sentry_unit.run(cmd)
1988
639
        if code == 0:
1989
640
            self.log.debug('{} `{}` command returned {} '
1990
641
                           '(OK)'.format(sentry_unit.info['unit_name'],
1991
642
                                         cmd, code))
1992
643
        else:
1993
644
            msg = ('{} `{}` command returned {} '
1994
645
                   '{}'.format(sentry_unit.info['unit_name'],
1995
646
                               cmd, code, output))
1996
647
            amulet.raise_status(amulet.FAIL, msg=msg)
1997
648
        return str(output), code
1998
649
1999
650
    def file_exists_on_unit(self, sentry_unit, file_name):
2000
651
        """Check if a file exists on a unit."""
2001
652
        try:
2002
653
            sentry_unit.file_stat(file_name)
2003
654
            return True
2004
655
        except IOError:
2005
656
            return False
2006
657
        except Exception as e:
2007
658
            msg = 'Error checking file {}: {}'.format(file_name, e)
2008
659
            amulet.raise_status(amulet.FAIL, msg=msg)
2009
660
2010
661
    def file_contents_safe(self, sentry_unit, file_name,
2011
662
                           max_wait=60, fatal=False):
2012
663
        """Get file contents from a sentry unit.  Wrap amulet file_contents
2013
664
        with retry logic to address races where a file checks as existing,
2014
665
        but no longer exists by the time file_contents is called.
2015
666
        Return None if file not found. Optionally raise if fatal is True."""
2016
667
        unit_name = sentry_unit.info['unit_name']
2017
668
        file_contents = False
2018
669
        tries = 0
2019
670
        while not file_contents and tries < (max_wait / 4):
2020
671
            try:
2021
672
                file_contents = sentry_unit.file_contents(file_name)
2022
673
            except IOError:
2023
674
                self.log.debug('Attempt {} to open file {} from {} '
2024
675
                               'failed'.format(tries, file_name,
2025
676
                                               unit_name))
2026
677
                time.sleep(4)
2027
678
                tries += 1
2028
679
2029
680
        if file_contents:
2030
681
            return file_contents
2031
682
        elif not fatal:
2032
683
            return None
2033
684
        elif fatal:
2034
685
            msg = 'Failed to get file contents from unit.'
2035
686
            amulet.raise_status(amulet.FAIL, msg)
2036
687
2037
688
    def port_knock_tcp(self, host="localhost", port=22, timeout=15):
2038
689
        """Open a TCP socket to check for a listening sevice on a host.
2039
690
2040
691
        :param host: host name or IP address, default to localhost
2041
692
        :param port: TCP port number, default to 22
2042
693
        :param timeout: Connect timeout, default to 15 seconds
2043
694
        :returns: True if successful, False if connect failed
2044
695
        """
2045
696
2046
697
        # Resolve host name if possible
2047
698
        try:
2048
699
            connect_host = socket.gethostbyname(host)
2049
700
            host_human = "{} ({})".format(connect_host, host)
2050
701
        except socket.error, e:
2051
702
            self.log.warn('Unable to resolve address: '
2052
703
                          '{} ({}) Trying anyway!'.format(host, e))
2053
704
            connect_host = host
2054
705
            host_human = connect_host
2055
706
2056
707
        # Attempt socket connection
2057
708
        try:
2058
709
            knock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
2059
710
            knock.settimeout(timeout)
2060
711
            knock.connect((connect_host, port))
2061
712
            knock.close()
2062
713
            self.log.debug('Socket connect OK for host '
2063
714
                           '{} on port {}.'.format(host_human, port))
2064
715
            return True
2065
716
        except socket.error, e:
2066
717
            self.log.debug('Socket connect FAIL for'
2067
718
                           ' {} port {} ({})'.format(host_human, port, e))
2068
719
            return False
2069
720
2070
721
    def port_knock_units(self, sentry_units, port=22,
2071
722
                         timeout=15, expect_success=True):
2072
723
        """Open a TCP socket to check for a listening sevice on each
2073
724
        listed juju unit.
2074
725
2075
726
        :param sentry_units: list of sentry unit pointers
2076
727
        :param port: TCP port number, default to 22
2077
728
        :param timeout: Connect timeout, default to 15 seconds
2078
729
        :expect_success: True by default, set False to invert logic
2079
730
        :returns: None if successful, Failure message otherwise
2080
731
        """
2081
732
        for unit in sentry_units:
2082
733
            host = unit.info['public-address']
2083
734
            connected = self.port_knock_tcp(host, port, timeout)
2084
735
            if not connected and expect_success:
2085
736
                return 'Socket connect failed.'
2086
737
            elif connected and not expect_success:
2087
738
                return 'Socket connected unexpectedly.'
2088
739
2089
740
    def get_uuid_epoch_stamp(self):
2090
741
        """Returns a stamp string based on uuid4 and epoch time.  Useful in
2091
742
        generating test messages which need to be unique-ish."""
2092
743
        return '[{}-{}]'.format(uuid.uuid4(), time.time())
2093
744
2094
745
# amulet juju action helpers:
2095
746
    def run_action(self, unit_sentry, action,
2096
747
                   _check_output=subprocess.check_output):
2097
748
        """Run the named action on a given unit sentry.
2098
749
2099
750
        _check_output parameter is used for dependency injection.
2100
751
2101
752
        @return action_id.
2102
753
        """
2103
754
        unit_id = unit_sentry.info["unit_name"]
2104
755
        command = ["juju", "action", "do", "--format=json", unit_id, action]
2105
756
        self.log.info("Running command: %s\n" % " ".join(command))
2106
757
        output = _check_output(command, universal_newlines=True)
2107
758
        data = json.loads(output)
2108
759
        action_id = data[u'Action queued with id']
2109
760
        return action_id
2110
761
2111
762
    def wait_on_action(self, action_id, _check_output=subprocess.check_output):
2112
763
        """Wait for a given action, returning if it completed or not.
2113
764
2114
765
        _check_output parameter is used for dependency injection.
2115
766
        """
2116
767
        command = ["juju", "action", "fetch", "--format=json", "--wait=0",
2117
768
                   action_id]
2118
769
        output = _check_output(command, universal_newlines=True)
2119
770
        data = json.loads(output)
2120
771
        return data.get(u"status") == "completed"
2121
0
772
2122
=== added directory 'tests/charmhelpers/contrib/openstack'
2123
=== added file 'tests/charmhelpers/contrib/openstack/__init__.py'
2124
--- tests/charmhelpers/contrib/openstack/__init__.py	1970-01-01 00:00:00 +0000
2125
+++ tests/charmhelpers/contrib/openstack/__init__.py	2015-09-01 02:46:36 +0000
2126
@@ -0,0 +1,15 @@
2127
1
# Copyright 2014-2015 Canonical Limited.
2128
2
#
2129
3
# This file is part of charm-helpers.
2130
4
#
2131
5
# charm-helpers is free software: you can redistribute it and/or modify
2132
6
# it under the terms of the GNU Lesser General Public License version 3 as
2133
7
# published by the Free Software Foundation.
2134
8
#
2135
9
# charm-helpers is distributed in the hope that it will be useful,
2136
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
2137
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2138
12
# GNU Lesser General Public License for more details.
2139
13
#
2140
14
# You should have received a copy of the GNU Lesser General Public License
2141
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
2142
0
16
2143
=== added directory 'tests/charmhelpers/contrib/openstack/amulet'
2144
=== added file 'tests/charmhelpers/contrib/openstack/amulet/__init__.py'
2145
--- tests/charmhelpers/contrib/openstack/amulet/__init__.py	1970-01-01 00:00:00 +0000
2146
+++ tests/charmhelpers/contrib/openstack/amulet/__init__.py	2015-09-01 02:46:36 +0000
2147
@@ -0,0 +1,15 @@
2148
1
# Copyright 2014-2015 Canonical Limited.
2149
2
#
2150
3
# This file is part of charm-helpers.
2151
4
#
2152
5
# charm-helpers is free software: you can redistribute it and/or modify
2153
6
# it under the terms of the GNU Lesser General Public License version 3 as
2154
7
# published by the Free Software Foundation.
2155
8
#
2156
9
# charm-helpers is distributed in the hope that it will be useful,
2157
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
2158
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2159
12
# GNU Lesser General Public License for more details.
2160
13
#
2161
14
# You should have received a copy of the GNU Lesser General Public License
2162
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
2163
0
16
2164
=== added file 'tests/charmhelpers/contrib/openstack/amulet/deployment.py'
2165
--- tests/charmhelpers/contrib/openstack/amulet/deployment.py	1970-01-01 00:00:00 +0000
2166
+++ tests/charmhelpers/contrib/openstack/amulet/deployment.py	2015-09-01 02:46:36 +0000
2167
@@ -0,0 +1,198 @@
2168
1
# Copyright 2014-2015 Canonical Limited.
2169
2
#
2170
3
# This file is part of charm-helpers.
2171
4
#
2172
5
# charm-helpers is free software: you can redistribute it and/or modify
2173
6
# it under the terms of the GNU Lesser General Public License version 3 as
2174
7
# published by the Free Software Foundation.
2175
8
#
2176
9
# charm-helpers is distributed in the hope that it will be useful,
2177
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
2178
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2179
12
# GNU Lesser General Public License for more details.
2180
13
#
2181
14
# You should have received a copy of the GNU Lesser General Public License
2182
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
2183
16
2184
17
import six
2185
18
from collections import OrderedDict
2186
19
from charmhelpers.contrib.amulet.deployment import (
2187
20
    AmuletDeployment
2188
21
)
2189
22
2190
23
2191
24
class OpenStackAmuletDeployment(AmuletDeployment):
2192
25
    """OpenStack amulet deployment.
2193
26
2194
27
       This class inherits from AmuletDeployment and has additional support
2195
28
       that is specifically for use by OpenStack charms.
2196
29
       """
2197
30
2198
31
    def __init__(self, series=None, openstack=None, source=None, stable=True):
2199
32
        """Initialize the deployment environment."""
2200
33
        super(OpenStackAmuletDeployment, self).__init__(series)
2201
34
        self.openstack = openstack
2202
35
        self.source = source
2203
36
        self.stable = stable
2204
37
        # Note(coreycb): this needs to be changed when new next branches come
2205
38
        # out.
2206
39
        self.current_next = "trusty"
2207
40
2208
41
    def _determine_branch_locations(self, other_services):
2209
42
        """Determine the branch locations for the other services.
2210
43
2211
44
           Determine if the local branch being tested is derived from its
2212
45
           stable or next (dev) branch, and based on this, use the corresonding
2213
46
           stable or next branches for the other_services."""
2214
47
2215
48
        # Charms outside the lp:~openstack-charmers namespace
2216
49
        base_charms = ['mysql', 'mongodb', 'nrpe']
2217
50
2218
51
        # Force these charms to current series even when using an older series.
2219
52
        # ie. Use trusty/nrpe even when series is precise, as the P charm
2220
53
        # does not possess the necessary external master config and hooks.
2221
54
        force_series_current = ['nrpe']
2222
55
2223
56
        if self.series in ['precise', 'trusty']:
2224
57
            base_series = self.series
2225
58
        else:
2226
59
            base_series = self.current_next
2227
60
2228
61
        if self.stable:
2229
62
            for svc in other_services:
2230
63
                if svc['name'] in force_series_current:
2231
64
                    base_series = self.current_next
2232
65
2233
66
                temp = 'lp:charms/{}/{}'
2234
67
                svc['location'] = temp.format(base_series,
2235
68
                                              svc['name'])
2236
69
        else:
2237
70
            for svc in other_services:
2238
71
                if svc['name'] in force_series_current:
2239
72
                    base_series = self.current_next
2240
73
2241
74
                if svc['name'] in base_charms:
2242
75
                    temp = 'lp:charms/{}/{}'
2243
76
                    svc['location'] = temp.format(base_series,
2244
77
                                                  svc['name'])
2245
78
                else:
2246
79
                    temp = 'lp:~openstack-charmers/charms/{}/{}/next'
2247
80
                    svc['location'] = temp.format(self.current_next,
2248
81
                                                  svc['name'])
2249
82
        return other_services
2250
83
2251
84
    def _add_services(self, this_service, other_services):
2252
85
        """Add services to the deployment and set openstack-origin/source."""
2253
86
        other_services = self._determine_branch_locations(other_services)
2254
87
2255
88
        super(OpenStackAmuletDeployment, self)._add_services(this_service,
2256
89
                                                             other_services)
2257
90
2258
91
        services = other_services
2259
92
        services.append(this_service)
2260
93
2261
94
        # Charms which should use the source config option
2262
95
        use_source = ['mysql', 'mongodb', 'rabbitmq-server', 'ceph',
2263
96
                      'ceph-osd', 'ceph-radosgw']
2264
97
2265
98
        # Charms which can not use openstack-origin, ie. many subordinates
2266
99
        no_origin = ['cinder-ceph', 'hacluster', 'neutron-openvswitch', 'nrpe']
2267
100
2268
101
        if self.openstack:
2269
102
            for svc in services:
2270
103
                if svc['name'] not in use_source + no_origin:
2271
104
                    config = {'openstack-origin': self.openstack}
2272
105
                    self.d.configure(svc['name'], config)
2273
106
2274
107
        if self.source:
2275
108
            for svc in services:
2276
109
                if svc['name'] in use_source and svc['name'] not in no_origin:
2277
110
                    config = {'source': self.source}
2278
111
                    self.d.configure(svc['name'], config)
2279
112
2280
113
    def _configure_services(self, configs):
2281
114
        """Configure all of the services."""
2282
115
        for service, config in six.iteritems(configs):
2283
116
            self.d.configure(service, config)
2284
117
2285
118
    def _get_openstack_release(self):
2286
119
        """Get openstack release.
2287
120
2288
121
           Return an integer representing the enum value of the openstack
2289
122
           release.
2290
123
           """
2291
124
        # Must be ordered by OpenStack release (not by Ubuntu release):
2292
125
        (self.precise_essex, self.precise_folsom, self.precise_grizzly,
2293
126
         self.precise_havana, self.precise_icehouse,
2294
127
         self.trusty_icehouse, self.trusty_juno, self.utopic_juno,
2295
128
         self.trusty_kilo, self.vivid_kilo, self.trusty_liberty,
2296
129
         self.wily_liberty) = range(12)
2297
130
2298
131
        releases = {
2299
132
            ('precise', None): self.precise_essex,
2300
133
            ('precise', 'cloud:precise-folsom'): self.precise_folsom,
2301
134
            ('precise', 'cloud:precise-grizzly'): self.precise_grizzly,
2302
135
            ('precise', 'cloud:precise-havana'): self.precise_havana,
2303
136
            ('precise', 'cloud:precise-icehouse'): self.precise_icehouse,
2304
137
            ('trusty', None): self.trusty_icehouse,
2305
138
            ('trusty', 'cloud:trusty-juno'): self.trusty_juno,
2306
139
            ('trusty', 'cloud:trusty-kilo'): self.trusty_kilo,
2307
140
            ('trusty', 'cloud:trusty-liberty'): self.trusty_liberty,
2308
141
            ('utopic', None): self.utopic_juno,
2309
142
            ('vivid', None): self.vivid_kilo,
2310
143
            ('wily', None): self.wily_liberty}
2311
144
        return releases[(self.series, self.openstack)]
2312
145
2313
146
    def _get_openstack_release_string(self):
2314
147
        """Get openstack release string.
2315
148
2316
149
           Return a string representing the openstack release.
2317
150
           """
2318
151
        releases = OrderedDict([
2319
152
            ('precise', 'essex'),
2320
153
            ('quantal', 'folsom'),
2321
154
            ('raring', 'grizzly'),
2322
155
            ('saucy', 'havana'),
2323
156
            ('trusty', 'icehouse'),
2324
157
            ('utopic', 'juno'),
2325
158
            ('vivid', 'kilo'),
2326
159
            ('wily', 'liberty'),
2327
160
        ])
2328
161
        if self.openstack:
2329
162
            os_origin = self.openstack.split(':')[1]
2330
163
            return os_origin.split('%s-' % self.series)[1].split('/')[0]
2331
164
        else:
2332
165
            return releases[self.series]
2333
166
2334
167
    def get_ceph_expected_pools(self, radosgw=False):
2335
168
        """Return a list of expected ceph pools in a ceph + cinder + glance
2336
169
        test scenario, based on OpenStack release and whether ceph radosgw
2337
170
        is flagged as present or not."""
2338
171
2339
172
        if self._get_openstack_release() >= self.trusty_kilo:
2340
173
            # Kilo or later
2341
174
            pools = [
2342
175
                'rbd',
2343
176
                'cinder',
2344
177
                'glance'
2345
178
            ]
2346
179
        else:
2347
180
            # Juno or earlier
2348
181
            pools = [
2349
182
                'data',
2350
183
                'metadata',
2351
184
                'rbd',
2352
185
                'cinder',
2353
186
                'glance'
2354
187
            ]
2355
188
2356
189
        if radosgw:
2357
190
            pools.extend([
2358
191
                '.rgw.root',
2359
192
                '.rgw.control',
2360
193
                '.rgw',
2361
194
                '.rgw.gc',
2362
195
                '.users.uid'
2363
196
            ])
2364
197
2365
198
        return pools
2366
0
199
2367
=== added file 'tests/charmhelpers/contrib/openstack/amulet/utils.py'
2368
--- tests/charmhelpers/contrib/openstack/amulet/utils.py	1970-01-01 00:00:00 +0000
2369
+++ tests/charmhelpers/contrib/openstack/amulet/utils.py	2015-09-01 02:46:36 +0000
2370
@@ -0,0 +1,965 @@
2371
1
# Copyright 2014-2015 Canonical Limited.
2372
2
#
2373
3
# This file is part of charm-helpers.
2374
4
#
2375
5
# charm-helpers is free software: you can redistribute it and/or modify
2376
6
# it under the terms of the GNU Lesser General Public License version 3 as
2377
7
# published by the Free Software Foundation.
2378
8
#
2379
9
# charm-helpers is distributed in the hope that it will be useful,
2380
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
2381
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2382
12
# GNU Lesser General Public License for more details.
2383
13
#
2384
14
# You should have received a copy of the GNU Lesser General Public License
2385
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
2386
16
2387
17
import amulet
2388
18
import json
2389
19
import logging
2390
20
import os
2391
21
import six
2392
22
import time
2393
23
import urllib
2394
24
2395
25
import cinderclient.v1.client as cinder_client
2396
26
import glanceclient.v1.client as glance_client
2397
27
import heatclient.v1.client as heat_client
2398
28
import keystoneclient.v2_0 as keystone_client
2399
29
import novaclient.v1_1.client as nova_client
2400
30
import pika
2401
31
import swiftclient
2402
32
2403
33
from charmhelpers.contrib.amulet.utils import (
2404
34
    AmuletUtils
2405
35
)
2406
36
2407
37
DEBUG = logging.DEBUG
2408
38
ERROR = logging.ERROR
2409
39
2410
40
2411
41
class OpenStackAmuletUtils(AmuletUtils):
2412
42
    """OpenStack amulet utilities.
2413
43
2414
44
       This class inherits from AmuletUtils and has additional support
2415
45
       that is specifically for use by OpenStack charm tests.
2416
46
       """
2417
47
2418
48
    def __init__(self, log_level=ERROR):
2419
49
        """Initialize the deployment environment."""
2420
50
        super(OpenStackAmuletUtils, self).__init__(log_level)
2421
51
2422
52
    def validate_endpoint_data(self, endpoints, admin_port, internal_port,
2423
53
                               public_port, expected):
2424
54
        """Validate endpoint data.
2425
55
2426
56
           Validate actual endpoint data vs expected endpoint data. The ports
2427
57
           are used to find the matching endpoint.
2428
58
           """
2429
59
        self.log.debug('Validating endpoint data...')
2430
60
        self.log.debug('actual: {}'.format(repr(endpoints)))
2431
61
        found = False
2432
62
        for ep in endpoints:
2433
63
            self.log.debug('endpoint: {}'.format(repr(ep)))
2434
64
            if (admin_port in ep.adminurl and
2435
65
                    internal_port in ep.internalurl and
2436
66
                    public_port in ep.publicurl):
2437
67
                found = True
2438
68
                actual = {'id': ep.id,
2439
69
                          'region': ep.region,
2440
70
                          'adminurl': ep.adminurl,
2441
71
                          'internalurl': ep.internalurl,
2442
72
                          'publicurl': ep.publicurl,
2443
73
                          'service_id': ep.service_id}
2444
74
                ret = self._validate_dict_data(expected, actual)
2445
75
                if ret:
2446
76
                    return 'unexpected endpoint data - {}'.format(ret)
2447
77
2448
78
        if not found:
2449
79
            return 'endpoint not found'
2450
80
2451
81
    def validate_svc_catalog_endpoint_data(self, expected, actual):
2452
82
        """Validate service catalog endpoint data.
2453
83
2454
84
           Validate a list of actual service catalog endpoints vs a list of
2455
85
           expected service catalog endpoints.
2456
86
           """
2457
87
        self.log.debug('Validating service catalog endpoint data...')
2458
88
        self.log.debug('actual: {}'.format(repr(actual)))
2459
89
        for k, v in six.iteritems(expected):
2460
90
            if k in actual:
2461
91
                ret = self._validate_dict_data(expected[k][0], actual[k][0])
2462
92
                if ret:
2463
93
                    return self.endpoint_error(k, ret)
2464
94
            else:
2465
95
                return "endpoint {} does not exist".format(k)
2466
96
        return ret
2467
97
2468
98
    def validate_tenant_data(self, expected, actual):
2469
99
        """Validate tenant data.
2470
100
2471
101
           Validate a list of actual tenant data vs list of expected tenant
2472
102
           data.
2473
103
           """
2474
104
        self.log.debug('Validating tenant data...')
2475
105
        self.log.debug('actual: {}'.format(repr(actual)))
2476
106
        for e in expected:
2477
107
            found = False
2478
108
            for act in actual:
2479
109
                a = {'enabled': act.enabled, 'description': act.description,
2480
110
                     'name': act.name, 'id': act.id}
2481
111
                if e['name'] == a['name']:
2482
112
                    found = True
2483
113
                    ret = self._validate_dict_data(e, a)
2484
114
                    if ret:
2485
115
                        return "unexpected tenant data - {}".format(ret)
2486
116
            if not found:
2487
117
                return "tenant {} does not exist".format(e['name'])
2488
118
        return ret
2489
119
2490
120
    def validate_role_data(self, expected, actual):
2491
121
        """Validate role data.
2492
122
2493
123
           Validate a list of actual role data vs a list of expected role
2494
124
           data.
2495
125
           """
2496
126
        self.log.debug('Validating role data...')
2497
127
        self.log.debug('actual: {}'.format(repr(actual)))
2498
128
        for e in expected:
2499
129
            found = False
2500
130
            for act in actual:
2501
131
                a = {'name': act.name, 'id': act.id}
2502
132
                if e['name'] == a['name']:
2503
133
                    found = True
2504
134
                    ret = self._validate_dict_data(e, a)
2505
135
                    if ret:
2506
136
                        return "unexpected role data - {}".format(ret)
2507
137
            if not found:
2508
138
                return "role {} does not exist".format(e['name'])
2509
139
        return ret
2510
140
2511
141
    def validate_user_data(self, expected, actual):
2512
142
        """Validate user data.
2513
143
2514
144
           Validate a list of actual user data vs a list of expected user
2515
145
           data.
2516
146
           """
2517
147
        self.log.debug('Validating user data...')
2518
148
        self.log.debug('actual: {}'.format(repr(actual)))
2519
149
        for e in expected:
2520
150
            found = False
2521
151
            for act in actual:
2522
152
                a = {'enabled': act.enabled, 'name': act.name,
2523
153
                     'email': act.email, 'tenantId': act.tenantId,
2524
154
                     'id': act.id}
2525
155
                if e['name'] == a['name']:
2526
156
                    found = True
2527
157
                    ret = self._validate_dict_data(e, a)
2528
158
                    if ret:
2529
159
                        return "unexpected user data - {}".format(ret)
2530
160
            if not found:
2531
161
                return "user {} does not exist".format(e['name'])
2532
162
        return ret
2533
163
2534
164
    def validate_flavor_data(self, expected, actual):
2535
165
        """Validate flavor data.
2536
166
2537
167
           Validate a list of actual flavors vs a list of expected flavors.
2538
168
           """
2539
169
        self.log.debug('Validating flavor data...')
2540
170
        self.log.debug('actual: {}'.format(repr(actual)))
2541
171
        act = [a.name for a in actual]
2542
172
        return self._validate_list_data(expected, act)
2543
173
2544
174
    def tenant_exists(self, keystone, tenant):
2545
175
        """Return True if tenant exists."""
2546
176
        self.log.debug('Checking if tenant exists ({})...'.format(tenant))
2547
177
        return tenant in [t.name for t in keystone.tenants.list()]
2548
178
2549
179
    def authenticate_cinder_admin(self, keystone_sentry, username,
2550
180
                                  password, tenant):
2551
181
        """Authenticates admin user with cinder."""
2552
182
        # NOTE(beisner): cinder python client doesn't accept tokens.
2553
183
        service_ip = \
2554
184
            keystone_sentry.relation('shared-db',
2555
185
                                     'mysql:shared-db')['private-address']
2556
186
        ept = "http://{}:5000/v2.0".format(service_ip.strip().decode('utf-8'))
2557
187
        return cinder_client.Client(username, password, tenant, ept)
2558
188
2559
189
    def authenticate_keystone_admin(self, keystone_sentry, user, password,
2560
190
                                    tenant):
2561
191
        """Authenticates admin user with the keystone admin endpoint."""
2562
192
        self.log.debug('Authenticating keystone admin...')
2563
193
        unit = keystone_sentry
2564
194
        service_ip = unit.relation('shared-db',
2565
195
                                   'mysql:shared-db')['private-address']
2566
196
        ep = "http://{}:35357/v2.0".format(service_ip.strip().decode('utf-8'))
2567
197
        return keystone_client.Client(username=user, password=password,
2568
198
                                      tenant_name=tenant, auth_url=ep)
2569
199
2570
200
    def authenticate_keystone_user(self, keystone, user, password, tenant):
2571
201
        """Authenticates a regular user with the keystone public endpoint."""
2572
202
        self.log.debug('Authenticating keystone user ({})...'.format(user))
2573
203
        ep = keystone.service_catalog.url_for(service_type='identity',
2574
204
                                              endpoint_type='publicURL')
2575
205
        return keystone_client.Client(username=user, password=password,
2576
206
                                      tenant_name=tenant, auth_url=ep)
2577
207
2578
208
    def authenticate_glance_admin(self, keystone):
2579
209
        """Authenticates admin user with glance."""
2580
210
        self.log.debug('Authenticating glance admin...')
2581
211
        ep = keystone.service_catalog.url_for(service_type='image',
2582
212
                                              endpoint_type='adminURL')
2583
213
        return glance_client.Client(ep, token=keystone.auth_token)
2584
214
2585
215
    def authenticate_heat_admin(self, keystone):
2586
216
        """Authenticates the admin user with heat."""
2587
217
        self.log.debug('Authenticating heat admin...')
2588
218
        ep = keystone.service_catalog.url_for(service_type='orchestration',
2589
219
                                              endpoint_type='publicURL')
2590
220
        return heat_client.Client(endpoint=ep, token=keystone.auth_token)
2591
221
2592
222
    def authenticate_nova_user(self, keystone, user, password, tenant):
2593
223
        """Authenticates a regular user with nova-api."""
2594
224
        self.log.debug('Authenticating nova user ({})...'.format(user))
2595
225
        ep = keystone.service_catalog.url_for(service_type='identity',
2596
226
                                              endpoint_type='publicURL')
2597
227
        return nova_client.Client(username=user, api_key=password,
2598
228
                                  project_id=tenant, auth_url=ep)
2599
229
2600
230
    def authenticate_swift_user(self, keystone, user, password, tenant):
2601
231
        """Authenticates a regular user with swift api."""
2602
232
        self.log.debug('Authenticating swift user ({})...'.format(user))
2603
233
        ep = keystone.service_catalog.url_for(service_type='identity',
2604
234
                                              endpoint_type='publicURL')
2605
235
        return swiftclient.Connection(authurl=ep,
2606
236
                                      user=user,
2607
237
                                      key=password,
2608
238
                                      tenant_name=tenant,
2609
239
                                      auth_version='2.0')
2610
240
2611
241
    def create_cirros_image(self, glance, image_name):
2612
242
        """Download the latest cirros image and upload it to glance,
2613
243
        validate and return a resource pointer.
2614
244
2615
245
        :param glance: pointer to authenticated glance connection
2616
246
        :param image_name: display name for new image
2617
247
        :returns: glance image pointer
2618
248
        """
2619
249
        self.log.debug('Creating glance cirros image '
2620
250
                       '({})...'.format(image_name))
2621
251
2622
252
        # Download cirros image
2623
253
        http_proxy = os.getenv('AMULET_HTTP_PROXY')
2624
254
        self.log.debug('AMULET_HTTP_PROXY: {}'.format(http_proxy))
2625
255
        if http_proxy:
2626
256
            proxies = {'http': http_proxy}
2627
257
            opener = urllib.FancyURLopener(proxies)
2628
258
        else:
2629
259
            opener = urllib.FancyURLopener()
2630
260
2631
261
        f = opener.open('http://download.cirros-cloud.net/version/released')
2632
262
        version = f.read().strip()
2633
263
        cirros_img = 'cirros-{}-x86_64-disk.img'.format(version)
2634
264
        local_path = os.path.join('tests', cirros_img)
2635
265
2636
266
        if not os.path.exists(local_path):
2637
267
            cirros_url = 'http://{}/{}/{}'.format('download.cirros-cloud.net',
2638
268
                                                  version, cirros_img)
2639
269
            opener.retrieve(cirros_url, local_path)
2640
270
        f.close()
2641
271
2642
272
        # Create glance image
2643
273
        with open(local_path) as f:
2644
274
            image = glance.images.create(name=image_name, is_public=True,
2645
275
                                         disk_format='qcow2',
2646
276
                                         container_format='bare', data=f)
2647
277
2648
278
        # Wait for image to reach active status
2649
279
        img_id = image.id
2650
280
        ret = self.resource_reaches_status(glance.images, img_id,
2651
281
                                           expected_stat='active',
2652
282
                                           msg='Image status wait')
2653
283
        if not ret:
2654
284
            msg = 'Glance image failed to reach expected state.'
2655
285
            amulet.raise_status(amulet.FAIL, msg=msg)
2656
286
2657
287
        # Re-validate new image
2658
288
        self.log.debug('Validating image attributes...')
2659
289
        val_img_name = glance.images.get(img_id).name
2660
290
        val_img_stat = glance.images.get(img_id).status
2661
291
        val_img_pub = glance.images.get(img_id).is_public
2662
292
        val_img_cfmt = glance.images.get(img_id).container_format
2663
293
        val_img_dfmt = glance.images.get(img_id).disk_format
2664
294
        msg_attr = ('Image attributes - name:{} public:{} id:{} stat:{} '
2665
295
                    'container fmt:{} disk fmt:{}'.format(
2666
296
                        val_img_name, val_img_pub, img_id,
2667
297
                        val_img_stat, val_img_cfmt, val_img_dfmt))
2668
298
2669
299
        if val_img_name == image_name and val_img_stat == 'active' \
2670
300
                and val_img_pub is True and val_img_cfmt == 'bare' \
2671
301
                and val_img_dfmt == 'qcow2':
2672
302
            self.log.debug(msg_attr)
2673
303
        else:
2674
304
            msg = ('Volume validation failed, {}'.format(msg_attr))
2675
305
            amulet.raise_status(amulet.FAIL, msg=msg)
2676
306
2677
307
        return image
2678
308
2679
309
    def delete_image(self, glance, image):
2680
310
        """Delete the specified image."""
2681
311
2682
312
        # /!\ DEPRECATION WARNING
2683
313
        self.log.warn('/!\\ DEPRECATION WARNING:  use '
2684
314
                      'delete_resource instead of delete_image.')
2685
315
        self.log.debug('Deleting glance image ({})...'.format(image))
2686
316
        return self.delete_resource(glance.images, image, msg='glance image')
2687
317
2688
318
    def create_instance(self, nova, image_name, instance_name, flavor):
2689
319
        """Create the specified instance."""
2690
320
        self.log.debug('Creating instance '
2691
321
                       '({}|{}|{})'.format(instance_name, image_name, flavor))
2692
322
        image = nova.images.find(name=image_name)
2693
323
        flavor = nova.flavors.find(name=flavor)
2694
324
        instance = nova.servers.create(name=instance_name, image=image,
2695
325
                                       flavor=flavor)
2696
326
2697
327
        count = 1
2698
328
        status = instance.status
2699
329
        while status != 'ACTIVE' and count < 60:
2700
330
            time.sleep(3)
2701
331
            instance = nova.servers.get(instance.id)
2702
332
            status = instance.status
2703
333
            self.log.debug('instance status: {}'.format(status))
2704
334
            count += 1
2705
335
2706
336
        if status != 'ACTIVE':
2707
337
            self.log.error('instance creation timed out')
2708
338
            return None
2709
339
2710
340
        return instance
2711
341
2712
342
    def delete_instance(self, nova, instance):
2713
343
        """Delete the specified instance."""
2714
344
2715
345
        # /!\ DEPRECATION WARNING
2716
346
        self.log.warn('/!\\ DEPRECATION WARNING:  use '
2717
347
                      'delete_resource instead of delete_instance.')
2718
348
        self.log.debug('Deleting instance ({})...'.format(instance))
2719
349
        return self.delete_resource(nova.servers, instance,
2720
350
                                    msg='nova instance')
2721
351
2722
352
    def create_or_get_keypair(self, nova, keypair_name="testkey"):
2723
353
        """Create a new keypair, or return pointer if it already exists."""
2724
354
        try:
2725
355
            _keypair = nova.keypairs.get(keypair_name)
2726
356
            self.log.debug('Keypair ({}) already exists, '
2727
357
                           'using it.'.format(keypair_name))
2728
358
            return _keypair
2729
359
        except:
2730
360
            self.log.debug('Keypair ({}) does not exist, '
2731
361
                           'creating it.'.format(keypair_name))
2732
362
2733
363
        _keypair = nova.keypairs.create(name=keypair_name)
2734
364
        return _keypair
2735
365
2736
366
    def create_cinder_volume(self, cinder, vol_name="demo-vol", vol_size=1,
2737
367
                             img_id=None, src_vol_id=None, snap_id=None):
2738
368
        """Create cinder volume, optionally from a glance image, OR
2739
369
        optionally as a clone of an existing volume, OR optionally
2740
370
        from a snapshot.  Wait for the new volume status to reach
2741
371
        the expected status, validate and return a resource pointer.
2742
372
2743
373
        :param vol_name: cinder volume display name
2744
374
        :param vol_size: size in gigabytes
2745
375
        :param img_id: optional glance image id
2746
376
        :param src_vol_id: optional source volume id to clone
2747
377
        :param snap_id: optional snapshot id to use
2748
378
        :returns: cinder volume pointer
2749
379
        """
2750
380
        # Handle parameter input and avoid impossible combinations
2751
381
        if img_id and not src_vol_id and not snap_id:
2752
382
            # Create volume from image
2753
383
            self.log.debug('Creating cinder volume from glance image...')
2754
384
            bootable = 'true'
2755
385
        elif src_vol_id and not img_id and not snap_id:
2756
386
            # Clone an existing volume
2757
387
            self.log.debug('Cloning cinder volume...')
2758
388
            bootable = cinder.volumes.get(src_vol_id).bootable
2759
389
        elif snap_id and not src_vol_id and not img_id:
2760
390
            # Create volume from snapshot
2761
391
            self.log.debug('Creating cinder volume from snapshot...')
2762
392
            snap = cinder.volume_snapshots.find(id=snap_id)
2763
393
            vol_size = snap.size
2764
394
            snap_vol_id = cinder.volume_snapshots.get(snap_id).volume_id
2765
395
            bootable = cinder.volumes.get(snap_vol_id).bootable
2766
396
        elif not img_id and not src_vol_id and not snap_id:
2767
397
            # Create volume
2768
398
            self.log.debug('Creating cinder volume...')
2769
399
            bootable = 'false'
2770
400
        else:
2771
401
            # Impossible combination of parameters
2772
402
            msg = ('Invalid method use - name:{} size:{} img_id:{} '
2773
403
                   'src_vol_id:{} snap_id:{}'.format(vol_name, vol_size,
2774
404
                                                     img_id, src_vol_id,
2775
405
                                                     snap_id))
2776
406
            amulet.raise_status(amulet.FAIL, msg=msg)
2777
407
2778
408
        # Create new volume
2779
409
        try:
2780
410
            vol_new = cinder.volumes.create(display_name=vol_name,
2781
411
                                            imageRef=img_id,
2782
412
                                            size=vol_size,
2783
413
                                            source_volid=src_vol_id,
2784
414
                                            snapshot_id=snap_id)
2785
415
            vol_id = vol_new.id
2786
416
        except Exception as e:
2787
417
            msg = 'Failed to create volume: {}'.format(e)
2788
418
            amulet.raise_status(amulet.FAIL, msg=msg)
2789
419
2790
420
        # Wait for volume to reach available status
2791
421
        ret = self.resource_reaches_status(cinder.volumes, vol_id,
2792
422
                                           expected_stat="available",
2793
423
                                           msg="Volume status wait")
2794
424
        if not ret:
2795
425
            msg = 'Cinder volume failed to reach expected state.'
2796
426
            amulet.raise_status(amulet.FAIL, msg=msg)
2797
427
2798
428
        # Re-validate new volume
2799
429
        self.log.debug('Validating volume attributes...')
2800
430
        val_vol_name = cinder.volumes.get(vol_id).display_name
2801
431
        val_vol_boot = cinder.volumes.get(vol_id).bootable
2802
432
        val_vol_stat = cinder.volumes.get(vol_id).status
2803
433
        val_vol_size = cinder.volumes.get(vol_id).size
2804
434
        msg_attr = ('Volume attributes - name:{} id:{} stat:{} boot:'
2805
435
                    '{} size:{}'.format(val_vol_name, vol_id,
2806
436
                                        val_vol_stat, val_vol_boot,
2807
437
                                        val_vol_size))
2808
438
2809
439
        if val_vol_boot == bootable and val_vol_stat == 'available' \
2810
440
                and val_vol_name == vol_name and val_vol_size == vol_size:
2811
441
            self.log.debug(msg_attr)
2812
442
        else:
2813
443
            msg = ('Volume validation failed, {}'.format(msg_attr))
2814
444
            amulet.raise_status(amulet.FAIL, msg=msg)
2815
445
2816
446
        return vol_new
2817
447
2818
448
    def delete_resource(self, resource, resource_id,
2819
449
                        msg="resource", max_wait=120):
2820
450
        """Delete one openstack resource, such as one instance, keypair,
2821
451
        image, volume, stack, etc., and confirm deletion within max wait time.
2822
452
2823
453
        :param resource: pointer to os resource type, ex:glance_client.images
2824
454
        :param resource_id: unique name or id for the openstack resource
2825
455
        :param msg: text to identify purpose in logging
2826
456
        :param max_wait: maximum wait time in seconds
2827
457
        :returns: True if successful, otherwise False
2828
458
        """
2829
459
        self.log.debug('Deleting OpenStack resource '
2830
460
                       '{} ({})'.format(resource_id, msg))
2831
461
        num_before = len(list(resource.list()))
2832
462
        resource.delete(resource_id)
2833
463
2834
464
        tries = 0
2835
465
        num_after = len(list(resource.list()))
2836
466
        while num_after != (num_before - 1) and tries < (max_wait / 4):
2837
467
            self.log.debug('{} delete check: '
2838
468
                           '{} [{}:{}] {}'.format(msg, tries,
2839
469
                                                  num_before,
2840
470
                                                  num_after,
2841
471
                                                  resource_id))
2842
472
            time.sleep(4)
2843
473
            num_after = len(list(resource.list()))
2844
474
            tries += 1
2845
475
2846
476
        self.log.debug('{}:  expected, actual count = {}, '
2847
477
                       '{}'.format(msg, num_before - 1, num_after))
2848
478
2849
479
        if num_after == (num_before - 1):
2850
480
            return True
2851
481
        else:
2852
482
            self.log.error('{} delete timed out'.format(msg))
2853
483
            return False
2854
484
2855
485
    def resource_reaches_status(self, resource, resource_id,
2856
486
                                expected_stat='available',
2857
487
                                msg='resource', max_wait=120):
2858
488
        """Wait for an openstack resources status to reach an
2859
489
           expected status within a specified time.  Useful to confirm that
2860
490
           nova instances, cinder vols, snapshots, glance images, heat stacks
2861
491
           and other resources eventually reach the expected status.
2862
492
2863
493
        :param resource: pointer to os resource type, ex: heat_client.stacks
2864
494
        :param resource_id: unique id for the openstack resource
2865
495
        :param expected_stat: status to expect resource to reach
2866
496
        :param msg: text to identify purpose in logging
2867
497
        :param max_wait: maximum wait time in seconds
2868
498
        :returns: True if successful, False if status is not reached
2869
499
        """
2870
500
2871
501
        tries = 0
2872
502
        resource_stat = resource.get(resource_id).status
2873
503
        while resource_stat != expected_stat and tries < (max_wait / 4):
2874
504
            self.log.debug('{} status check: '
2875
505
                           '{} [{}:{}] {}'.format(msg, tries,
2876
506
                                                  resource_stat,
2877
507
                                                  expected_stat,
2878
508
                                                  resource_id))
2879
509
            time.sleep(4)
2880
510
            resource_stat = resource.get(resource_id).status
2881
511
            tries += 1
2882
512
2883
513
        self.log.debug('{}:  expected, actual status = {}, '
2884
514
                       '{}'.format(msg, resource_stat, expected_stat))
2885
515
2886
516
        if resource_stat == expected_stat:
2887
517
            return True
2888
518
        else:
2889
519
            self.log.debug('{} never reached expected status: '
2890
520
                           '{}'.format(resource_id, expected_stat))
2891
521
            return False
2892
522
2893
523
    def get_ceph_osd_id_cmd(self, index):
2894
524
        """Produce a shell command that will return a ceph-osd id."""
2895
525
        return ("`initctl list | grep 'ceph-osd ' | "
2896
526
                "awk 'NR=={} {{ print $2 }}' | "
2897
527
                "grep -o '[0-9]*'`".format(index + 1))
2898
528
2899
529
    def get_ceph_pools(self, sentry_unit):
2900
530
        """Return a dict of ceph pools from a single ceph unit, with
2901
531
        pool name as keys, pool id as vals."""
2902
532
        pools = {}
2903
533
        cmd = 'sudo ceph osd lspools'
2904
534
        output, code = sentry_unit.run(cmd)
2905
535
        if code != 0:
2906
536
            msg = ('{} `{}` returned {} '
2907
537
                   '{}'.format(sentry_unit.info['unit_name'],
2908
538
                               cmd, code, output))
2909
539
            amulet.raise_status(amulet.FAIL, msg=msg)
2910
540
2911
541
        # Example output: 0 data,1 metadata,2 rbd,3 cinder,4 glance,
2912
542
        for pool in str(output).split(','):
2913
543
            pool_id_name = pool.split(' ')
2914
544
            if len(pool_id_name) == 2:
2915
545
                pool_id = pool_id_name[0]
2916
546
                pool_name = pool_id_name[1]
2917
547
                pools[pool_name] = int(pool_id)
2918
548
2919
549
        self.log.debug('Pools on {}: {}'.format(sentry_unit.info['unit_name'],
2920
550
                                                pools))
2921
551
        return pools
2922
552
2923
553
    def get_ceph_df(self, sentry_unit):
2924
554
        """Return dict of ceph df json output, including ceph pool state.
2925
555
2926
556
        :param sentry_unit: Pointer to amulet sentry instance (juju unit)
2927
557
        :returns: Dict of ceph df output
2928
558
        """
2929
559
        cmd = 'sudo ceph df --format=json'
2930
560
        output, code = sentry_unit.run(cmd)
2931
561
        if code != 0:
2932
562
            msg = ('{} `{}` returned {} '
2933
563
                   '{}'.format(sentry_unit.info['unit_name'],
2934
564
                               cmd, code, output))
2935
565
            amulet.raise_status(amulet.FAIL, msg=msg)
2936
566
        return json.loads(output)
2937
567
2938
568
    def get_ceph_pool_sample(self, sentry_unit, pool_id=0):
2939
569
        """Take a sample of attributes of a ceph pool, returning ceph
2940
570
        pool name, object count and disk space used for the specified
2941
571
        pool ID number.
2942
572
2943
573
        :param sentry_unit: Pointer to amulet sentry instance (juju unit)
2944
574
        :param pool_id: Ceph pool ID
2945
575
        :returns: List of pool name, object count, kb disk space used
2946
576
        """
2947
577
        df = self.get_ceph_df(sentry_unit)
2948
578
        pool_name = df['pools'][pool_id]['name']
2949
579
        obj_count = df['pools'][pool_id]['stats']['objects']
2950
580
        kb_used = df['pools'][pool_id]['stats']['kb_used']
2951
581
        self.log.debug('Ceph {} pool (ID {}): {} objects, '
2952
582
                       '{} kb used'.format(pool_name, pool_id,
2953
583
                                           obj_count, kb_used))
2954
584
        return pool_name, obj_count, kb_used
2955
585
2956
586
    def validate_ceph_pool_samples(self, samples, sample_type="resource pool"):
2957
587
        """Validate ceph pool samples taken over time, such as pool
2958
588
        object counts or pool kb used, before adding, after adding, and
2959
589
        after deleting items which affect those pool attributes.  The
2960
590
        2nd element is expected to be greater than the 1st; 3rd is expected
2961
591
        to be less than the 2nd.
2962
592
2963
593
        :param samples: List containing 3 data samples
2964
594
        :param sample_type: String for logging and usage context
2965
595
        :returns: None if successful, Failure message otherwise
2966
596
        """
2967
597
        original, created, deleted = range(3)
2968
598
        if samples[created] <= samples[original] or \
2969
599
                samples[deleted] >= samples[created]:
2970
600
            return ('Ceph {} samples ({}) '
2971
601
                    'unexpected.'.format(sample_type, samples))
2972
602
        else:
2973
603
            self.log.debug('Ceph {} samples (OK): '
2974
604
                           '{}'.format(sample_type, samples))
2975
605
            return None
2976
606
2977
607
# rabbitmq/amdqp specific helpers:
2978
608
    def add_rmq_test_user(self, sentry_units,
2979
609
                          username="testuser1", password="changeme"):
2980
610
        """Add a test user via the first rmq juju unit, check connection as
2981
611
        the new user against all sentry units.
2982
612
2983
613
        :param sentry_units: list of sentry unit pointers
2984
614
        :param username: amqp user name, default to testuser1
2985
615
        :param password: amqp user password
2986
616
        :returns: None if successful.  Raise on error.
2987
617
        """
2988
618
        self.log.debug('Adding rmq user ({})...'.format(username))
2989
619
2990
620
        # Check that user does not already exist
2991
621
        cmd_user_list = 'rabbitmqctl list_users'
2992
622
        output, _ = self.run_cmd_unit(sentry_units[0], cmd_user_list)
2993
623
        if username in output:
2994
624
            self.log.warning('User ({}) already exists, returning '
2995
625
                             'gracefully.'.format(username))
2996
626
            return
2997
627
2998
628
        perms = '".*" ".*" ".*"'
2999
629
        cmds = ['rabbitmqctl add_user {} {}'.format(username, password),
3000
630
                'rabbitmqctl set_permissions {} {}'.format(username, perms)]
3001
631
3002
632
        # Add user via first unit
3003
633
        for cmd in cmds:
3004
634
            output, _ = self.run_cmd_unit(sentry_units[0], cmd)
3005
635
3006
636
        # Check connection against the other sentry_units
3007
637
        self.log.debug('Checking user connect against units...')
3008
638
        for sentry_unit in sentry_units:
3009
639
            connection = self.connect_amqp_by_unit(sentry_unit, ssl=False,
3010
640
                                                   fatal=False,
3011
641
                                                   username=username,
3012
642
                                                   password=password)
3013
643
            connection.close()
3014
644
3015
645
    def delete_rmq_test_user(self, sentry_units, username="testuser1"):
3016
646
        """Delete a rabbitmq user via the first rmq juju unit.
3017
647
3018
648
        :param sentry_units: list of sentry unit pointers
3019
649
        :param username: amqp user name, default to testuser1
3020
650
        :param password: amqp user password
3021
651
        :returns: None if successful or no such user.
3022
652
        """
3023
653
        self.log.debug('Deleting rmq user ({})...'.format(username))
3024
654
3025
655
        # Check that user does not already exist
3026
656
        cmd_user_list = 'rabbitmqctl list_users'
3027
657
        output, _ = self.run_cmd_unit(sentry_units[0], cmd_user_list)
3028
658
3029
659
        if username not in output:
3030
660
            self.log.warning('User ({}) does not exist, returning '
3031
661
                             'gracefully.'.format(username))
3032
662
            return
3033
663
3034
664
        # Delete the user
3035
665
        cmd_user_del = 'rabbitmqctl delete_user {}'.format(username)
3036
666
        output, _ = self.run_cmd_unit(sentry_units[0], cmd_user_del)
3037
667
3038
668
    def get_rmq_cluster_status(self, sentry_unit):
3039
669
        """Execute rabbitmq cluster status command on a unit and return
3040
670
        the full output.
3041
671
3042
672
        :param unit: sentry unit
3043
673
        :returns: String containing console output of cluster status command
3044
674
        """
3045
675
        cmd = 'rabbitmqctl cluster_status'
3046
676
        output, _ = self.run_cmd_unit(sentry_unit, cmd)
3047
677
        self.log.debug('{} cluster_status:\n{}'.format(
3048
678
            sentry_unit.info['unit_name'], output))
3049
679
        return str(output)
3050
680
3051
681
    def get_rmq_cluster_running_nodes(self, sentry_unit):
3052
682
        """Parse rabbitmqctl cluster_status output string, return list of
3053
683
        running rabbitmq cluster nodes.
3054
684
3055
685
        :param unit: sentry unit
3056
686
        :returns: List containing node names of running nodes
3057
687
        """
3058
688
        # NOTE(beisner): rabbitmqctl cluster_status output is not
3059
689
        # json-parsable, do string chop foo, then json.loads that.
3060
690
        str_stat = self.get_rmq_cluster_status(sentry_unit)
3061
691
        if 'running_nodes' in str_stat:
3062
692
            pos_start = str_stat.find("{running_nodes,") + 15
3063
693
            pos_end = str_stat.find("]},", pos_start) + 1
3064
694
            str_run_nodes = str_stat[pos_start:pos_end].replace("'", '"')
3065
695
            run_nodes = json.loads(str_run_nodes)
3066
696
            return run_nodes
3067
697
        else:
3068
698
            return []
3069
699
3070
700
    def validate_rmq_cluster_running_nodes(self, sentry_units):
3071
701
        """Check that all rmq unit hostnames are represented in the
3072
702
        cluster_status output of all units.
3073
703
3074
704
        :param host_names: dict of juju unit names to host names
3075
705
        :param units: list of sentry unit pointers (all rmq units)
3076
706
        :returns: None if successful, otherwise return error message
3077
707
        """
3078
708
        host_names = self.get_unit_hostnames(sentry_units)
3079
709
        errors = []
3080
710
3081
711
        # Query every unit for cluster_status running nodes
3082
712
        for query_unit in sentry_units:
3083
713
            query_unit_name = query_unit.info['unit_name']
3084
714
            running_nodes = self.get_rmq_cluster_running_nodes(query_unit)
3085
715
3086
716
            # Confirm that every unit is represented in the queried unit's
3087
717
            # cluster_status running nodes output.
3088
718
            for validate_unit in sentry_units:
3089
719
                val_host_name = host_names[validate_unit.info['unit_name']]
3090
720
                val_node_name = 'rabbit@{}'.format(val_host_name)
3091
721
3092
722
                if val_node_name not in running_nodes:
3093
723
                    errors.append('Cluster member check failed on {}: {} not '
3094
724
                                  'in {}\n'.format(query_unit_name,
3095
725
                                                   val_node_name,
3096
726
                                                   running_nodes))
3097
727
        if errors:
3098
728
            return ''.join(errors)
3099
729
3100
730
    def rmq_ssl_is_enabled_on_unit(self, sentry_unit, port=None):
3101
731
        """Check a single juju rmq unit for ssl and port in the config file."""
3102
732
        host = sentry_unit.info['public-address']
3103
733
        unit_name = sentry_unit.info['unit_name']
3104
734
3105
735
        conf_file = '/etc/rabbitmq/rabbitmq.config'
3106
736
        conf_contents = str(self.file_contents_safe(sentry_unit,
3107
737
                                                    conf_file, max_wait=16))
3108
738
        # Checks
3109
739
        conf_ssl = 'ssl' in conf_contents
3110
740
        conf_port = str(port) in conf_contents
3111
741
3112
742
        # Port explicitly checked in config
3113
743
        if port and conf_port and conf_ssl:
3114
744
            self.log.debug('SSL is enabled  @{}:{} '
3115
745
                           '({})'.format(host, port, unit_name))
3116
746
            return True
3117
747
        elif port and not conf_port and conf_ssl:
3118
748
            self.log.debug('SSL is enabled @{} but not on port {} '
3119
749
                           '({})'.format(host, port, unit_name))
3120
750
            return False
3121
751
        # Port not checked (useful when checking that ssl is disabled)
3122
752
        elif not port and conf_ssl:
3123
753
            self.log.debug('SSL is enabled  @{}:{} '
3124
754
                           '({})'.format(host, port, unit_name))
3125
755
            return True
3126
756
        elif not port and not conf_ssl:
3127
757
            self.log.debug('SSL not enabled @{}:{} '
3128
758
                           '({})'.format(host, port, unit_name))
3129
759
            return False
3130
760
        else:
3131
761
            msg = ('Unknown condition when checking SSL status @{}:{} '
3132
762
                   '({})'.format(host, port, unit_name))
3133
763
            amulet.raise_status(amulet.FAIL, msg)
3134
764
3135
765
    def validate_rmq_ssl_enabled_units(self, sentry_units, port=None):
3136
766
        """Check that ssl is enabled on rmq juju sentry units.
3137
767
3138
768
        :param sentry_units: list of all rmq sentry units
3139
769
        :param port: optional ssl port override to validate
3140
770
        :returns: None if successful, otherwise return error message
3141
771
        """
3142
772
        for sentry_unit in sentry_units:
3143
773
            if not self.rmq_ssl_is_enabled_on_unit(sentry_unit, port=port):
3144
774
                return ('Unexpected condition:  ssl is disabled on unit '
3145
775
                        '({})'.format(sentry_unit.info['unit_name']))
3146
776
        return None
3147
777
3148
778
    def validate_rmq_ssl_disabled_units(self, sentry_units):
3149
779
        """Check that ssl is enabled on listed rmq juju sentry units.
3150
780
3151
781
        :param sentry_units: list of all rmq sentry units
3152
782
        :returns: True if successful.  Raise on error.
3153
783
        """
3154
784
        for sentry_unit in sentry_units:
3155
785
            if self.rmq_ssl_is_enabled_on_unit(sentry_unit):
3156
786
                return ('Unexpected condition:  ssl is enabled on unit '
3157
787
                        '({})'.format(sentry_unit.info['unit_name']))
3158
788
        return None
3159
789
3160
790
    def configure_rmq_ssl_on(self, sentry_units, deployment,
3161
791
                             port=None, max_wait=60):
3162
792
        """Turn ssl charm config option on, with optional non-default
3163
793
        ssl port specification.  Confirm that it is enabled on every
3164
794
        unit.
3165
795
3166
796
        :param sentry_units: list of sentry units
3167
797
        :param deployment: amulet deployment object pointer
3168
798
        :param port: amqp port, use defaults if None
3169
799
        :param max_wait: maximum time to wait in seconds to confirm
3170
800
        :returns: None if successful.  Raise on error.
3171
801
        """
3172
802
        self.log.debug('Setting ssl charm config option:  on')
3173
803
3174
804
        # Enable RMQ SSL
3175
805
        config = {'ssl': 'on'}
3176
806
        if port:
3177
807
            config['ssl_port'] = port
3178
808
3179
809
        deployment.configure('rabbitmq-server', config)
3180
810
3181
811
        # Confirm
3182
812
        tries = 0
3183
813
        ret = self.validate_rmq_ssl_enabled_units(sentry_units, port=port)
3184
814
        while ret and tries < (max_wait / 4):
3185
815
            time.sleep(4)
3186
816
            self.log.debug('Attempt {}: {}'.format(tries, ret))
3187
817
            ret = self.validate_rmq_ssl_enabled_units(sentry_units, port=port)
3188
818
            tries += 1
3189
819
3190
820
        if ret:
3191
821
            amulet.raise_status(amulet.FAIL, ret)
3192
822
3193
823
    def configure_rmq_ssl_off(self, sentry_units, deployment, max_wait=60):
3194
824
        """Turn ssl charm config option off, confirm that it is disabled
3195
825
        on every unit.
3196
826
3197
827
        :param sentry_units: list of sentry units
3198
828
        :param deployment: amulet deployment object pointer
3199
829
        :param max_wait: maximum time to wait in seconds to confirm
3200
830
        :returns: None if successful.  Raise on error.
3201
831
        """
3202
832
        self.log.debug('Setting ssl charm config option:  off')
3203
833
3204
834
        # Disable RMQ SSL
3205
835
        config = {'ssl': 'off'}
3206
836
        deployment.configure('rabbitmq-server', config)
3207
837
3208
838
        # Confirm
3209
839
        tries = 0
3210
840
        ret = self.validate_rmq_ssl_disabled_units(sentry_units)
3211
841
        while ret and tries < (max_wait / 4):
3212
842
            time.sleep(4)
3213
843
            self.log.debug('Attempt {}: {}'.format(tries, ret))
3214
844
            ret = self.validate_rmq_ssl_disabled_units(sentry_units)
3215
845
            tries += 1
3216
846
3217
847
        if ret:
3218
848
            amulet.raise_status(amulet.FAIL, ret)
3219
849
3220
850
    def connect_amqp_by_unit(self, sentry_unit, ssl=False,
3221
851
                             port=None, fatal=True,
3222
852
                             username="testuser1", password="changeme"):
3223
853
        """Establish and return a pika amqp connection to the rabbitmq service
3224
854
        running on a rmq juju unit.
3225
855
3226
856
        :param sentry_unit: sentry unit pointer
3227
857
        :param ssl: boolean, default to False
3228
858
        :param port: amqp port, use defaults if None
3229
859
        :param fatal: boolean, default to True (raises on connect error)
3230
860
        :param username: amqp user name, default to testuser1
3231
861
        :param password: amqp user password
3232
862
        :returns: pika amqp connection pointer or None if failed and non-fatal
3233
863
        """
3234
864
        host = sentry_unit.info['public-address']
3235
865
        unit_name = sentry_unit.info['unit_name']
3236
866
3237
867
        # Default port logic if port is not specified
3238
868
        if ssl and not port:
3239
869
            port = 5671
3240
870
        elif not ssl and not port:
3241
871
            port = 5672
3242
872
3243
873
        self.log.debug('Connecting to amqp on {}:{} ({}) as '
3244
874
                       '{}...'.format(host, port, unit_name, username))
3245
875
3246
876
        try:
3247
877
            credentials = pika.PlainCredentials(username, password)
3248
878
            parameters = pika.ConnectionParameters(host=host, port=port,
3249
879
                                                   credentials=credentials,
3250
880
                                                   ssl=ssl,
3251
881
                                                   #heartbeat_interval=0,
3252
882
                                                   connection_attempts=3,
3253
883
                                                   retry_delay=5,
3254
884
                                                   socket_timeout=1)
3255
885
            connection = pika.BlockingConnection(parameters)
3256
886
            assert connection.server_properties['product'] == 'RabbitMQ'
3257
887
            self.log.debug('Connect OK')
3258
888
            return connection
3259
889
        except Exception as e:
3260
890
            msg = ('amqp connection failed to {}:{} as '
3261
891
                   '{} ({})'.format(host, port, username, str(e)))
3262
892
            if fatal:
3263
893
                amulet.raise_status(amulet.FAIL, msg)
3264
894
            else:
3265
895
                self.log.warn(msg)
3266
896
                return None
3267
897
3268
898
    def publish_amqp_message_by_unit(self, sentry_unit, message,
3269
899
                                     queue="test", ssl=False,
3270
900
                                     username="testuser1",
3271
901
                                     password="changeme",
3272
902
                                     port=None):
3273
903
        """Publish an amqp message to a rmq juju unit.
3274
904
3275
905
        :param sentry_unit: sentry unit pointer
3276
906
        :param message: amqp message string
3277
907
        :param queue: message queue, default to test
3278
908
        :param username: amqp user name, default to testuser1
3279
909
        :param password: amqp user password
3280
910
        :param ssl: boolean, default to False
3281
911
        :param port: amqp port, use defaults if None
3282
912
        :returns: None.  Raises exception if publish failed.
3283
913
        """
3284
914
        self.log.debug('Publishing message to {} queue:\n{}'.format(queue,
3285
915
                                                                    message))
3286
916
        connection = self.connect_amqp_by_unit(sentry_unit, ssl=ssl,
3287
917
                                               port=port,
3288
918
                                               username=username,
3289
919
                                               password=password)
3290
920
3291
921
        # NOTE(beisner): extra debug here re: pika hang potential:
3292
922
        #   https://github.com/pika/pika/issues/297
3293
923
        #   https://groups.google.com/forum/#!topic/rabbitmq-users/Ja0iyfF0Szw
3294
924
        self.log.debug('Defining channel...')
3295
925
        channel = connection.channel()
3296
926
        self.log.debug('Declaring queue...')
3297
927
        channel.queue_declare(queue=queue, auto_delete=False, durable=True)
3298
928
        self.log.debug('Publishing message...')
3299
929
        channel.basic_publish(exchange='', routing_key=queue, body=message)
3300
930
        self.log.debug('Closing channel...')
3301
931
        channel.close()
3302
932
        self.log.debug('Closing connection...')
3303
933
        connection.close()
3304
934
3305
935
    def get_amqp_message_by_unit(self, sentry_unit, queue="test",
3306
936
                                 username="testuser1",
3307
937
                                 password="changeme",
3308
938
                                 ssl=False, port=None):
3309
939
        """Get an amqp message from a rmq juju unit.
3310
940
3311
941
        :param sentry_unit: sentry unit pointer
3312
942
        :param queue: message queue, default to test
3313
943
        :param username: amqp user name, default to testuser1
3314
944
        :param password: amqp user password
3315
945
        :param ssl: boolean, default to False
3316
946
        :param port: amqp port, use defaults if None
3317
947
        :returns: amqp message body as string.  Raise if get fails.
3318
948
        """
3319
949
        connection = self.connect_amqp_by_unit(sentry_unit, ssl=ssl,
3320
950
                                               port=port,
3321
951
                                               username=username,
3322
952
                                               password=password)
3323
953
        channel = connection.channel()
3324
954
        method_frame, _, body = channel.basic_get(queue)
3325
955
3326
956
        if method_frame:
3327
957
            self.log.debug('Retreived message from {} queue:\n{}'.format(queue,
3328
958
                                                                         body))
3329
959
            channel.basic_ack(method_frame.delivery_tag)
3330
960
            channel.close()
3331
961
            connection.close()
3332
962
            return body
3333
963
        else:
3334
964
            msg = 'No message retrieved.'
3335
965
            amulet.raise_status(amulet.FAIL, msg)
3336
0
966
3337
=== removed directory 'tests/charmhelpers/contrib/ssl'
3338
=== removed file 'tests/charmhelpers/contrib/ssl/__init__.py'
3339
--- tests/charmhelpers/contrib/ssl/__init__.py	2015-04-13 22:11:34 +0000
3340
+++ tests/charmhelpers/contrib/ssl/__init__.py	1970-01-01 00:00:00 +0000
3341
@@ -1,94 +0,0 @@
3342
1
# Copyright 2014-2015 Canonical Limited.
3343
2
#
3344
3
# This file is part of charm-helpers.
3345
4
#
3346
5
# charm-helpers is free software: you can redistribute it and/or modify
3347
6
# it under the terms of the GNU Lesser General Public License version 3 as
3348
7
# published by the Free Software Foundation.
3349
8
#
3350
9
# charm-helpers is distributed in the hope that it will be useful,
3351
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
3352
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3353
12
# GNU Lesser General Public License for more details.
3354
13
#
3355
14
# You should have received a copy of the GNU Lesser General Public License
3356
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
3357
16
3358
17
import subprocess
3359
18
from charmhelpers.core import hookenv
3360
19
3361
20
3362
21
def generate_selfsigned(keyfile, certfile, keysize="1024", config=None, subject=None, cn=None):
3363
22
    """Generate selfsigned SSL keypair
3364
23
3365
24
    You must provide one of the 3 optional arguments:
3366
25
    config, subject or cn
3367
26
    If more than one is provided the leftmost will be used
3368
27
3369
28
    Arguments:
3370
29
    keyfile -- (required) full path to the keyfile to be created
3371
30
    certfile -- (required) full path to the certfile to be created
3372
31
    keysize -- (optional) SSL key length
3373
32
    config -- (optional) openssl configuration file
3374
33
    subject -- (optional) dictionary with SSL subject variables
3375
34
    cn -- (optional) cerfificate common name
3376
35
3377
36
    Required keys in subject dict:
3378
37
    cn -- Common name (eq. FQDN)
3379
38
3380
39
    Optional keys in subject dict
3381
40
    country -- Country Name (2 letter code)
3382
41
    state -- State or Province Name (full name)
3383
42
    locality -- Locality Name (eg, city)
3384
43
    organization -- Organization Name (eg, company)
3385
44
    organizational_unit -- Organizational Unit Name (eg, section)
3386
45
    email -- Email Address
3387
46
    """
3388
47
3389
48
    cmd = []
3390
49
    if config:
3391
50
        cmd = ["/usr/bin/openssl", "req", "-new", "-newkey",
3392
51
               "rsa:{}".format(keysize), "-days", "365", "-nodes", "-x509",
3393
52
               "-keyout", keyfile,
3394
53
               "-out", certfile, "-config", config]
3395
54
    elif subject:
3396
55
        ssl_subject = ""
3397
56
        if "country" in subject:
3398
57
            ssl_subject = ssl_subject + "/C={}".format(subject["country"])
3399
58
        if "state" in subject:
3400
59
            ssl_subject = ssl_subject + "/ST={}".format(subject["state"])
3401
60
        if "locality" in subject:
3402
61
            ssl_subject = ssl_subject + "/L={}".format(subject["locality"])
3403
62
        if "organization" in subject:
3404
63
            ssl_subject = ssl_subject + "/O={}".format(subject["organization"])
3405
64
        if "organizational_unit" in subject:
3406
65
            ssl_subject = ssl_subject + "/OU={}".format(subject["organizational_unit"])
3407
66
        if "cn" in subject:
3408
67
            ssl_subject = ssl_subject + "/CN={}".format(subject["cn"])
3409
68
        else:
3410
69
            hookenv.log("When using \"subject\" argument you must "
3411
70
                        "provide \"cn\" field at very least")
3412
71
            return False
3413
72
        if "email" in subject:
3414
73
            ssl_subject = ssl_subject + "/emailAddress={}".format(subject["email"])
3415
74
3416
75
        cmd = ["/usr/bin/openssl", "req", "-new", "-newkey",
3417
76
               "rsa:{}".format(keysize), "-days", "365", "-nodes", "-x509",
3418
77
               "-keyout", keyfile,
3419
78
               "-out", certfile, "-subj", ssl_subject]
3420
79
    elif cn:
3421
80
        cmd = ["/usr/bin/openssl", "req", "-new", "-newkey",
3422
81
               "rsa:{}".format(keysize), "-days", "365", "-nodes", "-x509",
3423
82
               "-keyout", keyfile,
3424
83
               "-out", certfile, "-subj", "/CN={}".format(cn)]
3425
84
3426
85
    if not cmd:
3427
86
        hookenv.log("No config, subject or cn provided,"
3428
87
                    "unable to generate self signed SSL certificates")
3429
88
        return False
3430
89
    try:
3431
90
        subprocess.check_call(cmd)
3432
91
        return True
3433
92
    except Exception as e:
3434
93
        print("Execution of openssl command failed:\n{}".format(e))
3435
94
        return False
3436
95
0
3437
=== removed file 'tests/charmhelpers/contrib/ssl/service.py'
3438
--- tests/charmhelpers/contrib/ssl/service.py	2015-04-16 21:35:24 +0000
3439
+++ tests/charmhelpers/contrib/ssl/service.py	1970-01-01 00:00:00 +0000
3440
@@ -1,279 +0,0 @@
3441
1
# Copyright 2014-2015 Canonical Limited.
3442
2
#
3443
3
# This file is part of charm-helpers.
3444
4
#
3445
5
# charm-helpers is free software: you can redistribute it and/or modify
3446
6
# it under the terms of the GNU Lesser General Public License version 3 as
3447
7
# published by the Free Software Foundation.
3448
8
#
3449
9
# charm-helpers is distributed in the hope that it will be useful,
3450
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
3451
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3452
12
# GNU Lesser General Public License for more details.
3453
13
#
3454
14
# You should have received a copy of the GNU Lesser General Public License
3455
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
3456
16
3457
17
import os
3458
18
from os.path import join as path_join
3459
19
from os.path import exists
3460
20
import subprocess
3461
21
3462
22
from charmhelpers.core.hookenv import log, DEBUG
3463
23
3464
24
STD_CERT = "standard"
3465
25
3466
26
# Mysql server is fairly picky about cert creation
3467
27
# and types, spec its creation separately for now.
3468
28
MYSQL_CERT = "mysql"
3469
29
3470
30
3471
31
class ServiceCA(object):
3472
32
3473
33
    default_expiry = str(365 * 2)
3474
34
    default_ca_expiry = str(365 * 6)
3475
35
3476
36
    def __init__(self, name, ca_dir, cert_type=STD_CERT):
3477
37
        self.name = name
3478
38
        self.ca_dir = ca_dir
3479
39
        self.cert_type = cert_type
3480
40
3481
41
    ###############
3482
42
    # Hook Helper API
3483
43
    @staticmethod
3484
44
    def get_ca(type=STD_CERT):
3485
45
        service_name = os.environ['JUJU_UNIT_NAME'].split('/')[0]
3486
46
        ca_path = os.path.join(os.environ['CHARM_DIR'], 'ca')
3487
47
        ca = ServiceCA(service_name, ca_path, type)
3488
48
        ca.init()
3489
49
        return ca
3490
50
3491
51
    @classmethod
3492
52
    def get_service_cert(cls, type=STD_CERT):
3493
53
        service_name = os.environ['JUJU_UNIT_NAME'].split('/')[0]
3494
54
        ca = cls.get_ca()
3495
55
        crt, key = ca.get_or_create_cert(service_name)
3496
56
        return crt, key, ca.get_ca_bundle()
3497
57
3498
58
    ###############
3499
59
3500
60
    def init(self):
3501
61
        log("initializing service ca", level=DEBUG)
3502
62
        if not exists(self.ca_dir):
3503
63
            self._init_ca_dir(self.ca_dir)
3504
64
            self._init_ca()
3505
65
3506
66
    @property
3507
67
    def ca_key(self):
3508
68
        return path_join(self.ca_dir, 'private', 'cacert.key')
3509
69
3510
70
    @property
3511
71
    def ca_cert(self):
3512
72
        return path_join(self.ca_dir, 'cacert.pem')
3513
73
3514
74
    @property
3515
75
    def ca_conf(self):
3516
76
        return path_join(self.ca_dir, 'ca.cnf')
3517
77
3518
78
    @property
3519
79
    def signing_conf(self):
3520
80
        return path_join(self.ca_dir, 'signing.cnf')
3521
81
3522
82
    def _init_ca_dir(self, ca_dir):
3523
83
        os.mkdir(ca_dir)
3524
84
        for i in ['certs', 'crl', 'newcerts', 'private']:
3525
85
            sd = path_join(ca_dir, i)
3526
86
            if not exists(sd):
3527
87
                os.mkdir(sd)
3528
88
3529
89
        if not exists(path_join(ca_dir, 'serial')):
3530
90
            with open(path_join(ca_dir, 'serial'), 'w') as fh:
3531
91
                fh.write('02\n')
3532
92
3533
93
        if not exists(path_join(ca_dir, 'index.txt')):
3534
94
            with open(path_join(ca_dir, 'index.txt'), 'w') as fh:
3535
95
                fh.write('')
3536
96
3537
97
    def _init_ca(self):
3538
98
        """Generate the root ca's cert and key.
3539
99
        """
3540
100
        if not exists(path_join(self.ca_dir, 'ca.cnf')):
3541
101
            with open(path_join(self.ca_dir, 'ca.cnf'), 'w') as fh:
3542
102
                fh.write(
3543
103
                    CA_CONF_TEMPLATE % (self.get_conf_variables()))
3544
104
3545
105
        if not exists(path_join(self.ca_dir, 'signing.cnf')):
3546
106
            with open(path_join(self.ca_dir, 'signing.cnf'), 'w') as fh:
3547
107
                fh.write(
3548
108
                    SIGNING_CONF_TEMPLATE % (self.get_conf_variables()))
3549
109
3550
110
        if exists(self.ca_cert) or exists(self.ca_key):
3551
111
            raise RuntimeError("Initialized called when CA already exists")
3552
112
        cmd = ['openssl', 'req', '-config', self.ca_conf,
3553
113
               '-x509', '-nodes', '-newkey', 'rsa',
3554
114
               '-days', self.default_ca_expiry,
3555
115
               '-keyout', self.ca_key, '-out', self.ca_cert,
3556
116
               '-outform', 'PEM']
3557
117
        output = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
3558
118
        log("CA Init:\n %s" % output, level=DEBUG)
3559
119
3560
120
    def get_conf_variables(self):
3561
121
        return dict(
3562
122
            org_name="juju",
3563
123
            org_unit_name="%s service" % self.name,
3564
124
            common_name=self.name,
3565
125
            ca_dir=self.ca_dir)
3566
126
3567
127
    def get_or_create_cert(self, common_name):
3568
128
        if common_name in self:
3569
129
            return self.get_certificate(common_name)
3570
130
        return self.create_certificate(common_name)
3571
131
3572
132
    def create_certificate(self, common_name):
3573
133
        if common_name in self:
3574
134
            return self.get_certificate(common_name)
3575
135
        key_p = path_join(self.ca_dir, "certs", "%s.key" % common_name)
3576
136
        crt_p = path_join(self.ca_dir, "certs", "%s.crt" % common_name)
3577
137
        csr_p = path_join(self.ca_dir, "certs", "%s.csr" % common_name)
3578
138
        self._create_certificate(common_name, key_p, csr_p, crt_p)
3579
139
        return self.get_certificate(common_name)
3580
140
3581
141
    def get_certificate(self, common_name):
3582
142
        if common_name not in self:
3583
143
            raise ValueError("No certificate for %s" % common_name)
3584
144
        key_p = path_join(self.ca_dir, "certs", "%s.key" % common_name)
3585
145
        crt_p = path_join(self.ca_dir, "certs", "%s.crt" % common_name)
3586
146
        with open(crt_p) as fh:
3587
147
            crt = fh.read()
3588
148
        with open(key_p) as fh:
3589
149
            key = fh.read()
3590
150
        return crt, key
3591
151
3592
152
    def __contains__(self, common_name):
3593
153
        crt_p = path_join(self.ca_dir, "certs", "%s.crt" % common_name)
3594
154
        return exists(crt_p)
3595
155
3596
156
    def _create_certificate(self, common_name, key_p, csr_p, crt_p):
3597
157
        template_vars = self.get_conf_variables()
3598
158
        template_vars['common_name'] = common_name
3599
159
        subj = '/O=%(org_name)s/OU=%(org_unit_name)s/CN=%(common_name)s' % (
3600
160
            template_vars)
3601
161
3602
162
        log("CA Create Cert %s" % common_name, level=DEBUG)
3603
163
        cmd = ['openssl', 'req', '-sha1', '-newkey', 'rsa:2048',
3604
164
               '-nodes', '-days', self.default_expiry,
3605
165
               '-keyout', key_p, '-out', csr_p, '-subj', subj]
3606
166
        subprocess.check_call(cmd, stderr=subprocess.PIPE)
3607
167
        cmd = ['openssl', 'rsa', '-in', key_p, '-out', key_p]
3608
168
        subprocess.check_call(cmd, stderr=subprocess.PIPE)
3609
169
3610
170
        log("CA Sign Cert %s" % common_name, level=DEBUG)
3611
171
        if self.cert_type == MYSQL_CERT:
3612
172
            cmd = ['openssl', 'x509', '-req',
3613
173
                   '-in', csr_p, '-days', self.default_expiry,
3614
174
                   '-CA', self.ca_cert, '-CAkey', self.ca_key,
3615
175
                   '-set_serial', '01', '-out', crt_p]
3616
176
        else:
3617
177
            cmd = ['openssl', 'ca', '-config', self.signing_conf,
3618
178
                   '-extensions', 'req_extensions',
3619
179
                   '-days', self.default_expiry, '-notext',
3620
180
                   '-in', csr_p, '-out', crt_p, '-subj', subj, '-batch']
3621
181
        log("running %s" % " ".join(cmd), level=DEBUG)
3622
182
        subprocess.check_call(cmd, stderr=subprocess.PIPE)
3623
183
3624
184
    def get_ca_bundle(self):
3625
185
        with open(self.ca_cert) as fh:
3626
186
            return fh.read()
3627
187
3628
188
3629
189
CA_CONF_TEMPLATE = """
3630
190
[ ca ]
3631
191
default_ca = CA_default
3632
192
3633
193
[ CA_default ]
3634
194
dir                     = %(ca_dir)s
3635
195
policy                  = policy_match
3636
196
database                = $dir/index.txt
3637
197
serial                  = $dir/serial
3638
198
certs                   = $dir/certs
3639
199
crl_dir                 = $dir/crl
3640
200
new_certs_dir           = $dir/newcerts
3641
201
certificate             = $dir/cacert.pem
3642
202
private_key             = $dir/private/cacert.key
3643
203
RANDFILE                = $dir/private/.rand
3644
204
default_md              = default
3645
205
3646
206
[ req ]
3647
207
default_bits            = 1024
3648
208
default_md              = sha1
3649
209
3650
210
prompt                  = no
3651
211
distinguished_name      = ca_distinguished_name
3652
212
3653
213
x509_extensions         = ca_extensions
3654
214
3655
215
[ ca_distinguished_name ]
3656
216
organizationName        = %(org_name)s
3657
217
organizationalUnitName  = %(org_unit_name)s Certificate Authority
3658
218
3659
219
3660
220
[ policy_match ]
3661
221
countryName             = optional
3662
222
stateOrProvinceName     = optional
3663
223
organizationName        = match
3664
224
organizationalUnitName  = optional
3665
225
commonName              = supplied
3666
226
3667
227
[ ca_extensions ]
3668
228
basicConstraints        = critical,CA:true
3669
229
subjectKeyIdentifier    = hash
3670
230
authorityKeyIdentifier  = keyid:always, issuer
3671
231
keyUsage                = cRLSign, keyCertSign
3672
232
"""
3673
233
3674
234
3675
235
SIGNING_CONF_TEMPLATE = """
3676
236
[ ca ]
3677
237
default_ca = CA_default
3678
238
3679
239
[ CA_default ]
3680
240
dir                     = %(ca_dir)s
3681
241
policy                  = policy_match
3682
242
database                = $dir/index.txt
3683
243
serial                  = $dir/serial
3684
244
certs                   = $dir/certs
3685
245
crl_dir                 = $dir/crl
3686
246
new_certs_dir           = $dir/newcerts
3687
247
certificate             = $dir/cacert.pem
3688
248
private_key             = $dir/private/cacert.key
3689
249
RANDFILE                = $dir/private/.rand
3690
250
default_md              = default
3691
251
3692
252
[ req ]
3693
253
default_bits            = 1024
3694
254
default_md              = sha1
3695
255
3696
256
prompt                  = no
3697
257
distinguished_name      = req_distinguished_name
3698
258
3699
259
x509_extensions         = req_extensions
3700
260
3701
261
[ req_distinguished_name ]
3702
262
organizationName        = %(org_name)s
3703
263
organizationalUnitName  = %(org_unit_name)s machine resources
3704
264
commonName              = %(common_name)s
3705
265
3706
266
[ policy_match ]
3707
267
countryName             = optional
3708
268
stateOrProvinceName     = optional
3709
269
organizationName        = match
3710
270
organizationalUnitName  = optional
3711
271
commonName              = supplied
3712
272
3713
273
[ req_extensions ]
3714
274
basicConstraints        = CA:false
3715
275
subjectKeyIdentifier    = hash
3716
276
authorityKeyIdentifier  = keyid:always, issuer
3717
277
keyUsage                = digitalSignature, keyEncipherment, keyAgreement
3718
278
extendedKeyUsage        = serverAuth, clientAuth
3719
279
"""
3720
280
0
3721
=== removed directory 'tests/charmhelpers/core'
3722
=== removed file 'tests/charmhelpers/core/__init__.py'
3723
--- tests/charmhelpers/core/__init__.py	2015-04-13 22:11:34 +0000
3724
+++ tests/charmhelpers/core/__init__.py	1970-01-01 00:00:00 +0000
3725
@@ -1,15 +0,0 @@
3726
1
# Copyright 2014-2015 Canonical Limited.
3727
2
#
3728
3
# This file is part of charm-helpers.
3729
4
#
3730
5
# charm-helpers is free software: you can redistribute it and/or modify
3731
6
# it under the terms of the GNU Lesser General Public License version 3 as
3732
7
# published by the Free Software Foundation.
3733
8
#
3734
9
# charm-helpers is distributed in the hope that it will be useful,
3735
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
3736
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3737
12
# GNU Lesser General Public License for more details.
3738
13
#
3739
14
# You should have received a copy of the GNU Lesser General Public License
3740
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
3741
16
0
3742
=== removed file 'tests/charmhelpers/core/decorators.py'
3743
--- tests/charmhelpers/core/decorators.py	2015-04-13 22:11:34 +0000
3744
+++ tests/charmhelpers/core/decorators.py	1970-01-01 00:00:00 +0000
3745
@@ -1,57 +0,0 @@
3746
1
# Copyright 2014-2015 Canonical Limited.
3747
2
#
3748
3
# This file is part of charm-helpers.
3749
4
#
3750
5
# charm-helpers is free software: you can redistribute it and/or modify
3751
6
# it under the terms of the GNU Lesser General Public License version 3 as
3752
7
# published by the Free Software Foundation.
3753
8
#
3754
9
# charm-helpers is distributed in the hope that it will be useful,
3755
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
3756
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3757
12
# GNU Lesser General Public License for more details.
3758
13
#
3759
14
# You should have received a copy of the GNU Lesser General Public License
3760
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
3761
16
3762
17
#
3763
18
# Copyright 2014 Canonical Ltd.
3764
19
#
3765
20
# Authors:
3766
21
#  Edward Hope-Morley <opentastic@gmail.com>
3767
22
#
3768
23
3769
24
import time
3770
25
3771
26
from charmhelpers.core.hookenv import (
3772
27
    log,
3773
28
    INFO,
3774
29
)
3775
30
3776
31
3777
32
def retry_on_exception(num_retries, base_delay=0, exc_type=Exception):
3778
33
    """If the decorated function raises exception exc_type, allow num_retries
3779
34
    retry attempts before raise the exception.
3780
35
    """
3781
36
    def _retry_on_exception_inner_1(f):
3782
37
        def _retry_on_exception_inner_2(*args, **kwargs):
3783
38
            retries = num_retries
3784
39
            multiplier = 1
3785
40
            while True:
3786
41
                try:
3787
42
                    return f(*args, **kwargs)
3788
43
                except exc_type:
3789
44
                    if not retries:
3790
45
                        raise
3791
46
3792
47
                delay = base_delay * multiplier
3793
48
                multiplier += 1
3794
49
                log("Retrying '%s' %d more times (delay=%s)" %
3795
50
                    (f.__name__, retries, delay), level=INFO)
3796
51
                retries -= 1
3797
52
                if delay:
3798
53
                    time.sleep(delay)
3799
54
3800
55
        return _retry_on_exception_inner_2
3801
56
3802
57
    return _retry_on_exception_inner_1
3803
58
0
3804
=== removed file 'tests/charmhelpers/core/files.py'
3805
--- tests/charmhelpers/core/files.py	2015-07-29 10:48:05 +0000
3806
+++ tests/charmhelpers/core/files.py	1970-01-01 00:00:00 +0000
3807
@@ -1,45 +0,0 @@
3808
1
#!/usr/bin/env python
3809
2
# -*- coding: utf-8 -*-
3810
3
3811
4
# Copyright 2014-2015 Canonical Limited.
3812
5
#
3813
6
# This file is part of charm-helpers.
3814
7
#
3815
8
# charm-helpers is free software: you can redistribute it and/or modify
3816
9
# it under the terms of the GNU Lesser General Public License version 3 as
3817
10
# published by the Free Software Foundation.
3818
11
#
3819
12
# charm-helpers is distributed in the hope that it will be useful,
3820
13
# but WITHOUT ANY WARRANTY; without even the implied warranty of
3821
14
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3822
15
# GNU Lesser General Public License for more details.
3823
16
#
3824
17
# You should have received a copy of the GNU Lesser General Public License
3825
18
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
3826
19
3827
20
__author__ = 'Jorge Niedbalski <niedbalski@ubuntu.com>'
3828
21
3829
22
import os
3830
23
import subprocess
3831
24
3832
25
3833
26
def sed(filename, before, after, flags='g'):
3834
27
    """
3835
28
    Search and replaces the given pattern on filename.
3836
29
3837
30
    :param filename: relative or absolute file path.
3838
31
    :param before: expression to be replaced (see 'man sed')
3839
32
    :param after: expression to replace with (see 'man sed')
3840
33
    :param flags: sed-compatible regex flags in example, to make
3841
34
    the  search and replace case insensitive, specify ``flags="i"``.
3842
35
    The ``g`` flag is always specified regardless, so you do not
3843
36
    need to remember to include it when overriding this parameter.
3844
37
    :returns: If the sed command exit code was zero then return,
3845
38
    otherwise raise CalledProcessError.
3846
39
    """
3847
40
    expression = r's/{0}/{1}/{2}'.format(before,
3848
41
                                         after, flags)
3849
42
3850
43
    return subprocess.check_call(["sed", "-i", "-r", "-e",
3851
44
                                  expression,
3852
45
                                  os.path.expanduser(filename)])
3853
46
0
3854
=== removed file 'tests/charmhelpers/core/fstab.py'
3855
--- tests/charmhelpers/core/fstab.py	2015-04-13 22:11:34 +0000
3856
+++ tests/charmhelpers/core/fstab.py	1970-01-01 00:00:00 +0000
3857
@@ -1,134 +0,0 @@
3858
1
#!/usr/bin/env python
3859
2
# -*- coding: utf-8 -*-
3860
3
3861
4
# Copyright 2014-2015 Canonical Limited.
3862
5
#
3863
6
# This file is part of charm-helpers.
3864
7
#
3865
8
# charm-helpers is free software: you can redistribute it and/or modify
3866
9
# it under the terms of the GNU Lesser General Public License version 3 as
3867
10
# published by the Free Software Foundation.
3868
11
#
3869
12
# charm-helpers is distributed in the hope that it will be useful,
3870
13
# but WITHOUT ANY WARRANTY; without even the implied warranty of
3871
14
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
3872
15
# GNU Lesser General Public License for more details.
3873
16
#
3874
17
# You should have received a copy of the GNU Lesser General Public License
3875
18
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
3876
19
3877
20
import io
3878
21
import os
3879
22
3880
23
__author__ = 'Jorge Niedbalski R. <jorge.niedbalski@canonical.com>'
3881
24
3882
25
3883
26
class Fstab(io.FileIO):
3884
27
    """This class extends file in order to implement a file reader/writer
3885
28
    for file `/etc/fstab`
3886
29
    """
3887
30
3888
31
    class Entry(object):
3889
32
        """Entry class represents a non-comment line on the `/etc/fstab` file
3890
33
        """
3891
34
        def __init__(self, device, mountpoint, filesystem,
3892
35
                     options, d=0, p=0):
3893
36
            self.device = device
3894
37
            self.mountpoint = mountpoint
3895
38
            self.filesystem = filesystem
3896
39
3897
40
            if not options:
3898
41
                options = "defaults"
3899
42
3900
43
            self.options = options
3901
44
            self.d = int(d)
3902
45
            self.p = int(p)
3903
46
3904
47
        def __eq__(self, o):
3905
48
            return str(self) == str(o)
3906
49
3907
50
        def __str__(self):
3908
51
            return "{} {} {} {} {} {}".format(self.device,
3909
52
                                              self.mountpoint,
3910
53
                                              self.filesystem,
3911
54
                                              self.options,
3912
55
                                              self.d,
3913
56
                                              self.p)
3914
57
3915
58
    DEFAULT_PATH = os.path.join(os.path.sep, 'etc', 'fstab')
3916
59
3917
60
    def __init__(self, path=None):
3918
61
        if path:
3919
62
            self._path = path
3920
63
        else:
3921
64
            self._path = self.DEFAULT_PATH
3922
65
        super(Fstab, self).__init__(self._path, 'rb+')
3923
66
3924
67
    def _hydrate_entry(self, line):
3925
68
        # NOTE: use split with no arguments to split on any
3926
69
        #       whitespace including tabs
3927
70
        return Fstab.Entry(*filter(
3928
71
            lambda x: x not in ('', None),
3929
72
            line.strip("\n").split()))
3930
73
3931
74
    @property
3932
75
    def entries(self):
3933
76
        self.seek(0)
3934
77
        for line in self.readlines():
3935
78
            line = line.decode('us-ascii')
3936
79
            try:
3937
80
                if line.strip() and not line.strip().startswith("#"):
3938
81
                    yield self._hydrate_entry(line)
3939
82
            except ValueError:
3940
83
                pass
3941
84
3942
85
    def get_entry_by_attr(self, attr, value):
3943
86
        for entry in self.entries:
3944
87
            e_attr = getattr(entry, attr)
3945
88
            if e_attr == value:
3946
89
                return entry
3947
90
        return None
3948
91
3949
92
    def add_entry(self, entry):
3950
93
        if self.get_entry_by_attr('device', entry.device):
3951
94
            return False
3952
95
3953
96
        self.write((str(entry) + '\n').encode('us-ascii'))
3954
97
        self.truncate()
3955
98
        return entry
3956
99
3957
100
    def remove_entry(self, entry):
3958
101
        self.seek(0)
3959
102
3960
103
        lines = [l.decode('us-ascii') for l in self.readlines()]
3961
104
3962
105
        found = False
3963
106
        for index, line in enumerate(lines):
3964
107
            if line.strip() and not line.strip().startswith("#"):
3965
108
                if self._hydrate_entry(line) == entry:
3966
109
                    found = True
3967
110
                    break
3968
111
3969
112
        if not found:
3970
113
            return False
3971
114
3972
115
        lines.remove(line)
3973
116
3974
117
        self.seek(0)
3975
118
        self.write(''.join(lines).encode('us-ascii'))
3976
119
        self.truncate()
3977
120
        return True
3978
121
3979
122
    @classmethod
3980
123
    def remove_by_mountpoint(cls, mountpoint, path=None):
3981
124
        fstab = cls(path=path)
3982
125
        entry = fstab.get_entry_by_attr('mountpoint', mountpoint)
3983
126
        if entry:
3984
127
            return fstab.remove_entry(entry)
3985
128
        return False
3986
129
3987
130
    @classmethod
3988
131
    def add(cls, device, mountpoint, filesystem, options=None, path=None):
3989
132
        return cls(path=path).add_entry(Fstab.Entry(device,
3990
133
                                                    mountpoint, filesystem,
3991
134
                                                    options=options))
3992
135
0
3993
=== removed file 'tests/charmhelpers/core/hookenv.py'
3994
--- tests/charmhelpers/core/hookenv.py	2015-08-19 13:49:53 +0000
3995
+++ tests/charmhelpers/core/hookenv.py	1970-01-01 00:00:00 +0000
3996
@@ -1,896 +0,0 @@
3997
1
# Copyright 2014-2015 Canonical Limited.
3998
2
#
3999
3
# This file is part of charm-helpers.
4000
4
#
4001
5
# charm-helpers is free software: you can redistribute it and/or modify
4002
6
# it under the terms of the GNU Lesser General Public License version 3 as
4003
7
# published by the Free Software Foundation.
4004
8
#
4005
9
# charm-helpers is distributed in the hope that it will be useful,
4006
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
4007
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4008
12
# GNU Lesser General Public License for more details.
4009
13
#
4010
14
# You should have received a copy of the GNU Lesser General Public License
4011
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
4012
16
4013
17
"Interactions with the Juju environment"
4014
18
# Copyright 2013 Canonical Ltd.
4015
19
#
4016
20
# Authors:
4017
21
#  Charm Helpers Developers <juju@lists.ubuntu.com>
4018
22
4019
23
from __future__ import print_function
4020
24
import copy
4021
25
from distutils.version import LooseVersion
4022
26
from functools import wraps
4023
27
import glob
4024
28
import os
4025
29
import json
4026
30
import yaml
4027
31
import subprocess
4028
32
import sys
4029
33
import errno
4030
34
import tempfile
4031
35
from subprocess import CalledProcessError
4032
36
4033
37
import six
4034
38
if not six.PY3:
4035
39
    from UserDict import UserDict
4036
40
else:
4037
41
    from collections import UserDict
4038
42
4039
43
CRITICAL = "CRITICAL"
4040
44
ERROR = "ERROR"
4041
45
WARNING = "WARNING"
4042
46
INFO = "INFO"
4043
47
DEBUG = "DEBUG"
4044
48
MARKER = object()
4045
49
4046
50
cache = {}
4047
51
4048
52
4049
53
def cached(func):
4050
54
    """Cache return values for multiple executions of func + args
4051
55
4052
56
    For example::
4053
57
4054
58
        @cached
4055
59
        def unit_get(attribute):
4056
60
            pass
4057
61
4058
62
        unit_get('test')
4059
63
4060
64
    will cache the result of unit_get + 'test' for future calls.
4061
65
    """
4062
66
    @wraps(func)
4063
67
    def wrapper(*args, **kwargs):
4064
68
        global cache
4065
69
        key = str((func, args, kwargs))
4066
70
        try:
4067
71
            return cache[key]
4068
72
        except KeyError:
4069
73
            pass  # Drop out of the exception handler scope.
4070
74
        res = func(*args, **kwargs)
4071
75
        cache[key] = res
4072
76
        return res
4073
77
    wrapper._wrapped = func
4074
78
    return wrapper
4075
79
4076
80
4077
81
def flush(key):
4078
82
    """Flushes any entries from function cache where the
4079
83
    key is found in the function+args """
4080
84
    flush_list = []
4081
85
    for item in cache:
4082
86
        if key in item:
4083
87
            flush_list.append(item)
4084
88
    for item in flush_list:
4085
89
        del cache[item]
4086
90
4087
91
4088
92
def log(message, level=None):
4089
93
    """Write a message to the juju log"""
4090
94
    command = ['juju-log']
4091
95
    if level:
4092
96
        command += ['-l', level]
4093
97
    if not isinstance(message, six.string_types):
4094
98
        message = repr(message)
4095
99
    command += [message]
4096
100
    # Missing juju-log should not cause failures in unit tests
4097
101
    # Send log output to stderr
4098
102
    try:
4099
103
        subprocess.call(command)
4100
104
    except OSError as e:
4101
105
        if e.errno == errno.ENOENT:
4102
106
            if level:
4103
107
                message = "{}: {}".format(level, message)
4104
108
            message = "juju-log: {}".format(message)
4105
109
            print(message, file=sys.stderr)
4106
110
        else:
4107
111
            raise
4108
112
4109
113
4110
114
class Serializable(UserDict):
4111
115
    """Wrapper, an object that can be serialized to yaml or json"""
4112
116
4113
117
    def __init__(self, obj):
4114
118
        # wrap the object
4115
119
        UserDict.__init__(self)
4116
120
        self.data = obj
4117
121
4118
122
    def __getattr__(self, attr):
4119
123
        # See if this object has attribute.
4120
124
        if attr in ("json", "yaml", "data"):
4121
125
            return self.__dict__[attr]
4122
126
        # Check for attribute in wrapped object.
4123
127
        got = getattr(self.data, attr, MARKER)
4124
128
        if got is not MARKER:
4125
129
            return got
4126
130
        # Proxy to the wrapped object via dict interface.
4127
131
        try:
4128
132
            return self.data[attr]
4129
133
        except KeyError:
4130
134
            raise AttributeError(attr)
4131
135
4132
136
    def __getstate__(self):
4133
137
        # Pickle as a standard dictionary.
4134
138
        return self.data
4135
139
4136
140
    def __setstate__(self, state):
4137
141
        # Unpickle into our wrapper.
4138
142
        self.data = state
4139
143
4140
144
    def json(self):
4141
145
        """Serialize the object to json"""
4142
146
        return json.dumps(self.data)
4143
147
4144
148
    def yaml(self):
4145
149
        """Serialize the object to yaml"""
4146
150
        return yaml.dump(self.data)
4147
151
4148
152
4149
153
def execution_environment():
4150
154
    """A convenient bundling of the current execution context"""
4151
155
    context = {}
4152
156
    context['conf'] = config()
4153
157
    if relation_id():
4154
158
        context['reltype'] = relation_type()
4155
159
        context['relid'] = relation_id()
4156
160
        context['rel'] = relation_get()
4157
161
    context['unit'] = local_unit()
4158
162
    context['rels'] = relations()
4159
163
    context['env'] = os.environ
4160
164
    return context
4161
165
4162
166
4163
167
def in_relation_hook():
4164
168
    """Determine whether we're running in a relation hook"""
4165
169
    return 'JUJU_RELATION' in os.environ
4166
170
4167
171
4168
172
def relation_type():
4169
173
    """The scope for the current relation hook"""
4170
174
    return os.environ.get('JUJU_RELATION', None)
4171
175
4172
176
4173
177
@cached
4174
178
def relation_id(relation_name=None, service_or_unit=None):
4175
179
    """The relation ID for the current or a specified relation"""
4176
180
    if not relation_name and not service_or_unit:
4177
181
        return os.environ.get('JUJU_RELATION_ID', None)
4178
182
    elif relation_name and service_or_unit:
4179
183
        service_name = service_or_unit.split('/')[0]
4180
184
        for relid in relation_ids(relation_name):
4181
185
            remote_service = remote_service_name(relid)
4182
186
            if remote_service == service_name:
4183
187
                return relid
4184
188
    else:
4185
189
        raise ValueError('Must specify neither or both of relation_name and service_or_unit')
4186
190
4187
191
4188
192
def local_unit():
4189
193
    """Local unit ID"""
4190
194
    return os.environ['JUJU_UNIT_NAME']
4191
195
4192
196
4193
197
def remote_unit():
4194
198
    """The remote unit for the current relation hook"""
4195
199
    return os.environ.get('JUJU_REMOTE_UNIT', None)
4196
200
4197
201
4198
202
def service_name():
4199
203
    """The name service group this unit belongs to"""
4200
204
    return local_unit().split('/')[0]
4201
205
4202
206
4203
207
@cached
4204
208
def remote_service_name(relid=None):
4205
209
    """The remote service name for a given relation-id (or the current relation)"""
4206
210
    if relid is None:
4207
211
        unit = remote_unit()
4208
212
    else:
4209
213
        units = related_units(relid)
4210
214
        unit = units[0] if units else None
4211
215
    return unit.split('/')[0] if unit else None
4212
216
4213
217
4214
218
def hook_name():
4215
219
    """The name of the currently executing hook"""
4216
220
    return os.environ.get('JUJU_HOOK_NAME', os.path.basename(sys.argv[0]))
4217
221
4218
222
4219
223
class Config(dict):
4220
224
    """A dictionary representation of the charm's config.yaml, with some
4221
225
    extra features:
4222
226
4223
227
    - See which values in the dictionary have changed since the previous hook.
4224
228
    - For values that have changed, see what the previous value was.
4225
229
    - Store arbitrary data for use in a later hook.
4226
230
4227
231
    NOTE: Do not instantiate this object directly - instead call
4228
232
    ``hookenv.config()``, which will return an instance of :class:`Config`.
4229
233
4230
234
    Example usage::
4231
235
4232
236
        >>> # inside a hook
4233
237
        >>> from charmhelpers.core import hookenv
4234
238
        >>> config = hookenv.config()
4235
239
        >>> config['foo']
4236
240
        'bar'
4237
241
        >>> # store a new key/value for later use
4238
242
        >>> config['mykey'] = 'myval'
4239
243
4240
244
4241
245
        >>> # user runs `juju set mycharm foo=baz`
4242
246
        >>> # now we're inside subsequent config-changed hook
4243
247
        >>> config = hookenv.config()
4244
248
        >>> config['foo']
4245
249
        'baz'
4246
250
        >>> # test to see if this val has changed since last hook
4247
251
        >>> config.changed('foo')
4248
252
        True
4249
253
        >>> # what was the previous value?
4250
254
        >>> config.previous('foo')
4251
255
        'bar'
4252
256
        >>> # keys/values that we add are preserved across hooks
4253
257
        >>> config['mykey']
4254
258
        'myval'
4255
259
4256
260
    """
4257
261
    CONFIG_FILE_NAME = '.juju-persistent-config'
4258
262
4259
263
    def __init__(self, *args, **kw):
4260
264
        super(Config, self).__init__(*args, **kw)
4261
265
        self.implicit_save = True
4262
266
        self._prev_dict = None
4263
267
        self.path = os.path.join(charm_dir(), Config.CONFIG_FILE_NAME)
4264
268
        if os.path.exists(self.path):
4265
269
            self.load_previous()
4266
270
        atexit(self._implicit_save)
4267
271
4268
272
    def load_previous(self, path=None):
4269
273
        """Load previous copy of config from disk.
4270
274
4271
275
        In normal usage you don't need to call this method directly - it
4272
276
        is called automatically at object initialization.
4273
277
4274
278
        :param path:
4275
279
4276
280
            File path from which to load the previous config. If `None`,
4277
281
            config is loaded from the default location. If `path` is
4278
282
            specified, subsequent `save()` calls will write to the same
4279
283
            path.
4280
284
4281
285
        """
4282
286
        self.path = path or self.path
4283
287
        with open(self.path) as f:
4284
288
            self._prev_dict = json.load(f)
4285
289
        for k, v in copy.deepcopy(self._prev_dict).items():
4286
290
            if k not in self:
4287
291
                self[k] = v
4288
292
4289
293
    def changed(self, key):
4290
294
        """Return True if the current value for this key is different from
4291
295
        the previous value.
4292
296
4293
297
        """
4294
298
        if self._prev_dict is None:
4295
299
            return True
4296
300
        return self.previous(key) != self.get(key)
4297
301
4298
302
    def previous(self, key):
4299
303
        """Return previous value for this key, or None if there
4300
304
        is no previous value.
4301
305
4302
306
        """
4303
307
        if self._prev_dict:
4304
308
            return self._prev_dict.get(key)
4305
309
        return None
4306
310
4307
311
    def save(self):
4308
312
        """Save this config to disk.
4309
313
4310
314
        If the charm is using the :mod:`Services Framework <services.base>`
4311
315
        or :meth:'@hook <Hooks.hook>' decorator, this
4312
316
        is called automatically at the end of successful hook execution.
4313
317
        Otherwise, it should be called directly by user code.
4314
318
4315
319
        To disable automatic saves, set ``implicit_save=False`` on this
4316
320
        instance.
4317
321
4318
322
        """
4319
323
        with open(self.path, 'w') as f:
4320
324
            json.dump(self, f)
4321
325
4322
326
    def _implicit_save(self):
4323
327
        if self.implicit_save:
4324
328
            self.save()
4325
329
4326
330
4327
331
@cached
4328
332
def config(scope=None):
4329
333
    """Juju charm configuration"""
4330
334
    config_cmd_line = ['config-get']
4331
335
    if scope is not None:
4332
336
        config_cmd_line.append(scope)
4333
337
    config_cmd_line.append('--format=json')
4334
338
    try:
4335
339
        config_data = json.loads(
4336
340
            subprocess.check_output(config_cmd_line).decode('UTF-8'))
4337
341
        if scope is not None:
4338
342
            return config_data
4339
343
        return Config(config_data)
4340
344
    except ValueError:
4341
345
        return None
4342
346
4343
347
4344
348
@cached
4345
349
def relation_get(attribute=None, unit=None, rid=None):
4346
350
    """Get relation information"""
4347
351
    _args = ['relation-get', '--format=json']
4348
352
    if rid:
4349
353
        _args.append('-r')
4350
354
        _args.append(rid)
4351
355
    _args.append(attribute or '-')
4352
356
    if unit:
4353
357
        _args.append(unit)
4354
358
    try:
4355
359
        return json.loads(subprocess.check_output(_args).decode('UTF-8'))
4356
360
    except ValueError:
4357
361
        return None
4358
362
    except CalledProcessError as e:
4359
363
        if e.returncode == 2:
4360
364
            return None
4361
365
        raise
4362
366
4363
367
4364
368
def relation_set(relation_id=None, relation_settings=None, **kwargs):
4365
369
    """Set relation information for the current unit"""
4366
370
    relation_settings = relation_settings if relation_settings else {}
4367
371
    relation_cmd_line = ['relation-set']
4368
372
    accepts_file = "--file" in subprocess.check_output(
4369
373
        relation_cmd_line + ["--help"], universal_newlines=True)
4370
374
    if relation_id is not None:
4371
375
        relation_cmd_line.extend(('-r', relation_id))
4372
376
    settings = relation_settings.copy()
4373
377
    settings.update(kwargs)
4374
378
    for key, value in settings.items():
4375
379
        # Force value to be a string: it always should, but some call
4376
380
        # sites pass in things like dicts or numbers.
4377
381
        if value is not None:
4378
382
            settings[key] = "{}".format(value)
4379
383
    if accepts_file:
4380
384
        # --file was introduced in Juju 1.23.2. Use it by default if
4381
385
        # available, since otherwise we'll break if the relation data is
4382
386
        # too big. Ideally we should tell relation-set to read the data from
4383
387
        # stdin, but that feature is broken in 1.23.2: Bug #1454678.
4384
388
        with tempfile.NamedTemporaryFile(delete=False) as settings_file:
4385
389
            settings_file.write(yaml.safe_dump(settings).encode("utf-8"))
4386
390
        subprocess.check_call(
4387
391
            relation_cmd_line + ["--file", settings_file.name])
4388
392
        os.remove(settings_file.name)
4389
393
    else:
4390
394
        for key, value in settings.items():
4391
395
            if value is None:
4392
396
                relation_cmd_line.append('{}='.format(key))
4393
397
            else:
4394
398
                relation_cmd_line.append('{}={}'.format(key, value))
4395
399
        subprocess.check_call(relation_cmd_line)
4396
400
    # Flush cache of any relation-gets for local unit
4397
401
    flush(local_unit())
4398
402
4399
403
4400
404
def relation_clear(r_id=None):
4401
405
    ''' Clears any relation data already set on relation r_id '''
4402
406
    settings = relation_get(rid=r_id,
4403
407
                            unit=local_unit())
4404
408
    for setting in settings:
4405
409
        if setting not in ['public-address', 'private-address']:
4406
410
            settings[setting] = None
4407
411
    relation_set(relation_id=r_id,
4408
412
                 **settings)
4409
413
4410
414
4411
415
@cached
4412
416
def relation_ids(reltype=None):
4413
417
    """A list of relation_ids"""
4414
418
    reltype = reltype or relation_type()
4415
419
    relid_cmd_line = ['relation-ids', '--format=json']
4416
420
    if reltype is not None:
4417
421
        relid_cmd_line.append(reltype)
4418
422
        return json.loads(
4419
423
            subprocess.check_output(relid_cmd_line).decode('UTF-8')) or []
4420
424
    return []
4421
425
4422
426
4423
427
@cached
4424
428
def related_units(relid=None):
4425
429
    """A list of related units"""
4426
430
    relid = relid or relation_id()
4427
431
    units_cmd_line = ['relation-list', '--format=json']
4428
432
    if relid is not None:
4429
433
        units_cmd_line.extend(('-r', relid))
4430
434
    return json.loads(
4431
435
        subprocess.check_output(units_cmd_line).decode('UTF-8')) or []
4432
436
4433
437
4434
438
@cached
4435
439
def relation_for_unit(unit=None, rid=None):
4436
440
    """Get the json represenation of a unit's relation"""
4437
441
    unit = unit or remote_unit()
4438
442
    relation = relation_get(unit=unit, rid=rid)
4439
443
    for key in relation:
4440
444
        if key.endswith('-list'):
4441
445
            relation[key] = relation[key].split()
4442
446
    relation['__unit__'] = unit
4443
447
    return relation
4444
448
4445
449
4446
450
@cached
4447
451
def relations_for_id(relid=None):
4448
452
    """Get relations of a specific relation ID"""
4449
453
    relation_data = []
4450
454
    relid = relid or relation_ids()
4451
455
    for unit in related_units(relid):
4452
456
        unit_data = relation_for_unit(unit, relid)
4453
457
        unit_data['__relid__'] = relid
4454
458
        relation_data.append(unit_data)
4455
459
    return relation_data
4456
460
4457
461
4458
462
@cached
4459
463
def relations_of_type(reltype=None):
4460
464
    """Get relations of a specific type"""
4461
465
    relation_data = []
4462
466
    reltype = reltype or relation_type()
4463
467
    for relid in relation_ids(reltype):
4464
468
        for relation in relations_for_id(relid):
4465
469
            relation['__relid__'] = relid
4466
470
            relation_data.append(relation)
4467
471
    return relation_data
4468
472
4469
473
4470
474
@cached
4471
475
def metadata():
4472
476
    """Get the current charm metadata.yaml contents as a python object"""
4473
477
    with open(os.path.join(charm_dir(), 'metadata.yaml')) as md:
4474
478
        return yaml.safe_load(md)
4475
479
4476
480
4477
481
@cached
4478
482
def relation_types():
4479
483
    """Get a list of relation types supported by this charm"""
4480
484
    rel_types = []
4481
485
    md = metadata()
4482
486
    for key in ('provides', 'requires', 'peers'):
4483
487
        section = md.get(key)
4484
488
        if section:
4485
489
            rel_types.extend(section.keys())
4486
490
    return rel_types
4487
491
4488
492
4489
493
@cached
4490
494
def relation_to_interface(relation_name):
4491
495
    """
4492
496
    Given the name of a relation, return the interface that relation uses.
4493
497
4494
498
    :returns: The interface name, or ``None``.
4495
499
    """
4496
500
    return relation_to_role_and_interface(relation_name)[1]
4497
501
4498
502
4499
503
@cached
4500
504
def relation_to_role_and_interface(relation_name):
4501
505
    """
4502
506
    Given the name of a relation, return the role and the name of the interface
4503
507
    that relation uses (where role is one of ``provides``, ``requires``, or ``peer``).
4504
508
4505
509
    :returns: A tuple containing ``(role, interface)``, or ``(None, None)``.
4506
510
    """
4507
511
    _metadata = metadata()
4508
512
    for role in ('provides', 'requires', 'peer'):
4509
513
        interface = _metadata.get(role, {}).get(relation_name, {}).get('interface')
4510
514
        if interface:
4511
515
            return role, interface
4512
516
    return None, None
4513
517
4514
518
4515
519
@cached
4516
520
def role_and_interface_to_relations(role, interface_name):
4517
521
    """
4518
522
    Given a role and interface name, return a list of relation names for the
4519
523
    current charm that use that interface under that role (where role is one
4520
524
    of ``provides``, ``requires``, or ``peer``).
4521
525
4522
526
    :returns: A list of relation names.
4523
527
    """
4524
528
    _metadata = metadata()
4525
529
    results = []
4526
530
    for relation_name, relation in _metadata.get(role, {}).items():
4527
531
        if relation['interface'] == interface_name:
4528
532
            results.append(relation_name)
4529
533
    return results
4530
534
4531
535
4532
536
@cached
4533
537
def interface_to_relations(interface_name):
4534
538
    """
4535
539
    Given an interface, return a list of relation names for the current
4536
540
    charm that use that interface.
4537
541
4538
542
    :returns: A list of relation names.
4539
543
    """
4540
544
    results = []
4541
545
    for role in ('provides', 'requires', 'peer'):
4542
546
        results.extend(role_and_interface_to_relations(role, interface_name))
4543
547
    return results
4544
548
4545
549
4546
550
@cached
4547
551
def charm_name():
4548
552
    """Get the name of the current charm as is specified on metadata.yaml"""
4549
553
    return metadata().get('name')
4550
554
4551
555
4552
556
@cached
4553
557
def relations():
4554
558
    """Get a nested dictionary of relation data for all related units"""
4555
559
    rels = {}
4556
560
    for reltype in relation_types():
4557
561
        relids = {}
4558
562
        for relid in relation_ids(reltype):
4559
563
            units = {local_unit(): relation_get(unit=local_unit(), rid=relid)}
4560
564
            for unit in related_units(relid):
4561
565
                reldata = relation_get(unit=unit, rid=relid)
4562
566
                units[unit] = reldata
4563
567
            relids[relid] = units
4564
568
        rels[reltype] = relids
4565
569
    return rels
4566
570
4567
571
4568
572
@cached
4569
573
def is_relation_made(relation, keys='private-address'):
4570
574
    '''
4571
575
    Determine whether a relation is established by checking for
4572
576
    presence of key(s).  If a list of keys is provided, they
4573
577
    must all be present for the relation to be identified as made
4574
578
    '''
4575
579
    if isinstance(keys, str):
4576
580
        keys = [keys]
4577
581
    for r_id in relation_ids(relation):
4578
582
        for unit in related_units(r_id):
4579
583
            context = {}
4580
584
            for k in keys:
4581
585
                context[k] = relation_get(k, rid=r_id,
4582
586
                                          unit=unit)
4583
587
            if None not in context.values():
4584
588
                return True
4585
589
    return False
4586
590
4587
591
4588
592
def open_port(port, protocol="TCP"):
4589
593
    """Open a service network port"""
4590
594
    _args = ['open-port']
4591
595
    _args.append('{}/{}'.format(port, protocol))
4592
596
    subprocess.check_call(_args)
4593
597
4594
598
4595
599
def close_port(port, protocol="TCP"):
4596
600
    """Close a service network port"""
4597
601
    _args = ['close-port']
4598
602
    _args.append('{}/{}'.format(port, protocol))
4599
603
    subprocess.check_call(_args)
4600
604
4601
605
4602
606
@cached
4603
607
def unit_get(attribute):
4604
608
    """Get the unit ID for the remote unit"""
4605
609
    _args = ['unit-get', '--format=json', attribute]
4606
610
    try:
4607
611
        return json.loads(subprocess.check_output(_args).decode('UTF-8'))
4608
612
    except ValueError:
4609
613
        return None
4610
614
4611
615
4612
616
def unit_public_ip():
4613
617
    """Get this unit's public IP address"""
4614
618
    return unit_get('public-address')
4615
619
4616
620
4617
621
def unit_private_ip():
4618
622
    """Get this unit's private IP address"""
4619
623
    return unit_get('private-address')
4620
624
4621
625
4622
626
class UnregisteredHookError(Exception):
4623
627
    """Raised when an undefined hook is called"""
4624
628
    pass
4625
629
4626
630
4627
631
class Hooks(object):
4628
632
    """A convenient handler for hook functions.
4629
633
4630
634
    Example::
4631
635
4632
636
        hooks = Hooks()
4633
637
4634
638
        # register a hook, taking its name from the function name
4635
639
        @hooks.hook()
4636
640
        def install():
4637
641
            pass  # your code here
4638
642
4639
643
        # register a hook, providing a custom hook name
4640
644
        @hooks.hook("config-changed")
4641
645
        def config_changed():
4642
646
            pass  # your code here
4643
647
4644
648
        if __name__ == "__main__":
4645
649
            # execute a hook based on the name the program is called by
4646
650
            hooks.execute(sys.argv)
4647
651
    """
4648
652
4649
653
    def __init__(self, config_save=None):
4650
654
        super(Hooks, self).__init__()
4651
655
        self._hooks = {}
4652
656
4653
657
        # For unknown reasons, we allow the Hooks constructor to override
4654
658
        # config().implicit_save.
4655
659
        if config_save is not None:
4656
660
            config().implicit_save = config_save
4657
661
4658
662
    def register(self, name, function):
4659
663
        """Register a hook"""
4660
664
        self._hooks[name] = function
4661
665
4662
666
    def execute(self, args):
4663
667
        """Execute a registered hook based on args[0]"""
4664
668
        _run_atstart()
4665
669
        hook_name = os.path.basename(args[0])
4666
670
        if hook_name in self._hooks:
4667
671
            try:
4668
672
                self._hooks[hook_name]()
4669
673
            except SystemExit as x:
4670
674
                if x.code is None or x.code == 0:
4671
675
                    _run_atexit()
4672
676
                raise
4673
677
            _run_atexit()
4674
678
        else:
4675
679
            raise UnregisteredHookError(hook_name)
4676
680
4677
681
    def hook(self, *hook_names):
4678
682
        """Decorator, registering them as hooks"""
4679
683
        def wrapper(decorated):
4680
684
            for hook_name in hook_names:
4681
685
                self.register(hook_name, decorated)
4682
686
            else:
4683
687
                self.register(decorated.__name__, decorated)
4684
688
                if '_' in decorated.__name__:
4685
689
                    self.register(
4686
690
                        decorated.__name__.replace('_', '-'), decorated)
4687
691
            return decorated
4688
692
        return wrapper
4689
693
4690
694
4691
695
def charm_dir():
4692
696
    """Return the root directory of the current charm"""
4693
697
    return os.environ.get('CHARM_DIR')
4694
698
4695
699
4696
700
@cached
4697
701
def action_get(key=None):
4698
702
    """Gets the value of an action parameter, or all key/value param pairs"""
4699
703
    cmd = ['action-get']
4700
704
    if key is not None:
4701
705
        cmd.append(key)
4702
706
    cmd.append('--format=json')
4703
707
    action_data = json.loads(subprocess.check_output(cmd).decode('UTF-8'))
4704
708
    return action_data
4705
709
4706
710
4707
711
def action_set(values):
4708
712
    """Sets the values to be returned after the action finishes"""
4709
713
    cmd = ['action-set']
4710
714
    for k, v in list(values.items()):
4711
715
        cmd.append('{}={}'.format(k, v))
4712
716
    subprocess.check_call(cmd)
4713
717
4714
718
4715
719
def action_fail(message):
4716
720
    """Sets the action status to failed and sets the error message.
4717
721
4718
722
    The results set by action_set are preserved."""
4719
723
    subprocess.check_call(['action-fail', message])
4720
724
4721
725
4722
726
def action_name():
4723
727
    """Get the name of the currently executing action."""
4724
728
    return os.environ.get('JUJU_ACTION_NAME')
4725
729
4726
730
4727
731
def action_uuid():
4728
732
    """Get the UUID of the currently executing action."""
4729
733
    return os.environ.get('JUJU_ACTION_UUID')
4730
734
4731
735
4732
736
def action_tag():
4733
737
    """Get the tag for the currently executing action."""
4734
738
    return os.environ.get('JUJU_ACTION_TAG')
4735
739
4736
740
4737
741
def status_set(workload_state, message):
4738
742
    """Set the workload state with a message
4739
743
4740
744
    Use status-set to set the workload state with a message which is visible
4741
745
    to the user via juju status. If the status-set command is not found then
4742
746
    assume this is juju < 1.23 and juju-log the message unstead.
4743
747
4744
748
    workload_state -- valid juju workload state.
4745
749
    message        -- status update message
4746
750
    """
4747
751
    valid_states = ['maintenance', 'blocked', 'waiting', 'active']
4748
752
    if workload_state not in valid_states:
4749
753
        raise ValueError(
4750
754
            '{!r} is not a valid workload state'.format(workload_state)
4751
755
        )
4752
756
    cmd = ['status-set', workload_state, message]
4753
757
    try:
4754
758
        ret = subprocess.call(cmd)
4755
759
        if ret == 0:
4756
760
            return
4757
761
    except OSError as e:
4758
762
        if e.errno != errno.ENOENT:
4759
763
            raise
4760
764
    log_message = 'status-set failed: {} {}'.format(workload_state,
4761
765
                                                    message)
4762
766
    log(log_message, level='INFO')
4763
767
4764
768
4765
769
def status_get():
4766
770
    """Retrieve the previously set juju workload state
4767
771
4768
772
    If the status-set command is not found then assume this is juju < 1.23 and
4769
773
    return 'unknown'
4770
774
    """
4771
775
    cmd = ['status-get']
4772
776
    try:
4773
777
        raw_status = subprocess.check_output(cmd, universal_newlines=True)
4774
778
        status = raw_status.rstrip()
4775
779
        return status
4776
780
    except OSError as e:
4777
781
        if e.errno == errno.ENOENT:
4778
782
            return 'unknown'
4779
783
        else:
4780
784
            raise
4781
785
4782
786
4783
787
def translate_exc(from_exc, to_exc):
4784
788
    def inner_translate_exc1(f):
4785
789
        def inner_translate_exc2(*args, **kwargs):
4786
790
            try:
4787
791
                return f(*args, **kwargs)
4788
792
            except from_exc:
4789
793
                raise to_exc
4790
794
4791
795
        return inner_translate_exc2
4792
796
4793
797
    return inner_translate_exc1
4794
798
4795
799
4796
800
@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
4797
801
def is_leader():
4798
802
    """Does the current unit hold the juju leadership
4799
803
4800
804
    Uses juju to determine whether the current unit is the leader of its peers
4801
805
    """
4802
806
    cmd = ['is-leader', '--format=json']
4803
807
    return json.loads(subprocess.check_output(cmd).decode('UTF-8'))
4804
808
4805
809
4806
810
@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
4807
811
def leader_get(attribute=None):
4808
812
    """Juju leader get value(s)"""
4809
813
    cmd = ['leader-get', '--format=json'] + [attribute or '-']
4810
814
    return json.loads(subprocess.check_output(cmd).decode('UTF-8'))
4811
815
4812
816
4813
817
@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
4814
818
def leader_set(settings=None, **kwargs):
4815
819
    """Juju leader set value(s)"""
4816
820
    # Don't log secrets.
4817
821
    # log("Juju leader-set '%s'" % (settings), level=DEBUG)
4818
822
    cmd = ['leader-set']
4819
823
    settings = settings or {}
4820
824
    settings.update(kwargs)
4821
825
    for k, v in settings.items():
4822
826
        if v is None:
4823
827
            cmd.append('{}='.format(k))
4824
828
        else:
4825
829
            cmd.append('{}={}'.format(k, v))
4826
830
    subprocess.check_call(cmd)
4827
831
4828
832
4829
833
@cached
4830
834
def juju_version():
4831
835
    """Full version string (eg. '1.23.3.1-trusty-amd64')"""
4832
836
    # Per https://bugs.launchpad.net/juju-core/+bug/1455368/comments/1
4833
837
    jujud = glob.glob('/var/lib/juju/tools/machine-*/jujud')[0]
4834
838
    return subprocess.check_output([jujud, 'version'],
4835
839
                                   universal_newlines=True).strip()
4836
840
4837
841
4838
842
@cached
4839
843
def has_juju_version(minimum_version):
4840
844
    """Return True if the Juju version is at least the provided version"""
4841
845
    return LooseVersion(juju_version()) >= LooseVersion(minimum_version)
4842
846
4843
847
4844
848
_atexit = []
4845
849
_atstart = []
4846
850
4847
851
4848
852
def atstart(callback, *args, **kwargs):
4849
853
    '''Schedule a callback to run before the main hook.
4850
854
4851
855
    Callbacks are run in the order they were added.
4852
856
4853
857
    This is useful for modules and classes to perform initialization
4854
858
    and inject behavior. In particular:
4855
859
4856
860
        - Run common code before all of your hooks, such as logging
4857
861
          the hook name or interesting relation data.
4858
862
        - Defer object or module initialization that requires a hook
4859
863
          context until we know there actually is a hook context,
4860
864
          making testing easier.
4861
865
        - Rather than requiring charm authors to include boilerplate to
4862
866
          invoke your helper's behavior, have it run automatically if
4863
867
          your object is instantiated or module imported.
4864
868
4865
869
    This is not at all useful after your hook framework as been launched.
4866
870
    '''
4867
871
    global _atstart
4868
872
    _atstart.append((callback, args, kwargs))
4869
873
4870
874
4871
875
def atexit(callback, *args, **kwargs):
4872
876
    '''Schedule a callback to run on successful hook completion.
4873
877
4874
878
    Callbacks are run in the reverse order that they were added.'''
4875
879
    _atexit.append((callback, args, kwargs))
4876
880
4877
881
4878
882
def _run_atstart():
4879
883
    '''Hook frameworks must invoke this before running the main hook body.'''
4880
884
    global _atstart
4881
885
    for callback, args, kwargs in _atstart:
4882
886
        callback(*args, **kwargs)
4883
887
    del _atstart[:]
4884
888
4885
889
4886
890
def _run_atexit():
4887
891
    '''Hook frameworks must invoke this after the main hook body has
4888
892
    successfully completed. Do not invoke it if the hook fails.'''
4889
893
    global _atexit
4890
894
    for callback, args, kwargs in reversed(_atexit):
4891
895
        callback(*args, **kwargs)
4892
896
    del _atexit[:]
4893
897
0
4894
=== removed file 'tests/charmhelpers/core/host.py'
4895
--- tests/charmhelpers/core/host.py	2015-08-19 13:49:53 +0000
4896
+++ tests/charmhelpers/core/host.py	1970-01-01 00:00:00 +0000
4897
@@ -1,570 +0,0 @@
4898
1
# Copyright 2014-2015 Canonical Limited.
4899
2
#
4900
3
# This file is part of charm-helpers.
4901
4
#
4902
5
# charm-helpers is free software: you can redistribute it and/or modify
4903
6
# it under the terms of the GNU Lesser General Public License version 3 as
4904
7
# published by the Free Software Foundation.
4905
8
#
4906
9
# charm-helpers is distributed in the hope that it will be useful,
4907
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
4908
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
4909
12
# GNU Lesser General Public License for more details.
4910
13
#
4911
14
# You should have received a copy of the GNU Lesser General Public License
4912
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
4913
16
4914
17
"""Tools for working with the host system"""
4915
18
# Copyright 2012 Canonical Ltd.
4916
19
#
4917
20
# Authors:
4918
21
#  Nick Moffitt <nick.moffitt@canonical.com>
4919
22
#  Matthew Wedgwood <matthew.wedgwood@canonical.com>
4920
23
4921
24
import os
4922
25
import re
4923
26
import pwd
4924
27
import glob
4925
28
import grp
4926
29
import random
4927
30
import string
4928
31
import subprocess
4929
32
import hashlib
4930
33
from contextlib import contextmanager
4931
34
from collections import OrderedDict
4932
35
4933
36
import six
4934
37
4935
38
from .hookenv import log
4936
39
from .fstab import Fstab
4937
40
4938
41
4939
42
def service_start(service_name):
4940
43
    """Start a system service"""
4941
44
    return service('start', service_name)
4942
45
4943
46
4944
47
def service_stop(service_name):
4945
48
    """Stop a system service"""
4946
49
    return service('stop', service_name)
4947
50
4948
51
4949
52
def service_restart(service_name):
4950
53
    """Restart a system service"""
4951
54
    return service('restart', service_name)
4952
55
4953
56
4954
57
def service_reload(service_name, restart_on_failure=False):
4955
58
    """Reload a system service, optionally falling back to restart if
4956
59
    reload fails"""
4957
60
    service_result = service('reload', service_name)
4958
61
    if not service_result and restart_on_failure:
4959
62
        service_result = service('restart', service_name)
4960
63
    return service_result
4961
64
4962
65
4963
66
def service_pause(service_name, init_dir=None):
4964
67
    """Pause a system service.
4965
68
4966
69
    Stop it, and prevent it from starting again at boot."""
4967
70
    if init_dir is None:
4968
71
        init_dir = "/etc/init"
4969
72
    stopped = service_stop(service_name)
4970
73
    # XXX: Support systemd too
4971
74
    override_path = os.path.join(
4972
75
        init_dir, '{}.override'.format(service_name))
4973
76
    with open(override_path, 'w') as fh:
4974
77
        fh.write("manual\n")
4975
78
    return stopped
4976
79
4977
80
4978
81
def service_resume(service_name, init_dir=None):
4979
82
    """Resume a system service.
4980
83
4981
84
    Reenable starting again at boot. Start the service"""
4982
85
    # XXX: Support systemd too
4983
86
    if init_dir is None:
4984
87
        init_dir = "/etc/init"
4985
88
    override_path = os.path.join(
4986
89
        init_dir, '{}.override'.format(service_name))
4987
90
    if os.path.exists(override_path):
4988
91
        os.unlink(override_path)
4989
92
    started = service_start(service_name)
4990
93
    return started
4991
94
4992
95
4993
96
def service(action, service_name):
4994
97
    """Control a system service"""
4995
98
    cmd = ['service', service_name, action]
4996
99
    return subprocess.call(cmd) == 0
4997
100
4998
101
4999
102
def service_running(service):
5000
103
    """Determine whether a system service is running"""
Status:	Superseded
Proposed branch:	lp:~1chb1n/charms/trusty/rabbitmq-server/amulet-refactor-1508
Merge into:	lp:~openstack-charmers-archive/charms/trusty/rabbitmq-server/next
Diff against target:	6948 lines (+2700/-3906) (has conflicts) 45 files modified Makefile (+5/-4) charm-helpers-tests.yaml (+2/-3) hooks/rabbitmq_server_relations.py (+18/-0) metadata.yaml (+4/-1) tests/00-setup (+16/-0) tests/014-basic-precise-icehouse (+11/-0) tests/015-basic-trusty-icehouse (+9/-0) tests/016-basic-trusty-juno (+11/-0) tests/017-basic-trusty-kilo (+11/-0) tests/019-basic-vivid-kilo (+9/-0) tests/020-basic-trusty-liberty (+11/-0) tests/021-basic-wily-liberty (+9/-0) tests/basic_deployment.py (+492/-0) tests/charmhelpers/__init__.py (+0/-38) tests/charmhelpers/cli/__init__.py (+0/-191) tests/charmhelpers/cli/benchmark.py (+0/-36) tests/charmhelpers/cli/commands.py (+0/-32) tests/charmhelpers/cli/hookenv.py (+0/-23) tests/charmhelpers/cli/host.py (+0/-31) tests/charmhelpers/cli/unitdata.py (+0/-39) tests/charmhelpers/contrib/__init__.py (+0/-15) tests/charmhelpers/contrib/amulet/__init__.py (+15/-0) tests/charmhelpers/contrib/amulet/deployment.py (+93/-0) tests/charmhelpers/contrib/amulet/utils.py (+771/-0) tests/charmhelpers/contrib/openstack/__init__.py (+15/-0) tests/charmhelpers/contrib/openstack/amulet/__init__.py (+15/-0) tests/charmhelpers/contrib/openstack/amulet/deployment.py (+198/-0) tests/charmhelpers/contrib/openstack/amulet/utils.py (+965/-0) tests/charmhelpers/contrib/ssl/__init__.py (+0/-94) tests/charmhelpers/contrib/ssl/service.py (+0/-279) tests/charmhelpers/core/__init__.py (+0/-15) tests/charmhelpers/core/decorators.py (+0/-57) tests/charmhelpers/core/files.py (+0/-45) tests/charmhelpers/core/fstab.py (+0/-134) tests/charmhelpers/core/hookenv.py (+0/-896) tests/charmhelpers/core/host.py (+0/-570) tests/charmhelpers/core/hugepage.py (+0/-62) tests/charmhelpers/core/services/__init__.py (+0/-18) tests/charmhelpers/core/services/base.py (+0/-353) tests/charmhelpers/core/services/helpers.py (+0/-283) tests/charmhelpers/core/strutils.py (+0/-42) tests/charmhelpers/core/sysctl.py (+0/-56) tests/charmhelpers/core/templating.py (+0/-68) tests/charmhelpers/core/unitdata.py (+0/-521) tests/tests.yaml (+20/-0) Text conflict in hooks/rabbitmq_server_relations.py
To merge this branch:	bzr merge lp:~1chb1n/charms/trusty/rabbitmq-server/amulet-refactor-1508
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
OpenStack Charmers		2015-08-21	Pending
Review via email: mp+268811@code.launchpad.net