Merge lp:~frankban/juju-quickstart/support-cache-yaml into lp:juju-quickstart

[Francesco Banconi]

Use API info to connect to existing environments.

Do not rely on jenv files for handling already bootstrapped
environments. Instead, use the `juju api-info` command in order
to retrieve the existing environment's credentials, API addresses
and UUID.

As a consequence, drop support to Juju 1.18: the minimum supported
version is now Juju 1.22.1 (present in trusty-updates).

Also update to test against jujubundlelib 0.2.0 and jujuclient 0.50.2.

Apologies for the long diff, but a lot of code has been removed and
simplified.

Tests: `make check`.

QA: run quickstart (`devenv/bin/juju-quickstart`) to set up envs and
deploy bundles both with jes enabled (`export JUJU_DEV_FEATURE_FLAGS=jes`)
and disabled. Check that everything works as usual.

[Martin Hilton (martin-hilton)]

LGTM no QA

review: Approve

[Francesco Banconi (frankban)]

Thanks for the review Martin!

[lp:~frankban/juju-quickstart/support-cache-yaml]

150. By Francesco Banconi on 2015-11-04

Fix typo.

151. By Francesco Banconi on 2015-11-04

Fix functional tests.

[Madison Scott-Clary (makyo)]

QA okay with one minor comment below, thanks!

review: Approve (code+qa)

[lp:~frankban/juju-quickstart/support-cache-yaml]

152. By Francesco Banconi on 2015-11-05

Update jujuclient and jujubundlelib dependencies.

[Francesco Banconi (frankban)]

Thanks for the review Madison, I fixed the test.

[lp:~frankban/juju-quickstart/support-cache-yaml]

153. By Francesco Banconi on 2015-11-05

Fix tests intermittently failing due to sorting issues.

=== modified file 'quickstart/__init__.py'
--- quickstart/__init__.py	2015-08-07 10:24:11 +0000
+++ quickstart/__init__.py	2015-11-05 10:58:41 +0000
@@ -45,7 +45,7 @@
 Once Juju has been installed, the command can also be run as a juju plugin,
 without the hyphen ("juju quickstart").
 """
-VERSION = (2, 2, 1)
+VERSION = (2, 2, 2)
 
 
 def get_version():

=== modified file 'quickstart/app.py'
--- quickstart/app.py	2015-08-11 09:06:56 +0000
+++ quickstart/app.py	2015-11-05 10:58:41 +0000
@@ -21,7 +21,6 @@
     unicode_literals,
 )
 
-import json
 import logging
 import sys
 import time
@@ -40,7 +39,6 @@
     utils,
     watchers,
 )
-from quickstart.models import jenv
 
 
 class ProgramExit(Exception):
@@ -179,25 +177,18 @@
         raise ProgramExit(bytes(err))
 
 
-def check_bootstrapped(env_name):
-    """Check if the environment named env_name is already bootstrapped.
+def get_api_address(env_info):
+    """Return the API address for the environment described by the given info.
 
-    If so, return the environment API address to be used to connect to the Juju
-    API server. If not already bootstrapped, or if the API address cannot be
-    retrieved, return None.
+    Return None if the address cannot be found or the environment is not
+    bootstrapped.
     """
-    if not jenv.exists(env_name):
-        return None
-    # Retrieve the Juju API addresses from the jenv file.
-    try:
-        candidates = jenv.get_value(env_name, 'state-servers')
-    except ValueError as err:
-        logging.warn(b'cannot retrieve the Juju API address: {}'.format(err))
+    if not env_info:
         return None
     # Look for a reachable API address.
+    candidates = env_info['state-servers']
     if not candidates:
-        logging.warn(
-            'cannot retrieve the Juju API address: no addresses found')
+        logging.warn('cannot retrieve the API address: no addresses found')
         return None
     for candidate in candidates:
         error = netutils.check_listening(candidate)
@@ -206,7 +197,7 @@
             return candidate
         logging.debug(error)
     logging.warn(
-        'cannot retrieve the Juju API address: cannot connect to any of the '
+        'cannot retrieve the API address: cannot connect to any of the '
         'following addresses: {}'.format(', '.join(candidates)))
     return None
 
@@ -282,52 +273,6 @@
     raise ProgramExit('the state server is not ready:\n{}'.format(details))
 
 
-def get_env_uuid_or_none(env_name):
-    """Return the Juju environment unique id for the given environment name.
-
-    Parse the jenv file to retrieve the environment UUID.
-
-    Return None if the environment UUID is not present in the jenv file.
-    Raise a ProgramExit if the jenv file is not valid.
-    """
-    try:
-        return jenv.get_env_uuid(env_name)
-    except ValueError as err:
-        msg = b'cannot retrieve environment unique identifier: {}'.format(err)
-        raise ProgramExit(msg)
-
-
-def get_credentials(env_name):
-    """Return the Juju credentials for the given environment name.
-
-    Parse the jenv file to retrieve the environment user name and password.
-    Raise a ProgramExit if the credentials cannot be retrieved.
-    """
-    try:
-        return jenv.get_credentials(env_name)
-    except ValueError as err:
-        msg = b'cannot retrieve environment credentials: {}'.format(err)
-        raise ProgramExit(msg)
-
-
-def get_api_address(env_name, juju_command):
-    """Return a Juju API address for the given environment name.
-
-    Only the address is returned, without the schema or the path. For instance:
-    "api.example.com:17070".
-
-    Use the Juju CLI in a subprocess in order to retrieve the API addresses.
-    Raise a ProgramExit if any error occurs.
-    """
-    retcode, output, error = utils.call(
-        juju_command, 'api-endpoints', '-e', env_name, '--format', 'json')
-    if retcode:
-        raise ProgramExit(error)
-    # Assuming there is always at least one API address, grab the first one
-    # from the JSON output.
-    return json.loads(output)[0]
-
-
 def connect(api_url, username, password):
     """Connect to the Juju API server and log in using the given credentials.
 

=== modified file 'quickstart/cli/params.py'
--- quickstart/cli/params.py	2015-01-12 15:39:20 +0000
+++ quickstart/cli/params.py	2015-11-05 10:58:41 +0000
@@ -33,9 +33,8 @@
 _PARAMS = (
     'env_type_db',
     'env_db',
-    'jenv_db',
+    'active_db',
     'save_callable',
-    'remove_jenv_callable',
 )
 
 
@@ -52,7 +51,6 @@
         return self.__class__(
             env_type_db=self.env_type_db,
             env_db=copy.deepcopy(self.env_db),
-            jenv_db=copy.deepcopy(self.jenv_db),
+            active_db=copy.deepcopy(self.active_db),
             save_callable=self.save_callable,
-            remove_jenv_callable=self.remove_jenv_callable,
         )

=== modified file 'quickstart/cli/views.py'
--- quickstart/cli/views.py	2015-01-12 15:39:20 +0000
+++ quickstart/cli/views.py	2015-11-05 10:58:41 +0000
@@ -116,8 +116,8 @@
     ui,
 )
 from quickstart.models import (
+    apiinfo,
     envs,
-    jenv,
 )
 
 
@@ -165,7 +165,7 @@
     Receives a params namedtuple-like object including the following fields:
         - env_type_db: the environments meta information;
         - env_db: the environments database;
-        - jenv_db: the jenv files database;
+        - active_db: the active environments database;
         - save_callable: a function called to save a new environment database.
     See quickstart.cli.params.Params.
     """
@@ -176,7 +176,7 @@
     # without selecting an environment to use.
     app.set_return_value_on_exit((params.env_db, None))
     detail_view = functools.partial(env_detail, app, params)
-    jenv_view = functools.partial(jenv_detail, app, params)
+    active_view = functools.partial(active_detail, app, params)
     edit_view = functools.partial(env_edit, app, params)
     # Alphabetically sort the existing environments.
     environments = sorted([
@@ -262,7 +262,7 @@
     focus_position = None
     active_found = default_found = errors_found = False
     existing_widgets_num = len(widgets)
-    remaining_jenv_db = copy.deepcopy(params.jenv_db)
+    remaining_active_db = copy.deepcopy(params.active_db)
     for position, env_data in enumerate(environments):
         bullet = '\N{BULLET}'
         # Is this environment the default one?
@@ -271,7 +271,7 @@
             # The first two positions are the section header and the divider.
             focus_position = position + existing_widgets_num
             bullet = '\N{CHECK MARK}'
-        if remaining_jenv_db['environments'].pop(env_data['name'], None):
+        if remaining_active_db['environments'].pop(env_data['name'], None):
             # This is an active environment. Is it running? Who knows...
             active_found = True
             bullet = ('active', bullet)
@@ -290,8 +290,8 @@
     # Alphabetically sort the remaining environments not included in the
     # environments.yaml file.
     environments = list(sorted([
-        envs.get_env_data(remaining_jenv_db, env_name)
-        for env_name in remaining_jenv_db['environments']
+        envs.get_env_data(remaining_active_db, env_name)
+        for env_name in remaining_active_db['environments']
     ], key=operator.itemgetter('name')))
 
     if environments:
@@ -308,9 +308,10 @@
         ])
         bullet = ('active', '\N{BULLET}')
         for env_data in environments:
-            env_short_description = jenv.get_env_short_description(env_data)
+            env_short_description = envs.get_env_short_description(env_data)
             text = [bullet, ' {}'.format(env_short_description)]
-            widgets.append(ui.MenuButton(text, ui.thunk(jenv_view, env_data)))
+            widgets.append(
+                ui.MenuButton(text, ui.thunk(active_view, env_data)))
 
     # Set up the "create a new environment" section.
     widgets.extend([
@@ -389,7 +390,7 @@
     Receives a params namedtuple-like object including the following fields:
         - env_type_db: the environments meta information;
         - env_db: the environments database;
-        - jenv_db: the jenv files database;
+        - active_db: the active environments database;
         - save_callable: a function called to save a new environment database.
     See quickstart.cli.params.Params.
     Also receives the current environment data env_data.
@@ -494,17 +495,17 @@
     redirect_view()
 
 
-def jenv_detail(app, params, env_data):
-    """Show details on a Juju imported environment.
+def active_detail(app, params, env_data):
+    """Show details on a Juju active/imported environment.
 
     The environment is not included in the environments.yaml file, but just
-    found in the jenv database.
+    found in the active database.
     From this view it is possible to start the environment.
 
     Receives a params namedtuple-like object including the following fields:
         - env_type_db: the environments meta information;
         - env_db: the environments database;
-        - jenv_db: the jenv files database;
+        - active_db: the active environments database;
         - save_callable: a function called to save a new environment database;
     See quickstart.cli.params.Params.
     Also receives the current environment data env_data.
@@ -516,9 +517,9 @@
     app.set_return_value_on_exit((params.env_db, None))
     index_view = functools.partial(env_index, app, params)
 
-    app.set_title(jenv.get_env_short_description(env_data))
+    app.set_title(envs.get_env_short_description(env_data))
     widgets = []
-    for key, value in jenv.get_env_details(env_data):
+    for key, value in apiinfo.get_env_details(env_data):
         widgets.append(urwid.Text(['{}: '.format(key), ('highlight', value)]))
     widgets.extend([
         urwid.Divider(),
@@ -528,23 +529,13 @@
             '\nFor this reason, it is not possible to edit it.\n'
             'However, you can use the link below to ',
             ('highlight', 'use Juju Quickstart'),
-            ' with this environment or ',
-            ('highlight', 'remove the corresponding jenv file'),
-            '.\n'
-            'Note that removing the Juju generated environment file does not '
-            'destroy the corresponding active environment.'
+            ' with this environment',
         ]),
     ])
 
-    remove_callback = ui.thunk(
-        _remove_jenv, params.jenv_db, env_data, params.remove_jenv_callable,
-        app.set_message, index_view)
-    confirm_removal_callback = ui.thunk(
-        _confirm_removal, app, env_data, remove_callback)
     controls = [
         ui.MenuButton('back', ui.thunk(index_view)),
         ui.MenuButton('use', ui.thunk(_use, params.env_db, env_data)),
-        ui.MenuButton(('control alert', 'remove'), confirm_removal_callback),
     ]
     widgets.append(ui.create_controls(*controls))
     listbox = urwid.ListBox(urwid.SimpleFocusListWalker(widgets))
@@ -552,24 +543,6 @@
     app.set_status([' \N{RIGHTWARDS ARROW OVER LEFTWARDS ARROW} navigate '])
 
 
-def _remove_jenv(
-        jenv_db, env_data, remove_jenv_callable, set_message, redirect_view):
-    """Remove the jenv file corresonding to the env_data environment.
-
-    Update the provided jenv_db and return to the given view.
-    Also output a notification using the given set_message callable.
-    """
-    env_name = env_data['name']
-    # Remove the jenv file.
-    msg = remove_jenv_callable(env_name)
-    if msg is None:
-        msg = '{} successfully removed'.format(env_name)
-        # Also remove the environments from the jenv database.
-        del jenv_db['environments'][env_name]
-    set_message(msg)
-    redirect_view()
-
-
 def env_edit(app, params, env_data):
     """Create or modify a Juju environment.
 
@@ -580,7 +553,7 @@
     Receives a params namedtuple-like object including the following fields:
         - env_type_db: the environments meta information;
         - env_db: the environments database;
-        - jenv_db: the jenv files database;
+        - active_db: the active environments database;
         - save_callable: a function called to save a new environment database;
     See quickstart.cli.params.Params.
     Also receives the current environment data env_data.

=== modified file 'quickstart/manage.py'
--- quickstart/manage.py	2015-05-29 15:03:27 +0000
+++ quickstart/manage.py	2015-11-05 10:58:41 +0000
@@ -45,9 +45,9 @@
     views,
 )
 from quickstart.models import (
+    apiinfo,
     bundles,
     envs,
-    jenv,
 )
 
 
@@ -162,9 +162,14 @@
     options.gui_source = (user, branch)
 
 
-def _validate_platform(platform, parser):
+def _validate_platform(platform, options, parser):
     """Validate the platform.
 
+    Populate the options namespace with the following names:
+        - info: and object that can be used to retrieve API info on envs;
+        - juju_command: the path to the Juju command on the given platform;
+        - platform: the current OS platform as defined in the settings module.
+
     Exit with an error if platform is not supported by quickstart or is
     missing files.
     """
@@ -172,6 +177,9 @@
         platform_support.validate_platform(platform)
     except ValueError as err:
         return parser.error(bytes(err))
+    options.juju_command = platform_support.get_juju_command(platform)
+    options.platform = platform
+    options.info = apiinfo.Info(options.juju_command)
 
 
 def _validate_port(port, parser):
@@ -214,7 +222,8 @@
     return save_callable
 
 
-def _start_interactive_session(parser, env_type_db, env_db, jenv_db, env_file):
+def _start_interactive_session(
+        parser, env_type_db, env_db, active_db, env_file):
     """Start the Urwid interactive session.
 
     Return the env_data corresponding to the user selected environment.
@@ -224,9 +233,8 @@
     parameters = params.Params(
         env_type_db=env_type_db,
         env_db=env_db,
-        jenv_db=jenv_db,
+        active_db=active_db,
         save_callable=_create_save_callable(parser, env_file),
-        remove_jenv_callable=jenv.remove,
     )
     new_env_db, env_data = views.show(views.env_index, parameters)
     if new_env_db != env_db:
@@ -239,7 +247,7 @@
     return env_data
 
 
-def _retrieve_env_data(parser, env_type_db, env_db, jenv_db, env_name):
+def _retrieve_env_data(parser, env_type_db, env_db, active_db, env_name):
     """Retrieve and return the env_data corresponding to the given env_name.
 
     Invoke a parser error if the environment does not exist or is not valid.
@@ -250,7 +258,7 @@
         # The specified environment does not exist in the environments file.
         # Check if this is an imported environment.
         try:
-            return envs.get_env_data(jenv_db, env_name)
+            return envs.get_env_data(active_db, env_name)
         except ValueError as err:
             # The environment cannot be found anywhere, exit with an error.
             return parser.error(bytes(err))
@@ -299,21 +307,21 @@
 
     # Retrieve the environment database (or create an in-memory empty one).
     env_db = _retrieve_env_db(parser, env_file if env_file_exists else None)
-    jenv_db = jenv.get_env_db()
+    active_db = options.info.all()
 
     # Validate the environment.
     env_type_db = envs.get_env_type_db()
     if interactive:
         # Start the interactive session.
         env_data = _start_interactive_session(
-            parser, env_type_db, env_db, jenv_db, env_file)
+            parser, env_type_db, env_db, active_db, env_file)
     else:
         # This is a non-interactive session and we need to validate the
         # selected environment before proceeding.
         env_data = _retrieve_env_data(
-            parser, env_type_db, env_db, jenv_db, env_name)
+            parser, env_type_db, env_db, active_db, env_name)
     # Check for local support, if requested.
-    options.env_type = env_data['type']
+    options.env_type = env_data.get('type')
     no_local_support = not platform_support.supports_local(options.platform)
     if options.env_type == 'local' and no_local_support:
         return parser.error(
@@ -368,11 +376,15 @@
         - distro_only: install Juju only using the distribution packages;
         - env_file: the absolute path of the Juju environments.yaml file;
         - env_name: the name of the Juju environment to use;
-        - env_type: the provider type of the selected Juju environment;
+        - env_type: the provider type of the selected Juju environment, or None
+          if the environment type cannot be retrieved at setup time;
         - gui_source: the optional Juju GUI branch source on github, or None;
+        - info: an instance of "quickstart.models.apiinfo.Info", used to
+          retrieve information about the current environment in use;
         - interactive: whether to start the interactive session;
+        - juju_command: the path to the Juju command on the current platform;
         - open_browser: whether the GUI browser must be opened;
-        - platform: The host platform;
+        - platform: the host platform;
         - port: the optional Juju GUI port, or None;
         - uncommitted: whether the provided bundle must be deployed using the
           Juju GUI uncommitted state;
@@ -520,10 +532,8 @@
     # Set up logging.
     _configure_logging(logging.DEBUG if options.debug else logging.INFO)
 
-    # Validate and add in the platform for convenience.
-    _validate_platform(platform, parser)
-    options.platform = platform
-
+    # Validate the platform and add in platform info for convenience.
+    _validate_platform(platform, options, parser)
     # Convert the provided string arguments to unicode.
     _convert_options_to_unicode(options)
     # Validate and process the provided arguments.
@@ -544,12 +554,9 @@
         print('contents loaded for {} (services: {})'.format(
             options.bundle, len(options.bundle.services())))
 
-    juju_command, custom_juju = platform_support.get_juju_command(
-        options.platform)
-
     logging.debug('ensuring juju and dependencies are installed')
     juju_version = app.ensure_dependencies(
-        options.distro_only, options.platform, juju_command)
+        options.distro_only, options.platform, options.juju_command)
     app.check_juju_supported(juju_version)
 
     logging.debug('ensuring SSH keys are available')
@@ -558,7 +565,8 @@
     # Bootstrap the Juju environment or reuse an already bootstrapped one.
     already_bootstrapped = True
     env_type = options.env_type
-    api_address = app.check_bootstrapped(options.env_name)
+    env_info = options.info.get(options.env_name)
+    api_address = app.get_api_address(env_info)
     if api_address is None:
         print('bootstrapping the {} environment'.format(options.env_name))
         if env_type == 'local':
@@ -567,7 +575,8 @@
             print('sudo privileges will be required to bootstrap the '
                   'environment')
         already_bootstrapped = app.bootstrap(
-            options.env_name, juju_command,
+            options.env_name,
+            options.juju_command,
             debug=options.debug,
             upload_tools=options.upload_tools,
             upload_series=options.upload_series,
@@ -579,26 +588,21 @@
     # Retrieve the environment status, ensure it is in a ready state and
     # contextually fetch the bootstrap node series.
     print('retrieving the environment status')
-    bootstrap_node_series = app.status(options.env_name, juju_command)
+    bootstrap_node_series = app.status(options.env_name, options.juju_command)
 
     # If the environment was not already bootstrapped, we need to retrieve
     # the API address.
     if api_address is None:
-        print('retrieving the Juju API address')
-        api_address = app.get_api_address(options.env_name, juju_command)
-
-    # Retrieve the Juju environment unique identifier.
-    env_uuid = app.get_env_uuid_or_none(options.env_name)
+        print('retrieving the Juju API address and credentials')
+        env_info = options.info.get(options.env_name)
+        api_address = app.get_api_address(env_info)
 
     # Build the Juju API endpoint based on the Juju version and environment id.
-    api_url = jujutools.get_api_url(api_address, juju_version, env_uuid)
-
-    # Retrieve the admin-secret for the current environment.
-    print('retrieving the Juju environment credentials')
-    username, password = app.get_credentials(options.env_name)
+    api_url = jujutools.get_api_url(
+        api_address, juju_version, env_info['uuid'])
 
     print('connecting to {}'.format(api_url))
-    env = app.connect(api_url, username, password)
+    env = app.connect(api_url, env_info['user'], env_info['password'])
 
     if already_bootstrapped:
         # Retrieve the environment type from the live environment: it may be
@@ -629,19 +633,19 @@
     url = utils.build_web_url(
         address, gui_config['port'], gui_config['secure'])
     print('\nJuju GUI URL: {}\nusername: {}\npassword: {}\n'.format(
-        url, username, password))
+        url, env_info['user'], env_info['password']))
 
     # Connect to the GUI server WebSocket API.
     print('connecting to the Juju GUI server')
     gui_api_url = jujutools.get_api_url(
-        '{}:{}'.format(address, gui_config['port']), juju_version, env_uuid,
-        path_prefix='ws', charm_ref=charm_ref,
+        '{}:{}'.format(address, gui_config['port']), juju_version,
+        env_info['uuid'], path_prefix='ws', charm_ref=charm_ref,
         insecure=not gui_config['secure'])
 
     # We need to connect to an API WebSocket server supporting bundle
     # deployments and automatic auth-token login. The GUI builtin server,
     # listening on the Juju GUI address, exposes a suitable API.
-    gui_env = app.connect(gui_api_url, username, password)
+    gui_env = app.connect(gui_api_url, env_info['user'], env_info['password'])
     changes_token = None
     # Handle bundle deployment.
     if options.bundle_source is not None:

=== added file 'quickstart/models/apiinfo.py'
--- quickstart/models/apiinfo.py	1970-01-01 00:00:00 +0000
+++ quickstart/models/apiinfo.py	2015-11-05 10:58:41 +0000
@@ -0,0 +1,110 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Juju Quickstart API info handling.
+
+This module is used to collect information about already bootstrapped
+environments. The Juju command line is used to retrieve data useful when
+connecting to these environments.
+"""
+
+from __future__ import unicode_literals
+
+import json
+import logging
+import os
+
+from quickstart import (
+    settings,
+    utils,
+)
+
+
+class Info(object):
+    """Collect methods used for retrieving environment information."""
+
+    def __init__(self, juju_command):
+        """Initialize the object with the path to the Juju command."""
+        self._juju_command = juju_command
+
+    def get(self, env_name):
+        """Return info on the given bootstrapped environment.
+
+        Return an empty dict if the environment is not found, is not
+        bootstrapped or it is not possible to retrieve information, for
+        instance because Juju is not installed.
+        """
+        retcode, output, error = utils.call(
+            self._juju_command, 'api-info',
+            '-e', env_name, '--password', '--format', 'json')
+        if retcode:
+            logging.debug(
+                'unable to get API info for {}: {}'.format(env_name, error))
+            return {}
+
+        data = json.loads(output)
+        return {
+            'name': env_name,
+            'user': data['user'],
+            'password': data['password'],
+            'uuid': data['environ-uuid'],
+            'state-servers': data['state-servers'],
+        }
+
+    def all(self):
+        """Return information about all bootstrapped environments.
+
+        The returned dict is similar to what is returned by models.envs.load().
+
+        The environment database returned by this method does not contain the
+        usual fields used as bootstrap options. The included fields are:
+        "name", "user", "password", "uuid" and "state-servers".
+        """
+        retcode, output, _ = utils.call(self._juju_command, 'system', 'list')
+        names = _env_names_from_jenvs() if retcode else output.splitlines()
+        return {'environments': dict((name, self.get(name)) for name in names)}
+
+
+def _env_names_from_jenvs():
+    """Return active environment names by searching for jenv files."""
+    names = []
+    path = os.path.expanduser(os.path.join(settings.JUJU_HOME, 'environments'))
+    if not os.path.isdir(path):
+        logging.debug('environments directory not found in the Juju home')
+        return names
+    for filename in sorted(os.listdir(path)):
+        fullpath = os.path.join(path, filename)
+        # Check that the current file is a jenv file.
+        if not os.path.isfile(fullpath):
+            continue
+        name, ext = os.path.splitext(filename)
+        if ext == '.jenv':
+            names.append(name)
+    return names
+
+
+def get_env_details(env_data):
+    """Return the environment details as a sequence of tuples (label, value).
+
+    In each tuple, the label is the field name, and the value is the
+    corresponding value in the given env_data.
+    """
+    return [
+        ('name', env_data['name']),
+        ('user', env_data['user']),
+        ('uuid', env_data['uuid']),
+        ('state servers', ', '.join(env_data['state-servers'])),
+    ]

=== modified file 'quickstart/models/jenv.py'
--- quickstart/models/jenv.py	2015-02-09 11:22:44 +0000
+++ quickstart/models/jenv.py	2015-11-05 10:58:41 +0000
@@ -18,6 +18,11 @@
 
 At bootstrap, Juju writes a generated file (jenv) located in JUJU_HOME.
 This module includes functions to load and parse those jenv file contents.
+
+NOTE: this module is deprecated and still here for API compatibility only.
+Do not import this module on quickstart code. External programs using this
+module should move to more reliable ways to retrieve information on already
+bootstrapped environments. For instance, see "quickstart.models.apiinfo".
 """
 
 from __future__ import unicode_literals
@@ -31,6 +36,9 @@
 )
 
 
+# This module is deprecated.
+logging.warn('using deprecated module "quickstart.models.jenv"')
+
 # Define the default Juju user when an environment is initially bootstrapped.
 JUJU_DEFAULT_USER = 'admin'
 # Define an env type to use when the real type is not included in the jenv.

=== modified file 'quickstart/platform_support.py'
--- quickstart/platform_support.py	2015-05-22 11:33:00 +0000
+++ quickstart/platform_support.py	2015-11-05 10:58:41 +0000
@@ -117,23 +117,17 @@
 def get_juju_command(platform):
     """Return the path to the Juju command on the given platform.
 
-    Also return a flag indicating whether the user requested to customize
-    the Juju command by providing a JUJU environment variable.
-
-    If the platform does not have a novel location, the default will be
-    returned.
-
-    If the environment variable JUJU is set, then its value will be
-    returned.
+    If the platform does not have a novel location, the default is returned.
+    If the environment variable JUJU is set, then its value is returned.
     """
     juju_command = os.getenv('JUJU', '').strip()
     platform_command = settings.JUJU_CMD_PATHS.get(
         platform,
         settings.JUJU_CMD_PATHS['default'])
     if juju_command and juju_command != platform_command:
-        logging.warn("a customized juju is being used")
-        return juju_command, True
-    return platform_command, False
+        logging.warn('a customized juju is being used')
+        return juju_command
+    return platform_command
 
 
 def get_juju_installer(platform):

=== modified file 'quickstart/settings.py'
--- quickstart/settings.py	2015-08-12 12:04:34 +0000
+++ quickstart/settings.py	2015-11-05 10:58:41 +0000
@@ -77,7 +77,7 @@
 JUJU_GUI_SUPPORTED_SERIES = tuple(DEFAULT_CHARM_URLS.keys())
 
 # The minimum Juju version supported by Juju Quickstart,
-JUJU_SUPPORTED_VERSION = (1, 18, 1)
+JUJU_SUPPORTED_VERSION = (1, 22, 1)
 
 # The path to the MAAS command line interface.
 MAAS_CMD = '/usr/bin/maas'

=== modified file 'quickstart/tests/cli/test_params.py'
--- quickstart/tests/cli/test_params.py	2015-01-12 12:10:38 +0000
+++ quickstart/tests/cli/test_params.py	2015-11-05 10:58:41 +0000
@@ -31,35 +31,30 @@
         # Store parameters.
         self.env_type_db = envs.get_env_type_db()
         self.env_db = helpers.make_env_db()
-        self.jenv_db = helpers.make_jenv_db()
+        self.active_db = helpers.make_active_db()
         self.save_callable = lambda env_db: None
-        self.remove_jenv_callable = lambda env_db: None
         # Set up a params object used in tests.
         self.params = params.Params(
             env_type_db=self.env_type_db,
             env_db=self.env_db,
-            jenv_db=self.jenv_db,
+            active_db=self.active_db,
             save_callable=self.save_callable,
-            remove_jenv_callable=self.remove_jenv_callable,
         )
 
     def test_tuple(self):
         # The params object can be used as a tuple.
-        env_type_db, env_db, jenv_db, save, remove = self.params
+        env_type_db, env_db, active_db, save = self.params
         self.assertIs(self.env_type_db, env_type_db)
         self.assertIs(self.env_db, env_db)
-        self.assertIs(self.jenv_db, jenv_db)
+        self.assertIs(self.active_db, active_db)
         self.assertIs(self.save_callable, save)
-        self.assertIs(self.remove_jenv_callable, remove)
 
     def test_attributes(self):
         # Parameters can be accessed as attributes.
         self.assertIs(self.env_type_db, self.params.env_type_db)
         self.assertIs(self.env_db, self.params.env_db)
-        self.assertIs(self.jenv_db, self.params.jenv_db)
+        self.assertIs(self.active_db, self.params.active_db)
         self.assertIs(self.save_callable, self.params.save_callable)
-        self.assertIs(
-            self.remove_jenv_callable, self.params.remove_jenv_callable)
 
     def test_immutable(self):
         # It is not possible to replace a stored parameter.
@@ -72,10 +67,8 @@
         # The original object is not mutated by the copy.
         self.assertIs(self.env_type_db, self.params.env_type_db)
         self.assertIs(self.env_db, self.params.env_db)
-        self.assertIs(self.jenv_db, self.params.jenv_db)
+        self.assertIs(self.active_db, self.params.active_db)
         self.assertIs(self.save_callable, self.params.save_callable)
-        self.assertIs(
-            self.remove_jenv_callable, self.params.remove_jenv_callable)
         # The new params object stores the same data.
         self.assertEqual(self.params, params)
         # But they do not refer to the same object.

=== modified file 'quickstart/tests/cli/test_views.py'
--- quickstart/tests/cli/test_views.py	2015-01-12 13:59:45 +0000
+++ quickstart/tests/cli/test_views.py	2015-11-05 10:58:41 +0000
@@ -36,8 +36,8 @@
     views,
 )
 from quickstart.models import (
+    apiinfo,
     envs,
-    jenv,
 )
 from quickstart.tests import helpers
 from quickstart.tests.cli import helpers as cli_helpers
@@ -137,7 +137,6 @@
         # Set up the base Urwid application.
         self.loop, self.app = base.setup_urwid_app()
         self.save_callable = mock.Mock()
-        self.remove_jenv_callable = mock.Mock(return_value=None)
 
     def get_widgets_in_contents(self, filter_function=None):
         """Return a list of widgets included in the app contents.
@@ -168,14 +167,13 @@
         """
         return lambda arg: isinstance(arg, cls)
 
-    def make_params(self, env_db, jenv_db):
+    def make_params(self, env_db, active_db):
         """Create and return view parameters using the given env databases."""
         return params.Params(
             env_type_db=self.env_type_db,
             env_db=env_db,
-            jenv_db=jenv_db,
+            active_db=active_db,
             save_callable=self.save_callable,
-            remove_jenv_callable=self.remove_jenv_callable,
         )
 
     def click_remove_button(self, env_name):
@@ -230,8 +228,8 @@
         # a tuple including a copy of the given env_db and None, the latter
         # meaning no environment has been selected.
         env_db = helpers.make_env_db()
-        jenv_db = helpers.make_jenv_db()
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = helpers.make_active_db()
+        views.env_index(self.app, self.make_params(env_db, active_db))
         new_env_db, env_data = self.get_on_exit_return_value(self.loop)
         self.assertEqual(env_db, new_env_db)
         self.assertIsNot(env_db, new_env_db)
@@ -240,8 +238,8 @@
     def test_view_title(self):
         # The application title is correctly set up.
         env_db = helpers.make_env_db()
-        jenv_db = helpers.make_jenv_db()
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = helpers.make_active_db()
+        views.env_index(self.app, self.make_params(env_db, active_db))
         self.assertEqual(
             'Select an existing Juju environment or create a new one',
             self.app.get_title())
@@ -249,8 +247,8 @@
     def test_view_title_no_environments(self):
         # The application title changes if the env_db has no environments.
         env_db = {'environments': {}}
-        jenv_db = helpers.make_jenv_db()
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = helpers.make_active_db()
+        views.env_index(self.app, self.make_params(env_db, active_db))
         self.assertEqual(
             'No Juju environments already set up: please create one',
             self.app.get_title())
@@ -259,9 +257,9 @@
         # The view displays a list of the environments in env_db, and buttons
         # to create new environments.
         env_db = helpers.make_env_db()
-        jenv_db = {'environments': {}}
+        active_db = {'environments': {}}
         with local_envs_supported(True):
-            views.env_index(self.app, self.make_params(env_db, jenv_db))
+            views.env_index(self.app, self.make_params(env_db, active_db))
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # A button is created for each existing environment (see details) and
@@ -274,9 +272,9 @@
         # The view displays a list of active imported environments, and buttons
         # to create new environments.
         env_db = {'environments': {}}
-        jenv_db = helpers.make_jenv_db()
+        active_db = helpers.make_active_db()
         with local_envs_supported(True):
-            views.env_index(self.app, self.make_params(env_db, jenv_db))
+            views.env_index(self.app, self.make_params(env_db, active_db))
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # A button is created for each existing environment (see details) and
@@ -284,7 +282,7 @@
         env_types = envs.get_supported_env_types(self.env_type_db)
         expected_buttons_number = (
             # The number of active environments.
-            len(jenv_db['environments']) +
+            len(active_db['environments']) +
             # The buttons to create new environments.
             len(env_types) +
             # The button to automatically create a new local environment.
@@ -299,8 +297,8 @@
     def test_view_contents_without_imported_envs(self):
         # If there are no active imported environments the corresponding
         # header text is not displayed.
-        env_db = jenv_db = {'environments': {}}
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        env_db = active_db = {'environments': {}}
+        views.env_index(self.app, self.make_params(env_db, active_db))
         widgets = self.get_widgets_in_contents(
             filter_function=self.is_a(urwid.Text))
         texts = [widget.text for widget in widgets]
@@ -310,9 +308,9 @@
         # The option to create a new local environment is not present if they
         # are not supported in the current platform.
         env_db = helpers.make_env_db()
-        jenv_db = helpers.make_jenv_db()
+        active_db = helpers.make_active_db()
         with local_envs_supported(False):
-            views.env_index(self.app, self.make_params(env_db, jenv_db))
+            views.env_index(self.app, self.make_params(env_db, active_db))
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         captions = map(cli_helpers.get_button_caption, buttons)
@@ -326,8 +324,8 @@
     def test_environment_clicked(self, mock_env_detail):
         # The environment detail view is called when clicking an environment.
         env_db = helpers.make_env_db()
-        jenv_db = {'environments': {}}
-        params = self.make_params(env_db, jenv_db)
+        active_db = {'environments': {}}
+        params = self.make_params(env_db, active_db)
         views.env_index(self.app, params)
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
@@ -347,40 +345,41 @@
             # loop cycle.
             mock_env_detail.reset_mock()
 
-    @mock.patch('quickstart.cli.views.jenv_detail')
-    def test_imported_environment_clicked(self, mock_jenv_detail):
-        # The jenv detail view is called when clicking an imported environment.
+    @mock.patch('quickstart.cli.views.active_detail')
+    def test_imported_environment_clicked(self, mock_active_detail):
+        # The active detail view is called when clicking an imported
+        # environment.
         env_db = {'environments': {}}
-        jenv_db = helpers.make_jenv_db()
-        params = self.make_params(env_db, jenv_db)
+        active_db = helpers.make_active_db()
+        params = self.make_params(env_db, active_db)
         with local_envs_supported(False):
             views.env_index(self.app, params)
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # The environments are listed in alphabetical order.
-        environments = sorted(jenv_db['environments'])
+        environments = sorted(active_db['environments'])
         for env_name, button in zip(environments, buttons):
-            env_data = envs.get_env_data(jenv_db, env_name)
+            env_data = envs.get_env_data(active_db, env_name)
             # The caption includes the environment description.
-            env_description = jenv.get_env_short_description(env_data)
+            env_description = envs.get_env_short_description(env_data)
             self.assertIn(
                 env_description, cli_helpers.get_button_caption(button))
-            # When the button is clicked, the jenv detail view is called
+            # When the button is clicked, the active detail view is called
             # passing the corresponding environment data.
             cli_helpers.emit(button)
-            mock_jenv_detail.assert_called_once_with(
+            mock_active_detail.assert_called_once_with(
                 self.app, params, env_data)
             # Reset the mock so that it does not include any calls on the next
             # loop cycle.
-            mock_jenv_detail.reset_mock()
+            mock_active_detail.reset_mock()
 
     @mock.patch('quickstart.cli.views.env_edit')
     def test_create_new_environment_clicked(self, mock_env_edit):
         # The environment edit view is called when clicking to create a new
         # environment.
         env_db = helpers.make_env_db()
-        jenv_db = {'environments': {}}
-        params = self.make_params(env_db, jenv_db)
+        active_db = {'environments': {}}
+        params = self.make_params(env_db, active_db)
         with local_envs_supported(True):
             views.env_index(self.app, params)
         buttons = self.get_widgets_in_contents(
@@ -410,10 +409,10 @@
         # If that option is clicked, the view quits the application returning
         # the newly created env_data.
         env_db = envs.create_empty_env_db()
-        jenv_db = helpers.make_jenv_db()
+        active_db = helpers.make_active_db()
         with maas_env_detected(False):
             with local_envs_supported(True):
-                views.env_index(self.app, self.make_params(env_db, jenv_db))
+                views.env_index(self.app, self.make_params(env_db, active_db))
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # The "create and bootstrap" button is the first one in the contents.
@@ -434,9 +433,9 @@
         # environment is not displayed if the current platform does not support
         # local environments.
         env_db = envs.create_empty_env_db()
-        jenv_db = helpers.make_jenv_db()
+        active_db = helpers.make_active_db()
         with local_envs_supported(False):
-            views.env_index(self.app, self.make_params(env_db, jenv_db))
+            views.env_index(self.app, self.make_params(env_db, active_db))
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # No "create and bootstrap local" buttons are present.
@@ -450,9 +449,9 @@
         # If that option is clicked, the view quits the application returning
         # the newly created env_data.
         env_db = envs.create_empty_env_db()
-        jenv_db = helpers.make_jenv_db()
+        active_db = helpers.make_active_db()
         with maas_env_detected(True):
-            views.env_index(self.app, self.make_params(env_db, jenv_db))
+            views.env_index(self.app, self.make_params(env_db, active_db))
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # The "create and bootstrap" button is the first one in the contents.
@@ -473,9 +472,9 @@
         # environment is not displayed if no MAAS API endpoints are
         # available on the system
         env_db = envs.create_empty_env_db()
-        jenv_db = helpers.make_jenv_db()
+        active_db = helpers.make_active_db()
         with maas_env_detected(False):
-            views.env_index(self.app, self.make_params(env_db, jenv_db))
+            views.env_index(self.app, self.make_params(env_db, active_db))
         buttons = self.get_widgets_in_contents(
             filter_function=self.is_a(ui.MenuButton))
         # No "create and bootstrap MAAS" buttons are present.
@@ -485,8 +484,8 @@
     def test_selected_environment(self):
         # The default environment is already selected in the list.
         env_db = helpers.make_env_db(default='lxc')
-        jenv_db = helpers.make_jenv_db()
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = helpers.make_active_db()
+        views.env_index(self.app, self.make_params(env_db, active_db))
         env_data = envs.get_env_data(env_db, 'lxc')
         env_description = envs.get_env_short_description(env_data)
         contents = self.app.get_contents()
@@ -498,32 +497,32 @@
     def test_status_with_errors(self):
         # The status message explains how errors are displayed.
         env_db = helpers.make_env_db()
-        jenv_db = {'environments': {}}
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = {'environments': {}}
+        views.env_index(self.app, self.make_params(env_db, active_db))
         status = self.app.get_status()
         self.assertEqual(self.base_status + ' \N{BULLET} has errors ', status)
 
     def test_status_with_default(self):
         # The status message explains how default environment is represented.
         env_db = helpers.make_env_db(default='lxc', exclude_invalid=True)
-        jenv_db = {'environments': {}}
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = {'environments': {}}
+        views.env_index(self.app, self.make_params(env_db, active_db))
         status = self.app.get_status()
         self.assertEqual(self.base_status + ' \N{CHECK MARK} default ', status)
 
     def test_status_with_active(self):
         # The status message explains how active environments are displayed.
         env_db = helpers.make_env_db(exclude_invalid=True)
-        jenv_db = helpers.make_jenv_db()
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = helpers.make_active_db()
+        views.env_index(self.app, self.make_params(env_db, active_db))
         status = self.app.get_status()
         self.assertEqual(self.base_status + ' \N{BULLET} active ', status)
 
     def test_complete_status(self):
         # The status message includes default, active and errors explanations.
         env_db = helpers.make_env_db(default='lxc')
-        jenv_db = helpers.make_jenv_db()
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = helpers.make_active_db()
+        views.env_index(self.app, self.make_params(env_db, active_db))
         status = self.app.get_status()
         self.assertEqual(
             self.base_status +
@@ -535,8 +534,8 @@
     def test_base_status(self):
         # The status only includes navigation info if there are no errors.
         env_db = helpers.make_env_db(exclude_invalid=True)
-        jenv_db = {'environments': {}}
-        views.env_index(self.app, self.make_params(env_db, jenv_db))
+        active_db = {'environments': {}}
+        views.env_index(self.app, self.make_params(env_db, active_db))
         status = self.app.get_status()
         self.assertEqual(self.base_status, status)
 
@@ -545,12 +544,12 @@
 
     base_status = ' \N{RIGHTWARDS ARROW OVER LEFTWARDS ARROW} navigate '
     env_db = helpers.make_env_db(default='lxc')
-    jenv_db = helpers.make_jenv_db()
+    active_db = helpers.make_active_db()
 
     def call_view(self, env_name='lxc'):
         """Call the view passing the env_data corresponding to env_name."""
         self.env_data = envs.get_env_data(self.env_db, env_name)
-        self.params = self.make_params(self.env_db, self.jenv_db)
+        self.params = self.make_params(self.env_db, self.active_db)
         return views.env_detail(self.app, self.params, self.env_data)
 
     def test_view_default_return_value_on_exit(self):
@@ -707,16 +706,16 @@
         self.assertEqual(self.base_status, status)
 
 
-class TestJenvDetail(EnvViewTestsMixin, unittest.TestCase):
+class TestActiveDetail(EnvViewTestsMixin, unittest.TestCase):
 
     env_db = helpers.make_env_db(default='lxc')
-    jenv_db = helpers.make_jenv_db()
+    active_db = helpers.make_active_db()
 
     def call_view(self, env_name='lxc'):
         """Call the view passing the env_data corresponding to env_name."""
-        self.env_data = envs.get_env_data(self.jenv_db, env_name)
-        self.params = self.make_params(self.env_db, self.jenv_db)
-        return views.jenv_detail(self.app, self.params, self.env_data)
+        self.env_data = envs.get_env_data(self.active_db, env_name)
+        self.params = self.make_params(self.env_db, self.active_db)
+        return views.active_detail(self.app, self.params, self.env_data)
 
     def test_view_default_return_value_on_exit(self):
         # The view configures the app so that the return value on user exit is
@@ -730,19 +729,19 @@
 
     def test_view_title(self):
         # The application title is correctly set up: it shows the description
-        # of the current jenv environment.
+        # of the current active environment.
         self.call_view()
-        env_description = jenv.get_env_short_description(self.env_data)
+        env_description = envs.get_env_short_description(self.env_data)
         self.assertEqual(env_description, self.app.get_title())
 
     def test_view_contents(self):
-        # The view displays the jenv details.
+        # The view displays the active details.
         self.call_view()
         widgets = self.get_widgets_in_contents(
             filter_function=self.is_a(urwid.Text))
         expected_texts = [
             '{}: {}'.format(label, value) for label, value
-            in jenv.get_env_details(self.env_data)
+            in apiinfo.get_env_details(self.env_data)
         ]
         for expected_text, widget in zip(expected_texts, widgets):
             self.assertEqual(expected_text, widget.text)
@@ -752,7 +751,7 @@
         self.call_view(env_name='ec2-west')
         buttons = self.get_control_buttons()
         captions = map(cli_helpers.get_button_caption, buttons)
-        self.assertEqual(['back', 'use', 'remove'], captions)
+        self.assertEqual(['back', 'use'], captions)
 
     @mock.patch('quickstart.cli.views.env_index')
     def test_back_button(self, mock_env_index):
@@ -775,64 +774,11 @@
         self.assertEqual(
             expected_return_value, context_manager.exception.return_value)
 
-    def test_remove_button(self):
-        # A confirmation dialog is displayed if the "remove" button is clicked.
-        self.call_view(env_name='test-jenv')
-        buttons, _ = self.click_remove_button('test-jenv')
-        # The dialog includes the "cancel" and "confirm" buttons.
-        self.assertEqual(2, len(buttons))
-        captions = map(cli_helpers.get_button_caption, buttons)
-        self.assertEqual(['cancel', 'confirm'], captions)
-
-    def test_remove_cancelled(self):
-        # The "remove" confirmation dialog can be safely dismissed.
-        self.call_view(env_name='test-jenv')
-        original_contents = self.cancel_removal('test-jenv')
-        # The original contents have been restored.
-        self.assertIs(original_contents, self.app.get_contents())
-
-    @mock.patch('quickstart.cli.views.env_index')
-    def test_remove_confirmed(self, mock_env_index):
-        # The jenv file is removed if the "remove" button is clicked and then
-        # then the deletion is confirmed. Subsequently the application switches
-        # to the index view.
-        env_name = 'test-jenv'
-        self.call_view(env_name=env_name)
-        self.confirm_removal(env_name)
-        # A message notifies the environment has been removed.
-        self.assertEqual(
-            '{} successfully removed'.format(env_name), self.app.get_message())
-        # The index view has been called passing the modified jenv_db params.
-        self.assertTrue(mock_env_index.called)
-        params = mock_env_index.call_args[0][1]
-        # The new jenv_db no longer includes the "test-jenv" environment.
-        self.assertNotIn(env_name, params.jenv_db['environments'])
-        # The corresponding jenv file has been removed.
-        self.remove_jenv_callable.assert_called_once_with(env_name)
-        self.assertEqual(
-            'test-jenv successfully removed', self.app.get_message())
-
-    @mock.patch('quickstart.cli.views.env_index')
-    def test_remove_confirmed_error(self, mock_env_index):
-        # Errors occurred while trying to remove the jenv files are notified.
-        env_name = 'test-jenv'
-        self.call_view(env_name=env_name)
-        # Simulate an error removing the jenv file.
-        self.remove_jenv_callable.return_value = 'bad wolf'
-        self.confirm_removal(env_name)
-        # The error is notified.
-        self.assertEqual('bad wolf'.format(env_name), self.app.get_message())
-        # The index view has been called passing the original jenv_db params.
-        self.assertTrue(mock_env_index.called)
-        params = mock_env_index.call_args[0][1]
-        # The jenv_db still includes the "test_jenv" environment.
-        self.assertIn(env_name, params.jenv_db['environments'])
-
 
 class TestEnvEdit(EnvViewTestsMixin, unittest.TestCase):
 
     env_db = helpers.make_env_db(default='lxc')
-    jenv_db = helpers.make_jenv_db()
+    active_db = helpers.make_active_db()
 
     def call_view(self, env_name='lxc', env_type=None):
         """Call the view passing the env_data corresponding to env_name.
@@ -844,7 +790,7 @@
             self.env_data = envs.get_env_data(self.env_db, env_name)
         else:
             self.env_data = {'type': env_type}
-        self.params = self.make_params(self.env_db, self.jenv_db)
+        self.params = self.make_params(self.env_db, self.active_db)
         return views.env_edit(self.app, self.params, self.env_data)
 
     def get_form_contents(self):

=== modified file 'quickstart/tests/functional/test_functional.py'
--- quickstart/tests/functional/test_functional.py	2015-08-12 12:36:32 +0000
+++ quickstart/tests/functional/test_functional.py	2015-11-05 10:58:41 +0000
@@ -91,7 +91,7 @@
     Return a tuple including the command exit code, its output and error.
     """
     platform = platform_support.get_platform()
-    cmd, _ = platform_support.get_juju_command(platform)
+    cmd = platform_support.get_juju_command(platform)
     return utils.call(cmd, *args)
 
 

=== modified file 'quickstart/tests/helpers.py'
--- quickstart/tests/helpers.py	2015-04-23 12:16:20 +0000
+++ quickstart/tests/helpers.py	2015-11-05 10:58:41 +0000
@@ -148,6 +148,22 @@
         return env_file.name
 
 
+class FakeApiInfo(object):
+    """Implement the "quickstart.models.apiinfo.Info" interface for tests."""
+
+    def __init__(self, envs):
+        """Initialize the fake object with the given envs."""
+        self.envs = collections.OrderedDict((env['name'], env) for env in envs)
+
+    def get(self, env_name):
+        """See "quickstart.models.apiinfo.Info.get."""
+        return self.envs.get(env_name, {})
+
+    def all(self):
+        """See "quickstart.models.apiinfo.Info.all."""
+        return {'environments': self.envs}
+
+
 class JenvFileTestsMixin(object):
     """Shared methods for testing Juju generated environment files (jenv)."""
 
@@ -271,22 +287,25 @@
     return env_db
 
 
-def make_jenv_db():
-    """Create and return a jenv files database."""
+def make_active_db():
+    """Create and return a active environments database."""
     environments = {
         'ec2-west': {
-            'type': '__unknown__',
             'user': 'who',
+            'password': 'geronimo',
+            'uuid': 'ec2-uuid',
             'state-servers': ('1.2.3.4:42', '1.2.3.4:47'),
         },
         'lxc': {
-            'type': 'local',
             'user': 'dalek',
+            'password': 'exterminate',
+            'uuid': 'lxc-uuid',
             'state-servers': ('localhost:17070', '10.0.3.1:17070'),
         },
-        'test-jenv': {
-            'type': '__unknown__',
+        'test-env': {
             'user': 'my-user',
+            'password': 'my-password',
+            'uuid': 'test-uuid',
             'state-servers': ('10.0.3.1:17070',),
         },
     }

=== added file 'quickstart/tests/models/test_apiinfo.py'
--- quickstart/tests/models/test_apiinfo.py	1970-01-01 00:00:00 +0000
+++ quickstart/tests/models/test_apiinfo.py	2015-11-05 10:58:41 +0000
@@ -0,0 +1,242 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the Juju Quickstart jenv generated files handling."""
+
+from __future__ import unicode_literals
+
+from contextlib import contextmanager
+import json
+import os
+import shutil
+import tempfile
+import unittest
+
+import mock
+
+from quickstart.models import apiinfo
+from quickstart.tests import helpers
+
+
+class TestInfo(
+        unittest.TestCase, helpers.CallTestsMixin, helpers.JenvFileTestsMixin):
+
+    def setUp(self):
+        # Instantiate an Info object.
+        self.juju_command = '/path/to/juju'
+        self.info = apiinfo.Info(self.juju_command)
+
+    @contextmanager
+    def make_juju_home(self, envs=()):
+        """Create a Juju home with the given optional environments.
+
+        An empty jenv file is created for each environment name in envs.
+        The "environments" subdir of the Juju home is provided in the context
+        block.
+        """
+        home = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, home)
+        envs_dir = os.path.join(home, 'environments')
+        os.mkdir(envs_dir)
+        for env in envs:
+            jenv = os.path.join(envs_dir, env + '.jenv')
+            open(jenv, 'a').close()
+        with mock.patch('quickstart.settings.JUJU_HOME', home):
+            yield envs_dir
+
+    def test_get(self):
+        # The environment info is returned correctly.
+        output = json.dumps({
+            'user': 'who',
+            'password': 'Secret!',
+            'environ-uuid': 'env-uuid',
+            'state-servers': ['localhost:17070', '10.0.3.1:17070'],
+        })
+        with self.patch_call(0, output, '') as mock_call:
+            info = self.info.get('ec2')
+        mock_call.assert_called_once_with(
+            self.juju_command, 'api-info', '-e', 'ec2', '--password',
+            '--format', u'json')
+        expected_info = {
+            'name': 'ec2',
+            'user': 'who',
+            'password': 'Secret!',
+            'uuid': 'env-uuid',
+            'state-servers': ['localhost:17070', '10.0.3.1:17070'],
+        }
+        self.assertEqual(expected_info, info)
+
+    def test_get_error(self):
+        # An empty dict is returned if the environment info cannot be
+        # retrieved.
+        expected_message = 'unable to get API info for ec2: bad wolf'
+        with self.patch_call(1, '', 'bad wolf'):
+            with helpers.assert_logs([expected_message], level='debug'):
+                info = self.info.get('ec2')
+        self.assertEqual({}, info)
+
+    def test_all(self):
+        # The active environments database is properly returned.
+        output1 = '\n'.join(['local', 'ec2'])
+        output2 = json.dumps({
+            'user': 'local-user',
+            'password': 'pswd1',
+            'environ-uuid': 'local-uuid',
+            'state-servers': ['localhost:17070', '10.0.3.1:17070'],
+        })
+        output3 = json.dumps({
+            'user': 'ec2-user',
+            'password': 'pswd2',
+            'environ-uuid': 'ec2-uuid',
+            'state-servers': ['1.2.3.4:17070'],
+        })
+        side_effect = [
+            # First call to retrieve the list of environments.
+            (0, output1, ''),
+            # Second call to retrieve info on the local environment.
+            (0, output2, ''),
+            # Third call to retrieve info on the ec2 environment.
+            (0, output3, ''),
+        ]
+        with self.patch_multiple_calls(side_effect) as mock_call:
+            db = self.info.all()
+        self.assertEqual(3, mock_call.call_count)
+        mock_call.assert_has_calls([
+            mock.call(self.juju_command, 'system', 'list'),
+            mock.call(self.juju_command, 'api-info', '-e', 'local',
+                      '--password', '--format', u'json'),
+            mock.call(self.juju_command, 'api-info', '-e', 'ec2', '--password',
+                      '--format', u'json'),
+        ])
+        expected_db = {'environments': {
+            'ec2': {
+                'name': 'ec2',
+                'user': 'ec2-user',
+                'password': 'pswd2',
+                'uuid': 'ec2-uuid',
+                'state-servers': ['1.2.3.4:17070'],
+            },
+            'local': {
+                'name': 'local',
+                'user': 'local-user',
+                'password': 'pswd1',
+                'uuid': 'local-uuid',
+                'state-servers': ['localhost:17070', '10.0.3.1:17070'],
+            },
+        }}
+        self.assertEqual(expected_db, db)
+
+    def test_all_empty(self):
+        # An empty active environments database is returned when there are no
+        # active environments.
+        with self.patch_call(0, '', '') as mock_call:
+            db = self.info.all()
+        mock_call.assert_called_once_with(self.juju_command, 'system', 'list')
+        self.assertEqual({'environments': {}}, db)
+
+    def test_all_legacy(self):
+        # Active environments are detected even when using an old version of
+        # Juju not supporting controllers.
+        output1 = json.dumps({
+            'user': 'ec2-user',
+            'password': 'pswd2',
+            'environ-uuid': 'ec2-uuid',
+            'state-servers': ['1.2.3.4:17070'],
+        })
+        output2 = json.dumps({
+            'user': 'local-user',
+            'password': 'pswd1',
+            'environ-uuid': 'local-uuid',
+            'state-servers': ['localhost:17070', '10.0.3.1:17070'],
+        })
+        side_effect = [
+            # First call to retrieve the list of environments.
+            (1, '', 'not implemented'),
+            # Second call to retrieve info on the local environment.
+            (0, output1, ''),
+            # Third call to retrieve info on the ec2 environment.
+            (0, output2, ''),
+        ]
+        with self.make_juju_home(envs=('local', 'ec2')):
+            with self.patch_multiple_calls(side_effect) as mock_call:
+                db = self.info.all()
+        self.assertEqual(3, mock_call.call_count)
+        mock_call.assert_has_calls([
+            mock.call(self.juju_command, 'system', 'list'),
+            mock.call(self.juju_command, 'api-info', '-e', 'ec2', '--password',
+                      '--format', u'json'),
+            mock.call(self.juju_command, 'api-info', '-e', 'local',
+                      '--password', '--format', u'json'),
+        ])
+        expected_db = {'environments': {
+            'ec2': {
+                'name': 'ec2',
+                'user': 'ec2-user',
+                'password': 'pswd2',
+                'uuid': 'ec2-uuid',
+                'state-servers': ['1.2.3.4:17070'],
+            },
+            'local': {
+                'name': 'local',
+                'user': 'local-user',
+                'password': 'pswd1',
+                'uuid': 'local-uuid',
+                'state-servers': ['localhost:17070', '10.0.3.1:17070'],
+            },
+        }}
+        self.assertEqual(expected_db, db)
+
+    def test_all_legacy_empty(self):
+        # An empty active environments database is returned when there are no
+        # active environments and an old version of Juju is in use.
+        with self.make_juju_home() as envs_dir:
+            # Directories and non-jenv files are ignored.
+            os.mkdir(os.path.join(envs_dir, 'dir'))
+            open(os.path.join(envs_dir, 'ec2.ext'), 'a').close()
+            with self.patch_call(2, '', 'not implemented'):
+                db = self.info.all()
+        self.assertEqual({'environments': {}}, db)
+
+    def test_all_legacy_no_juju_home(self):
+        # An empty active environments database is returned when the Juju home
+        # does not exist and an old version of Juju is in use.
+        with self.make_juju_home() as envs_dir:
+            # Remove the environments directory.
+            os.rmdir(envs_dir)
+            with self.patch_call(2, '', 'not implemented'):
+                db = self.info.all()
+        self.assertEqual({'environments': {}}, db)
+
+
+class TestGetEnvDetails(unittest.TestCase):
+
+    def test_details(self):
+        # The environment details are properly returned.
+        env_data = {
+            'name': 'lxc',
+            'user': 'who',
+            'password': 'pswd',
+            'uuid': 'env-uuid',
+            'state-servers': ('1.2.3.4:17060', 'localhost:17070'),
+        }
+        expected_details = [
+            ('name', 'lxc'),
+            ('user', 'who'),
+            ('uuid', 'env-uuid'),
+            ('state servers', '1.2.3.4:17060, localhost:17070'),
+        ]
+        details = apiinfo.get_env_details(env_data)
+        self.assertEqual(expected_details, details)

=== modified file 'quickstart/tests/models/test_bundles.py'
--- quickstart/tests/models/test_bundles.py	2015-08-11 09:42:32 +0000
+++ quickstart/tests/models/test_bundles.py	2015-11-05 10:58:41 +0000
@@ -80,22 +80,22 @@
              'method': 'addCharm',
              'args': ['cs:vivid/mysql-47'],
              'requires': []},
-            {'id': 'addService-1',
+            {'id': 'deploy-1',
              'method': 'deploy',
-             'args': ['cs:vivid/mysql-47', 'mysql', {}],
+             'args': ['$addCharm-0', 'mysql', {}, ''],
              'requires': ['addCharm-0']},
             {'id': 'addCharm-2',
              'method': 'addCharm',
              'args': ['cs:trusty/wordpress-42'],
              'requires': []},
-            {'id': 'addService-3',
+            {'id': 'deploy-3',
              'method': 'deploy',
-             'args': ['cs:trusty/wordpress-42', 'wordpress', {}],
+             'args': ['$addCharm-2', 'wordpress', {}, ''],
              'requires': ['addCharm-2']},
             {'id': 'addUnit-4',
              'method': 'addUnit',
-             'args': ['$addService-3', 1, None],
-             'requires': ['addService-3']},
+             'args': ['$deploy-3', None],
+             'requires': ['deploy-3']},
         )
         bundle = helpers.make_ordered_bundle(self.bundle)
         self.assertEqual(expected_changeset, tuple(bundle.get_changeset()))

=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2015-08-12 16:24:35 +0000
+++ quickstart/tests/test_app.py	2015-11-05 10:58:41 +0000
@@ -19,8 +19,6 @@
 from __future__ import unicode_literals
 
 from contextlib import contextmanager
-import json
-import os
 import unittest
 
 from jujubundlelib import references
@@ -325,8 +323,8 @@
 
 class TestCheckJujuSupported(ProgramExitTestsMixin, unittest.TestCase):
 
-    supported_versions = [(1, 18, 1), (1, 19, 0), (1, 42, 47), (2, 0, 0)]
-    unsupported_versions = [(1, 18, 0), (1, 17, 42), (1, 0, 0), (0, 20, 47)]
+    supported_versions = [(1, 22, 1), (1, 22, 2), (1, 42, 47), (2, 0, 0)]
+    unsupported_versions = [(1, 22, 0), (1, 17, 42), (1, 0, 0), (0, 20, 47)]
 
     def test_supported(self):
         # No exceptions are raised if the Juju version is supported.
@@ -479,57 +477,43 @@
         self.assertTrue(mock_create_keys.called)
 
 
-class TestCheckBootstrapped(helpers.JenvFileTestsMixin, unittest.TestCase):
-
-    def test_no_jenv_file(self):
-        # A None API address is returned if the jenv file is not present.
-        with self.make_jenv('ec2', ''):
-            with helpers.assert_logs([], level='warn'):
-                api_address = app.check_bootstrapped('hp')
-        self.assertIsNone(api_address)
-
-    def test_invalid_jenv_file(self):
-        # A None API address is returned if the list of API addresses cannot be
-        # retrieved from the jenv file.
-        with self.make_jenv('ec2', '') as path:
-            logs = [
-                'cannot retrieve the Juju API address: '
-                'cannot read {}: invalid YAML contents: '
-                'state-servers key not found in the root section'.format(path)
-            ]
-            with helpers.assert_logs(logs, level='warn'):
-                api_address = app.check_bootstrapped('ec2')
+class TestGetApiAddress(unittest.TestCase):
+
+    def test_no_env_info(self):
+        # A None API address is returned if no environment info is provided.
+        env_info = {}
+        with helpers.assert_logs([], level='warn'):
+            api_address = app.get_api_address(env_info)
         self.assertIsNone(api_address)
 
     def test_no_api_addresses(self):
         # A None API address is returned if the list of API addresses is empty.
-        jenv_data = {'state-servers': []}
-        logs = ['cannot retrieve the Juju API address: no addresses found']
-        with self.make_jenv('local', yaml.safe_dump(jenv_data)):
-            with helpers.assert_logs(logs, level='warn'):
-                api_address = app.check_bootstrapped('local')
+        env_info = {'state-servers': []}
+        logs = ['cannot retrieve the API address: no addresses found']
+        with helpers.assert_logs(logs, level='warn'):
+            api_address = app.get_api_address(env_info)
         self.assertIsNone(api_address)
 
     def test_api_address_not_listening(self):
         # A None API address is returned if there is no reachable API address.
+        env_info = {'state-servers': ['localhost:17070', '10.0.3.1:17070']}
         logs = [
-            'cannot retrieve the Juju API address: '
+            'cannot retrieve the API address: '
             'cannot connect to any of the following addresses: '
             'localhost:17070, 10.0.3.1:17070'
         ]
-        with self.make_jenv('local', yaml.safe_dump(self.jenv_data)):
-            with helpers.assert_logs(logs, level='warn'):
-                with helpers.patch_socket_create_connection('bad wolf'):
-                    api_address = app.check_bootstrapped('local')
+        with helpers.assert_logs(logs, level='warn'):
+            with helpers.patch_socket_create_connection('bad wolf'):
+                api_address = app.get_api_address(env_info)
         self.assertIsNone(api_address)
 
     def test_bootstrapped(self):
         # The first listening API address is returned if the environment is
         # already bootstrapped.
-        with self.make_jenv('hp', yaml.safe_dump(self.jenv_data)):
-            with helpers.assert_logs([], level='warn'):
-                with helpers.patch_socket_create_connection():
-                    api_address = app.check_bootstrapped('hp')
+        env_info = {'state-servers': ['localhost:17070', '10.0.3.1:17070']}
+        with helpers.assert_logs([], level='warn'):
+            with helpers.patch_socket_create_connection():
+                api_address = app.get_api_address(env_info)
         # The first API address is returned.
         self.assertEqual('localhost:17070', api_address)
 
@@ -725,82 +709,6 @@
         mock_call.assert_has_calls(expected_calls)
 
 
-class TestGetEnvUuidOrNone(
-        helpers.JenvFileTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
-
-    def test_success(self):
-        # The environment UUID is successfully retrieved.
-        with self.make_jenv('ec2', yaml.safe_dump(self.jenv_data)):
-            env_uuid = app.get_env_uuid_or_none('ec2')
-        self.assertEqual('__unique_identifier__', env_uuid)
-
-    def test_no_uuid(self):
-        # None is returned if the environment UUID is not found.
-        data = {'user': 'jean-luc', 'password': 'Secret!'}
-        with self.make_jenv('ec2', yaml.safe_dump(data)):
-            env_uuid = app.get_env_uuid_or_none('ec2')
-        self.assertIsNone(env_uuid)
-
-    def test_error(self):
-        # A ProgramExit is raised if the environment UUID cannot be retrieved.
-        with self.make_jenv('ec2', '') as path:
-            os.remove(path)
-            expected_error = (
-                'cannot retrieve environment unique identifier: unable to '
-                "open file {}: [Errno 2] No such file or directory: '{}'"
-                ''.format(path, path))
-            with self.assert_program_exit(expected_error):
-                app.get_env_uuid_or_none('ec2')
-
-
-class TestGetCredentials(
-        helpers.JenvFileTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
-
-    def test_success(self):
-        # The user name and password are successfully retrieved.
-        with self.make_jenv('ec2', yaml.safe_dump(self.jenv_data)):
-            username, password = app.get_credentials('ec2')
-        self.assertEqual('admin', username)
-        self.assertEqual('Secret!', password)
-
-    def test_error(self):
-        # A ProgramExit is raised if the credentials cannot be retrieved.
-        with self.make_jenv('ec2', '') as path:
-            expected_error = (
-                'cannot retrieve environment credentials: cannot parse {}: '
-                'cannot retrieve the password: invalid YAML contents: '
-                'bootstrap-config key not found in the root section'
-                ''.format(path))
-            with self.assert_program_exit(expected_error):
-                app.get_credentials('ec2')
-
-
-class TestGetApiAddress(
-        helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
-
-    env_name = 'ec2'
-    juju_command = settings.JUJU_CMD_PATHS['default']
-
-    def test_success(self):
-        # The API address is correctly returned.
-        api_addresses = json.dumps(['api.example.com:17070', 'not-today'])
-        with self.patch_call(retcode=0, output=api_addresses) as mock_call:
-            api_address = app.get_api_address(self.env_name, self.juju_command)
-        self.assertEqual('api.example.com:17070', api_address)
-        mock_call.assert_called_once_with(
-            self.juju_command, 'api-endpoints', '-e', self.env_name,
-            '--format', 'json')
-
-    def test_failure(self):
-        # A ProgramExit is raised if an error occurs retrieving the address.
-        with self.patch_call(retcode=1, error='bad wolf') as mock_call:
-            with self.assert_program_exit('bad wolf'):
-                app.get_api_address(self.env_name, self.juju_command)
-        mock_call.assert_called_once_with(
-            self.juju_command, 'api-endpoints', '-e', self.env_name,
-            '--format', 'json')
-
-
 class TestConnect(ProgramExitTestsMixin, unittest.TestCase):
 
     username = 'MyUser'

=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2015-05-29 15:03:27 +0000
+++ quickstart/tests/test_manage.py	2015-11-05 10:58:41 +0000
@@ -40,9 +40,9 @@
     views,
 )
 from quickstart.models import (
+    apiinfo,
     bundles,
     envs,
-    jenv,
 )
 from quickstart.tests import helpers
 
@@ -229,14 +229,14 @@
         self.env_type_db = envs.get_env_type_db()
         self.env_file = self.make_env_file()
         self.env_db = envs.load(self.env_file)
-        self.jenv_db = helpers.make_jenv_db()
+        self.active_db = helpers.make_active_db()
 
     @contextmanager
-    def patch_interactive_mode(self, env_db, jenv_db, return_value):
+    def patch_interactive_mode(self, env_db, active_db, return_value):
         """Patch the quickstart.cli.views.show function.
 
         Ensure the interactive mode is started by the code in the context block
-        passing the given env_db and jenv_db.
+        passing the given env_db and active_db.
         Make the view return the given return_value.
         """
         create_save_callable_path = 'quickstart.manage._create_save_callable'
@@ -248,9 +248,8 @@
         expected_params = params.Params(
             env_type_db=self.env_type_db,
             env_db=env_db,
-            jenv_db=jenv_db,
+            active_db=active_db,
             save_callable=mock_save_callable(),
-            remove_jenv_callable=jenv.remove,
         )
         mock_show.assert_called_once_with(views.env_index, expected_params)
 
@@ -259,9 +258,9 @@
         # which case the function returns the corresponding env_data.
         env_data = envs.get_env_data(self.env_db, 'aws')
         with self.patch_interactive_mode(
-                self.env_db, self.jenv_db, [self.env_db, env_data]):
+                self.env_db, self.active_db, [self.env_db, env_data]):
             obtained_env_data = manage._start_interactive_session(
-                self.parser, self.env_type_db, self.env_db, self.jenv_db,
+                self.parser, self.env_type_db, self.env_db, self.active_db,
                 self.env_file)
         self.assertEqual(env_data, obtained_env_data)
 
@@ -272,9 +271,9 @@
         env_data = envs.get_env_data(self.env_db, 'aws')
         new_env_db = helpers.make_env_db()
         with self.patch_interactive_mode(
-                self.env_db, self.jenv_db, [new_env_db, env_data]):
+                self.env_db, self.active_db, [new_env_db, env_data]):
             manage._start_interactive_session(
-                self.parser, self.env_type_db, self.env_db, self.jenv_db,
+                self.parser, self.env_type_db, self.env_db, self.active_db,
                 self.env_file)
         mock_print.assert_called_once_with(
             'changes to the environments file have been saved')
@@ -284,9 +283,9 @@
         # If the user explicitly quits the interactive mode, the program exits
         # without proceeding with the environment bootstrapping.
         with self.patch_interactive_mode(
-                self.env_db, self.jenv_db, [self.env_db, None]):
+                self.env_db, self.active_db, [self.env_db, None]):
             manage._start_interactive_session(
-                self.parser, self.env_type_db, self.env_db, self.jenv_db,
+                self.parser, self.env_type_db, self.env_db, self.active_db,
                 self.env_file)
         mock_exit.assert_called_once_with('quitting')
 
@@ -298,28 +297,28 @@
         self.parser = mock.Mock()
         self.env_type_db = envs.get_env_type_db()
         self.env_db = helpers.make_env_db()
-        self.jenv_db = helpers.make_jenv_db()
+        self.active_db = helpers.make_active_db()
 
     def test_resulting_env_data(self):
         # The env_data is correctly validated and returned.
         expected_env_data = envs.get_env_data(self.env_db, 'lxc')
         env_data = manage._retrieve_env_data(
-            self.parser, self.env_type_db, self.env_db, self.jenv_db, 'lxc')
+            self.parser, self.env_type_db, self.env_db, self.active_db, 'lxc')
         self.assertEqual(expected_env_data, env_data)
 
     def test_jenv_data(self):
         # The env_data is correctly retrieved from the jenv database.
-        expected_env_data = envs.get_env_data(self.jenv_db, 'test-jenv')
+        expected_env_data = envs.get_env_data(self.active_db, 'test-env')
         env_data = manage._retrieve_env_data(
-            self.parser, self.env_type_db, self.env_db, self.jenv_db,
-            'test-jenv')
+            self.parser, self.env_type_db, self.env_db, self.active_db,
+            'test-env')
         self.assertEqual(expected_env_data, env_data)
 
     def test_error_environment_not_found(self):
         # A parser error is invoked if the provided environment is not included
         # in the environments database.
         manage._retrieve_env_data(
-            self.parser, self.env_type_db, self.env_db, self.jenv_db,
+            self.parser, self.env_type_db, self.env_db, self.active_db,
             'no-such')
         self.parser.error.assert_called_once_with(
             'environment no-such not found')
@@ -327,7 +326,7 @@
     def test_error_environment_not_valid(self):
         # A parser error is invoked if the selected environment is not valid.
         manage._retrieve_env_data(
-            self.parser, self.env_type_db, self.env_db, self.jenv_db,
+            self.parser, self.env_type_db, self.env_db, self.active_db,
             'local-with-errors')
         self.parser.error.assert_called_once_with(
             'cannot use the local-with-errors environment:\n'
@@ -367,14 +366,16 @@
 class TestValidatePlatform(unittest.TestCase):
 
     def setUp(self):
-        # Set up a parser.
+        # Set up options and a parser.
+        self.options = argparse.Namespace()
         self.parser = mock.Mock()
 
     def test_platform_validation_fails(self):
         # If the platform validation fails a parser error is given.
         path = 'quickstart.manage.platform_support.validate_platform'
         with mock.patch(path, side_effect=ValueError('Bad platform, yo')):
-            manage._validate_platform(settings.LINUX_RPM, self.parser)
+            manage._validate_platform(
+                settings.LINUX_RPM, self.options, self.parser)
         self.parser.error.assert_called_once_with(
             'Bad platform, yo')
 
@@ -382,8 +383,13 @@
         # If the platform validation passes it returns None.
         path = 'quickstart.platform_support.validate_platform'
         with mock.patch(path, side_effect=None):
-            result = manage._validate_platform(settings.LINUX_RPM, self.parser)
+            with mock.patch('os.environ', {'JUJU': '/tmp/juju'}):
+                result = manage._validate_platform(
+                    settings.LINUX_RPM, self.options, self.parser)
         self.assertIsNone(result)
+        self.assertEqual('/tmp/juju', self.options.juju_command)
+        self.assertEqual(settings.LINUX_RPM, self.options.platform)
+        self.assertIsInstance(self.options.info, apiinfo.Info)
 
 
 class TestValidatePort(unittest.TestCase):
@@ -409,9 +415,7 @@
             'invalid Juju GUI port: not in range 1-65535')
 
 
-class TestSetupEnv(
-        helpers.EnvFileTestsMixin, helpers.JenvFileTestsMixin,
-        unittest.TestCase):
+class TestSetupEnv(helpers.EnvFileTestsMixin, unittest.TestCase):
 
     def setUp(self):
         self.parser = mock.Mock()
@@ -422,6 +426,13 @@
         return mock.Mock(
             env_file=env_file,
             env_name=env_name,
+            info=helpers.FakeApiInfo([{
+                'name': 'ec2',
+                'user': 'the-doctor',
+                'password': 'in-the-tardis',
+                'uuid': 'who',
+                'state-servers': ['1.2.3.4:17070'],
+            }]),
             interactive=interactive,
             platform=platform,
         )
@@ -514,17 +525,16 @@
         # Simulate the user did not make any changes to the env_db from the
         # interactive session.
         env_db = yaml.load(self.valid_contents)
+        active_db = options.info.all()
         # Simulate the aws environment has been selected and started from the
         # interactive session.
         env_data = envs.get_env_data(env_db, 'aws')
         get_env_type_db_path = 'quickstart.models.envs.get_env_type_db'
         with mock.patch(get_env_type_db_path) as mock_get_env_type_db:
-            with self.make_jenv('ec2', yaml.safe_dump(self.jenv_data)):
-                jenv_db = jenv.get_env_db()
-                with self.patch_interactive_mode(env_data) as mock_interactive:
-                    manage._setup_env(options, self.parser)
+            with self.patch_interactive_mode(env_data) as mock_interactive:
+                manage._setup_env(options, self.parser)
         mock_interactive.assert_called_once_with(
-            self.parser, mock_get_env_type_db(), env_db, jenv_db, env_file)
+            self.parser, mock_get_env_type_db(), env_db, active_db, env_file)
         # The options is updated with data from the selected environment.
         self.assertEqual(env_file, options.env_file)
         self.assertEqual('aws', options.env_name)
@@ -688,7 +698,13 @@
 @mock.patch('__builtin__.print', mock.Mock())
 class TestRun(helpers.BundleFileTestsMixin, unittest.TestCase):
 
-    juju_command = '/sbin/juju'
+    env_info = {
+        'name': 'aws',
+        'user': 'MyUser',
+        'password': 'Secret!',
+        'uuid': 'env-uuid',
+        'state-servers': ['1.2.3.4:17070', 'localhost:1234'],
+    }
 
     def make_options(self, **kwargs):
         """Set up the options to be passed to the run function."""
@@ -700,6 +716,8 @@
             'env_name': 'aws',
             'env_type': 'ec2',
             'gui_source': None,
+            'info': helpers.FakeApiInfo([self.env_info]),
+            'juju_command': '/sbin/juju',
             'open_browser': True,
             'port': None,
             'uncommitted': False,
@@ -724,18 +742,12 @@
             'check_juju_supported': None,
             # Ensure the SSH keys are properly configured.
             'ensure_ssh_keys': None,
-            # The environment is not already bootstrapped.
-            'check_bootstrapped': None,
+            # The environment is not already bootstrapped: the
+            # "app.get_api_address" call is handled below.
             # This is also confirmed by the bootstrap function.
             'bootstrap': False,
             # Status is then called, returning the bootstrap node series.
             'status': 'trusty',
-            # The API address must be retrieved (the environment is not ready).
-            'get_api_address': '1.2.3.4:17070',
-            # Retrieve the environment unique identifier.
-            'get_env_uuid_or_none': 'env-uuid',
-            # Retrieve the environment credentials.
-            'get_credentials': ('MyUser', 'Secret!'),
             # Connect to the Juju Environment API endpoint.
             'connect': env,
             # The environment is then checked.
@@ -760,38 +772,38 @@
         defaults.update(kwargs)
         for attr, return_value in defaults.items():
             getattr(mock_app, attr).return_value = return_value
+        # The "app.get_api_address" function is called twice.
+        mock_app.get_api_address.side_effect = [
+            None, self.env_info['state-servers'][0]]
         return env
 
-    def patch_get_juju_command(self):
-        """Patch the platform_support.get_juju_command function."""
-        path = 'quickstart.manage.platform_support.get_juju_command'
-        return mock.patch(path, return_value=(self.juju_command, False))
-
     def test_run(self, mock_app, mock_open):
         # The application runs correctly if no bundle is provided.
         env = self.configure_app(mock_app)
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         # Ensure the functions have been used correctly.
         mock_app.ensure_dependencies.assert_called_once_with(
-            options.distro_only, options.platform, self.juju_command)
+            options.distro_only, options.platform, options.juju_command)
         mock_app.check_juju_supported.assert_called_once_with((1, 22, 0))
         mock_app.ensure_ssh_keys.assert_called_once_with()
-        mock_app.check_bootstrapped.assert_called_once_with(options.env_name)
+        # The "app.get_api_address" function has been called twice: the first
+        # time to check if the environment is already bootstrapped, the second
+        # time after the environment has been effectively bootstrapped.
+        self.assertEqual(2, mock_app.get_api_address.call_count)
+        mock_app.get_api_address.assert_has_calls([
+            mock.call(self.env_info),
+            mock.call(self.env_info),
+        ])
         mock_app.bootstrap.assert_called_once_with(
-            options.env_name, self.juju_command,
+            options.env_name, options.juju_command,
             debug=options.debug,
             upload_tools=options.upload_tools,
             upload_series=options.upload_series,
             constraints=options.constraints)
         mock_app.status.assert_called_once_with(
-            options.env_name, self.juju_command)
-        mock_app.get_api_address.assert_called_once_with(
-            options.env_name, self.juju_command)
-        mock_app.get_env_uuid_or_none.assert_called_once_with(options.env_name)
-        mock_app.get_credentials.assert_called_once_with(options.env_name)
+            options.env_name, options.juju_command)
         mock_app.connect.assert_has_calls([
             mock.call(
                 'wss://1.2.3.4:17070/environment/env-uuid/api',
@@ -823,8 +835,7 @@
         self.configure_app(mock_app, ensure_dependencies=(1, 19, 0))
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         mock_app.connect.assert_has_calls([
             mock.call('wss://1.2.3.4:17070', 'MyUser', 'Secret!'),
             mock.call().close(),
@@ -844,8 +855,7 @@
         ))
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         mock_app.connect.assert_has_calls([
             mock.call(
                 'wss://1.2.3.4:17070/environment/env-uuid/api',
@@ -863,8 +873,7 @@
             mock_app, get_service_config={'port': 8080, 'secure': True})
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         mock_app.connect.assert_has_calls([
             mock.call(
                 'wss://1.2.3.4:17070/environment/env-uuid/api',
@@ -887,8 +896,7 @@
             mock_app, get_service_config={'port': 443, 'secure': False})
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         mock_app.connect.assert_has_calls([
             mock.call(
                 'wss://1.2.3.4:17070/environment/env-uuid/api',
@@ -906,16 +914,18 @@
 
     def test_already_bootstrapped(self, mock_app, mock_open):
         # The application correctly reuses an already bootstrapped environment.
-        env = self.configure_app(mock_app, check_bootstrapped='example.com')
+        env = self.configure_app(mock_app)
+        mock_app.get_api_address.side_effect = ['example.com']
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         # The environment type is retrieved from the jenv.
         mock_app.get_env_type.assert_called_once_with(env)
-        # No reason to call bootstrap or get_api_address functions.
+        # No reason to call bootstrap.
         self.assertFalse(mock_app.bootstrap.called)
-        self.assertFalse(mock_app.get_api_address.called)
+        # The API address is only retrieved once at the beginning of the
+        # program execution.
+        mock_app.get_api_address.assert_called_once_with(self.env_info)
 
     def test_already_bootstrapped_race(self, mock_app, mock_open):
         # The application correctly reuses an already bootstrapped environment.
@@ -924,19 +934,16 @@
         env = self.configure_app(mock_app, bootstrap=True)
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         # The bootstrap and get_api_address functions are still called, but
         # this time also get_env_type is required.
-        # The environment type is retrieved from the jenv.
         mock_app.bootstrap.assert_called_once_with(
-            options.env_name, self.juju_command,
+            options.env_name, options.juju_command,
             debug=options.debug,
             upload_tools=options.upload_tools,
             upload_series=options.upload_series,
             constraints=options.constraints)
-        mock_app.get_api_address.assert_called_once_with(
-            options.env_name, self.juju_command)
+        self.assertEqual(2, mock_app.get_api_address.call_count)
         mock_app.get_env_type.assert_called_once_with(env)
 
     def test_no_token(self, mock_app, mock_open):
@@ -945,8 +952,7 @@
         env = self.configure_app(mock_app, create_auth_token=None)
         # Run the application.
         options = self.make_options()
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         # Ensure the browser is still open without an auth token.
         mock_app.create_auth_token.assert_called_once_with(env)
         mock_open.assert_called_once_with('https://1.2.3.5')
@@ -956,8 +962,7 @@
         env = self.configure_app(mock_app)
         # Run the application.
         options = self.make_options(gui_source=('juju', 'develop'), port=4242)
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         expected_config = {
             'port': 4242,
             'juju-gui-source': u'https://github.com/juju/juju-gui.git develop',
@@ -974,8 +979,7 @@
         bundle = bundles.Bundle(self.bundle_data, reference=reference)
         # Run the application.
         options = self.make_options(bundle_source=bundle_source, bundle=bundle)
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         # Ensure the bundle is correctly deployed.
         ref = references.Reference.from_string('cs:trusty/juju-gui-42')
         mock_app.deploy_bundle.assert_called_once_with(env, bundle, False, ref)
@@ -989,8 +993,7 @@
         # Run the application.
         options = self.make_options(
             bundle_source=bundle_source, bundle=bundle, uncommitted=True)
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         # Ensure the bundle is correctly deployed.
         ref = references.Reference.from_string('cs:trusty/juju-gui-42')
         mock_app.deploy_bundle.assert_called_once_with(env, bundle, True, ref)
@@ -1003,15 +1006,13 @@
         self.configure_app(mock_app, create_auth_token=None)
         # Run the application.
         options = self.make_options(env_type='local')
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
 
     def test_no_browser(self, mock_app, mock_open):
         # It is possible to avoid opening the GUI in the browser.
         self.configure_app(mock_app, create_auth_token=None)
         # Run the application.
         options = self.make_options(open_browser=False)
-        with self.patch_get_juju_command():
-            manage.run(options)
+        manage.run(options)
         # The browser is not opened.
         self.assertFalse(mock_open.called)

=== modified file 'quickstart/tests/test_platform_support.py'
--- quickstart/tests/test_platform_support.py	2014-08-25 14:45:50 +0000
+++ quickstart/tests/test_platform_support.py	2015-11-05 10:58:41 +0000
@@ -170,13 +170,13 @@
 class TestGetJujuCommand(unittest.TestCase):
 
     def test_getenv_succeeds(self):
+        # The Juju path is taken from the JUJU environment variable.
         expected_command = '/custom/juju'
         with mock.patch('os.environ', {'JUJU': expected_command}):
-            command, customized = platform_support.get_juju_command(None)
+            command = platform_support.get_juju_command(None)
         self.assertEqual(expected_command, command)
-        self.assertTrue(customized)
 
     def test_without_env_var(self):
-        expected = settings.JUJU_CMD_PATHS['default'], False
-        actual = platform_support.get_juju_command('default')
-        self.assertEqual(expected, actual)
+        # The Juju path is declared by quickstart itself.
+        command = platform_support.get_juju_command('default')
+        self.assertEqual(settings.JUJU_CMD_PATHS['default'], command)

=== modified file 'tox.ini'
--- tox.ini	2015-08-11 09:57:18 +0000
+++ tox.ini	2015-11-05 10:58:41 +0000
@@ -71,8 +71,8 @@
     # Dependencies present in ppa:juju/stable.
     # See https://launchpad.net/~juju/+archive/ubuntu/stable.
     websocket-client==0.18.0
-    jujuclient==0.50.1
-    jujubundlelib==0.1.9
+    jujuclient==0.50.3
+    jujubundlelib==0.2.1
     urwid==1.2.1
     # The distribution PyYAML requirement is used in this case.
 
@@ -82,7 +82,7 @@
     # Ubuntu 14.04 (trusty) distro dependencies.
     websocket-client==0.12.0
     jujuclient==0.17.5
-    jujubundlelib==0.1.9
+    jujubundlelib==0.2.0
     PyYAML==3.10
     urwid==1.1.1
 
@@ -92,7 +92,7 @@
     # Ubuntu 15.04 (vivid) distro dependencies.
     websocket-client==0.18.0
     jujuclient==0.18.5
-    jujubundlelib==0.1.9
+    jujubundlelib==0.2.0
     PyYAML==3.11
     urwid==1.2.1
 
@@ -102,7 +102,7 @@
     # Ubuntu 15.10 (wily) distro dependencies.
     websocket-client==0.18.0
     jujuclient==0.50.1
-    jujubundlelib==0.1.9
+    jujubundlelib==0.2.0
     PyYAML==3.11
     urwid==1.2.1