1
=== added directory 'actions'
2
=== added file 'actions.yaml'
3
--- actions.yaml	1970-01-01 00:00:00 +0000
4
+++ actions.yaml	2015-09-15 12:31:21 +0000
5
@@ -0,0 +1,4 @@
6
1
pause:
7
2
  description: Pause the MySQL service.
8
3
resume:
9
4
  description: Resume the MySQL service.
10
0
\ No newline at end of file
5
\ No newline at end of file
11
1
6
12
=== added file 'actions/actions.py'
13
--- actions/actions.py	1970-01-01 00:00:00 +0000
14
+++ actions/actions.py	2015-09-15 12:31:21 +0000
15
@@ -0,0 +1,51 @@
16
1
#!/usr/bin/python
17
2
18
3
import os
19
4
import sys
20
5
21
6
from charmhelpers.core.host import service_pause, service_resume
22
7
from charmhelpers.core.hookenv import action_fail, status_set
23
8
24
9
25
10
MYSQL_SERVICE = "mysql"
26
11
27
12
def pause(args):
28
13
    """Pause the MySQL service.
29
14
30
15
    @raises Exception should the service fail to stop.
31
16
    """
32
17
    if not service_pause(MYSQL_SERVICE):
33
18
        raise Exception("Failed to pause MySQL service.")
34
19
    status_set(
35
20
        "maintenance", "Paused. Use 'resume' action to resume normal service.")
36
21
37
22
def resume(args):
38
23
    """Resume the MySQL service.
39
24
40
25
    @raises Exception should the service fail to start."""
41
26
    if not service_resume(MYSQL_SERVICE):
42
27
        raise Exception("Failed to resume MySQL service.")
43
28
    status_set("active", "")
44
29
45
30
46
31
# A dictionary of all the defined actions to callables (which take
47
32
# parsed arguments).
48
33
ACTIONS = {"pause": pause, "resume": resume}
49
34
50
35
51
36
def main(args):
52
37
    action_name = os.path.basename(args[0])
53
38
    try:
54
39
        action = ACTIONS[action_name]
55
40
    except KeyError:
56
41
        return "Action %s undefined" % action_name
57
42
    else:
58
43
        try:
59
44
            action(args)
60
45
        except Exception as e:
61
46
            action_fail(str(e))
62
47
63
48
64
49
if __name__ == "__main__":
65
50
    sys.exit(main(sys.argv))
66
51
67
0
52
68
=== added symlink 'actions/charmhelpers'
69
=== target is u'../charmhelpers'
70
=== added symlink 'actions/pause'
71
=== target is u'actions.py'
72
=== added symlink 'actions/resume'
73
=== target is u'actions.py'
74
=== modified file 'charm-helpers-tests.yaml'
75
--- charm-helpers-tests.yaml	2015-04-15 14:23:37 +0000
76
+++ charm-helpers-tests.yaml	2015-09-15 12:31:21 +0000
77
@@ -3,3 +3,4 @@
78
3
include:
3
include:
79
4
    - contrib.amulet
4
    - contrib.amulet
80
5
    - contrib.openstack.amulet
5
    - contrib.openstack.amulet
81
6
    - core.hookenv
82
6
7
83
=== renamed directory 'hooks/charmhelpers' => 'charmhelpers'
84
=== modified file 'charmhelpers/contrib/network/ip.py'
85
--- hooks/charmhelpers/contrib/network/ip.py	2015-03-03 02:26:12 +0000
86
+++ charmhelpers/contrib/network/ip.py	2015-09-15 12:31:21 +0000
87
@@ -435,8 +435,12 @@
88
435
435
89
436
        rev = dns.reversename.from_address(address)
436
        rev = dns.reversename.from_address(address)
90
437
        result = ns_query(rev)
437
        result = ns_query(rev)
91
438
92
438
        if not result:
439
        if not result:
94
439
            return None
440
            try:
95
441
                result = socket.gethostbyaddr(address)[0]
96
442
            except:
97
443
                return None
98
440
    else:
444
    else:
99
441
        result = address
445
        result = address
100
442
446
101
443
447
102
=== modified file 'charmhelpers/core/hookenv.py'
103
--- hooks/charmhelpers/core/hookenv.py	2015-08-26 13:11:30 +0000
104
+++ charmhelpers/core/hookenv.py	2015-09-15 12:31:21 +0000
105
@@ -767,21 +767,23 @@
106
767
767
107
768
768
108
769
def status_get():
769
def status_get():
113
770
    """Retrieve the previously set juju workload state
770
    """Retrieve the previously set juju workload state and message
114
771
771
115
772
    If the status-set command is not found then assume this is juju < 1.23 and
772
    If the status-get command is not found then assume this is juju < 1.23 and
116
773
    return 'unknown'
773
    return 'unknown', ""
117
774
118
774
    """
775
    """
120
775
    cmd = ['status-get']
776
    cmd = ['status-get', "--format=json", "--include-data"]
121
776
    try:
777
    try:
125
777
        raw_status = subprocess.check_output(cmd, universal_newlines=True)
778
        raw_status = subprocess.check_output(cmd)
123
778
        status = raw_status.rstrip()
124
779
        return status
126
780
    except OSError as e:
779
    except OSError as e:
127
781
        if e.errno == errno.ENOENT:
780
        if e.errno == errno.ENOENT:
129
782
            return 'unknown'
781
            return ('unknown', "")
130
783
        else:
782
        else:
131
784
            raise
783
            raise
132
784
    else:
133
785
        status = json.loads(raw_status.decode("UTF-8"))
134
786
        return (status["status"], status["message"])
135
785
787
136
786
788
137
787
def translate_exc(from_exc, to_exc):
789
def translate_exc(from_exc, to_exc):
138
788
790
139
=== modified file 'charmhelpers/core/host.py'
140
--- hooks/charmhelpers/core/host.py	2015-08-26 13:11:30 +0000
141
+++ charmhelpers/core/host.py	2015-09-15 12:31:21 +0000
142
@@ -63,32 +63,48 @@
143
63
    return service_result
63
    return service_result
144
64
64
145
65
65
147
66
def service_pause(service_name, init_dir=None):
66
def service_pause(service_name, init_dir="/etc/init", initd_dir="/etc/init.d"):
148
67
    """Pause a system service.
67
    """Pause a system service.
149
68
68
150
69
    Stop it, and prevent it from starting again at boot."""
69
    Stop it, and prevent it from starting again at boot."""
151
70
    if init_dir is None:
152
71
        init_dir = "/etc/init"
153
72
    stopped = service_stop(service_name)
70
    stopped = service_stop(service_name)
159
73
    # XXX: Support systemd too
71
    upstart_file = os.path.join(init_dir, "{}.conf".format(service_name))
160
74
    override_path = os.path.join(
72
    sysv_file = os.path.join(initd_dir, service_name)
161
75
        init_dir, '{}.override'.format(service_name))
73
    if os.path.exists(upstart_file):
162
76
    with open(override_path, 'w') as fh:
74
        override_path = os.path.join(
163
77
        fh.write("manual\n")
75
            init_dir, '{}.override'.format(service_name))
164
76
        with open(override_path, 'w') as fh:
165
77
            fh.write("manual\n")
166
78
    elif os.path.exists(sysv_file):
167
79
        subprocess.check_call(["update-rc.d", service_name, "disable"])
168
80
    else:
169
81
        # XXX: Support SystemD too
170
82
        raise ValueError(
171
83
            "Unable to detect {0} as either Upstart {1} or SysV {2}".format(
172
84
                service_name, upstart_file, sysv_file))
173
78
    return stopped
85
    return stopped
174
79
86
175
80
87
177
81
def service_resume(service_name, init_dir=None):
88
def service_resume(service_name, init_dir="/etc/init",
178
89
                   initd_dir="/etc/init.d"):
179
82
    """Resume a system service.
90
    """Resume a system service.
180
83
91
181
84
    Reenable starting again at boot. Start the service"""
92
    Reenable starting again at boot. Start the service"""
189
85
    # XXX: Support systemd too
93
    upstart_file = os.path.join(init_dir, "{}.conf".format(service_name))
190
86
    if init_dir is None:
94
    sysv_file = os.path.join(initd_dir, service_name)
191
87
        init_dir = "/etc/init"
95
    if os.path.exists(upstart_file):
192
88
    override_path = os.path.join(
96
        override_path = os.path.join(
193
89
        init_dir, '{}.override'.format(service_name))
97
            init_dir, '{}.override'.format(service_name))
194
90
    if os.path.exists(override_path):
98
        if os.path.exists(override_path):
195
91
        os.unlink(override_path)
99
            os.unlink(override_path)
196
100
    elif os.path.exists(sysv_file):
197
101
        subprocess.check_call(["update-rc.d", service_name, "enable"])
198
102
    else:
199
103
        # XXX: Support SystemD too
200
104
        raise ValueError(
201
105
            "Unable to detect {0} as either Upstart {1} or SysV {2}".format(
202
106
                service_name, upstart_file, sysv_file))
203
107
204
92
    started = service_start(service_name)
108
    started = service_start(service_name)
205
93
    return started
109
    return started
206
94
110
207
95
111
208
=== added file 'charmhelpers/core/kernel.py'
209
--- charmhelpers/core/kernel.py	1970-01-01 00:00:00 +0000
210
+++ charmhelpers/core/kernel.py	2015-09-15 12:31:21 +0000
211
@@ -0,0 +1,68 @@
212
1
#!/usr/bin/env python
213
2
# -*- coding: utf-8 -*-
214
3
215
4
# Copyright 2014-2015 Canonical Limited.
216
5
#
217
6
# This file is part of charm-helpers.
218
7
#
219
8
# charm-helpers is free software: you can redistribute it and/or modify
220
9
# it under the terms of the GNU Lesser General Public License version 3 as
221
10
# published by the Free Software Foundation.
222
11
#
223
12
# charm-helpers is distributed in the hope that it will be useful,
224
13
# but WITHOUT ANY WARRANTY; without even the implied warranty of
225
14
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
226
15
# GNU Lesser General Public License for more details.
227
16
#
228
17
# You should have received a copy of the GNU Lesser General Public License
229
18
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
230
19
231
20
__author__ = "Jorge Niedbalski <jorge.niedbalski@canonical.com>"
232
21
233
22
from charmhelpers.core.hookenv import (
234
23
    log,
235
24
    INFO
236
25
)
237
26
238
27
from subprocess import check_call, check_output
239
28
import re
240
29
241
30
242
31
def modprobe(module, persist=True):
243
32
    """Load a kernel module and configure for auto-load on reboot."""
244
33
    cmd = ['modprobe', module]
245
34
246
35
    log('Loading kernel module %s' % module, level=INFO)
247
36
248
37
    check_call(cmd)
249
38
    if persist:
250
39
        with open('/etc/modules', 'r+') as modules:
251
40
            if module not in modules.read():
252
41
                modules.write(module)
253
42
254
43
255
44
def rmmod(module, force=False):
256
45
    """Remove a module from the linux kernel"""
257
46
    cmd = ['rmmod']
258
47
    if force:
259
48
        cmd.append('-f')
260
49
    cmd.append(module)
261
50
    log('Removing kernel module %s' % module, level=INFO)
262
51
    return check_call(cmd)
263
52
264
53
265
54
def lsmod():
266
55
    """Shows what kernel modules are currently loaded"""
267
56
    return check_output(['lsmod'],
268
57
                        universal_newlines=True)
269
58
270
59
271
60
def is_module_loaded(module):
272
61
    """Checks if a kernel module is already loaded"""
273
62
    matches = re.findall('^%s[ ]+' % module, lsmod(), re.M)
274
63
    return len(matches) > 0
275
64
276
65
277
66
def update_initramfs(version='all'):
278
67
    """Updates an initramfs image"""
279
68
    return check_call(["update-initramfs", "-k", version, "-u"])
280
0
69
281
=== added symlink 'hooks/charmhelpers'
282
=== target is u'../charmhelpers'
283
=== modified file 'tests/00-setup'
284
--- tests/00-setup	2015-08-26 13:22:41 +0000
285
+++ tests/00-setup	2015-09-15 12:31:21 +0000
286
@@ -7,6 +7,7 @@
287
7
sudo apt-get install --yes amulet \
7
sudo apt-get install --yes amulet \
288
8
                           python-cinderclient \
8
                           python-cinderclient \
289
9
                           python-distro-info \
9
                           python-distro-info \
290
10
                           python3-distro-info \
291
10
                           python-glanceclient \
11
                           python-glanceclient \
292
11
                           python-heatclient \
12
                           python-heatclient \
293
12
                           python-keystoneclient \
13
                           python-keystoneclient \
294
@@ -14,3 +15,4 @@
295
14
                           python-novaclient \
15
                           python-novaclient \
296
15
                           python-pika \
16
                           python-pika \
297
16
                           python-swiftclient
17
                           python-swiftclient
298
18
299
17
19
300
=== added file 'tests/31-test-pause-and-resume.py'
301
--- tests/31-test-pause-and-resume.py	1970-01-01 00:00:00 +0000
302
+++ tests/31-test-pause-and-resume.py	2015-09-15 12:31:21 +0000
303
@@ -0,0 +1,38 @@
304
1
#!/usr/bin/python3
305
2
# test percona-cluster pause and resum
306
3
307
4
import basic_deployment
308
5
from charmhelpers.contrib.amulet.utils import AmuletUtils
309
6
310
7
utils = AmuletUtils()
311
8
312
9
313
10
class PauseResume(basic_deployment.BasicDeployment):
314
11
315
12
    def run(self):
316
13
        super(PauseResume, self).run()
317
14
        uid = 'percona-cluster/0'
318
15
        unit = self.d.sentry.unit[uid]
319
16
        assert self.is_mysqld_running(unit), 'mysql not running: %s' % uid
320
17
        assert utils.status_get(unit)[0] == "unknown"
321
18
322
19
        action_id = utils.run_action(unit, "pause")
323
20
        assert utils.wait_on_action(action_id), "Pause action failed."
324
21
325
22
        # Note that is_mysqld_running will print an error message when
326
23
        # mysqld is not running.  This is by design but it looks odd
327
24
        # in the output.
328
25
        assert not self.is_mysqld_running(unit=unit), \
329
26
            "mysqld is still running!"
330
27
331
28
        assert utils.status_get(unit)[0] == "maintenance"
332
29
        action_id = utils.run_action(unit, "resume")
333
30
        assert utils.wait_on_action(action_id), "Resume action failed"
334
31
        assert utils.status_get(unit)[0] == "active"
335
32
        assert self.is_mysqld_running(unit=unit), \
336
33
            "mysqld not running after resume."
337
34
338
35
339
36
if __name__ == "__main__":
340
37
    p = PauseResume()
341
38
    p.run()
342
0
39
343
=== modified file 'tests/charmhelpers/contrib/amulet/deployment.py'
344
--- tests/charmhelpers/contrib/amulet/deployment.py	2015-04-15 14:23:37 +0000
345
+++ tests/charmhelpers/contrib/amulet/deployment.py	2015-09-15 12:31:21 +0000
346
@@ -51,7 +51,8 @@
347
51
        if 'units' not in this_service:
51
        if 'units' not in this_service:
348
52
            this_service['units'] = 1
52
            this_service['units'] = 1
349
53
53
351
54
        self.d.add(this_service['name'], units=this_service['units'])
54
        self.d.add(this_service['name'], units=this_service['units'],
352
55
                   constraints=this_service.get('constraints'))
353
55
56
354
56
        for svc in other_services:
57
        for svc in other_services:
355
57
            if 'location' in svc:
58
            if 'location' in svc:
356
@@ -64,7 +65,8 @@
357
64
            if 'units' not in svc:
65
            if 'units' not in svc:
358
65
                svc['units'] = 1
66
                svc['units'] = 1
359
66
67
361
67
            self.d.add(svc['name'], charm=branch_location, units=svc['units'])
68
            self.d.add(svc['name'], charm=branch_location, units=svc['units'],
362
69
                       constraints=svc.get('constraints'))
363
68
70
364
69
    def _add_relations(self, relations):
71
    def _add_relations(self, relations):
365
70
        """Add all of the relations for the services."""
72
        """Add all of the relations for the services."""
366
71
73
367
=== modified file 'tests/charmhelpers/contrib/amulet/utils.py'
368
--- tests/charmhelpers/contrib/amulet/utils.py	2015-08-26 13:11:30 +0000
369
+++ tests/charmhelpers/contrib/amulet/utils.py	2015-09-15 12:31:21 +0000
370
@@ -19,9 +19,11 @@
371
19
import logging
19
import logging
372
20
import os
20
import os
373
21
import re
21
import re
374
22
import socket
375
22
import subprocess
23
import subprocess
376
23
import sys
24
import sys
377
24
import time
25
import time
378
26
import uuid
379
25
27
380
26
import amulet
28
import amulet
381
27
import distro_info
29
import distro_info
382
@@ -114,7 +116,7 @@
383
114
        # /!\ DEPRECATION WARNING (beisner):
116
        # /!\ DEPRECATION WARNING (beisner):
384
115
        # New and existing tests should be rewritten to use
117
        # New and existing tests should be rewritten to use
385
116
        # validate_services_by_name() as it is aware of init systems.
118
        # validate_services_by_name() as it is aware of init systems.
387
117
        self.log.warn('/!\\ DEPRECATION WARNING:  use '
119
        self.log.warn('DEPRECATION WARNING:  use '
388
118
                      'validate_services_by_name instead of validate_services '
120
                      'validate_services_by_name instead of validate_services '
389
119
                      'due to init system differences.')
121
                      'due to init system differences.')
390
120
122
391
@@ -269,33 +271,52 @@
392
269
        """Get last modification time of directory."""
271
        """Get last modification time of directory."""
393
270
        return sentry_unit.directory_stat(directory)['mtime']
272
        return sentry_unit.directory_stat(directory)['mtime']
394
271
273
413
272
    def _get_proc_start_time(self, sentry_unit, service, pgrep_full=False):
274
    def _get_proc_start_time(self, sentry_unit, service, pgrep_full=None):
414
273
        """Get process' start time.
275
        """Get start time of a process based on the last modification time
415
274
276
           of the /proc/pid directory.
416
275
           Determine start time of the process based on the last modification
277
417
276
           time of the /proc/pid directory. If pgrep_full is True, the process
278
        :sentry_unit:  The sentry unit to check for the service on
418
277
           name is matched against the full command line.
279
        :service:  service name to look for in process table
419
278
           """
280
        :pgrep_full:  [Deprecated] Use full command line search mode with pgrep
420
279
        if pgrep_full:
281
        :returns:  epoch time of service process start
421
280
            cmd = 'pgrep -o -f {}'.format(service)
282
        :param commands:  list of bash commands
422
281
        else:
283
        :param sentry_units:  list of sentry unit pointers
423
282
            cmd = 'pgrep -o {}'.format(service)
284
        :returns:  None if successful; Failure message otherwise
424
283
        cmd = cmd + '  | grep  -v pgrep || exit 0'
285
        """
425
284
        cmd_out = sentry_unit.run(cmd)
286
        if pgrep_full is not None:
426
285
        self.log.debug('CMDout: ' + str(cmd_out))
287
            # /!\ DEPRECATION WARNING (beisner):
427
286
        if cmd_out[0]:
288
            # No longer implemented, as pidof is now used instead of pgrep.
428
287
            self.log.debug('Pid for %s %s' % (service, str(cmd_out[0])))
289
            # https://bugs.launchpad.net/charm-helpers/+bug/1474030
429
288
            proc_dir = '/proc/{}'.format(cmd_out[0].strip())
290
            self.log.warn('DEPRECATION WARNING:  pgrep_full bool is no '
430
289
            return self._get_dir_mtime(sentry_unit, proc_dir)
291
                          'longer implemented re: lp 1474030.')
431
292
432
293
        pid_list = self.get_process_id_list(sentry_unit, service)
433
294
        pid = pid_list[0]
434
295
        proc_dir = '/proc/{}'.format(pid)
435
296
        self.log.debug('Pid for {} on {}: {}'.format(
436
297
            service, sentry_unit.info['unit_name'], pid))
437
298
438
299
        return self._get_dir_mtime(sentry_unit, proc_dir)
439
290
300
440
291
    def service_restarted(self, sentry_unit, service, filename,
301
    def service_restarted(self, sentry_unit, service, filename,
442
292
                          pgrep_full=False, sleep_time=20):
302
                          pgrep_full=None, sleep_time=20):
443
293
        """Check if service was restarted.
303
        """Check if service was restarted.
444
294
304
445
295
           Compare a service's start time vs a file's last modification time
305
           Compare a service's start time vs a file's last modification time
446
296
           (such as a config file for that service) to determine if the service
306
           (such as a config file for that service) to determine if the service
447
297
           has been restarted.
307
           has been restarted.
448
298
           """
308
           """
449
309
        # /!\ DEPRECATION WARNING (beisner):
450
310
        # This method is prone to races in that no before-time is known.
451
311
        # Use validate_service_config_changed instead.
452
312
453
313
        # NOTE(beisner) pgrep_full is no longer implemented, as pidof is now
454
314
        # used instead of pgrep.  pgrep_full is still passed through to ensure
455
315
        # deprecation WARNS.  lp1474030
456
316
        self.log.warn('DEPRECATION WARNING:  use '
457
317
                      'validate_service_config_changed instead of '
458
318
                      'service_restarted due to known races.')
459
319
460
299
        time.sleep(sleep_time)
320
        time.sleep(sleep_time)
461
300
        if (self._get_proc_start_time(sentry_unit, service, pgrep_full) >=
321
        if (self._get_proc_start_time(sentry_unit, service, pgrep_full) >=
462
301
                self._get_file_mtime(sentry_unit, filename)):
322
                self._get_file_mtime(sentry_unit, filename)):
463
@@ -304,15 +325,15 @@
464
304
            return False
325
            return False
465
305
326
466
306
    def service_restarted_since(self, sentry_unit, mtime, service,
327
    def service_restarted_since(self, sentry_unit, mtime, service,
469
307
                                pgrep_full=False, sleep_time=20,
328
                                pgrep_full=None, sleep_time=20,
470
308
                                retry_count=2):
329
                                retry_count=2, retry_sleep_time=30):
471
309
        """Check if service was been started after a given time.
330
        """Check if service was been started after a given time.
472
310
331
473
311
        Args:
332
        Args:
474
312
          sentry_unit (sentry): The sentry unit to check for the service on
333
          sentry_unit (sentry): The sentry unit to check for the service on
475
313
          mtime (float): The epoch time to check against
334
          mtime (float): The epoch time to check against
476
314
          service (string): service name to look for in process table
335
          service (string): service name to look for in process table
478
315
          pgrep_full (boolean): Use full command line search mode with pgrep
336
          pgrep_full: [Deprecated] Use full command line search mode with pgrep
479
316
          sleep_time (int): Seconds to sleep before looking for process
337
          sleep_time (int): Seconds to sleep before looking for process
480
317
          retry_count (int): If service is not found, how many times to retry
338
          retry_count (int): If service is not found, how many times to retry
481
318
339
482
@@ -321,30 +342,44 @@
483
321
                False if service is older than mtime or if service was
342
                False if service is older than mtime or if service was
484
322
                not found.
343
                not found.
485
323
        """
344
        """
487
324
        self.log.debug('Checking %s restarted since %s' % (service, mtime))
345
        # NOTE(beisner) pgrep_full is no longer implemented, as pidof is now
488
346
        # used instead of pgrep.  pgrep_full is still passed through to ensure
489
347
        # deprecation WARNS.  lp1474030
490
348
491
349
        unit_name = sentry_unit.info['unit_name']
492
350
        self.log.debug('Checking that %s service restarted since %s on '
493
351
                       '%s' % (service, mtime, unit_name))
494
325
        time.sleep(sleep_time)
352
        time.sleep(sleep_time)
504
326
        proc_start_time = self._get_proc_start_time(sentry_unit, service,
353
        proc_start_time = None
505
327
                                                    pgrep_full)
354
        tries = 0
506
328
        while retry_count > 0 and not proc_start_time:
355
        while tries <= retry_count and not proc_start_time:
507
329
            self.log.debug('No pid file found for service %s, will retry %i '
356
            try:
508
330
                           'more times' % (service, retry_count))
357
                proc_start_time = self._get_proc_start_time(sentry_unit,
509
331
            time.sleep(30)
358
                                                            service,
510
332
            proc_start_time = self._get_proc_start_time(sentry_unit, service,
359
                                                            pgrep_full)
511
333
                                                        pgrep_full)
360
                self.log.debug('Attempt {} to get {} proc start time on {} '
512
334
            retry_count = retry_count - 1
361
                               'OK'.format(tries, service, unit_name))
513
362
            except IOError:
514
363
                # NOTE(beisner) - race avoidance, proc may not exist yet.
515
364
                # https://bugs.launchpad.net/charm-helpers/+bug/1474030
516
365
                self.log.debug('Attempt {} to get {} proc start time on {} '
517
366
                               'failed'.format(tries, service, unit_name))
518
367
                time.sleep(retry_sleep_time)
519
368
                tries += 1
520
335
369
521
336
        if not proc_start_time:
370
        if not proc_start_time:
522
337
            self.log.warn('No proc start time found, assuming service did '
371
            self.log.warn('No proc start time found, assuming service did '
523
338
                          'not start')
372
                          'not start')
524
339
            return False
373
            return False
525
340
        if proc_start_time >= mtime:
374
        if proc_start_time >= mtime:
528
341
            self.log.debug('proc start time is newer than provided mtime'
375
            self.log.debug('Proc start time is newer than provided mtime'
529
342
                           '(%s >= %s)' % (proc_start_time, mtime))
376
                           '(%s >= %s) on %s (OK)' % (proc_start_time,
530
377
                                                      mtime, unit_name))
531
343
            return True
378
            return True
532
344
        else:
379
        else:
536
345
            self.log.warn('proc start time (%s) is older than provided mtime '
380
            self.log.warn('Proc start time (%s) is older than provided mtime '
537
346
                          '(%s), service did not restart' % (proc_start_time,
381
                          '(%s) on %s, service did not '
538
347
                                                             mtime))
382
                          'restart' % (proc_start_time, mtime, unit_name))
539
348
            return False
383
            return False
540
349
384
541
350
    def config_updated_since(self, sentry_unit, filename, mtime,
385
    def config_updated_since(self, sentry_unit, filename, mtime,
542
@@ -374,8 +409,9 @@
543
374
            return False
409
            return False
544
375
410
545
376
    def validate_service_config_changed(self, sentry_unit, mtime, service,
411
    def validate_service_config_changed(self, sentry_unit, mtime, service,
548
377
                                        filename, pgrep_full=False,
412
                                        filename, pgrep_full=None,
549
378
                                        sleep_time=20, retry_count=2):
413
                                        sleep_time=20, retry_count=2,
550
414
                                        retry_sleep_time=30):
551
379
        """Check service and file were updated after mtime
415
        """Check service and file were updated after mtime
552
380
416
553
381
        Args:
417
        Args:
554
@@ -383,9 +419,10 @@
555
383
          mtime (float): The epoch time to check against
419
          mtime (float): The epoch time to check against
556
384
          service (string): service name to look for in process table
420
          service (string): service name to look for in process table
557
385
          filename (string): The file to check mtime of
421
          filename (string): The file to check mtime of
560
386
          pgrep_full (boolean): Use full command line search mode with pgrep
422
          pgrep_full: [Deprecated] Use full command line search mode with pgrep
561
387
          sleep_time (int): Seconds to sleep before looking for process
423
          sleep_time (int): Initial sleep in seconds to pass to test helpers
562
388
          retry_count (int): If service is not found, how many times to retry
424
          retry_count (int): If service is not found, how many times to retry
563
425
          retry_sleep_time (int): Time in seconds to wait between retries
564
389
426
565
390
        Typical Usage:
427
        Typical Usage:
566
391
            u = OpenStackAmuletUtils(ERROR)
428
            u = OpenStackAmuletUtils(ERROR)
567
@@ -402,15 +439,25 @@
568
402
                mtime, False if service is older than mtime or if service was
439
                mtime, False if service is older than mtime or if service was
569
403
                not found or if filename was modified before mtime.
440
                not found or if filename was modified before mtime.
570
404
        """
441
        """
580
405
        self.log.debug('Checking %s restarted since %s' % (service, mtime))
442
581
406
        time.sleep(sleep_time)
443
        # NOTE(beisner) pgrep_full is no longer implemented, as pidof is now
582
407
        service_restart = self.service_restarted_since(sentry_unit, mtime,
444
        # used instead of pgrep.  pgrep_full is still passed through to ensure
583
408
                                                       service,
445
        # deprecation WARNS.  lp1474030
584
409
                                                       pgrep_full=pgrep_full,
446
585
410
                                                       sleep_time=0,
447
        service_restart = self.service_restarted_since(
586
411
                                                       retry_count=retry_count)
448
            sentry_unit, mtime,
587
412
        config_update = self.config_updated_since(sentry_unit, filename, mtime,
449
            service,
588
413
                                                  sleep_time=0)
450
            pgrep_full=pgrep_full,
589
451
            sleep_time=sleep_time,
590
452
            retry_count=retry_count,
591
453
            retry_sleep_time=retry_sleep_time)
592
454
593
455
        config_update = self.config_updated_since(
594
456
            sentry_unit,
595
457
            filename,
596
458
            mtime,
597
459
            sleep_time=0)
598
460
599
414
        return service_restart and config_update
461
        return service_restart and config_update
600
415
462
601
416
    def get_sentry_time(self, sentry_unit):
463
    def get_sentry_time(self, sentry_unit):
602
@@ -428,7 +475,6 @@
603
428
        """Return a list of all Ubuntu releases in order of release."""
475
        """Return a list of all Ubuntu releases in order of release."""
604
429
        _d = distro_info.UbuntuDistroInfo()
476
        _d = distro_info.UbuntuDistroInfo()
605
430
        _release_list = _d.all
477
        _release_list = _d.all
606
431
        self.log.debug('Ubuntu release list: {}'.format(_release_list))
607
432
        return _release_list
478
        return _release_list
608
433
479
609
434
    def file_to_url(self, file_rel_path):
480
    def file_to_url(self, file_rel_path):
610
@@ -568,6 +614,142 @@
611
568
614
612
569
        return None
615
        return None
613
570
616
614
617
    def validate_sectionless_conf(self, file_contents, expected):
615
618
        """A crude conf parser.  Useful to inspect configuration files which
616
619
        do not have section headers (as would be necessary in order to use
617
620
        the configparser).  Such as openstack-dashboard or rabbitmq confs."""
618
621
        for line in file_contents.split('\n'):
619
622
            if '=' in line:
620
623
                args = line.split('=')
621
624
                if len(args) <= 1:
622
625
                    continue
623
626
                key = args[0].strip()
624
627
                value = args[1].strip()
625
628
                if key in expected.keys():
626
629
                    if expected[key] != value:
627
630
                        msg = ('Config mismatch.  Expected, actual:  {}, '
628
631
                               '{}'.format(expected[key], value))
629
632
                        amulet.raise_status(amulet.FAIL, msg=msg)
630
633
631
634
    def get_unit_hostnames(self, units):
632
635
        """Return a dict of juju unit names to hostnames."""
633
636
        host_names = {}
634
637
        for unit in units:
635
638
            host_names[unit.info['unit_name']] = \
636
639
                str(unit.file_contents('/etc/hostname').strip())
637
640
        self.log.debug('Unit host names: {}'.format(host_names))
638
641
        return host_names
639
642
640
643
    def run_cmd_unit(self, sentry_unit, cmd):
641
644
        """Run a command on a unit, return the output and exit code."""
642
645
        output, code = sentry_unit.run(cmd)
643
646
        if code == 0:
644
647
            self.log.debug('{} `{}` command returned {} '
645
648
                           '(OK)'.format(sentry_unit.info['unit_name'],
646
649
                                         cmd, code))
647
650
        else:
648
651
            msg = ('{} `{}` command returned {} '
649
652
                   '{}'.format(sentry_unit.info['unit_name'],
650
653
                               cmd, code, output))
651
654
            amulet.raise_status(amulet.FAIL, msg=msg)
652
655
        return str(output), code
653
656
654
657
    def file_exists_on_unit(self, sentry_unit, file_name):
655
658
        """Check if a file exists on a unit."""
656
659
        try:
657
660
            sentry_unit.file_stat(file_name)
658
661
            return True
659
662
        except IOError:
660
663
            return False
661
664
        except Exception as e:
662
665
            msg = 'Error checking file {}: {}'.format(file_name, e)
663
666
            amulet.raise_status(amulet.FAIL, msg=msg)
664
667
665
668
    def file_contents_safe(self, sentry_unit, file_name,
666
669
                           max_wait=60, fatal=False):
667
670
        """Get file contents from a sentry unit.  Wrap amulet file_contents
668
671
        with retry logic to address races where a file checks as existing,
669
672
        but no longer exists by the time file_contents is called.
670
673
        Return None if file not found. Optionally raise if fatal is True."""
671
674
        unit_name = sentry_unit.info['unit_name']
672
675
        file_contents = False
673
676
        tries = 0
674
677
        while not file_contents and tries < (max_wait / 4):
675
678
            try:
676
679
                file_contents = sentry_unit.file_contents(file_name)
677
680
            except IOError:
678
681
                self.log.debug('Attempt {} to open file {} from {} '
679
682
                               'failed'.format(tries, file_name,
680
683
                                               unit_name))
681
684
                time.sleep(4)
682
685
                tries += 1
683
686
684
687
        if file_contents:
685
688
            return file_contents
686
689
        elif not fatal:
687
690
            return None
688
691
        elif fatal:
689
692
            msg = 'Failed to get file contents from unit.'
690
693
            amulet.raise_status(amulet.FAIL, msg)
691
694
692
695
    def port_knock_tcp(self, host="localhost", port=22, timeout=15):
693
696
        """Open a TCP socket to check for a listening sevice on a host.
694
697
695
698
        :param host: host name or IP address, default to localhost
696
699
        :param port: TCP port number, default to 22
697
700
        :param timeout: Connect timeout, default to 15 seconds
698
701
        :returns: True if successful, False if connect failed
699
702
        """
700
703
701
704
        # Resolve host name if possible
702
705
        try:
703
706
            connect_host = socket.gethostbyname(host)
704
707
            host_human = "{} ({})".format(connect_host, host)
705
708
        except socket.error as e:
706
709
            self.log.warn('Unable to resolve address: '
707
710
                          '{} ({}) Trying anyway!'.format(host, e))
708
711
            connect_host = host
709
712
            host_human = connect_host
710
713
711
714
        # Attempt socket connection
712
715
        try:
713
716
            knock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
714
717
            knock.settimeout(timeout)
715
718
            knock.connect((connect_host, port))
716
719
            knock.close()
717
720
            self.log.debug('Socket connect OK for host '
718
721
                           '{} on port {}.'.format(host_human, port))
719
722
            return True
720
723
        except socket.error as e:
721
724
            self.log.debug('Socket connect FAIL for'
722
725
                           ' {} port {} ({})'.format(host_human, port, e))
723
726
            return False
724
727
725
728
    def port_knock_units(self, sentry_units, port=22,
726
729
                         timeout=15, expect_success=True):
727
730
        """Open a TCP socket to check for a listening sevice on each
728
731
        listed juju unit.
729
732
730
733
        :param sentry_units: list of sentry unit pointers
731
734
        :param port: TCP port number, default to 22
732
735
        :param timeout: Connect timeout, default to 15 seconds
733
736
        :expect_success: True by default, set False to invert logic
734
737
        :returns: None if successful, Failure message otherwise
735
738
        """
736
739
        for unit in sentry_units:
737
740
            host = unit.info['public-address']
738
741
            connected = self.port_knock_tcp(host, port, timeout)
739
742
            if not connected and expect_success:
740
743
                return 'Socket connect failed.'
741
744
            elif connected and not expect_success:
742
745
                return 'Socket connected unexpectedly.'
743
746
744
747
    def get_uuid_epoch_stamp(self):
745
748
        """Returns a stamp string based on uuid4 and epoch time.  Useful in
746
749
        generating test messages which need to be unique-ish."""
747
750
        return '[{}-{}]'.format(uuid.uuid4(), time.time())
748
751
749
752
# amulet juju action helpers:
750
571
    def run_action(self, unit_sentry, action,
753
    def run_action(self, unit_sentry, action,
751
572
                   _check_output=subprocess.check_output):
754
                   _check_output=subprocess.check_output):
752
573
        """Run the named action on a given unit sentry.
755
        """Run the named action on a given unit sentry.
753
@@ -594,3 +776,12 @@
754
594
        output = _check_output(command, universal_newlines=True)
776
        output = _check_output(command, universal_newlines=True)
755
595
        data = json.loads(output)
777
        data = json.loads(output)
756
596
        return data.get(u"status") == "completed"
778
        return data.get(u"status") == "completed"
757
779
758
780
    def status_get(self, unit):
759
781
        """Return the current service status of this unit."""
760
782
        raw_status, return_code = unit.run(
761
783
            "status-get --format=json --include-data")
762
784
        if return_code != 0:
763
785
            return ("unknown", "")
764
786
        status = json.loads(raw_status)
765
787
        return (status["status"], status["message"])
766
597
788
767
=== modified file 'tests/charmhelpers/contrib/openstack/amulet/deployment.py'
768
--- tests/charmhelpers/contrib/openstack/amulet/deployment.py	2015-08-26 13:11:30 +0000
769
+++ tests/charmhelpers/contrib/openstack/amulet/deployment.py	2015-09-15 12:31:21 +0000
770
@@ -44,20 +44,31 @@
771
44
           Determine if the local branch being tested is derived from its
44
           Determine if the local branch being tested is derived from its
772
45
           stable or next (dev) branch, and based on this, use the corresonding
45
           stable or next (dev) branch, and based on this, use the corresonding
773
46
           stable or next branches for the other_services."""
46
           stable or next branches for the other_services."""
774
47
775
48
        # Charms outside the lp:~openstack-charmers namespace
776
47
        base_charms = ['mysql', 'mongodb', 'nrpe']
49
        base_charms = ['mysql', 'mongodb', 'nrpe']
777
48
50
778
51
        # Force these charms to current series even when using an older series.
779
52
        # ie. Use trusty/nrpe even when series is precise, as the P charm
780
53
        # does not possess the necessary external master config and hooks.
781
54
        force_series_current = ['nrpe']
782
55
783
49
        if self.series in ['precise', 'trusty']:
56
        if self.series in ['precise', 'trusty']:
784
50
            base_series = self.series
57
            base_series = self.series
785
51
        else:
58
        else:
786
52
            base_series = self.current_next
59
            base_series = self.current_next
787
53
60
790
54
        if self.stable:
61
        for svc in other_services:
791
55
            for svc in other_services:
62
            if svc['name'] in force_series_current:
792
63
                base_series = self.current_next
793
64
            # If a location has been explicitly set, use it
794
65
            if svc.get('location'):
795
66
                continue
796
67
            if self.stable:
797
56
                temp = 'lp:charms/{}/{}'
68
                temp = 'lp:charms/{}/{}'
798
57
                svc['location'] = temp.format(base_series,
69
                svc['location'] = temp.format(base_series,
799
58
                                              svc['name'])
70
                                              svc['name'])
802
59
        else:
71
            else:
801
60
            for svc in other_services:
803
61
                if svc['name'] in base_charms:
72
                if svc['name'] in base_charms:
804
62
                    temp = 'lp:charms/{}/{}'
73
                    temp = 'lp:charms/{}/{}'
805
63
                    svc['location'] = temp.format(base_series,
74
                    svc['location'] = temp.format(base_series,
806
@@ -66,6 +77,7 @@
807
66
                    temp = 'lp:~openstack-charmers/charms/{}/{}/next'
77
                    temp = 'lp:~openstack-charmers/charms/{}/{}/next'
808
67
                    svc['location'] = temp.format(self.current_next,
78
                    svc['location'] = temp.format(self.current_next,
809
68
                                                  svc['name'])
79
                                                  svc['name'])
810
80
811
69
        return other_services
81
        return other_services
812
70
82
813
71
    def _add_services(self, this_service, other_services):
83
    def _add_services(self, this_service, other_services):
814
@@ -77,21 +89,23 @@
815
77
89
816
78
        services = other_services
90
        services = other_services
817
79
        services.append(this_service)
91
        services.append(this_service)
818
92
819
93
        # Charms which should use the source config option
820
80
        use_source = ['mysql', 'mongodb', 'rabbitmq-server', 'ceph',
94
        use_source = ['mysql', 'mongodb', 'rabbitmq-server', 'ceph',
821
81
                      'ceph-osd', 'ceph-radosgw']
95
                      'ceph-osd', 'ceph-radosgw']
825
82
        # Most OpenStack subordinate charms do not expose an origin option
96
826
83
        # as that is controlled by the principle.
97
        # Charms which can not use openstack-origin, ie. many subordinates
827
84
        ignore = ['cinder-ceph', 'hacluster', 'neutron-openvswitch', 'nrpe']
98
        no_origin = ['cinder-ceph', 'hacluster', 'neutron-openvswitch', 'nrpe']
828
85
99
829
86
        if self.openstack:
100
        if self.openstack:
830
87
            for svc in services:
101
            for svc in services:
832
88
                if svc['name'] not in use_source + ignore:
102
                if svc['name'] not in use_source + no_origin:
833
89
                    config = {'openstack-origin': self.openstack}
103
                    config = {'openstack-origin': self.openstack}
834
90
                    self.d.configure(svc['name'], config)
104
                    self.d.configure(svc['name'], config)
835
91
105
836
92
        if self.source:
106
        if self.source:
837
93
            for svc in services:
107
            for svc in services:
839
94
                if svc['name'] in use_source and svc['name'] not in ignore:
108
                if svc['name'] in use_source and svc['name'] not in no_origin:
840
95
                    config = {'source': self.source}
109
                    config = {'source': self.source}
841
96
                    self.d.configure(svc['name'], config)
110
                    self.d.configure(svc['name'], config)
842
97
111
843
98
112
844
=== modified file 'tests/charmhelpers/contrib/openstack/amulet/utils.py'
845
--- tests/charmhelpers/contrib/openstack/amulet/utils.py	2015-08-03 14:52:57 +0000
846
+++ tests/charmhelpers/contrib/openstack/amulet/utils.py	2015-09-15 12:31:21 +0000
847
@@ -27,6 +27,7 @@
848
27
import heatclient.v1.client as heat_client
27
import heatclient.v1.client as heat_client
849
28
import keystoneclient.v2_0 as keystone_client
28
import keystoneclient.v2_0 as keystone_client
850
29
import novaclient.v1_1.client as nova_client
29
import novaclient.v1_1.client as nova_client
851
30
import pika
852
30
import swiftclient
31
import swiftclient
853
31
32
854
32
from charmhelpers.contrib.amulet.utils import (
33
from charmhelpers.contrib.amulet.utils import (
855
@@ -602,3 +603,361 @@
856
602
            self.log.debug('Ceph {} samples (OK): '
603
            self.log.debug('Ceph {} samples (OK): '
857
603
                           '{}'.format(sample_type, samples))
604
                           '{}'.format(sample_type, samples))
858
604
            return None
605
            return None
859
606
860
607
# rabbitmq/amqp specific helpers:
861
608
    def add_rmq_test_user(self, sentry_units,
862
609
                          username="testuser1", password="changeme"):
863
610
        """Add a test user via the first rmq juju unit, check connection as
864
611
        the new user against all sentry units.
865
612
866
613
        :param sentry_units: list of sentry unit pointers
867
614
        :param username: amqp user name, default to testuser1
868
615
        :param password: amqp user password
869
616
        :returns: None if successful.  Raise on error.
870
617
        """
871
618
        self.log.debug('Adding rmq user ({})...'.format(username))
872
619
873
620
        # Check that user does not already exist
874
621
        cmd_user_list = 'rabbitmqctl list_users'
875
622
        output, _ = self.run_cmd_unit(sentry_units[0], cmd_user_list)
876
623
        if username in output:
877
624
            self.log.warning('User ({}) already exists, returning '
878
625
                             'gracefully.'.format(username))
879
626
            return
880
627
881
628
        perms = '".*" ".*" ".*"'
882
629
        cmds = ['rabbitmqctl add_user {} {}'.format(username, password),
883
630
                'rabbitmqctl set_permissions {} {}'.format(username, perms)]
884
631
885
632
        # Add user via first unit
886
633
        for cmd in cmds:
887
634
            output, _ = self.run_cmd_unit(sentry_units[0], cmd)
888
635
889
636
        # Check connection against the other sentry_units
890
637
        self.log.debug('Checking user connect against units...')
891
638
        for sentry_unit in sentry_units:
892
639
            connection = self.connect_amqp_by_unit(sentry_unit, ssl=False,
893
640
                                                   username=username,
894
641
                                                   password=password)
895
642
            connection.close()
896
643
897
644
    def delete_rmq_test_user(self, sentry_units, username="testuser1"):
898
645
        """Delete a rabbitmq user via the first rmq juju unit.
899
646
900
647
        :param sentry_units: list of sentry unit pointers
901
648
        :param username: amqp user name, default to testuser1
902
649
        :param password: amqp user password
903
650
        :returns: None if successful or no such user.
904
651
        """
905
652
        self.log.debug('Deleting rmq user ({})...'.format(username))
906
653
907
654
        # Check that the user exists
908
655
        cmd_user_list = 'rabbitmqctl list_users'
909
656
        output, _ = self.run_cmd_unit(sentry_units[0], cmd_user_list)
910
657
911
658
        if username not in output:
912
659
            self.log.warning('User ({}) does not exist, returning '
913
660
                             'gracefully.'.format(username))
914
661
            return
915
662
916
663
        # Delete the user
917
664
        cmd_user_del = 'rabbitmqctl delete_user {}'.format(username)
918
665
        output, _ = self.run_cmd_unit(sentry_units[0], cmd_user_del)
919
666
920
667
    def get_rmq_cluster_status(self, sentry_unit):
921
668
        """Execute rabbitmq cluster status command on a unit and return
922
669
        the full output.
923
670
924
671
        :param unit: sentry unit
925
672
        :returns: String containing console output of cluster status command
926
673
        """
927
674
        cmd = 'rabbitmqctl cluster_status'
928
675
        output, _ = self.run_cmd_unit(sentry_unit, cmd)
929
676
        self.log.debug('{} cluster_status:\n{}'.format(
930
677
            sentry_unit.info['unit_name'], output))
931
678
        return str(output)
932
679
933
680
    def get_rmq_cluster_running_nodes(self, sentry_unit):
934
681
        """Parse rabbitmqctl cluster_status output string, return list of
935
682
        running rabbitmq cluster nodes.
936
683
937
684
        :param unit: sentry unit
938
685
        :returns: List containing node names of running nodes
939
686
        """
940
687
        # NOTE(beisner): rabbitmqctl cluster_status output is not
941
688
        # json-parsable, do string chop foo, then json.loads that.
942
689
        str_stat = self.get_rmq_cluster_status(sentry_unit)
943
690
        if 'running_nodes' in str_stat:
944
691
            pos_start = str_stat.find("{running_nodes,") + 15
945
692
            pos_end = str_stat.find("]},", pos_start) + 1
946
693
            str_run_nodes = str_stat[pos_start:pos_end].replace("'", '"')
947
694
            run_nodes = json.loads(str_run_nodes)
948
695
            return run_nodes
949
696
        else:
950
697
            return []
951
698
952
699
    def validate_rmq_cluster_running_nodes(self, sentry_units):
953
700
        """Check that all rmq unit hostnames are represented in the
954
701
        cluster_status output of all units.
955
702
956
703
        :param host_names: dict of juju unit names to host names
957
704
        :param units: list of sentry unit pointers (all rmq units)
958
705
        :returns: None if successful, otherwise return error message
959
706
        """
960
707
        host_names = self.get_unit_hostnames(sentry_units)
961
708
        errors = []
962
709
963
710
        # Query every unit for cluster_status running nodes
964
711
        for query_unit in sentry_units:
965
712
            query_unit_name = query_unit.info['unit_name']
966
713
            running_nodes = self.get_rmq_cluster_running_nodes(query_unit)
967
714
968
715
            # Confirm that every unit is represented in the queried unit's
969
716
            # cluster_status running nodes output.
970
717
            for validate_unit in sentry_units:
971
718
                val_host_name = host_names[validate_unit.info['unit_name']]
972
719
                val_node_name = 'rabbit@{}'.format(val_host_name)
973
720
974
721
                if val_node_name not in running_nodes:
975
722
                    errors.append('Cluster member check failed on {}: {} not '
976
723
                                  'in {}\n'.format(query_unit_name,
977
724
                                                   val_node_name,
978
725
                                                   running_nodes))
979
726
        if errors:
980
727
            return ''.join(errors)
981
728
982
729
    def rmq_ssl_is_enabled_on_unit(self, sentry_unit, port=None):
983
730
        """Check a single juju rmq unit for ssl and port in the config file."""
984
731
        host = sentry_unit.info['public-address']
985
732
        unit_name = sentry_unit.info['unit_name']
986
733
987
734
        conf_file = '/etc/rabbitmq/rabbitmq.config'
988
735
        conf_contents = str(self.file_contents_safe(sentry_unit,
989
736
                                                    conf_file, max_wait=16))
990
737
        # Checks
991
738
        conf_ssl = 'ssl' in conf_contents
992
739
        conf_port = str(port) in conf_contents
993
740
994
741
        # Port explicitly checked in config
995
742
        if port and conf_port and conf_ssl:
996
743
            self.log.debug('SSL is enabled  @{}:{} '
997
744
                           '({})'.format(host, port, unit_name))
998
745
            return True
999
746
        elif port and not conf_port and conf_ssl:
1000
747
            self.log.debug('SSL is enabled @{} but not on port {} '
1001
748
                           '({})'.format(host, port, unit_name))
1002
749
            return False
1003
750
        # Port not checked (useful when checking that ssl is disabled)
1004
751
        elif not port and conf_ssl:
1005
752
            self.log.debug('SSL is enabled  @{}:{} '
1006
753
                           '({})'.format(host, port, unit_name))
1007
754
            return True
1008
755
        elif not port and not conf_ssl:
1009
756
            self.log.debug('SSL not enabled @{}:{} '
1010
757
                           '({})'.format(host, port, unit_name))
1011
758
            return False
1012
759
        else:
1013
760
            msg = ('Unknown condition when checking SSL status @{}:{} '
1014
761
                   '({})'.format(host, port, unit_name))
1015
762
            amulet.raise_status(amulet.FAIL, msg)
1016
763
1017
764
    def validate_rmq_ssl_enabled_units(self, sentry_units, port=None):
1018
765
        """Check that ssl is enabled on rmq juju sentry units.
1019
766
1020
767
        :param sentry_units: list of all rmq sentry units
1021
768
        :param port: optional ssl port override to validate
1022
769
        :returns: None if successful, otherwise return error message
1023
770
        """
1024
771
        for sentry_unit in sentry_units:
1025
772
            if not self.rmq_ssl_is_enabled_on_unit(sentry_unit, port=port):
1026
773
                return ('Unexpected condition:  ssl is disabled on unit '
1027
774
                        '({})'.format(sentry_unit.info['unit_name']))
1028
775
        return None
1029
776
1030
777
    def validate_rmq_ssl_disabled_units(self, sentry_units):
1031
778
        """Check that ssl is enabled on listed rmq juju sentry units.
1032
779
1033
780
        :param sentry_units: list of all rmq sentry units
1034
781
        :returns: True if successful.  Raise on error.
1035
782
        """
1036
783
        for sentry_unit in sentry_units:
1037
784
            if self.rmq_ssl_is_enabled_on_unit(sentry_unit):
1038
785
                return ('Unexpected condition:  ssl is enabled on unit '
1039
786
                        '({})'.format(sentry_unit.info['unit_name']))
1040
787
        return None
1041
788
1042
789
    def configure_rmq_ssl_on(self, sentry_units, deployment,
1043
790
                             port=None, max_wait=60):
1044
791
        """Turn ssl charm config option on, with optional non-default
1045
792
        ssl port specification.  Confirm that it is enabled on every
1046
793
        unit.
1047
794
1048
795
        :param sentry_units: list of sentry units
1049
796
        :param deployment: amulet deployment object pointer
1050
797
        :param port: amqp port, use defaults if None
1051
798
        :param max_wait: maximum time to wait in seconds to confirm
1052
799
        :returns: None if successful.  Raise on error.
1053
800
        """
1054
801
        self.log.debug('Setting ssl charm config option:  on')
1055
802
1056
803
        # Enable RMQ SSL
1057
804
        config = {'ssl': 'on'}
1058
805
        if port:
1059
806
            config['ssl_port'] = port
1060
807
1061
808
        deployment.configure('rabbitmq-server', config)
1062
809
1063
810
        # Confirm
1064
811
        tries = 0
1065
812
        ret = self.validate_rmq_ssl_enabled_units(sentry_units, port=port)
1066
813
        while ret and tries < (max_wait / 4):
1067
814
            time.sleep(4)
1068
815
            self.log.debug('Attempt {}: {}'.format(tries, ret))
1069
816
            ret = self.validate_rmq_ssl_enabled_units(sentry_units, port=port)
1070
817
            tries += 1
1071
818
1072
819
        if ret:
1073
820
            amulet.raise_status(amulet.FAIL, ret)
1074
821
1075
822
    def configure_rmq_ssl_off(self, sentry_units, deployment, max_wait=60):
1076
823
        """Turn ssl charm config option off, confirm that it is disabled
1077
824
        on every unit.
1078
825
1079
826
        :param sentry_units: list of sentry units
1080
827
        :param deployment: amulet deployment object pointer
1081
828
        :param max_wait: maximum time to wait in seconds to confirm
1082
829
        :returns: None if successful.  Raise on error.
1083
830
        """
1084
831
        self.log.debug('Setting ssl charm config option:  off')
1085
832
1086
833
        # Disable RMQ SSL
1087
834
        config = {'ssl': 'off'}
1088
835
        deployment.configure('rabbitmq-server', config)
1089
836
1090
837
        # Confirm
1091
838
        tries = 0
1092
839
        ret = self.validate_rmq_ssl_disabled_units(sentry_units)
1093
840
        while ret and tries < (max_wait / 4):
1094
841
            time.sleep(4)
1095
842
            self.log.debug('Attempt {}: {}'.format(tries, ret))
1096
843
            ret = self.validate_rmq_ssl_disabled_units(sentry_units)
1097
844
            tries += 1
1098
845
1099
846
        if ret:
1100
847
            amulet.raise_status(amulet.FAIL, ret)
1101
848
1102
849
    def connect_amqp_by_unit(self, sentry_unit, ssl=False,
1103
850
                             port=None, fatal=True,
1104
851
                             username="testuser1", password="changeme"):
1105
852
        """Establish and return a pika amqp connection to the rabbitmq service
1106
853
        running on a rmq juju unit.
1107
854
1108
855
        :param sentry_unit: sentry unit pointer
1109
856
        :param ssl: boolean, default to False
1110
857
        :param port: amqp port, use defaults if None
1111
858
        :param fatal: boolean, default to True (raises on connect error)
1112
859
        :param username: amqp user name, default to testuser1
1113
860
        :param password: amqp user password
1114
861
        :returns: pika amqp connection pointer or None if failed and non-fatal
1115
862
        """
1116
863
        host = sentry_unit.info['public-address']
1117
864
        unit_name = sentry_unit.info['unit_name']
1118
865
1119
866
        # Default port logic if port is not specified
1120
867
        if ssl and not port:
1121
868
            port = 5671
1122
869
        elif not ssl and not port:
1123
870
            port = 5672
1124
871
1125
872
        self.log.debug('Connecting to amqp on {}:{} ({}) as '
1126
873
                       '{}...'.format(host, port, unit_name, username))
1127
874
1128
875
        try:
1129
876
            credentials = pika.PlainCredentials(username, password)
1130
877
            parameters = pika.ConnectionParameters(host=host, port=port,
1131
878
                                                   credentials=credentials,
1132
879
                                                   ssl=ssl,
1133
880
                                                   connection_attempts=3,
1134
881
                                                   retry_delay=5,
1135
882
                                                   socket_timeout=1)
1136
883
            connection = pika.BlockingConnection(parameters)
1137
884
            assert connection.server_properties['product'] == 'RabbitMQ'
1138
885
            self.log.debug('Connect OK')
1139
886
            return connection
1140
887
        except Exception as e:
1141
888
            msg = ('amqp connection failed to {}:{} as '
1142
889
                   '{} ({})'.format(host, port, username, str(e)))
1143
890
            if fatal:
1144
891
                amulet.raise_status(amulet.FAIL, msg)
1145
892
            else:
1146
893
                self.log.warn(msg)
1147
894
                return None
1148
895
1149
896
    def publish_amqp_message_by_unit(self, sentry_unit, message,
1150
897
                                     queue="test", ssl=False,
1151
898
                                     username="testuser1",
1152
899
                                     password="changeme",
1153
900
                                     port=None):
1154
901
        """Publish an amqp message to a rmq juju unit.
1155
902
1156
903
        :param sentry_unit: sentry unit pointer
1157
904
        :param message: amqp message string
1158
905
        :param queue: message queue, default to test
1159
906
        :param username: amqp user name, default to testuser1
1160
907
        :param password: amqp user password
1161
908
        :param ssl: boolean, default to False
1162
909
        :param port: amqp port, use defaults if None
1163
910
        :returns: None.  Raises exception if publish failed.
1164
911
        """
1165
912
        self.log.debug('Publishing message to {} queue:\n{}'.format(queue,
1166
913
                                                                    message))
1167
914
        connection = self.connect_amqp_by_unit(sentry_unit, ssl=ssl,
1168
915
                                               port=port,
1169
916
                                               username=username,
1170
917
                                               password=password)
1171
918
1172
919
        # NOTE(beisner): extra debug here re: pika hang potential:
1173
920
        #   https://github.com/pika/pika/issues/297
1174
921
        #   https://groups.google.com/forum/#!topic/rabbitmq-users/Ja0iyfF0Szw
1175
922
        self.log.debug('Defining channel...')
1176
923
        channel = connection.channel()
1177
924
        self.log.debug('Declaring queue...')
1178
925
        channel.queue_declare(queue=queue, auto_delete=False, durable=True)
1179
926
        self.log.debug('Publishing message...')
1180
927
        channel.basic_publish(exchange='', routing_key=queue, body=message)
1181
928
        self.log.debug('Closing channel...')
1182
929
        channel.close()
1183
930
        self.log.debug('Closing connection...')
1184
931
        connection.close()
1185
932
1186
933
    def get_amqp_message_by_unit(self, sentry_unit, queue="test",
1187
934
                                 username="testuser1",
1188
935
                                 password="changeme",
1189
936
                                 ssl=False, port=None):
1190
937
        """Get an amqp message from a rmq juju unit.
1191
938
1192
939
        :param sentry_unit: sentry unit pointer
1193
940
        :param queue: message queue, default to test
1194
941
        :param username: amqp user name, default to testuser1
1195
942
        :param password: amqp user password
1196
943
        :param ssl: boolean, default to False
1197
944
        :param port: amqp port, use defaults if None
1198
945
        :returns: amqp message body as string.  Raise if get fails.
1199
946
        """
1200
947
        connection = self.connect_amqp_by_unit(sentry_unit, ssl=ssl,
1201
948
                                               port=port,
1202
949
                                               username=username,
1203
950
                                               password=password)
1204
951
        channel = connection.channel()
1205
952
        method_frame, _, body = channel.basic_get(queue)
1206
953
1207
954
        if method_frame:
1208
955
            self.log.debug('Retreived message from {} queue:\n{}'.format(queue,
1209
956
                                                                         body))
1210
957
            channel.basic_ack(method_frame.delivery_tag)
1211
958
            channel.close()
1212
959
            connection.close()
1213
960
            return body
1214
961
        else:
1215
962
            msg = 'No message retrieved.'
1216
963
            amulet.raise_status(amulet.FAIL, msg)
1217
605
964
1218
=== added directory 'tests/charmhelpers/core'
1219
=== added file 'tests/charmhelpers/core/__init__.py'
1220
--- tests/charmhelpers/core/__init__.py	1970-01-01 00:00:00 +0000
1221
+++ tests/charmhelpers/core/__init__.py	2015-09-15 12:31:21 +0000
1222
@@ -0,0 +1,15 @@
1223
1
# Copyright 2014-2015 Canonical Limited.
1224
2
#
1225
3
# This file is part of charm-helpers.
1226
4
#
1227
5
# charm-helpers is free software: you can redistribute it and/or modify
1228
6
# it under the terms of the GNU Lesser General Public License version 3 as
1229
7
# published by the Free Software Foundation.
1230
8
#
1231
9
# charm-helpers is distributed in the hope that it will be useful,
1232
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1233
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1234
12
# GNU Lesser General Public License for more details.
1235
13
#
1236
14
# You should have received a copy of the GNU Lesser General Public License
1237
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1238
0
16
1239
=== added file 'tests/charmhelpers/core/hookenv.py'
1240
--- tests/charmhelpers/core/hookenv.py	1970-01-01 00:00:00 +0000
1241
+++ tests/charmhelpers/core/hookenv.py	2015-09-15 12:31:21 +0000
1242
@@ -0,0 +1,898 @@
1243
1
# Copyright 2014-2015 Canonical Limited.
1244
2
#
1245
3
# This file is part of charm-helpers.
1246
4
#
1247
5
# charm-helpers is free software: you can redistribute it and/or modify
1248
6
# it under the terms of the GNU Lesser General Public License version 3 as
1249
7
# published by the Free Software Foundation.
1250
8
#
1251
9
# charm-helpers is distributed in the hope that it will be useful,
1252
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
1253
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1254
12
# GNU Lesser General Public License for more details.
1255
13
#
1256
14
# You should have received a copy of the GNU Lesser General Public License
1257
15
# along with charm-helpers.  If not, see <http://www.gnu.org/licenses/>.
1258
16
1259
17
"Interactions with the Juju environment"
1260
18
# Copyright 2013 Canonical Ltd.
1261
19
#
1262
20
# Authors:
1263
21
#  Charm Helpers Developers <juju@lists.ubuntu.com>
1264
22
1265
23
from __future__ import print_function
1266
24
import copy
1267
25
from distutils.version import LooseVersion
1268
26
from functools import wraps
1269
27
import glob
1270
28
import os
1271
29
import json
1272
30
import yaml
1273
31
import subprocess
1274
32
import sys
1275
33
import errno
1276
34
import tempfile
1277
35
from subprocess import CalledProcessError
1278
36
1279
37
import six
1280
38
if not six.PY3:
1281
39
    from UserDict import UserDict
1282
40
else:
1283
41
    from collections import UserDict
1284
42
1285
43
CRITICAL = "CRITICAL"
1286
44
ERROR = "ERROR"
1287
45
WARNING = "WARNING"
1288
46
INFO = "INFO"
1289
47
DEBUG = "DEBUG"
1290
48
MARKER = object()
1291
49
1292
50
cache = {}
1293
51
1294
52
1295
53
def cached(func):
1296
54
    """Cache return values for multiple executions of func + args
1297
55
1298
56
    For example::
1299
57
1300
58
        @cached
1301
59
        def unit_get(attribute):
1302
60
            pass
1303
61
1304
62
        unit_get('test')
1305
63
1306
64
    will cache the result of unit_get + 'test' for future calls.
1307
65
    """
1308
66
    @wraps(func)
1309
67
    def wrapper(*args, **kwargs):
1310
68
        global cache
1311
69
        key = str((func, args, kwargs))
1312
70
        try:
1313
71
            return cache[key]
1314
72
        except KeyError:
1315
73
            pass  # Drop out of the exception handler scope.
1316
74
        res = func(*args, **kwargs)
1317
75
        cache[key] = res
1318
76
        return res
1319
77
    wrapper._wrapped = func
1320
78
    return wrapper
1321
79
1322
80
1323
81
def flush(key):
1324
82
    """Flushes any entries from function cache where the
1325
83
    key is found in the function+args """
1326
84
    flush_list = []
1327
85
    for item in cache:
1328
86
        if key in item:
1329
87
            flush_list.append(item)
1330
88
    for item in flush_list:
1331
89
        del cache[item]
1332
90
1333
91
1334
92
def log(message, level=None):
1335
93
    """Write a message to the juju log"""
1336
94
    command = ['juju-log']
1337
95
    if level:
1338
96
        command += ['-l', level]
1339
97
    if not isinstance(message, six.string_types):
1340
98
        message = repr(message)
1341
99
    command += [message]
1342
100
    # Missing juju-log should not cause failures in unit tests
1343
101
    # Send log output to stderr
1344
102
    try:
1345
103
        subprocess.call(command)
1346
104
    except OSError as e:
1347
105
        if e.errno == errno.ENOENT:
1348
106
            if level:
1349
107
                message = "{}: {}".format(level, message)
1350
108
            message = "juju-log: {}".format(message)
1351
109
            print(message, file=sys.stderr)
1352
110
        else:
1353
111
            raise
1354
112
1355
113
1356
114
class Serializable(UserDict):
1357
115
    """Wrapper, an object that can be serialized to yaml or json"""
1358
116
1359
117
    def __init__(self, obj):
1360
118
        # wrap the object
1361
119
        UserDict.__init__(self)
1362
120
        self.data = obj
1363
121
1364
122
    def __getattr__(self, attr):
1365
123
        # See if this object has attribute.
1366
124
        if attr in ("json", "yaml", "data"):
1367
125
            return self.__dict__[attr]
1368
126
        # Check for attribute in wrapped object.
1369
127
        got = getattr(self.data, attr, MARKER)
1370
128
        if got is not MARKER:
1371
129
            return got
1372
130
        # Proxy to the wrapped object via dict interface.
1373
131
        try:
1374
132
            return self.data[attr]
1375
133
        except KeyError:
1376
134
            raise AttributeError(attr)
1377
135
1378
136
    def __getstate__(self):
1379
137
        # Pickle as a standard dictionary.
1380
138
        return self.data
1381
139
1382
140
    def __setstate__(self, state):
1383
141
        # Unpickle into our wrapper.
1384
142
        self.data = state
1385
143
1386
144
    def json(self):
1387
145
        """Serialize the object to json"""
1388
146
        return json.dumps(self.data)
1389
147
1390
148
    def yaml(self):
1391
149
        """Serialize the object to yaml"""
1392
150
        return yaml.dump(self.data)
1393
151
1394
152
1395
153
def execution_environment():
1396
154
    """A convenient bundling of the current execution context"""
1397
155
    context = {}
1398
156
    context['conf'] = config()
1399
157
    if relation_id():
1400
158
        context['reltype'] = relation_type()
1401
159
        context['relid'] = relation_id()
1402
160
        context['rel'] = relation_get()
1403
161
    context['unit'] = local_unit()
1404
162
    context['rels'] = relations()
1405
163
    context['env'] = os.environ
1406
164
    return context
1407
165
1408
166
1409
167
def in_relation_hook():
1410
168
    """Determine whether we're running in a relation hook"""
1411
169
    return 'JUJU_RELATION' in os.environ
1412
170
1413
171
1414
172
def relation_type():
1415
173
    """The scope for the current relation hook"""
1416
174
    return os.environ.get('JUJU_RELATION', None)
1417
175
1418
176
1419
177
@cached
1420
178
def relation_id(relation_name=None, service_or_unit=None):
1421
179
    """The relation ID for the current or a specified relation"""
1422
180
    if not relation_name and not service_or_unit:
1423
181
        return os.environ.get('JUJU_RELATION_ID', None)
1424
182
    elif relation_name and service_or_unit:
1425
183
        service_name = service_or_unit.split('/')[0]
1426
184
        for relid in relation_ids(relation_name):
1427
185
            remote_service = remote_service_name(relid)
1428
186
            if remote_service == service_name:
1429
187
                return relid
1430
188
    else:
1431
189
        raise ValueError('Must specify neither or both of relation_name and service_or_unit')
1432
190
1433
191
1434
192
def local_unit():
1435
193
    """Local unit ID"""
1436
194
    return os.environ['JUJU_UNIT_NAME']
1437
195
1438
196
1439
197
def remote_unit():
1440
198
    """The remote unit for the current relation hook"""
1441
199
    return os.environ.get('JUJU_REMOTE_UNIT', None)
1442
200
1443
201
1444
202
def service_name():
1445
203
    """The name service group this unit belongs to"""
1446
204
    return local_unit().split('/')[0]
1447
205
1448
206
1449
207
@cached
1450
208
def remote_service_name(relid=None):
1451
209
    """The remote service name for a given relation-id (or the current relation)"""
1452
210
    if relid is None:
1453
211
        unit = remote_unit()
1454
212
    else:
1455
213
        units = related_units(relid)
1456
214
        unit = units[0] if units else None
1457
215
    return unit.split('/')[0] if unit else None
1458
216
1459
217
1460
218
def hook_name():
1461
219
    """The name of the currently executing hook"""
1462
220
    return os.environ.get('JUJU_HOOK_NAME', os.path.basename(sys.argv[0]))
1463
221
1464
222
1465
223
class Config(dict):
1466
224
    """A dictionary representation of the charm's config.yaml, with some
1467
225
    extra features:
1468
226
1469
227
    - See which values in the dictionary have changed since the previous hook.
1470
228
    - For values that have changed, see what the previous value was.
1471
229
    - Store arbitrary data for use in a later hook.
1472
230
1473
231
    NOTE: Do not instantiate this object directly - instead call
1474
232
    ``hookenv.config()``, which will return an instance of :class:`Config`.
1475
233
1476
234
    Example usage::
1477
235
1478
236
        >>> # inside a hook
1479
237
        >>> from charmhelpers.core import hookenv
1480
238
        >>> config = hookenv.config()
1481
239
        >>> config['foo']
1482
240
        'bar'
1483
241
        >>> # store a new key/value for later use
1484
242
        >>> config['mykey'] = 'myval'
1485
243
1486
244
1487
245
        >>> # user runs `juju set mycharm foo=baz`
1488
246
        >>> # now we're inside subsequent config-changed hook
1489
247
        >>> config = hookenv.config()
1490
248
        >>> config['foo']
1491
249
        'baz'
1492
250
        >>> # test to see if this val has changed since last hook
1493
251
        >>> config.changed('foo')
1494
252
        True
1495
253
        >>> # what was the previous value?
1496
254
        >>> config.previous('foo')
1497
255
        'bar'
1498
256
        >>> # keys/values that we add are preserved across hooks
1499
257
        >>> config['mykey']
1500
258
        'myval'
1501
259
1502
260
    """
1503
261
    CONFIG_FILE_NAME = '.juju-persistent-config'
1504
262
1505
263
    def __init__(self, *args, **kw):
1506
264
        super(Config, self).__init__(*args, **kw)
1507
265
        self.implicit_save = True
1508
266
        self._prev_dict = None
1509
267
        self.path = os.path.join(charm_dir(), Config.CONFIG_FILE_NAME)
1510
268
        if os.path.exists(self.path):
1511
269
            self.load_previous()
1512
270
        atexit(self._implicit_save)
1513
271
1514
272
    def load_previous(self, path=None):
1515
273
        """Load previous copy of config from disk.
1516
274
1517
275
        In normal usage you don't need to call this method directly - it
1518
276
        is called automatically at object initialization.
1519
277
1520
278
        :param path:
1521
279
1522
280
            File path from which to load the previous config. If `None`,
1523
281
            config is loaded from the default location. If `path` is
1524
282
            specified, subsequent `save()` calls will write to the same
1525
283
            path.
1526
284
1527
285
        """
1528
286
        self.path = path or self.path
1529
287
        with open(self.path) as f:
1530
288
            self._prev_dict = json.load(f)
1531
289
        for k, v in copy.deepcopy(self._prev_dict).items():
1532
290
            if k not in self:
1533
291
                self[k] = v
1534
292
1535
293
    def changed(self, key):
1536
294
        """Return True if the current value for this key is different from
1537
295
        the previous value.
1538
296
1539
297
        """
1540
298
        if self._prev_dict is None:
1541
299
            return True
1542
300
        return self.previous(key) != self.get(key)
1543
301
1544
302
    def previous(self, key):
1545
303
        """Return previous value for this key, or None if there
1546
304
        is no previous value.
1547
305
1548
306
        """
1549
307
        if self._prev_dict:
1550
308
            return self._prev_dict.get(key)
1551
309
        return None
1552
310
1553
311
    def save(self):
1554
312
        """Save this config to disk.
1555
313
1556
314
        If the charm is using the :mod:`Services Framework <services.base>`
1557
315
        or :meth:'@hook <Hooks.hook>' decorator, this
1558
316
        is called automatically at the end of successful hook execution.
1559
317
        Otherwise, it should be called directly by user code.
1560
318
1561
319
        To disable automatic saves, set ``implicit_save=False`` on this
1562
320
        instance.
1563
321
1564
322
        """
1565
323
        with open(self.path, 'w') as f:
1566
324
            json.dump(self, f)
1567
325
1568
326
    def _implicit_save(self):
1569
327
        if self.implicit_save:
1570
328
            self.save()
1571
329
1572
330
1573
331
@cached
1574
332
def config(scope=None):
1575
333
    """Juju charm configuration"""
1576
334
    config_cmd_line = ['config-get']
1577
335
    if scope is not None:
1578
336
        config_cmd_line.append(scope)
1579
337
    config_cmd_line.append('--format=json')
1580
338
    try:
1581
339
        config_data = json.loads(
1582
340
            subprocess.check_output(config_cmd_line).decode('UTF-8'))
1583
341
        if scope is not None:
1584
342
            return config_data
1585
343
        return Config(config_data)
1586
344
    except ValueError:
1587
345
        return None
1588
346
1589
347
1590
348
@cached
1591
349
def relation_get(attribute=None, unit=None, rid=None):
1592
350
    """Get relation information"""
1593
351
    _args = ['relation-get', '--format=json']
1594
352
    if rid:
1595
353
        _args.append('-r')
1596
354
        _args.append(rid)
1597
355
    _args.append(attribute or '-')
1598
356
    if unit:
1599
357
        _args.append(unit)
1600
358
    try:
1601
359
        return json.loads(subprocess.check_output(_args).decode('UTF-8'))
1602
360
    except ValueError:
1603
361
        return None
1604
362
    except CalledProcessError as e:
1605
363
        if e.returncode == 2:
1606
364
            return None
1607
365
        raise
1608
366
1609
367
1610
368
def relation_set(relation_id=None, relation_settings=None, **kwargs):
1611
369
    """Set relation information for the current unit"""
1612
370
    relation_settings = relation_settings if relation_settings else {}
1613
371
    relation_cmd_line = ['relation-set']
1614
372
    accepts_file = "--file" in subprocess.check_output(
1615
373
        relation_cmd_line + ["--help"], universal_newlines=True)
1616
374
    if relation_id is not None:
1617
375
        relation_cmd_line.extend(('-r', relation_id))
1618
376
    settings = relation_settings.copy()
1619
377
    settings.update(kwargs)
1620
378
    for key, value in settings.items():
1621
379
        # Force value to be a string: it always should, but some call
1622
380
        # sites pass in things like dicts or numbers.
1623
381
        if value is not None:
1624
382
            settings[key] = "{}".format(value)
1625
383
    if accepts_file:
1626
384
        # --file was introduced in Juju 1.23.2. Use it by default if
1627
385
        # available, since otherwise we'll break if the relation data is
1628
386
        # too big. Ideally we should tell relation-set to read the data from
1629
387
        # stdin, but that feature is broken in 1.23.2: Bug #1454678.
1630
388
        with tempfile.NamedTemporaryFile(delete=False) as settings_file:
1631
389
            settings_file.write(yaml.safe_dump(settings).encode("utf-8"))
1632
390
        subprocess.check_call(
1633
391
            relation_cmd_line + ["--file", settings_file.name])
1634
392
        os.remove(settings_file.name)
1635
393
    else:
1636
394
        for key, value in settings.items():
1637
395
            if value is None:
1638
396
                relation_cmd_line.append('{}='.format(key))
1639
397
            else:
1640
398
                relation_cmd_line.append('{}={}'.format(key, value))
1641
399
        subprocess.check_call(relation_cmd_line)
1642
400
    # Flush cache of any relation-gets for local unit
1643
401
    flush(local_unit())
1644
402
1645
403
1646
404
def relation_clear(r_id=None):
1647
405
    ''' Clears any relation data already set on relation r_id '''
1648
406
    settings = relation_get(rid=r_id,
1649
407
                            unit=local_unit())
1650
408
    for setting in settings:
1651
409
        if setting not in ['public-address', 'private-address']:
1652
410
            settings[setting] = None
1653
411
    relation_set(relation_id=r_id,
1654
412
                 **settings)
1655
413
1656
414
1657
415
@cached
1658
416
def relation_ids(reltype=None):
1659
417
    """A list of relation_ids"""
1660
418
    reltype = reltype or relation_type()
1661
419
    relid_cmd_line = ['relation-ids', '--format=json']
1662
420
    if reltype is not None:
1663
421
        relid_cmd_line.append(reltype)
1664
422
        return json.loads(
1665
423
            subprocess.check_output(relid_cmd_line).decode('UTF-8')) or []
1666
424
    return []
1667
425
1668
426
1669
427
@cached
1670
428
def related_units(relid=None):
1671
429
    """A list of related units"""
1672
430
    relid = relid or relation_id()
1673
431
    units_cmd_line = ['relation-list', '--format=json']
1674
432
    if relid is not None:
1675
433
        units_cmd_line.extend(('-r', relid))
1676
434
    return json.loads(
1677
435
        subprocess.check_output(units_cmd_line).decode('UTF-8')) or []
1678
436
1679
437
1680
438
@cached
1681
439
def relation_for_unit(unit=None, rid=None):
1682
440
    """Get the json represenation of a unit's relation"""
1683
441
    unit = unit or remote_unit()
1684
442
    relation = relation_get(unit=unit, rid=rid)
1685
443
    for key in relation:
1686
444
        if key.endswith('-list'):
1687
445
            relation[key] = relation[key].split()
1688
446
    relation['__unit__'] = unit
1689
447
    return relation
1690
448
1691
449
1692
450
@cached
1693
451
def relations_for_id(relid=None):
1694
452
    """Get relations of a specific relation ID"""
1695
453
    relation_data = []
1696
454
    relid = relid or relation_ids()
1697
455
    for unit in related_units(relid):
1698
456
        unit_data = relation_for_unit(unit, relid)
1699
457
        unit_data['__relid__'] = relid
1700
458
        relation_data.append(unit_data)
1701
459
    return relation_data
1702
460
1703
461
1704
462
@cached
1705
463
def relations_of_type(reltype=None):
1706
464
    """Get relations of a specific type"""
1707
465
    relation_data = []
1708
466
    reltype = reltype or relation_type()
1709
467
    for relid in relation_ids(reltype):
1710
468
        for relation in relations_for_id(relid):
1711
469
            relation['__relid__'] = relid
1712
470
            relation_data.append(relation)
1713
471
    return relation_data
1714
472
1715
473
1716
474
@cached
1717
475
def metadata():
1718
476
    """Get the current charm metadata.yaml contents as a python object"""
1719
477
    with open(os.path.join(charm_dir(), 'metadata.yaml')) as md:
1720
478
        return yaml.safe_load(md)
1721
479
1722
480
1723
481
@cached
1724
482
def relation_types():
1725
483
    """Get a list of relation types supported by this charm"""
1726
484
    rel_types = []
1727
485
    md = metadata()
1728
486
    for key in ('provides', 'requires', 'peers'):
1729
487
        section = md.get(key)
1730
488
        if section:
1731
489
            rel_types.extend(section.keys())
1732
490
    return rel_types
1733
491
1734
492
1735
493
@cached
1736
494
def relation_to_interface(relation_name):
1737
495
    """
1738
496
    Given the name of a relation, return the interface that relation uses.
1739
497
1740
498
    :returns: The interface name, or ``None``.
1741
499
    """
1742
500
    return relation_to_role_and_interface(relation_name)[1]
1743
501
1744
502
1745
503
@cached
1746
504
def relation_to_role_and_interface(relation_name):
1747
505
    """
1748
506
    Given the name of a relation, return the role and the name of the interface
1749
507
    that relation uses (where role is one of ``provides``, ``requires``, or ``peer``).
1750
508
1751
509
    :returns: A tuple containing ``(role, interface)``, or ``(None, None)``.
1752
510
    """
1753
511
    _metadata = metadata()
1754
512
    for role in ('provides', 'requires', 'peer'):
1755
513
        interface = _metadata.get(role, {}).get(relation_name, {}).get('interface')
1756
514
        if interface:
1757
515
            return role, interface
1758
516
    return None, None
1759
517
1760
518
1761
519
@cached
1762
520
def role_and_interface_to_relations(role, interface_name):
1763
521
    """
1764
522
    Given a role and interface name, return a list of relation names for the
1765
523
    current charm that use that interface under that role (where role is one
1766
524
    of ``provides``, ``requires``, or ``peer``).
1767
525
1768
526
    :returns: A list of relation names.
1769
527
    """
1770
528
    _metadata = metadata()
1771
529
    results = []
1772
530
    for relation_name, relation in _metadata.get(role, {}).items():
1773
531
        if relation['interface'] == interface_name:
1774
532
            results.append(relation_name)
1775
533
    return results
1776
534
1777
535
1778
536
@cached
1779
537
def interface_to_relations(interface_name):
1780
538
    """
1781
539
    Given an interface, return a list of relation names for the current
1782
540
    charm that use that interface.
1783
541
1784
542
    :returns: A list of relation names.
1785
543
    """
1786
544
    results = []
1787
545
    for role in ('provides', 'requires', 'peer'):
1788
546
        results.extend(role_and_interface_to_relations(role, interface_name))
1789
547
    return results
1790
548
1791
549
1792
550
@cached
1793
551
def charm_name():
1794
552
    """Get the name of the current charm as is specified on metadata.yaml"""
1795
553
    return metadata().get('name')
1796
554
1797
555
1798
556
@cached
1799
557
def relations():
1800
558
    """Get a nested dictionary of relation data for all related units"""
1801
559
    rels = {}
1802
560
    for reltype in relation_types():
1803
561
        relids = {}
1804
562
        for relid in relation_ids(reltype):
1805
563
            units = {local_unit(): relation_get(unit=local_unit(), rid=relid)}
1806
564
            for unit in related_units(relid):
1807
565
                reldata = relation_get(unit=unit, rid=relid)
1808
566
                units[unit] = reldata
1809
567
            relids[relid] = units
1810
568
        rels[reltype] = relids
1811
569
    return rels
1812
570
1813
571
1814
572
@cached
1815
573
def is_relation_made(relation, keys='private-address'):
1816
574
    '''
1817
575
    Determine whether a relation is established by checking for
1818
576
    presence of key(s).  If a list of keys is provided, they
1819
577
    must all be present for the relation to be identified as made
1820
578
    '''
1821
579
    if isinstance(keys, str):
1822
580
        keys = [keys]
1823
581
    for r_id in relation_ids(relation):
1824
582
        for unit in related_units(r_id):
1825
583
            context = {}
1826
584
            for k in keys:
1827
585
                context[k] = relation_get(k, rid=r_id,
1828
586
                                          unit=unit)
1829
587
            if None not in context.values():
1830
588
                return True
1831
589
    return False
1832
590
1833
591
1834
592
def open_port(port, protocol="TCP"):
1835
593
    """Open a service network port"""
1836
594
    _args = ['open-port']
1837
595
    _args.append('{}/{}'.format(port, protocol))
1838
596
    subprocess.check_call(_args)
1839
597
1840
598
1841
599
def close_port(port, protocol="TCP"):
1842
600
    """Close a service network port"""
1843
601
    _args = ['close-port']
1844
602
    _args.append('{}/{}'.format(port, protocol))
1845
603
    subprocess.check_call(_args)
1846
604
1847
605
1848
606
@cached
1849
607
def unit_get(attribute):
1850
608
    """Get the unit ID for the remote unit"""
1851
609
    _args = ['unit-get', '--format=json', attribute]
1852
610
    try:
1853
611
        return json.loads(subprocess.check_output(_args).decode('UTF-8'))
1854
612
    except ValueError:
1855
613
        return None
1856
614
1857
615
1858
616
def unit_public_ip():
1859
617
    """Get this unit's public IP address"""
1860
618
    return unit_get('public-address')
1861
619
1862
620
1863
621
def unit_private_ip():
1864
622
    """Get this unit's private IP address"""
1865
623
    return unit_get('private-address')
1866
624
1867
625
1868
626
class UnregisteredHookError(Exception):
1869
627
    """Raised when an undefined hook is called"""
1870
628
    pass
1871
629
1872
630
1873
631
class Hooks(object):
1874
632
    """A convenient handler for hook functions.
1875
633
1876
634
    Example::
1877
635
1878
636
        hooks = Hooks()
1879
637
1880
638
        # register a hook, taking its name from the function name
1881
639
        @hooks.hook()
1882
640
        def install():
1883
641
            pass  # your code here
1884
642
1885
643
        # register a hook, providing a custom hook name
1886
644
        @hooks.hook("config-changed")
1887
645
        def config_changed():
1888
646
            pass  # your code here
1889
647
1890
648
        if __name__ == "__main__":
1891
649
            # execute a hook based on the name the program is called by
1892
650
            hooks.execute(sys.argv)
1893
651
    """
1894
652
1895
653
    def __init__(self, config_save=None):
1896
654
        super(Hooks, self).__init__()
1897
655
        self._hooks = {}
1898
656
1899
657
        # For unknown reasons, we allow the Hooks constructor to override
1900
658
        # config().implicit_save.
1901
659
        if config_save is not None:
1902
660
            config().implicit_save = config_save
1903
661
1904
662
    def register(self, name, function):
1905
663
        """Register a hook"""
1906
664
        self._hooks[name] = function
1907
665
1908
666
    def execute(self, args):
1909
667
        """Execute a registered hook based on args[0]"""
1910
668
        _run_atstart()
1911
669
        hook_name = os.path.basename(args[0])
1912
670
        if hook_name in self._hooks:
1913
671
            try:
1914
672
                self._hooks[hook_name]()
1915
673
            except SystemExit as x:
1916
674
                if x.code is None or x.code == 0:
1917
675
                    _run_atexit()
1918
676
                raise
1919
677
            _run_atexit()
1920
678
        else:
1921
679
            raise UnregisteredHookError(hook_name)
1922
680
1923
681
    def hook(self, *hook_names):
1924
682
        """Decorator, registering them as hooks"""
1925
683
        def wrapper(decorated):
1926
684
            for hook_name in hook_names:
1927
685
                self.register(hook_name, decorated)
1928
686
            else:
1929
687
                self.register(decorated.__name__, decorated)
1930
688
                if '_' in decorated.__name__:
1931
689
                    self.register(
1932
690
                        decorated.__name__.replace('_', '-'), decorated)
1933
691
            return decorated
1934
692
        return wrapper
1935
693
1936
694
1937
695
def charm_dir():
1938
696
    """Return the root directory of the current charm"""
1939
697
    return os.environ.get('CHARM_DIR')
1940
698
1941
699
1942
700
@cached
1943
701
def action_get(key=None):
1944
702
    """Gets the value of an action parameter, or all key/value param pairs"""
1945
703
    cmd = ['action-get']
1946
704
    if key is not None:
1947
705
        cmd.append(key)
1948
706
    cmd.append('--format=json')
1949
707
    action_data = json.loads(subprocess.check_output(cmd).decode('UTF-8'))
1950
708
    return action_data
1951
709
1952
710
1953
711
def action_set(values):
1954
712
    """Sets the values to be returned after the action finishes"""
1955
713
    cmd = ['action-set']
1956
714
    for k, v in list(values.items()):
1957
715
        cmd.append('{}={}'.format(k, v))
1958
716
    subprocess.check_call(cmd)
1959
717
1960
718
1961
719
def action_fail(message):
1962
720
    """Sets the action status to failed and sets the error message.
1963
721
1964
722
    The results set by action_set are preserved."""
1965
723
    subprocess.check_call(['action-fail', message])
1966
724
1967
725
1968
726
def action_name():
1969
727
    """Get the name of the currently executing action."""
1970
728
    return os.environ.get('JUJU_ACTION_NAME')
1971
729
1972
730
1973
731
def action_uuid():
1974
732
    """Get the UUID of the currently executing action."""
1975
733
    return os.environ.get('JUJU_ACTION_UUID')
1976
734
1977
735
1978
736
def action_tag():
1979
737
    """Get the tag for the currently executing action."""
1980
738
    return os.environ.get('JUJU_ACTION_TAG')
1981
739
1982
740
1983
741
def status_set(workload_state, message):
1984
742
    """Set the workload state with a message
1985
743
1986
744
    Use status-set to set the workload state with a message which is visible
1987
745
    to the user via juju status. If the status-set command is not found then
1988
746
    assume this is juju < 1.23 and juju-log the message unstead.
1989
747
1990
748
    workload_state -- valid juju workload state.
1991
749
    message        -- status update message
1992
750
    """
1993
751
    valid_states = ['maintenance', 'blocked', 'waiting', 'active']
1994
752
    if workload_state not in valid_states:
1995
753
        raise ValueError(
1996
754
            '{!r} is not a valid workload state'.format(workload_state)
1997
755
        )
1998
756
    cmd = ['status-set', workload_state, message]
1999
757
    try:
2000
758
        ret = subprocess.call(cmd)
2001
759
        if ret == 0:
2002
760
            return
2003
761
    except OSError as e:
2004
762
        if e.errno != errno.ENOENT:
2005
763
            raise
2006
764
    log_message = 'status-set failed: {} {}'.format(workload_state,
2007
765
                                                    message)
2008
766
    log(log_message, level='INFO')
2009
767
2010
768
2011
769
def status_get():
2012
770
    """Retrieve the previously set juju workload state and message
2013
771
2014
772
    If the status-get command is not found then assume this is juju < 1.23 and
2015
773
    return 'unknown', ""
2016
774
2017
775
    """
2018
776
    cmd = ['status-get', "--format=json", "--include-data"]
2019
777
    try:
2020
778
        raw_status = subprocess.check_output(cmd)
2021
779
    except OSError as e:
2022
780
        if e.errno == errno.ENOENT:
2023
781
            return ('unknown', "")
2024
782
        else:
2025
783
            raise
2026
784
    else:
2027
785
        status = json.loads(raw_status.decode("UTF-8"))
2028
786
        return (status["status"], status["message"])
2029
787
2030
788
2031
789
def translate_exc(from_exc, to_exc):
2032
790
    def inner_translate_exc1(f):
2033
791
        def inner_translate_exc2(*args, **kwargs):
2034
792
            try:
2035
793
                return f(*args, **kwargs)
2036
794
            except from_exc:
2037
795
                raise to_exc
2038
796
2039
797
        return inner_translate_exc2
2040
798
2041
799
    return inner_translate_exc1
2042
800
2043
801
2044
802
@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
2045
803
def is_leader():
2046
804
    """Does the current unit hold the juju leadership
2047
805
2048
806
    Uses juju to determine whether the current unit is the leader of its peers
2049
807
    """
2050
808
    cmd = ['is-leader', '--format=json']
2051
809
    return json.loads(subprocess.check_output(cmd).decode('UTF-8'))
2052
810
2053
811
2054
812
@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
2055
813
def leader_get(attribute=None):
2056
814
    """Juju leader get value(s)"""
2057
815
    cmd = ['leader-get', '--format=json'] + [attribute or '-']
2058
816
    return json.loads(subprocess.check_output(cmd).decode('UTF-8'))
2059
817
2060
818
2061
819
@translate_exc(from_exc=OSError, to_exc=NotImplementedError)
2062
820
def leader_set(settings=None, **kwargs):
2063
821
    """Juju leader set value(s)"""
2064
822
    # Don't log secrets.
2065
823
    # log("Juju leader-set '%s'" % (settings), level=DEBUG)
2066
824
    cmd = ['leader-set']
2067
825
    settings = settings or {}
2068
826
    settings.update(kwargs)
2069
827
    for k, v in settings.items():
2070
828
        if v is None:
2071
829
            cmd.append('{}='.format(k))
2072
830
        else:
2073
831
            cmd.append('{}={}'.format(k, v))
2074
832
    subprocess.check_call(cmd)
2075
833
2076
834
2077
835
@cached
2078
836
def juju_version():
2079
837
    """Full version string (eg. '1.23.3.1-trusty-amd64')"""
2080
838
    # Per https://bugs.launchpad.net/juju-core/+bug/1455368/comments/1
2081
839
    jujud = glob.glob('/var/lib/juju/tools/machine-*/jujud')[0]
2082
840
    return subprocess.check_output([jujud, 'version'],
2083
841
                                   universal_newlines=True).strip()
2084
842
2085
843
2086
844
@cached
2087
845
def has_juju_version(minimum_version):
2088
846
    """Return True if the Juju version is at least the provided version"""
2089
847
    return LooseVersion(juju_version()) >= LooseVersion(minimum_version)
2090
848
2091
849
2092
850
_atexit = []
2093
851
_atstart = []
2094
852
2095
853
2096
854
def atstart(callback, *args, **kwargs):
2097
855
    '''Schedule a callback to run before the main hook.
2098
856
2099
857
    Callbacks are run in the order they were added.
2100
858
2101
859
    This is useful for modules and classes to perform initialization
2102
860
    and inject behavior. In particular:
2103
861
2104
862
        - Run common code before all of your hooks, such as logging
2105
863
          the hook name or interesting relation data.
2106
864
        - Defer object or module initialization that requires a hook
2107
865
          context until we know there actually is a hook context,
2108
866
          making testing easier.
2109
867
        - Rather than requiring charm authors to include boilerplate to
2110
868
          invoke your helper's behavior, have it run automatically if
2111
869
          your object is instantiated or module imported.
2112
870
2113
871
    This is not at all useful after your hook framework as been launched.
2114
872
    '''
2115
873
    global _atstart
2116
874
    _atstart.append((callback, args, kwargs))
2117
875
2118
876
2119
877
def atexit(callback, *args, **kwargs):
2120
878
    '''Schedule a callback to run on successful hook completion.
2121
879
2122
880
    Callbacks are run in the reverse order that they were added.'''
2123
881
    _atexit.append((callback, args, kwargs))
2124
882
2125
883
2126
884
def _run_atstart():
2127
885
    '''Hook frameworks must invoke this before running the main hook body.'''
2128
886
    global _atstart
2129
887
    for callback, args, kwargs in _atstart:
2130
888
        callback(*args, **kwargs)
2131
889
    del _atstart[:]
2132
890
2133
891
2134
892
def _run_atexit():
2135
893
    '''Hook frameworks must invoke this after the main hook body has
2136
894
    successfully completed. Do not invoke it if the hook fails.'''
2137
895
    global _atexit
2138
896
    for callback, args, kwargs in reversed(_atexit):
2139
897
        callback(*args, **kwargs)
2140
898
    del _atexit[:]
Reviewer	Date Requested	Status
Chris Glass (community)	2015-08-17	Approve on 2015-09-18
Adam Collard (community)	2015-08-17	Approve on 2015-09-18
Review via email: mp+268238@code.launchpad.net