1
=== modified file 'quickstart/app.py'
2
--- quickstart/app.py	2013-10-15 15:31:12 +0000
3
+++ quickstart/app.py	2013-10-16 15:23:20 +0000
4
@@ -16,6 +16,10 @@
5
16
16
6
17
"""Juju Quickstart base application functions."""
17
"""Juju Quickstart base application functions."""
7
18
18
8
19
import json
9
20
10
21
from quickstart import utils
11
22
12
19
23
13
20
class ProgramExit(Exception):
24
class ProgramExit(Exception):
14
21
    """An error occurred while setting up the Juju environment.
25
    """An error occurred while setting up the Juju environment.
15
@@ -34,9 +38,39 @@
16
34
def bootstrap(env_name):
38
def bootstrap(env_name):
17
35
    """Bootstrap the Juju environment with the given name.
39
    """Bootstrap the Juju environment with the given name.
18
36
40
20
37
    Return the environment API address (e.g. "api.example.com:17070").
41
    Return when the bootstrap node is ready.
21
38
    Raise a ProgramExit if any error occurs in the bootstrap process.
42
    Raise a ProgramExit if any error occurs in the bootstrap process.
26
39
    Otherwise return when the environment is bootstrapped and the API server
43
    """
27
40
    is ready to accept connections.
44
    retcode, _, error = utils.call('juju', 'bootstrap', '-e', env_name)
28
41
    """
45
    if retcode:
29
42
    # TODO: everything!
46
        raise ProgramExit(error)
30
47
    # Call "juju status" multiple times until the bootstrap node is ready.
31
48
    for _ in range(5):
32
49
        retcode, output, error = utils.call('juju', 'status', '-e', env_name)
33
50
        if retcode:
34
51
            continue
35
52
        # Ensure the state server is up and the agent is started.
36
53
        try:
37
54
            agent_state = utils.parse_status_output(output)
38
55
        except ValueError:
39
56
            continue
40
57
        if agent_state == 'started':
41
58
            return
42
59
    details = ''.join(filter(None, [output, error])).strip()
43
60
    raise ProgramExit('the state server is not ready:\n{}'.format(details))
44
61
45
62
46
63
def get_api_url(env_name):
47
64
    """Return a Juju API URL for the given environment name.
48
65
49
66
    Use the Juju CLI in a subprocess in order to retrieve the API addresses.
50
67
    Return the complete URL, e.g. "wss://api.example.com:17070".
51
68
    """
52
69
    retcode, output, error = utils.call(
53
70
        'juju', 'api-endpoints', '-e', env_name, '--format', 'json')
54
71
    if retcode:
55
72
        raise ProgramExit(error)
56
73
    # Assuming there is always at least one API address, grab the first one
57
74
    # from the JSON output.
58
75
    api_address = json.loads(output)[0]
59
76
    return 'wss://{}'.format(api_address)
60
43
77
61
=== modified file 'quickstart/manage.py'
62
--- quickstart/manage.py	2013-10-15 15:40:31 +0000
63
+++ quickstart/manage.py	2013-10-16 15:23:20 +0000
64
@@ -18,6 +18,7 @@
65
18
18
66
19
from __future__ import print_function
19
from __future__ import print_function
67
20
import argparse
20
import argparse
68
21
import logging
69
21
import os
22
import os
70
22
23
71
23
import quickstart
24
import quickstart
72
@@ -54,7 +55,8 @@
73
54
            'It is possible to specify the environment name by either:\n'
55
            'It is possible to specify the environment name by either:\n'
74
55
            '  - passing the -e or --environment argument;\n'
56
            '  - passing the -e or --environment argument;\n'
75
56
            '  - setting the JUJU_ENV environment variable;\n'
57
            '  - setting the JUJU_ENV environment variable;\n'
77
57
            '  - using "juju switch" to select the default environment to use.'
58
            '  - using "juju switch" to select the default environment;\n'
78
59
            '  - setting the default environment in {}.'.format(env_file)
79
58
        )
60
        )
80
59
    # Validate the environment file.
61
    # Validate the environment file.
81
60
    try:
62
    try:
82
@@ -70,8 +72,25 @@
83
70
    options.env_type = env_type
72
    options.env_type = env_type
84
71
73
85
72
74
86
75
def _configure_logging(level):
87
76
    """Set up the application logging."""
88
77
    root = logging.getLogger()
89
78
    # Remove any previous handler on the root logger.
90
79
    for handler in root.handlers[:]:
91
80
        root.removeHandler(handler)
92
81
    logging.basicConfig(
93
82
        level=level,
94
83
        format=(
95
84
            '%(asctime)s %(levelname)s '
96
85
            '%(module)s@%(funcName)s:%(lineno)d '
97
86
            '%(message)s'
98
87
        ),
99
88
        datefmt='%H:%M:%S',
100
89
    )
101
90
102
91
103
73
def setup():
92
def setup():
105
74
    """Set up the application options.
93
    """Set up the application options and logger.
106
75
94
107
76
    Return the options as a namespace containing the followin attributes:
95
    Return the options as a namespace containing the followin attributes:
108
77
        - admin_secret: the password to use to access the Juju API;
96
        - admin_secret: the password to use to access the Juju API;
109
@@ -97,6 +116,8 @@
110
97
        help='the path to the Juju environments YAML file (%(default)s)')
116
        help='the path to the Juju environments YAML file (%(default)s)')
111
98
    parser.add_argument(
117
    parser.add_argument(
112
99
        '--version', action='version', version='%(prog)s {}'.format(version))
118
        '--version', action='version', version='%(prog)s {}'.format(version))
113
119
    parser.add_argument(
114
120
        '--debug', action='store_true', help='turn debug mode on')
115
100
    # This is required by juju-core: see "juju help plugins".
121
    # This is required by juju-core: see "juju help plugins".
116
101
    parser.add_argument(
122
    parser.add_argument(
117
102
        '--description', action=_DescriptionAction, default=argparse.SUPPRESS,
123
        '--description', action=_DescriptionAction, default=argparse.SUPPRESS,
118
@@ -105,6 +126,8 @@
119
105
    options = parser.parse_args()
126
    options = parser.parse_args()
120
106
    # Validate and process the provided arguments.
127
    # Validate and process the provided arguments.
121
107
    _validate_env(options, parser)
128
    _validate_env(options, parser)
122
129
    # Set up logging.
123
130
    _configure_logging(logging.DEBUG if options.debug else logging.INFO)
124
108
    return options
131
    return options
125
109
132
126
110
133
127
@@ -114,3 +137,6 @@
128
114
    print('bootstrapping the {} environment (type: {})'.format(
137
    print('bootstrapping the {} environment (type: {})'.format(
129
115
        options.env_name, options.env_type))
138
        options.env_name, options.env_type))
130
116
    app.bootstrap(options.env_name)
139
    app.bootstrap(options.env_name)
131
140
    print('retrieving the Juju API address')
132
141
    api_url = app.get_api_url(options.env_name)
133
142
    print('connecting to {}'.format(api_url))
134
117
143
135
=== modified file 'quickstart/tests/helpers.py'
136
--- quickstart/tests/helpers.py	2013-10-15 18:25:57 +0000
137
+++ quickstart/tests/helpers.py	2013-10-16 15:23:20 +0000
138
@@ -20,21 +20,35 @@
139
20
import os
20
import os
140
21
import tempfile
21
import tempfile
141
22
22
142
23
import mock
143
23
import yaml
24
import yaml
144
24
25
145
25
26
158
26
class ValueErrorTestsMixin(object):
27
class CallTestsMixin(object):
159
27
    """Set up some base methods for testing functions raising ValueErrors."""
28
    """Easily use the quickstart.utils.call function."""
160
28
29
161
29
    @contextmanager
30
    def patch_call(self, retcode, output='', error=''):
162
30
    def assert_value_error(self, error):
31
        """Patch the quickstart.utils.call function."""
163
31
        """Ensure a ValueError is raised in the context block.
32
        mock_call = mock.Mock(return_value=(retcode, output, error))
164
32
33
        return mock.patch('quickstart.utils.call', mock_call)
165
33
        Also check that the exception includes the expected error message.
34
166
34
        """
35
    def patch_multiple_calls(self, side_effect):
167
35
        with self.assertRaises(ValueError) as context_manager:
36
        """Patch multiple subsequent quickstart.utils.call calls."""
168
36
            yield
37
        mock_call = mock.Mock(side_effect=side_effect)
169
37
        self.assertEqual(error, str(context_manager.exception))
38
        return mock.patch('quickstart.utils.call', mock_call)
170
39
171
40
172
41
@contextmanager
173
42
def assert_logs(messages, level='debug'):
174
43
    """Ensure the given messages are logged using the given log level.
175
44
176
45
    Use this function as a context manager: the code executed in the context
177
46
    block must add the expected log entries.
178
47
    """
179
48
    with mock.patch('logging.{}'.format(level.lower())) as mock_log:
180
49
        yield
181
50
    expected_calls = [mock.call(message) for message in messages]
182
51
    mock_log.assert_has_calls(expected_calls)
183
38
52
184
39
53
185
40
class EnvFileTestsMixin(object):
54
class EnvFileTestsMixin(object):
186
@@ -58,3 +72,17 @@
187
58
        env_file.write(contents)
72
        env_file.write(contents)
188
59
        env_file.close()
73
        env_file.close()
189
60
        return env_file.name
74
        return env_file.name
190
75
191
76
192
77
class ValueErrorTestsMixin(object):
193
78
    """Set up some base methods for testing functions raising ValueErrors."""
194
79
195
80
    @contextmanager
196
81
    def assert_value_error(self, error):
197
82
        """Ensure a ValueError is raised in the context block.
198
83
199
84
        Also check that the exception includes the expected error message.
200
85
        """
201
86
        with self.assertRaises(ValueError) as context_manager:
202
87
            yield
203
88
        self.assertEqual(error, str(context_manager.exception))
204
61
89
205
=== modified file 'quickstart/tests/test_app.py'
206
--- quickstart/tests/test_app.py	2013-10-15 15:31:32 +0000
207
+++ quickstart/tests/test_app.py	2013-10-16 15:23:20 +0000
208
@@ -16,9 +16,15 @@
209
16
16
210
17
"""Tests for the Juju Quickstart base application functions."""
17
"""Tests for the Juju Quickstart base application functions."""
211
18
18
212
19
from contextlib import contextmanager
213
20
import json
214
19
import unittest
21
import unittest
215
20
22
216
23
import mock
217
24
import yaml
218
25
219
21
from quickstart import app
26
from quickstart import app
220
27
from quickstart.tests import helpers
221
22
28
222
23
29
223
24
class TestProgramExit(unittest.TestCase):
30
class TestProgramExit(unittest.TestCase):
224
@@ -27,3 +33,152 @@
225
27
        # The error is properly represented as a string.
33
        # The error is properly represented as a string.
226
28
        exception = app.ProgramExit('bad wolf')
34
        exception = app.ProgramExit('bad wolf')
227
29
        self.assertEqual('juju-quickstart: error: bad wolf', str(exception))
35
        self.assertEqual('juju-quickstart: error: bad wolf', str(exception))
228
36
229
37
230
38
class ProgramExitTestsMixin(object):
231
39
    """Set up some base methods for testing functions raising ProgramExit."""
232
40
233
41
    @contextmanager
234
42
    def assert_program_exit(self, error):
235
43
        """Ensure a ProgramExit is raised in the context block.
236
44
237
45
        Also check that the exception includes the expected error message.
238
46
        """
239
47
        with self.assertRaises(app.ProgramExit) as context_manager:
240
48
            yield
241
49
        expected = 'juju-quickstart: error: {}'.format(error)
242
50
        self.assertEqual(expected, str(context_manager.exception))
243
51
244
52
245
53
class TestBootstrap(
246
54
        helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
247
55
248
56
    env_name = 'ec2'
249
57
250
58
    def make_status_output(self, agent_state):
251
59
        """Create and return a YAML status output."""
252
60
        return yaml.safe_dump({
253
61
            'machines': {'0': {'agent-state': agent_state}},
254
62
        })
255
63
256
64
    def make_status_calls(self, number):
257
65
        """Return a list containing the given number of status calls."""
258
66
        return [
259
67
            mock.call('juju', 'status', '-e', self.env_name)
260
68
            for _ in range(number)
261
69
        ]
262
70
263
71
    def assert_status_retried(self, side_effects):
264
72
        """Ensure the "juju status" command is retried several times.
265
73
266
74
        Receive the list of side effects the mock status call will return.
267
75
        """
268
76
        with self.patch_multiple_calls(side_effects) as mock_call:
269
77
            app.bootstrap(self.env_name)
270
78
        mock_call.assert_has_calls([
271
79
            mock.call('juju', 'bootstrap', '-e', self.env_name),
272
80
        ] + self.make_status_calls(5))
273
81
274
82
    def test_success(self):
275
83
        # The environment is successfully bootstrapped.
276
84
        side_effects = [
277
85
            (0, '', ''),  # Add a bootstrap call.
278
86
            (0, self.make_status_output('started'), ''),  # Add a status call.
279
87
        ]
280
88
        with self.patch_multiple_calls(side_effects) as mock_call:
281
89
            app.bootstrap(self.env_name)
282
90
        mock_call.assert_has_calls([
283
91
            mock.call('juju', 'bootstrap', '-e', self.env_name),
284
92
        ] + self.make_status_calls(1))
285
93
286
94
    def test_bootstrap_failure(self):
287
95
        # A ProgramExit is raised if an error occurs while bootstrapping.
288
96
        with self.patch_call(1, error='bad wolf') as mock_call:
289
97
            with self.assert_program_exit('bad wolf'):
290
98
                app.bootstrap(self.env_name)
291
99
        mock_call.assert_called_once_with(
292
100
            'juju', 'bootstrap', '-e', self.env_name)
293
101
294
102
    def test_status_retry_error(self):
295
103
        # Before raising a ProgramExit, the functions tries to call
296
104
        # "juju status" multiple times if it exits with an error.
297
105
        side_effects = [
298
106
            (0, '', ''),  # Add the bootstrap call.
299
107
            # Add four status calls with a non-zero exit code.
300
108
            (1, '', 'these'),
301
109
            (2, '', 'are'),
302
110
            (3, '', 'the'),
303
111
            (4, '', 'voyages'),
304
112
            # Add a final valid status call.
305
113
            (0, self.make_status_output('started'), ''),
306
114
        ]
307
115
        self.assert_status_retried(side_effects)
308
116
309
117
    def test_status_retry_invalid_output(self):
310
118
        # Before raising a ProgramExit, the functions tries to call
311
119
        # "juju status" multiple times if its output is not well formed or if
312
120
        # the agent is not started.
313
121
        side_effects = [
314
122
            (0, '', ''),  # Add the bootstrap call.
315
123
            (0, '', ''),  # Add the first status call: no output.
316
124
            (0, ':', ''),  # Add the second status call: not YAML.
317
125
            (0, 'just-a-string', ''),  # Add the third status call: bad YAML.
318
126
            # Add the fourth status call: the agent is still pending.
319
127
            (0, self.make_status_output('pending'), ''),
320
128
            # Add a final valid status call.
321
129
            (0, self.make_status_output('started'), ''),
322
130
        ]
323
131
        self.assert_status_retried(side_effects)
324
132
325
133
    def test_status_retry_both(self):
326
134
        # Before raising a ProgramExit, the functions tries to call
327
135
        # "juju status" multiple times in any case.
328
136
        side_effects = [
329
137
            (0, '', ''),  # Add the bootstrap call.
330
138
            (1, '', 'error'),  # Add the first status call: error.
331
139
            (2, '', 'another error'),  # Add the second status call: error.
332
140
            # Add the third status call: the agent is still pending.
333
141
            (0, self.make_status_output('pending'), ''),
334
142
            (0, 'just-a-string', ''),  # Add the fourth status call: bad YAML.
335
143
            # Add a final valid status call.
336
144
            (0, self.make_status_output('started'), ''),
337
145
        ]
338
146
        self.assert_status_retried(side_effects)
339
147
340
148
    def test_status_failure(self):
341
149
        # A ProgramExit is raised if "juju status" keeps failing.
342
150
        status_side_effects = [
343
151
            (i, 'output #{}\n'.format(i), 'error #{}\n'.format(i))
344
152
            for i in range(5)
345
153
        ]
346
154
        side_effects = [(0, '', '')] + status_side_effects
347
155
        expected = 'the state server is not ready:\noutput #4\nerror #4'
348
156
        with self.patch_multiple_calls(side_effects) as mock_call:
349
157
            with self.assert_program_exit(expected):
350
158
                app.bootstrap(self.env_name)
351
159
        mock_call.assert_has_calls([
352
160
            mock.call('juju', 'bootstrap', '-e', self.env_name),
353
161
        ] + self.make_status_calls(5))
354
162
355
163
356
164
class TestGetApiUrl(
357
165
        helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
358
166
359
167
    env_name = 'ec2'
360
168
361
169
    def test_success(self):
362
170
        # The API URL is correctly returned.
363
171
        api_addresses = json.dumps(['api.example.com:17070', 'not-today'])
364
172
        with self.patch_call(0, output=api_addresses) as mock_call:
365
173
            api_url = app.get_api_url(self.env_name)
366
174
        self.assertEqual('wss://api.example.com:17070', api_url)
367
175
        mock_call.assert_called_once_with(
368
176
            'juju', 'api-endpoints', '-e', self.env_name, '--format', 'json')
369
177
370
178
    def test_failure(self):
371
179
        # A ProgramExit is raised if an error occurs retrieving the API URL.
372
180
        with self.patch_call(1, error='bad wolf') as mock_call:
373
181
            with self.assert_program_exit('bad wolf'):
374
182
                app.get_api_url(self.env_name)
375
183
        mock_call.assert_called_once_with(
376
184
            'juju', 'api-endpoints', '-e', self.env_name, '--format', 'json')
377
30
185
378
=== modified file 'quickstart/tests/test_manage.py'
379
--- quickstart/tests/test_manage.py	2013-10-15 18:25:57 +0000
380
+++ quickstart/tests/test_manage.py	2013-10-16 15:23:20 +0000
381
@@ -17,6 +17,7 @@
382
17
"""Tests for the Juju Quickstart management infrastructure."""
17
"""Tests for the Juju Quickstart management infrastructure."""
383
18
18
384
19
import argparse
19
import argparse
385
20
import logging
386
20
import os
21
import os
387
21
import unittest
22
import unittest
388
22
23
389
@@ -122,16 +123,17 @@
390
122
        path = 'quickstart.manage.utils.get_default_env_name'
123
        path = 'quickstart.manage.utils.get_default_env_name'
391
123
        return mock.patch(path, mock_get_default_env_name)
124
        return mock.patch(path, mock_get_default_env_name)
392
124
125
394
125
    def call_setup(self, args, env_name=None):
126
    def call_setup(self, args, env_name=None, exit_called=True):
395
126
        """Call the setup function simulating the given args and env name.
127
        """Call the setup function simulating the given args and env name.
396
127
128
398
128
        Also ensure the program exits without errors.
129
        Also ensure the program exits without errors if exit_called is True.
399
129
        """
130
        """
400
130
        with mock.patch('sys.argv', ['juju-quickstart'] + args):
131
        with mock.patch('sys.argv', ['juju-quickstart'] + args):
401
131
            with mock.patch('sys.exit') as mock_exit:
132
            with mock.patch('sys.exit') as mock_exit:
402
132
                with self.patch_get_default_env_name(env_name):
133
                with self.patch_get_default_env_name(env_name):
403
133
                    manage.setup()
134
                    manage.setup()
405
134
        mock_exit.assert_called_once_with(0)
135
        if exit_called:
406
136
            mock_exit.assert_called_once_with(0)
407
135
137
408
136
    def test_help(self):
138
    def test_help(self):
409
137
        # The program help message is properly formatted.
139
        # The program help message is properly formatted.
410
@@ -170,3 +172,15 @@
411
170
            self.call_setup(['--version'])
172
            self.call_setup(['--version'])
412
171
        expected = 'juju-quickstart {}\n'.format(quickstart.get_version())
173
        expected = 'juju-quickstart {}\n'.format(quickstart.get_version())
413
172
        mock_stderr.write.assert_called_once_with(expected)
174
        mock_stderr.write.assert_called_once_with(expected)
414
175
415
176
    def test_configure_logging(self):
416
177
        # Logging is properly set up at the info level.
417
178
        logger = logging.getLogger()
418
179
        self.call_setup([], 'ec2', exit_called=False)
419
180
        self.assertEqual(logging.INFO, logger.level)
420
181
421
182
    def test_configure_logging_debug(self):
422
183
        # Logging is properly set up at the debug level.
423
184
        logger = logging.getLogger()
424
185
        self.call_setup(['--debug'], 'ec2', exit_called=False)
425
186
        self.assertEqual(logging.DEBUG, logger.level)
426
173
187
427
=== modified file 'quickstart/tests/test_utils.py'
428
--- quickstart/tests/test_utils.py	2013-10-15 18:25:57 +0000
429
+++ quickstart/tests/test_utils.py	2013-10-16 15:23:20 +0000
430
@@ -61,13 +61,17 @@
431
61
            'no-such-command: [Errno 2] No such file or directory',
61
            'no-such-command: [Errno 2] No such file or directory',
432
62
            error)
62
            error)
433
63
63
441
64
64
    def test_logging(self):
442
65
class TestGetDefaultEnvName(unittest.TestCase):
65
        # The command line call and the results are properly logged.
443
66
66
        expected_messages = (
444
67
    def patch_call(self, retcode, output='', error=''):
67
            "running the following: echo 'we are the borg!'",
445
68
        """Patch the quickstart.utils.call function."""
68
            r"retcode: 0 | output: 'we are the borg!\n' | error: ''",
446
69
        mock_call = mock.Mock(return_value=(retcode, output, error))
69
        )
447
70
        return mock.patch('quickstart.utils.call', mock_call)
70
        with helpers.assert_logs(expected_messages):
448
71
            utils.call('echo', 'we are the borg!')
449
72
450
73
451
74
class TestGetDefaultEnvName(helpers.CallTestsMixin, unittest.TestCase):
452
71
75
453
72
    def test_environment_variable(self):
76
    def test_environment_variable(self):
454
73
        # The environment name is successfully returned if JUJU_ENV is set.
77
        # The environment name is successfully returned if JUJU_ENV is set.
455
@@ -176,3 +180,39 @@
456
176
        env_type, admin_secret = utils.parse_env_file(env_file, 'aws')
180
        env_type, admin_secret = utils.parse_env_file(env_file, 'aws')
457
177
        self.assertEqual('ec2', env_type)
181
        self.assertEqual('ec2', env_type)
458
178
        self.assertEqual('Secret!', admin_secret)
182
        self.assertEqual('Secret!', admin_secret)
459
183
460
184
461
185
class TestParseStatusOutput(helpers.ValueErrorTestsMixin, unittest.TestCase):
462
186
463
187
    def test_invalid_yaml(self):
464
188
        # A ValueError is raised if the output is not a valid YAML.
465
189
        with self.assertRaises(ValueError) as context_manager:
466
190
            utils.parse_status_output(':')
467
191
        expected = 'unable to parse the output'
468
192
        self.assertIn(expected, str(context_manager.exception))
469
193
470
194
    def test_invalid_yaml_contents(self):
471
195
        # A ValueError is raised if the output is not well formed.
472
196
        with self.assert_value_error('invalid YAML contents: a-string'):
473
197
            utils.parse_status_output('a-string')
474
198
475
199
    def test_no_env(self):
476
200
        # A ValueError is raised if the agent-state is not found in the YAML.
477
201
        data = {
478
202
            'machines': {
479
203
                '0': {'agent-version': '1.17.0.1'},
480
204
            },
481
205
        }
482
206
        expected = 'agent state not found in {}'.format(str(data))
483
207
        with self.assert_value_error(expected):
484
208
            utils.parse_status_output(yaml.safe_dump(data))
485
209
486
210
    def test_success(self):
487
211
        # The agent state is correctly returned.
488
212
        output = yaml.safe_dump({
489
213
            'machines': {
490
214
                '0': {'agent-version': '1.17.0.1', 'agent-state': 'started'},
491
215
            },
492
216
        })
493
217
        agent_state = utils.parse_status_output(output)
494
218
        self.assertEqual('started', agent_state)
495
179
219
496
=== modified file 'quickstart/utils.py'
497
--- quickstart/utils.py	2013-10-15 15:47:31 +0000
498
+++ quickstart/utils.py	2013-10-16 15:23:20 +0000
499
@@ -18,6 +18,8 @@
500
18
18
501
19
import re
19
import re
502
20
import os
20
import os
503
21
import logging
504
22
import pipes
505
21
import subprocess
23
import subprocess
506
22
24
507
23
import yaml
25
import yaml
508
@@ -34,6 +36,8 @@
509
34
    Return a tuple containing the subprocess return code, output and error.
36
    Return a tuple containing the subprocess return code, output and error.
510
35
    """
37
    """
511
36
    pipe = subprocess.PIPE
38
    pipe = subprocess.PIPE
512
39
    cmdline = ' '.join(map(pipes.quote, args))
513
40
    logging.debug('running the following: {}'.format(cmdline))
514
37
    try:
41
    try:
515
38
        process = subprocess.Popen(args, stdout=pipe, stderr=pipe)
42
        process = subprocess.Popen(args, stdout=pipe, stderr=pipe)
516
39
    except OSError as err:
43
    except OSError as err:
517
@@ -41,20 +45,32 @@
518
41
        # found in the PATH.
45
        # found in the PATH.
519
42
        return 127, '', '{}: {}'.format(args[0], err)
46
        return 127, '', '{}: {}'.format(args[0], err)
520
43
    output, error = process.communicate()
47
    output, error = process.communicate()
522
44
    return process.poll(), output, error
48
    retcode = process.poll()
523
49
    logging.debug('retcode: {} | output: {!r} | error: {!r}'.format(
524
50
        retcode, output, error))
525
51
    return retcode, output, error
526
45
52
527
46
53
528
47
def get_default_env_name():
54
def get_default_env_name():
529
48
    """Return the current Juju environment name.
55
    """Return the current Juju environment name.
530
49
56
533
50
    The environment name can be set either by setting the JUJU_ENV environment
57
    The environment name can be set either by
534
51
    variable or by using "juju switch". The former overrides the latter.
58
        - setting the JUJU_ENV environment variable;
535
59
        - using "juju switch my-env-name";
536
60
        - setting the default environment in the environments.yaml file.
537
61
    The former overrides the latter.
538
52
62
539
53
    Return None if a default environment is not found.
63
    Return None if a default environment is not found.
540
54
    """
64
    """
541
55
    env_name = os.getenv('JUJU_ENV', '').strip()
65
    env_name = os.getenv('JUJU_ENV', '').strip()
542
56
    if env_name:
66
    if env_name:
543
57
        return env_name
67
        return env_name
544
68
    # XXX 2013-10-16 frankban bug=1193244:
545
69
        # Switch to using "juju switch --raw" in order to avoid the fragility
546
70
        # of parsing the command output.
547
71
    # The "juju switch" command parses ~/.juju/current-environment file. If the
548
72
    # environment name is not found there, then it tries to retrieve the name
549
73
    # from the "default" section of the ~/.juju/environments.yaml file.
550
58
    retcode, output, _ = call('juju', 'switch')
74
    retcode, output, _ = call('juju', 'switch')
551
59
    if retcode:
75
    if retcode:
552
60
        return None
76
        return None
553
@@ -64,7 +80,7 @@
554
64
80
555
65
81
556
66
def parse_env_file(env_file, env_name):
82
def parse_env_file(env_file, env_name):
558
67
    """Parse the provided Juju environment.yaml file.
83
    """Parse the provided Juju environments.yaml file.
559
68
84
560
69
    Return a tuple containing the provider type and the admin secret associated
85
    Return a tuple containing the provider type and the admin secret associated
561
70
    with the given environment name.
86
    with the given environment name.
562
@@ -108,3 +124,22 @@
563
108
        msg = '{} admin secret not found in {}'.format(env_name, env_file)
124
        msg = '{} admin secret not found in {}'.format(env_name, env_file)
564
109
        raise ValueError(msg)
125
        raise ValueError(msg)
565
110
    return env_type, admin_secret
126
    return env_type, admin_secret
566
127
567
128
568
129
def parse_status_output(output):
569
130
    """Parse the output of juju status.
570
131
571
132
    Return the agent state.
572
133
    Raise a ValueError if the agent state cannot be retrieved.
573
134
    """
574
135
    try:
575
136
        status = yaml.safe_load(output)
576
137
    except Exception as err:
577
138
        raise ValueError('unable to parse the output: {}'.format(err))
578
139
    try:
579
140
        state = status.get('machines', {}).get('0', {}).get('agent-state')
580
141
    except AttributeError as err:
581
142
        raise ValueError('invalid YAML contents: {}'.format(status))
582
143
    if state is None:
583
144
        raise ValueError('agent state not found in {}'.format(status))
584
145
    return state
Status:	Merged
Merged at revision:	4
Proposed branch:	lp:~frankban/juju-gui/quickstart-real-bootstrap
Merge into:	lp:juju-gui/juju-quickstart
Diff against target:	584 lines (+365/-33) 7 files modified quickstart/app.py (+39/-5) quickstart/manage.py (+28/-2) quickstart/tests/helpers.py (+40/-12) quickstart/tests/test_app.py (+155/-0) quickstart/tests/test_manage.py (+17/-3) quickstart/tests/test_utils.py (+47/-7) quickstart/utils.py (+39/-4)
To merge this branch:	bzr merge lp:~frankban/juju-gui/quickstart-real-bootstrap
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Juju GUI Hackers		2013-10-16	Pending
Review via email: mp+191410@code.launchpad.net