Merge lp:~frankban/juju-quickstart/new-bootstrap-strategy into lp:juju-quickstart

[Francesco Banconi]

New bootstrap strategy.

This is a massive branch: my apologies.
But:
    - a new module has been created (netutils), so there
      are license headers and moreover some existing
      functions (with their tests) have been just moved
      from utils.py and must not be re-reviewed.
      The only new function there is check_listening.
    - most of the code are tests: we reached 700 unit
      tests yay!

This branch changes the way quickstart is run on an
existing environment: instead of always trying to
bootstrap, it looks for the jenv file for the current
environment, and, if present, it retrieves the API URL
from there. As a consequence, quickstart uses Juju
in a less expensive way, and it's also faster when
invoked on a bootstrapped environment.

Split the app.bootstrap function to two new
functions: app.bootstrap and app.status. The intent
is to make them more reusable and more easy to test.

Fix a subtle bug never reported and not easy to hit:
the environment type of an existing environment is
now retrieved from the jenv, rather than relying on
what's stored in the environments.yaml file.

Also reorganized the tests for manage.run: over
time they ended up failing to achieve their goal
of describing how the application is run, and
become not really easy to update and change.
Now this situation should be improved.

The little change to the HACKING file is to make
the rst to render correctly on sublime text.

Tests: `make check`.

QA: run quickstart as usual on local and ec2.
Run quickstart again on an already bootstrapped
environment (local and ec2). You should no longer
see the "bootstrapping environment" message.
Instead, a more correct "reusing the already
bootstrapped..." message is displayed.
Also this should feel quicker, especially on ec2.

Thank you!

https://codereview.appspot.com/172380043/

[Francesco Banconi (frankban)]

Reviewers: mp+241553_code.launchpad.net,

Message:
Please take a look.

Description:
New bootstrap strategy.

This is a massive branch: my apologies.
But:
     - a new module has been created (netutils), so there
       are license headers and moreover some existing
       functions (with their tests) have been just moved
       from utils.py and must not be re-reviewed.
       The only new function there is check_listening.
     - most of the code are tests: we reached 700 unit
       tests yay!

This branch changes the way quickstart is run on an
existing environment: instead of always trying to
bootstrap, it looks for the jenv file for the current
environment, and, if present, it retrieves the API URL
from there. As a consequence, quickstart uses Juju
in a less expensive way, and it's also faster when
invoked on a bootstrapped environment.

Split the app.bootstrap function to two new
functions: app.bootstrap and app.status. The intent
is to make them more reusable and more easy to test.

Fix a subtle bug never reported and not easy to hit:
the environment type of an existing environment is
now retrieved from the jenv, rather than relying on
what's stored in the environments.yaml file.

Also reorganized the tests for manage.run: over
time they ended up failing to achieve their goal
of describing how the application is run, and
become not really easy to update and change.
Now this situation should be improved.

The little change to the HACKING file is to make
the rst to render correctly on sublime text.

Tests: `make check`.

QA: run quickstart as usual on local and ec2.
Run quickstart again on an already bootstrapped
environment (local and ec2). You should no longer
see the "bootstrapping environment" message.
Instead, a more correct "reusing the already
bootstrapped..." message is displayed.
Also this should feel quicker, especially on ec2.

Thank you!

https://code.launchpad.net/~frankban/juju-quickstart/new-bootstrap-strategy/+merge/241553

(do not edit description out of merge proposal)

Please review this at https://codereview.appspot.com/172380043/

Affected files (+761, -511 lines):
   M HACKING.rst
   A [revision details]
   M quickstart/app.py
   M quickstart/manage.py
   A quickstart/netutils.py
   M quickstart/tests/helpers.py
   M quickstart/tests/test_app.py
   M quickstart/tests/test_manage.py
   A quickstart/tests/test_netutils.py
   M quickstart/tests/test_utils.py
   M quickstart/utils.py
   M quickstart/watchers.py

[Brad Crittenden (bac)]

Code LGTM with minor comments. Will QA now.

https://codereview.appspot.com/172380043/diff/1/quickstart/app.py
File quickstart/app.py (right):

https://codereview.appspot.com/172380043/diff/1/quickstart/app.py#newcode245
quickstart/app.py:245: # For this reason, a call to status() is usually
required at this point.
This is no different from the calling perspective than the 'not already
bootstrapped' situation, right?

If so, perhaps that should be noted in the docstring for this function.

https://codereview.appspot.com/172380043/diff/1/quickstart/manage.py
File quickstart/manage.py (right):

https://codereview.appspot.com/172380043/diff/1/quickstart/manage.py#newcode520
quickstart/manage.py:520: already_bootstrapped = app.bootstrap(
What is the scenario for api_url being None but it is already
bootstrapped? Someone deleted the jenv file out from under juju?

https://codereview.appspot.com/172380043/diff/1/quickstart/netutils.py
File quickstart/netutils.py (right):

https://codereview.appspot.com/172380043/diff/1/quickstart/netutils.py#newcode50
quickstart/netutils.py:50: timeout = 3
Make timeout an arg with default = 3?

https://codereview.appspot.com/172380043/

[Richard Harding (rharding)]

LGTM thank you for the updates.

https://codereview.appspot.com/172380043/diff/1/quickstart/app.py
File quickstart/app.py (right):

https://codereview.appspot.com/172380043/diff/1/quickstart/app.py#newcode190
quickstart/app.py:190: candidates = jenv.get_value(env_name,
'state-servers')
do you know how this list gets updated from Juju? In an HA situation
does juju rewrite the jenv file?

https://codereview.appspot.com/172380043/diff/1/quickstart/manage.py
File quickstart/manage.py (right):

https://codereview.appspot.com/172380043/diff/1/quickstart/manage.py#newcode520
quickstart/manage.py:520: already_bootstrapped = app.bootstrap(
On 2014/11/12 14:48:25, bac wrote:
> What is the scenario for api_url being None but it is already
bootstrapped?
> Someone deleted the jenv file out from under juju?

That has happened and there's been bugs/work around the scenario. It's a
good one to watch for.

https://codereview.appspot.com/172380043/

[Brad Crittenden (bac)]

QA ok

https://codereview.appspot.com/172380043/

[Francesco Banconi (frankban)]

Thanks for the reviews, really good stuff!

https://codereview.appspot.com/172380043/diff/1/quickstart/app.py
File quickstart/app.py (right):

https://codereview.appspot.com/172380043/diff/1/quickstart/app.py#newcode190
quickstart/app.py:190: candidates = jenv.get_value(env_name,
'state-servers')
On 2014/11/12 15:30:44, rharding wrote:
> do you know how this list gets updated from Juju? In an HA situation
does juju
> rewrite the jenv file?

I don't know that for sure: it could be the case when you set HA from
the CLI. I would be surprised if the jenv is updated when you will set
HA using the API. In case of stale addresses, we just fall back to the
old bootstrap strategy.

https://codereview.appspot.com/172380043/diff/1/quickstart/app.py#newcode245
quickstart/app.py:245: # For this reason, a call to status() is usually
required at this point.
On 2014/11/12 14:48:25, bac wrote:
> This is no different from the calling perspective than the 'not
already
> bootstrapped' situation, right?

> If so, perhaps that should be noted in the docstring for this
function.

Done.

https://codereview.appspot.com/172380043/diff/1/quickstart/netutils.py
File quickstart/netutils.py (right):

https://codereview.appspot.com/172380043/diff/1/quickstart/netutils.py#newcode50
quickstart/netutils.py:50: timeout = 3
On 2014/11/12 14:48:25, bac wrote:
> Make timeout an arg with default = 3?

Done.

https://codereview.appspot.com/172380043/

[lp:~frankban/juju-quickstart/new-bootstrap-strategy]

111. By Francesco Banconi on 2014-11-12

Changes as per review.

[Francesco Banconi (frankban)]

*** Submitted:

New bootstrap strategy.

This is a massive branch: my apologies.
But:
     - a new module has been created (netutils), so there
       are license headers and moreover some existing
       functions (with their tests) have been just moved
       from utils.py and must not be re-reviewed.
       The only new function there is check_listening.
     - most of the code are tests: we reached 700 unit
       tests yay!

This branch changes the way quickstart is run on an
existing environment: instead of always trying to
bootstrap, it looks for the jenv file for the current
environment, and, if present, it retrieves the API URL
from there. As a consequence, quickstart uses Juju
in a less expensive way, and it's also faster when
invoked on a bootstrapped environment.

Split the app.bootstrap function to two new
functions: app.bootstrap and app.status. The intent
is to make them more reusable and more easy to test.

Fix a subtle bug never reported and not easy to hit:
the environment type of an existing environment is
now retrieved from the jenv, rather than relying on
what's stored in the environments.yaml file.

Also reorganized the tests for manage.run: over
time they ended up failing to achieve their goal
of describing how the application is run, and
become not really easy to update and change.
Now this situation should be improved.

The little change to the HACKING file is to make
the rst to render correctly on sublime text.

Tests: `make check`.

QA: run quickstart as usual on local and ec2.
Run quickstart again on an already bootstrapped
environment (local and ec2). You should no longer
see the "bootstrapping environment" message.
Instead, a more correct "reusing the already
bootstrapped..." message is displayed.
Also this should feel quicker, especially on ec2.

Thank you!

R=bac, rharding
CC=
https://codereview.appspot.com/172380043

https://codereview.appspot.com/172380043/

=== modified file 'HACKING.rst'
--- HACKING.rst	2014-11-11 14:15:47 +0000
+++ HACKING.rst	2014-11-12 16:41:04 +0000
@@ -152,7 +152,8 @@
 
 * Verify an environment that has already been bootstrapped is recogized and
   the GUI is deployed.  This test also shows that a remote bundle is properly
-  deployed::
+  deployed
+::
 
     juju bootstrap -e local
     juju quickstart -e local bundle:mediawiki/single
 
=== modified file 'quickstart/app.py'
--- quickstart/app.py	2014-11-11 13:21:57 +0000
+++ quickstart/app.py	2014-11-12 16:41:04 +0000
@@ -30,6 +30,7 @@
 
 from quickstart import (
     juju,
+    netutils,
     platform_support,
     settings,
     ssh,
@@ -175,28 +176,55 @@
         raise ProgramExit(bytes(err))
 
 
+def check_bootstrapped(env_name):
+    """Check if the environment named env_name is already bootstrapped.
+
+    If so, return the environment API URL to be used to connect to the Juju API
+    server. If not already bootstrapped, or if the API URL cannot be retrieved,
+    return None.
+    """
+    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 URL: {}'.format(err))
+        return None
+    # Look for a reachable API URL.
+    if not candidates:
+        logging.warn('cannot retrieve the Juju API URL: no addresses found')
+        return None
+    for candidate in candidates:
+        error = netutils.check_listening(candidate)
+        if error is None:
+            # Juju API URL found.
+            return 'wss://{}'.format(candidate)
+        logging.debug(error)
+    logging.warn(
+        'cannot retrieve the Juju API URL: cannot connect to any of the '
+        'following addresses: {}'.format(', '.join(candidates)))
+    return None
+
+
 def bootstrap(
         env_name, juju_command, debug=False, upload_tools=False,
         upload_series=None, constraints=None):
     """Bootstrap the Juju environment with the given name.
 
+    Return a flag indicating whether the environment was already bootstrapped.
+
     Do not bootstrap the environment if already bootstrapped.
-
-    Return a tuple (already_bootstrapped, series) in which:
-        - already_bootstrapped indicates whether the environment was already
-          bootstrapped;
-        - series is the bootstrap node Ubuntu series.
-
-    The is_local argument indicates whether the environment is configured to
-    use the local provider. If so, sudo privileges are requested in order to
-    bootstrap the environment.
-
-    If debug is True and the environment not bootstrapped, execute the
-    bootstrap command passing the --debug flag.
+    If the environment is not bootstrapped, execute the bootstrap command with
+    the given juju_command, debug, upload_tools, upload_series and constraints
+    arguments.
+
+    When the function exists the Juju environment is bootstrapped, but we don't
+    know if it is ready yet. For this reason, a call to status() is usually
+    required at that point.
 
     Raise a ProgramExit if any error occurs in the bootstrap process.
     """
-    already_bootstrapped = False
     cmd = [juju_command, 'bootstrap', '-e', env_name]
     if debug:
         cmd.append('--debug')
@@ -207,34 +235,28 @@
     if constraints is not None:
         cmd.extend(['--constraints', constraints])
     retcode, _, error = utils.call(*cmd)
-    if retcode:
-        # XXX frankban 2013-11-13 bug 1252322: the check below is weak. We are
-        # relying on an error message in order to decide if the environment is
-        # already bootstrapped. Other possibilities include checking if the
-        # jenv file is present (in ~/.juju/environments/) and, if so, check the
-        # juju status. Unfortunately this is also prone to errors, because a
-        # jenv file can be there but the environment not really bootstrapped or
-        # functional (e.g. sync-tools was used, or a previous bootstrap failed,
-        # or the user terminated machines from the ec2 panel, etc.). Moreover
-        # jenv files seems to be an internal juju-core detail. Definitely we
-        # need to find a better way, but for now the "asking forgiveness"
-        # approach feels like the best compromise we have. Also note that,
-        # rather than comparing the expected error with the obtained one, we
-        # search in the error in order to support bootstrap --debug.
-        if 'environment is already bootstrapped' not in error:
-            # We exit if the error is not "already bootstrapped".
-            raise ProgramExit(error)
-        # Juju is bootstrapped, but we don't know if it is ready yet. Fall
-        # through to the next block for that check.
-        already_bootstrapped = True
-        print('reusing the already bootstrapped {} environment'.format(
-            env_name))
-    # Call "juju status" multiple times until the bootstrap node is ready.
-    # Exit with an error if the agent is not ready after ten minutes.
-    # Note: when using the local provider, calling "juju status" is very fast,
-    # but e.g. on ec2 the first call (right after "bootstrap") can take
-    # several minutes, and subsequent calls are relatively fast (seconds).
-    print('retrieving the environment status')
+    if not retcode:
+        return False
+    # XXX frankban 2013-11-13 bug 1252322: the check below is weak. We are
+    # relying on an error message in order to decide if the environment is
+    # already bootstrapped.  Also note that, rather than comparing the expected
+    # error with the obtained one, we search in the error in order to support
+    # bootstrap --debug.
+    if 'environment is already bootstrapped' not in error:
+        # We exit if the error is not "already bootstrapped".
+        raise ProgramExit(error)
+    # Juju is already bootstrapped.
+    return True
+
+
+def status(env_name, juju_command):
+    """Call "juju status" multiple times until the bootstrap node is ready.
+
+    Return the bootstrap node series of the Juju environment.
+
+    Raise a ProgramExit if the agent is not ready after ten minutes or if the
+    agent is in an error state.
+    """
     timeout = time.time() + (60*10)
     while time.time() < timeout:
         retcode, output, error = utils.call(
@@ -247,8 +269,7 @@
         except ValueError:
             continue
         if agent_state == 'started':
-            series = utils.get_bootstrap_node_series(output)
-            return already_bootstrapped, series
+            return utils.get_bootstrap_node_series(output)
         # If the agent is in an error state, there is nothing we can do, and
         # it's not useful to keep trying.
         if agent_state == 'error':
@@ -257,6 +278,21 @@
     raise ProgramExit('the state server is not ready:\n{}'.format(details))
 
 
+def get_env_type(env_name):
+    """Return the Juju environment type for the given environment name.
+
+    Since the environment type is retrieved by parsing the jenv file, the
+    environment must be already bootstrapped.
+
+    Raise a ProgramExit if the environment type cannot be retrieved.
+    """
+    try:
+        return jenv.get_value(env_name, 'bootstrap-config', 'type')
+    except ValueError as err:
+        msg = b'cannot retrieve environment type: {}'.format(err)
+        raise ProgramExit(msg)
+
+
 def get_admin_secret(env_name):
     """Return the Juju admin secret for the given environment name.
 
@@ -385,7 +421,7 @@
                 series = settings.JUJU_GUI_SUPPORTED_SERIES[-1]
             try:
                 # Try to get the charm URL from charmworld.
-                charm_url = utils.get_charm_url(series)
+                charm_url = netutils.get_charm_url(series)
             except (IOError, ValueError) as err:
                 # Fall back to the default URL for the current series.
                 msg = 'unable to retrieve the {} charm URL from the API: {}'
 
=== modified file 'quickstart/manage.py'
--- quickstart/manage.py	2014-11-11 11:10:33 +0000
+++ quickstart/manage.py	2014-11-12 16:41:04 +0000
@@ -32,6 +32,7 @@
 import quickstart
 from quickstart import (
     app,
+    netutils,
     packaging,
     platform_support,
     settings,
@@ -110,7 +111,7 @@
     if bundle.startswith('http://') or bundle.startswith('https://'):
         # Load the bundle from a remote URL.
         try:
-            bundle_yaml = utils.urlread(bundle)
+            bundle_yaml = netutils.urlread(bundle)
         except IOError as err:
             return parser.error('unable to open bundle URL: {}'.format(err))
     else:
@@ -504,32 +505,52 @@
     logging.debug('ensuring SSH keys are available')
     app.ensure_ssh_keys()
 
-    print('bootstrapping the {} environment (type: {})'.format(
-        options.env_name, options.env_type))
-    if options.env_type == 'local':
-        # If this is a local environment, notify the user that "sudo" will be
-        # required by Juju to bootstrap the application.
-        print('sudo privileges will be required to bootstrap the environment')
-
-    already_bootstrapped, bootstrap_node_series = app.bootstrap(
-        options.env_name, juju_command,
-        debug=options.debug,
-        upload_tools=options.upload_tools,
-        upload_series=options.upload_series,
-        constraints=options.constraints)
+    # Bootstrap the Juju environment or reuse an already bootstrapped one.
+    already_bootstrapped = True
+    env_type = options.env_type
+    api_url = app.check_bootstrapped(options.env_name)
+    if api_url is None:
+        print('bootstrapping the {} environment (type: {})'.format(
+            options.env_name, env_type))
+        if env_type == 'local':
+            # If this is a local environment, notify the user that "sudo" will
+            # be required by Juju to bootstrap the environment.
+            print('sudo privileges will be required to bootstrap the '
+                  'environment')
+        already_bootstrapped = app.bootstrap(
+            options.env_name, juju_command,
+            debug=options.debug,
+            upload_tools=options.upload_tools,
+            upload_series=options.upload_series,
+            constraints=options.constraints)
+    if already_bootstrapped:
+        # Retrieve the environment type from the jenv file: it may be different
+        # from the one declared on the environments.yaml file.
+        env_type = app.get_env_type(options.env_name)
+        print('reusing the already bootstrapped {} environment '
+              '(type: {})'.format(options.env_name, env_type))
+
+    # 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)
+
+    # If the environment was not already bootstrapped, we need to retrieve
+    # the API address.
+    if api_url is None:
+        print('retrieving the Juju API address')
+        api_url = app.get_api_url(options.env_name, juju_command)
 
     # Retrieve the admin-secret for the current environment.
     admin_secret = app.get_admin_secret(options.env_name)
 
-    print('retrieving the Juju API address')
-    api_url = app.get_api_url(options.env_name, juju_command)
     print('connecting to {}'.format(api_url))
     env = app.connect(api_url, admin_secret)
 
     # Inspect the environment and deploy the charm if required.
     charm_url, machine, service_data, unit_data = app.check_environment(
         env, settings.JUJU_GUI_SERVICE_NAME, options.charm_url,
-        options.env_type, bootstrap_node_series, already_bootstrapped)
+        env_type, bootstrap_node_series, already_bootstrapped)
     unit_name = app.deploy_gui(
         env, settings.JUJU_GUI_SERVICE_NAME, charm_url, machine,
         service_data, unit_data)
 
=== added file 'quickstart/netutils.py'
--- quickstart/netutils.py	1970-01-01 00:00:00 +0000
+++ quickstart/netutils.py	2014-11-12 16:41:04 +0000
@@ -0,0 +1,99 @@
+# 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) 2014 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 network utility functions."""
+
+from __future__ import unicode_literals
+
+import json
+import httplib
+import logging
+import socket
+import urllib2
+
+from quickstart import settings
+
+
+def check_resolvable(hostname):
+    """Check that the hostname can be resolved to a numeric IP address.
+
+    Return an error message if the address cannot be resolved.
+    """
+    try:
+        address = socket.gethostbyname(hostname)
+    except socket.error as err:
+        return bytes(err).decode('utf-8')
+    logging.debug('{} resolved to {}'.format(
+        hostname, address.decode('utf-8')))
+    return None
+
+
+def check_listening(address, timeout=3):
+    """Check that the given address is listening and accepts connections.
+
+    The address must be specified as a "host:port" string.
+    Use the given socket timeout in seconds.
+
+    Return an error message if connecting to the address fails.
+    """
+    try:
+        host, port = address.split(":")
+        sock = socket.create_connection((host, int(port)), timeout)
+    except (socket.error, TypeError, ValueError) as err:
+        return 'cannot connect to {}: {}'.format(
+            address, bytes(err).decode('utf-8'))
+    # Ignore all possible connection close exceptions.
+    try:
+        sock.close()
+    except:
+        pass
+    return None
+
+
+def get_charm_url(series):
+    """Return the charm URL of the latest Juju GUI charm revision.
+
+    Raise an IOError if any problems occur connecting to the API endpoint.
+    Raise a ValueError if the API returns invalid data.
+    """
+    url = settings.CHARMWORLD_API.format(
+        series=series, charm=settings.JUJU_GUI_CHARM_NAME)
+    charm_info = json.loads(urlread(url))
+    charm_url = charm_info.get('charm', {}).get('url')
+    if charm_url is None:
+        raise ValueError(b'unable to find the charm URL')
+    return charm_url
+
+
+def urlread(url):
+    """Open the given URL and return the page contents.
+
+    Raise an IOError if any problems occur.
+    """
+    try:
+        response = urllib2.urlopen(url)
+    except urllib2.URLError as err:
+        raise IOError(err.reason)
+    except (httplib.HTTPException, socket.error, urllib2.HTTPError) as err:
+        raise IOError(bytes(err))
+    contents = response.read()
+    content_type = response.headers['content-type']
+    charset = 'utf-8'
+    if 'charset=' in content_type:
+        sent_charset = content_type.split('charset=')[-1].strip()
+        if sent_charset:
+            charset = sent_charset
+    return contents.decode(charset, 'ignore')
 
=== modified file 'quickstart/tests/helpers.py'
--- quickstart/tests/helpers.py	2014-11-11 16:39:13 +0000
+++ quickstart/tests/helpers.py	2014-11-12 16:41:04 +0000
@@ -21,6 +21,7 @@
 from contextlib import contextmanager
 import os
 import shutil
+import socket
 import tempfile
 
 import mock
@@ -145,6 +146,7 @@
         'bootstrap-config': {
             'admin-secret': 'Secret!',
             'api-port': 17070,
+            'type': 'ec2',
         },
         'life': {'universe': {'everything': 42}},
     }
@@ -231,22 +233,34 @@
 mock_print = mock.patch('__builtin__.print')
 
 
+def patch_socket_create_connection(error=None):
+    """Patch the socket.create_connection function.
+
+    If error is not None, the mock object raises a socket.error with the given
+    message.
+    """
+    mock_create_connection = mock.Mock()
+    if error is not None:
+        mock_create_connection.side_effect = socket.error(error)
+    return mock.patch('socket.create_connection', mock_create_connection)
+
+
 def patch_check_resolvable(error=None):
-    """Patch the utils.check_resolvable function to return the given error.
+    """Patch the netutils.check_resolvable function to return the given error.
 
     This is done so that tests do not try to resolve hostname addresses.
     """
     return mock.patch(
-        'quickstart.utils.check_resolvable',
+        'quickstart.netutils.check_resolvable',
         lambda hostname: error,
     )
 
 
 class UrlReadTestsMixin(object):
-    """Expose a method to mock the quickstart.utils.urlread helper function."""
+    """Helpers to mock the quickstart.netutils.urlread helper function."""
 
     def patch_urlread(self, contents=None, error=False):
-        """Patch the quickstart.utils.urlread helper function.
+        """Patch the quickstart.netutils.urlread helper function.
 
         If contents is not None, urlread() will return the provided contents.
         If error is set to True, an IOError will be simulated.
@@ -256,7 +270,7 @@
             mock_urlread.return_value = contents
         if error:
             mock_urlread.side_effect = IOError('bad wolf')
-        return mock.patch('quickstart.utils.urlread', mock_urlread)
+        return mock.patch('quickstart.netutils.urlread', mock_urlread)
 
 
 class ValueErrorTestsMixin(object):
 
=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2014-11-11 13:21:57 +0000
+++ quickstart/tests/test_app.py	2014-11-12 16:41:04 +0000
@@ -454,141 +454,174 @@
         self.assertTrue(mock_create_keys.called)
 
 
[e-mail]_print
+class TestCheckBootstrapped(helpers.JenvFileTestsMixin, unittest.TestCase):
+
+    def test_no_jenv_file(self):
+        # A None API URL is returned if the jenv file is not present.
+        with self.make_jenv('ec2', ''):
+            with helpers.assert_logs([], level='warn'):
+                api_url = app.check_bootstrapped('hp')
+        self.assertIsNone(api_url)
+
+    def test_invalid_jenv_file(self):
+        # A None API URL 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 URL: '
+                'invalid YAML contents in {}: '
+                'state-servers key not found in the root section'.format(path)
+            ]
+            with helpers.assert_logs(logs, level='warn'):
+                api_url = app.check_bootstrapped('ec2')
+        self.assertIsNone(api_url)
+
+    def test_no_api_addresses(self):
+        # A None API URL is returned if the list of API addresses is empty.
+        jenv_data = {'state-servers': []}
+        logs = ['cannot retrieve the Juju API URL: no addresses found']
+        with self.make_jenv('local', yaml.safe_dump(jenv_data)):
+            with helpers.assert_logs(logs, level='warn'):
+                api_url = app.check_bootstrapped('local')
+        self.assertIsNone(api_url)
+
+    def test_api_address_not_listening(self):
+        # A None API URL is returned if there is no reachable API address.
+        logs = [
+            'cannot retrieve the Juju API URL: '
+            '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_url = app.check_bootstrapped('local')
+        self.assertIsNone(api_url)
+
+    def test_bootstrapped(self):
+        # The first listening API URL 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_url = app.check_bootstrapped('hp')
+        # The first API address is returned.
+        self.assertEqual('wss://localhost:17070', api_url)
+
+
 class TestBootstrap(
         helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
 
-    env_name = 'my-juju-env'
-    status_message = 'retrieving the environment status'
-    juju_command = settings.JUJU_CMD_PATHS['default']
-
-    def make_status_output(self, agent_state, series='hoary'):
+    def test_environment_not_bootstrapped(self):
+        # The environment is successfully bootstrapped and False is returned.
+        with self.patch_call(0) as mock_call:
+            already_bootstrapped = app.bootstrap('ec2', '/usr/bin/juju')
+        self.assertFalse(already_bootstrapped)
+        mock_call.assert_called_once_with(
+            '/usr/bin/juju', 'bootstrap', '-e', 'ec2')
+
+    def test_environment_already_bootstrapped(self):
+        # The function succeeds and returns True if the environment is already
+        # bootstrapped.
+        error = '***environment is already bootstrapped***'
+        with self.patch_call(1, error=error) as mock_call:
+            already_bootstrapped = app.bootstrap('hp', '/bin/juju')
+        self.assertTrue(already_bootstrapped)
+        mock_call.assert_called_once_with('/bin/juju', 'bootstrap', '-e', 'hp')
+
+    def test_bootstrap_failure(self):
+        # A ProgramExit is raised if an error occurs while bootstrapping.
+        with self.patch_call(1, error='bad wolf') as mock_call:
+            with self.assert_program_exit('bad wolf'):
+                app.bootstrap('local', 'juju')
+        mock_call.assert_called_once_with('juju', 'bootstrap', '-e', 'local')
+
+    def test_debug(self):
+        # The environment is bootstrapped in debug mode.
+        with self.patch_call(0) as mock_call:
+            app.bootstrap('ec2', '/usr/bin/juju', debug=True)
+        mock_call.assert_called_once_with(
+            '/usr/bin/juju', 'bootstrap', '-e', 'ec2', '--debug')
+
+    def test_upload_tools(self):
+        # The environment is bootstrapped with local tools
+        with self.patch_call(0) as mock_call:
+            app.bootstrap('local', '/usr/bin/juju', upload_tools=True)
+        mock_call.assert_called_once_with(
+            '/usr/bin/juju', 'bootstrap', '-e', 'local', '--upload-tools')
+
+    def test_upload_series(self):
+        # The environment is bootstrapped with tools for specific series.
+        with self.patch_call(0) as mock_call:
+            app.bootstrap('hp', '/usr/bin/juju', upload_series='trusty,utopic')
+        mock_call.assert_called_once_with(
+            '/usr/bin/juju', 'bootstrap', '-e', 'hp',
+            '--upload-series', 'trusty,utopic')
+
+    def test_constraints(self):
+        # The environment is bootstrapped with the specified constraints.
+        with self.patch_call(0) as mock_call:
+            app.bootstrap('maas', '/usr/bin/juju', constraints='mem=7G')
+        mock_call.assert_called_once_with(
+            '/usr/bin/juju', 'bootstrap', '-e', 'maas',
+            '--constraints', 'mem=7G')
+
+    def test_all_options(self):
+        # The environment is bootstrapped with all the options.
+        with self.patch_call(0) as mock_call:
+            app.bootstrap(
+                'local', '/usr/bin/juju', debug=True, upload_tools=True,
+                upload_series='vivid', constraints='mem=8G')
+        mock_call.assert_called_once_with(
+            '/usr/bin/juju', 'bootstrap', '-e', 'local',
+            '--debug', '--upload-tools', '--upload-series', 'vivid',
+            '--constraints', 'mem=8G')
+
+
+class TestStatus(
+        helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
+
+    def make_status_output(self, agent_state, series='utopic'):
         """Create and return a YAML status output."""
         return yaml.safe_dump({
-            'machines': {'0': {'agent-state': agent_state,
-                               'series': series}},
+            'machines': {
+                '0': {'agent-state': agent_state, 'series': series},
+            },
         })
 
-    def make_status_calls(self, number):
+    def make_status_calls(self, env_name, juju_command, number):
         """Return a list containing the given number of status calls."""
         call = mock.call(
-            self.juju_command, 'status', '-e', self.env_name,
-            '--format', 'yaml')
+            juju_command, 'status', '-e', env_name, '--format', 'yaml')
         return [call for _ in range(number)]
 
-    def make_side_effects(self):
-        """Return the minimum number of side effects for a successful call."""
-        return [
-            (0, '', ''),  # Add a bootstrap call.
-            (0, self.make_status_output('started'), ''),  # Add a status call.
-        ]
-
-    def assert_status_retried(self, side_effects):
+    def assert_status_retried(self, env_name, juju_command, side_effects):
         """Ensure the "juju status" command is retried several times.
 
         Receive the list of side effects the mock status call will return.
         """
-        with self.patch_multiple_calls(side_effects) as mock_call:
-            app.bootstrap(self.env_name, self.juju_command)
-        mock_call.assert_has_calls([
-            mock.call(self.juju_command, 'bootstrap', '-e', self.env_name),
-        ] + self.make_status_calls(5))
-
-    def test_success(self, mock_print):
-        # The environment is successfully bootstrapped.
-        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
-            already_bootstrapped, series = app.bootstrap(
-                self.env_name, self.juju_command)
-        self.assertFalse(already_bootstrapped)
-        self.assertEqual(series, 'hoary')
-        mock_call.assert_has_calls([
-            mock.call(self.juju_command, 'bootstrap', '-e', self.env_name),
-        ] + self.make_status_calls(1))
-        mock_print.assert_called_once_with(self.status_message)
-
-    def test_success_debug(self, mock_print):
-        # The environment is successfully bootstrapped in debug mode.
-        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
-            already_bootstrapped, series = app.bootstrap(
-                self.env_name, self.juju_command, debug=True)
-        self.assertFalse(already_bootstrapped)
-        self.assertEqual(series, 'hoary')
-        mock_call.assert_has_calls([
-            mock.call(
-                self.juju_command, 'bootstrap', '-e', self.env_name,
-                '--debug'),
-        ] + self.make_status_calls(1))
-
-    def test_success_upload_tools(self, mock_print):
-        # The environment is bootstrapped with local tools.
-        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
-            already_bootstrapped, series = app.bootstrap(
-                self.env_name, self.juju_command, upload_tools=True)
-        self.assertFalse(already_bootstrapped)
-        mock_call.assert_has_calls([
-            mock.call(
-                self.juju_command, 'bootstrap', '-e', self.env_name,
-                '--upload-tools'),
-        ] + self.make_status_calls(1))
-
-    def test_success_upload_series(self, mock_print):
-        # The environment is bootstrapped with tools for specific series.
-        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
-            already_bootstrapped, series = app.bootstrap(
-                self.env_name, self.juju_command, upload_series='hoary')
-        self.assertFalse(already_bootstrapped)
-        mock_call.assert_has_calls([
-            mock.call(
-                self.juju_command, 'bootstrap', '-e', self.env_name,
-                '--upload-series', 'hoary'),
-        ] + self.make_status_calls(1))
-
-    def test_success_constraints(self, mock_print):
-        # The environment is bootstrapped with given constraints.
-        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
-            already_bootstrapped, series = app.bootstrap(
-                self.env_name, self.juju_command, constraints='mem=7G')
-        self.assertFalse(already_bootstrapped)
-        mock_call.assert_has_calls([
-            mock.call(
-                self.juju_command, 'bootstrap', '-e', self.env_name,
-                '--constraints', 'mem=7G'),
-        ] + self.make_status_calls(1))
-
-    def test_already_bootstrapped(self, mock_print):
-        # The function succeeds and returns True if the environment is already
-        # bootstrapped.
-        side_effects = [
-            (1, '', '***environment is already bootstrapped**'),
-            (0, self.make_status_output('started', 'precise'), ''),
-        ]
-        with self.patch_multiple_calls(side_effects) as mock_call:
-            already_bootstrapped, series = app.bootstrap(
-                self.env_name, self.juju_command)
-        self.assertTrue(already_bootstrapped)
-        self.assertEqual(series, 'precise')
-        mock_call.assert_has_calls([
-            mock.call(self.juju_command, 'bootstrap', '-e', self.env_name),
-        ] + self.make_status_calls(1))
-        existing_message = 'reusing the already bootstrapped {} environment'
-        mock_print.assert_has_calls([
-            mock.call(existing_message.format(self.env_name)),
-            mock.call(self.status_message),
-        ])
-
-    def test_bootstrap_failure(self, mock_print):
-        # A ProgramExit is raised if an error occurs while bootstrapping.
-        with self.patch_call(retcode=1, error='bad wolf') as mock_call:
-            with self.assert_program_exit('bad wolf'):
-                app.bootstrap(self.env_name, self.juju_command)
-        mock_call.assert_called_once_with(
-            self.juju_command, 'bootstrap', '-e', self.env_name),
-
-    def test_status_retry_error(self, mock_print):
+        count = len(side_effects)
+        with self.patch_multiple_calls(side_effects) as mock_call:
+            app.status(env_name, juju_command)
+        self.assertEqual(count, mock_call.call_count)
+        expected_calls = self.make_status_calls(env_name, juju_command, count)
+        mock_call.assert_has_calls(expected_calls)
+
+    def test_success(self):
+        # The status command is correctly called and the bootstrap node series
+        # returned.
+        output = self.make_status_output('started')
+        with self.patch_call(0, output=output) as mock_call:
+            bootstrap_node_series = app.status('ec2', '/usr/bin/juju')
+        self.assertEqual('utopic', bootstrap_node_series)
+        self.assertEqual(1, mock_call.call_count)
+        expected_calls = self.make_status_calls('ec2', '/usr/bin/juju', 1)
+        mock_call.assert_has_calls(expected_calls)
+
+    def test_status_retry_error(self):
         # Before raising a ProgramExit, the functions tries to call
         # "juju status" multiple times if it exits with an error.
         side_effects = [
-            (0, '', ''),  # Add the bootstrap call.
             # Add four status calls with a non-zero exit code.
             (1, '', 'these'),
             (2, '', 'are'),
@@ -597,29 +630,28 @@
             # Add a final valid status call.
             (0, self.make_status_output('started'), ''),
         ]
-        self.assert_status_retried(side_effects)
+        self.assert_status_retried('local', 'juju', side_effects)
 
-    def test_status_retry_invalid_output(self, mock_print):
+    def test_status_retry_invalid_output(self):
         # Before raising a ProgramExit, the functions tries to call
         # "juju status" multiple times if its output is not well formed or if
         # the agent is not started.
         side_effects = [
-            (0, '', ''),  # Add the bootstrap call.
             (0, '', ''),  # Add the first status call: no output.
             (0, ':', ''),  # Add the second status call: not YAML.
             (0, 'just-a-string', ''),  # Add the third status call: bad YAML.
-            # Add the fourth status call: the agent is still pending.
+            # Add two other status calls: the agent is still pending.
+            (0, self.make_status_output('pending'), ''),
             (0, self.make_status_output('pending'), ''),
             # Add a final valid status call.
             (0, self.make_status_output('started'), ''),
         ]
-        self.assert_status_retried(side_effects)
+        self.assert_status_retried('hp', '/usr/bin/juju', side_effects)
 
-    def test_status_retry_both(self, mock_print):
+    def test_status_retry_both(self):
         # Before raising a ProgramExit, the functions tries to call
         # "juju status" multiple times in any case.
         side_effects = [
-            (0, '', ''),  # Add the bootstrap call.
             (1, '', 'error'),  # Add the first status call: error.
             (2, '', 'another error'),  # Add the second status call: error.
             # Add the third status call: the agent is still pending.
@@ -628,28 +660,23 @@
             # Add a final valid status call.
             (0, self.make_status_output('started'), ''),
         ]
-        self.assert_status_retried(side_effects)
+        self.assert_status_retried('local', '/usr/bin/juju', side_effects)
 
-    def test_agent_error(self, mock_print):
+    def test_agent_error(self):
         # A ProgramExit is raised immediately if the Juju agent in the
         # bootstrap node is in an error state.
-        status_output = self.make_status_output('error')
-        side_effects = [
-            (0, '', ''),  # Add the bootstrap call.
-            (0, status_output, ''),  # Add the status call: agent error.
-        ]
-        expected = 'state server failure:\n{}'.format(status_output)
-        with self.patch_multiple_calls(side_effects) as mock_call:
-            with self.assert_program_exit(expected):
-                app.bootstrap(self.env_name, self.juju_command)
-        mock_call.assert_has_calls([
-            mock.call(self.juju_command, 'bootstrap', '-e', self.env_name),
-        ] + self.make_status_calls(1))
+        output = self.make_status_output('error')
+        expected_error = 'state server failure:\n{}'.format(output)
+        with self.patch_call(0, output=output) as mock_call:
+            with self.assert_program_exit(expected_error):
+                app.status('ec2', '/usr/bin/juju')
+        self.assertEqual(1, mock_call.call_count)
+        expected_calls = self.make_status_calls('ec2', '/usr/bin/juju', 1)
+        mock_call.assert_has_calls(expected_calls)
 
-    def test_status_failure(self, mock_print):
+    def test_status_failure(self):
         # A ProgramExit is raised if "juju status" keeps failing.
         call_side_effects = [
-            (0, '', ''),  # Add the bootstrap call.
             (1, 'output1', 'error1'),  # Add the first status call: retried.
             (1, 'output2', 'error2'),  # Add the second status call: error.
         ]
@@ -660,17 +687,37 @@
             1000,  # Third call after the timeout expiration.
         ]
         mock_time = mock.Mock(side_effect=time_side_effects)
-        expected = 'the state server is not ready:\noutput2error2'
+        expected_error = 'the state server is not ready:\noutput2error2'
         with self.patch_multiple_calls(call_side_effects) as mock_call:
             # Simulate the timeout expired: the first time call is used to
             # calculate the timeout, the second one for the first status check,
             # the third for the second status check, the fourth should fail.
             with mock.patch('time.time', mock_time):
-                with self.assert_program_exit(expected):
-                    app.bootstrap(self.env_name, self.juju_command)
-        mock_call.assert_has_calls([
-            mock.call(self.juju_command, 'bootstrap', '-e', self.env_name),
-        ] + self.make_status_calls(2))
+                with self.assert_program_exit(expected_error):
+                    app.status('local', '/usr/bin/juju')
+        self.assertEqual(2, mock_call.call_count)
+        expected_calls = self.make_status_calls('local', '/usr/bin/juju', 2)
+        mock_call.assert_has_calls(expected_calls)
+
+
+class TestGetEnvType(
+        helpers.JenvFileTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
+
+    def test_success(self):
+        # The environment type is successfully retrieved.
+        with self.make_jenv('ec2', yaml.safe_dump(self.jenv_data)):
+            env_type = app.get_env_type('ec2')
+        self.assertEqual('ec2', env_type)
+
+    def test_error(self):
+        # A ProgramExit is raised if the environment type cannot be retrieved.
+        with self.make_jenv('aws', '') as path:
+            expected_error = (
+                'cannot retrieve environment type: invalid YAML '
+                'contents in {}: bootstrap-config key not found in the root '
+                'section'.format(path))
+            with self.assert_program_exit(expected_error):
+                app.get_env_type('aws')
 
 
 class TestGetAdminSecret(
@@ -850,7 +897,8 @@
         """Patch the get_charm_url helper function."""
         mock_get_charm_url = mock.Mock(
             return_value=return_value, side_effect=side_effect)
-        return mock.patch('quickstart.utils.get_charm_url', mock_get_charm_url)
+        return mock.patch(
+            'quickstart.netutils.get_charm_url', mock_get_charm_url)
 
     def test_environment_just_bootstrapped(self, mock_print):
         # The function correctly retrieves the charm URL and machine, and
 
=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2014-11-11 13:21:57 +0000
+++ quickstart/tests/test_manage.py	2014-11-12 16:41:04 +0000
@@ -38,7 +38,6 @@
 from quickstart.cli import views
 from quickstart.models import envs
 from quickstart.tests import helpers
-from quickstart import app
 
 
 class TestDescriptionAction(unittest.TestCase):
@@ -763,164 +762,177 @@
         options.update(kwargs)
         return mock.Mock(**options)
 
-    def test_no_bundle(self, mock_app, mock_open):
+    def configure_app(self, mock_app, **kwargs):
+        """Configure the given mock_app with the given kwargs.
+
+        Each key/value pair in kwargs represents a mock_app attribute and
+        the associated return value. Those values are used to override
+        defaults.
+
+        Return the mock Juju environment object.
+        """
+        env = mock.Mock()
+        defaults = {
+            # Dependencies are installed.
+            'ensure_dependencies': (1, 18, 0),
+            # Ensure the current Juju version is supported.
+            'check_juju_supported': None,
+            # Ensure the SSH keys are properly configured.
+            'ensure_ssh_keys': None,
+            # The environment is not already bootstrapped.
+            'check_bootstrapped': None,
+            # This is also confirmed by the bootstrap function.
+            'bootstrap': False,
+            # Status is then called, returning the bootstrap node series.
+            'status': 'trusty',
+            # The API URL must be retrieved (the environment was not ready).
+            'get_api_url': 'wss://1.2.3.4:17070',
+            # Retrieve the admin secret.
+            'get_admin_secret': 'Secret!',
+            # Connect to the Juju Environment API endpoint.
+            'connect': env,
+            # The environment is then checked.
+            'check_environment': (
+                'cs:trusty/juju-gui-42',
+                '0',
+                {'Name': 'juju-gui'},
+                {'Name': 'juju-gui/0'}
+            ),
+            # Deploy the Juju GUI charm.
+            'deploy_gui': 'juju-gui/0',
+            # Watch the deployment progress and return the unit address.
+            'watch': '1.2.3.4',
+            # Create the login token for the Juju GUI.
+            'create_auth_token': 'TOKEN',
+        }
+        defaults.update(kwargs)
+        for attr, return_value in defaults.items():
+            getattr(mock_app, attr).return_value = return_value
+        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.
-        mock_app.ensure_dependencies.return_value = (1, 18, 0)
-        # Make mock_app.bootstrap return the already_bootstrapped flag and the
-        # bootstrap node series.
-        mock_app.bootstrap.return_value = (True, 'trusty')
-        # Make mock_app.check_environment return the charm URL, the machine
-        # where to deploy the charm, the service and unit data.
-        service_data = {'Name': 'juju-gui'}
-        unit_data = {'Name': 'juju-gui/0'}
-        mock_app.check_environment.return_value = (
-            'cs:trusty/juju-gui-42', '0', service_data, unit_data)
-        # Make mock_app.get_admin_secret return the admin secret
-        mock_app.get_admin_secret.return_value = 'Secret!'
-        # Make mock_app.watch return the Juju GUI unit address.
-        mock_app.watch.return_value = '1.2.3.4'
-        # Make mock_app.create_auth_token return a fake authentication token.
-        mock_app.create_auth_token.return_value = 'AUTHTOKEN'
+        env = self.configure_app(mock_app)
+        # Run the application.
         options = self.make_options()
-        with mock.patch('quickstart.manage.platform_support.get_juju_command',
-                        side_effect=[(self.juju_command, False)]):
+        with self.patch_get_juju_command():
             manage.run(options)
-        mock_app.ensure_dependencies.assert_called()
-        mock_app.ensure_ssh_keys.assert_called()
+        # Ensure the functions have been used correctly.
+        mock_app.ensure_dependencies.assert_called_once_with(
+            options.distro_only, options.platform, self.juju_command)
+        mock_app.check_juju_supported.assert_called_once_with((1, 18, 0))
+        mock_app.ensure_ssh_keys.assert_called_once_with()
+        mock_app.check_bootstrapped.assert_called_once_with(options.env_name)
         mock_app.bootstrap.assert_called_once_with(
             options.env_name, self.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_url.assert_called_once_with(
             options.env_name, self.juju_command)
+        mock_app.get_admin_secret.assert_called_once_with(options.env_name)
         mock_app.connect.assert_has_calls([
-            mock.call(mock_app.get_api_url(), 'Secret!'),
+            mock.call('wss://1.2.3.4:17070', 'Secret!'),
             mock.call().close(),
             mock.call('wss://1.2.3.4:443/ws', 'Secret!'),
             mock.call().close(),
         ])
         mock_app.check_environment.assert_called_once_with(
-            mock_app.connect(), settings.JUJU_GUI_SERVICE_NAME,
-            options.charm_url, options.env_type, mock_app.bootstrap()[1],
-            mock_app.bootstrap()[0])
+            env, settings.JUJU_GUI_SERVICE_NAME, options.charm_url,
+            options.env_type, 'trusty', False)
         mock_app.deploy_gui.assert_called_once_with(
-            mock_app.connect(), settings.JUJU_GUI_SERVICE_NAME,
-            'cs:trusty/juju-gui-42', '0', service_data, unit_data)
-        mock_app.watch.assert_called_once_with(
-            mock_app.connect(), mock_app.deploy_gui())
-        mock_app.create_auth_token.assert_called_once_with(mock_app.connect())
-        mock_open.assert_called_once_with(
-            'https://{}/?authtoken={}'.format(mock_app.watch(), 'AUTHTOKEN'))
+            env, settings.JUJU_GUI_SERVICE_NAME, 'cs:trusty/juju-gui-42',
+            '0', {'Name': 'juju-gui'}, {'Name': 'juju-gui/0'})
+        mock_app.watch.assert_called_once_with(env, 'juju-gui/0')
+        mock_app.create_auth_token.assert_called_once_with(env)
+        mock_open.assert_called_once_with('https://1.2.3.4/?authtoken=TOKEN')
+        # Ensure some of the app function have not been called.
+        self.assertFalse(mock_app.get_env_type.called)
         self.assertFalse(mock_app.deploy_bundle.called)
 
+    def test_already_bootstrapped(self, mock_app, mock_open):
+        # The application correctly reuses an already bootstrapped environment.
+        self.configure_app(mock_app, check_bootstrapped='wss://example.com')
+        # Run the application.
+        options = self.make_options()
+        with self.patch_get_juju_command():
+            manage.run(options)
+        # The environment type is retrieved from the jenv.
+        mock_app.get_env_type.assert_called_once_with(options.env_name)
+        # No reason to call bootstrap or get_api_url functions.
+        self.assertFalse(mock_app.bootstrap.called)
+        self.assertFalse(mock_app.get_api_url.called)
+
+    def test_already_bootstrapped_race(self, mock_app, mock_open):
+        # The application correctly reuses an already bootstrapped environment.
+        # In this case, the environment seems not bootstrapped at first, but
+        # it ended up being up and running later.
+        self.configure_app(mock_app, bootstrap=True)
+        # Run the application.
+        options = self.make_options()
+        with self.patch_get_juju_command():
+            manage.run(options)
+        # The bootstrap and get_api_url 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,
+            debug=options.debug,
+            upload_tools=options.upload_tools,
+            upload_series=options.upload_series,
+            constraints=options.constraints)
+        mock_app.get_api_url.assert_called_once_with(
+            options.env_name, self.juju_command)
+        mock_app.get_env_type.assert_called_once_with(options.env_name)
+
     def test_no_token(self, mock_app, mock_open):
         # The process continues even if the authentication token cannot be
         # retrieved.
-        mock_app.create_auth_token.return_value = None
-        # Make mock_app.bootstrap return the already_bootstrapped flag and the
-        # bootstrap node series.
-        mock_app.bootstrap.return_value = (True, 'precise')
-        # Make mock_app.check_environment return the charm URL, the machine
-        # where to deploy the charm, the service and unit data.
-        mock_app.check_environment.return_value = (
-            'cs:precise/juju-gui-42', '0', None, None)
+        env = self.configure_app(mock_app, create_auth_token=None)
+        # Run the application.
         options = self.make_options()
-        manage.run(options)
-        mock_app.create_auth_token.assert_called_once_with(mock_app.connect())
-        mock_open.assert_called_once_with(
-            'https://{}'.format(mock_app.watch()))
+        with self.patch_get_juju_command():
+            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.4')
 
     def test_bundle(self, mock_app, mock_open):
         # A bundle is correctly deployed by the application.
+        env = self.configure_app(mock_app, create_auth_token=None)
+        # Run the application.
         options = self.make_options(
             bundle='/my/bundle/file.yaml', bundle_yaml='mybundle: contents',
             bundle_name='mybundle', bundle_services=['service1', 'service2'])
-        # Make mock_app.bootstrap return the already_bootstrapped flag and the
-        # bootstrap node series.
-        mock_app.bootstrap.return_value = (True, 'trusty')
-        # Make mock_app.check_environment return the charm URL, the machine
-        # where to deploy the charm, the service and unit data.
-        mock_app.check_environment.return_value = (
-            'cs:trusty/juju-gui-42', '0', None, None)
-        # Make mock_app.watch return the Juju GUI unit address.
-        mock_app.watch.return_value = 'gui.example.com'
-        manage.run(options)
+        with self.patch_get_juju_command():
+            manage.run(options)
+        # Ensure the bundle is correctly deployed.
         mock_app.deploy_bundle.assert_called_once_with(
-            mock_app.connect(), 'mybundle: contents', 'mybundle', None)
+            env, 'mybundle: contents', 'mybundle', None)
 
-    def test_local_provider_no_sudo(self, mock_app, mock_open):
+    def test_local_provider(self, mock_app, mock_open):
         # The application correctly handles working with local providers with
         # new Juju versions not requiring "sudo" to bootstrap the environment.
-        # Sudo privileges are not required if the Juju version is >= 1.17.2.
+        self.configure_app(mock_app, create_auth_token=None)
+        # Run the application.
         options = self.make_options(env_type='local')
-        versions = [
-            (1, 17, 2), (1, 17, 10), (1, 18, 0), (1, 18, 2), (2, 16, 1)]
-        # Make mock_app.bootstrap return the already_bootstrapped flag and the
-        # bootstrap node series.
-        mock_app.bootstrap.return_value = (True, 'precise')
-        # Make mock_app.check_environment return the charm URL, the machine
-        # where to deploy the charm, the service and unit data.
-        mock_app.check_environment.return_value = (
-            'cs:precise/juju-gui-42', '0', None, None)
-        for version in versions:
-            mock_app.ensure_dependencies.return_value = version
-            with mock.patch(
-                    'quickstart.manage.platform_support.get_juju_command',
-                    side_effect=[(self.juju_command, False)]):
-                manage.run(options)
-            mock_app.bootstrap.assert_called_once_with(
-                options.env_name, self.juju_command,
-                debug=options.debug,
-                upload_tools=options.upload_tools,
-                upload_series=options.upload_series,
-                constraints=options.constraints)
-            mock_app.bootstrap.reset_mock()
+        with self.patch_get_juju_command():
+            manage.run(options)
 
     def test_no_browser(self, mock_app, mock_open):
         # It is possible to avoid opening the GUI in the browser.
-        # Make mock_app.bootstrap return the already_bootstrapped flag and the
-        # bootstrap node series.
-        mock_app.bootstrap.return_value = (True, 'trusty')
-        # Make mock_app.check_environment return the charm URL, the machine
-        # where to deploy the charm, the service and unit data.
-        mock_app.check_environment.return_value = (
-            'cs:trusty/juju-gui-42', '0', None, None)
+        self.configure_app(mock_app, create_auth_token=None)
+        # Run the application.
         options = self.make_options(open_browser=False)
-        manage.run(options)
+        with self.patch_get_juju_command():
+            manage.run(options)
+        # The browser is not opened.
         self.assertFalse(mock_open.called)
-
-    def test_no_admin_secret_found(self, mock_app, mock_open):
-        # If admin-secret cannot be found a ProgramExit is called.
-        mock_app.get_admin_secret.side_effect = app.ProgramExit('bad wolf')
-        # Make mock_app.bootstrap return the already_bootstrapped flag and the
-        # bootstrap node series.
-        mock_app.bootstrap.return_value = (True, 'precise')
-        # Make mock_app.check_environment return the charm URL, the machine
-        # where to deploy the charm, the service and unit data.
-        mock_app.check_environment.return_value = (
-            'cs:precise/juju-gui-42', '0', None, None)
-        options = self.make_options(
-            env_name='local',
-            env_file='environments.yaml')
-        with self.assertRaises(app.ProgramExit) as context:
-            manage.run(options)
-        self.assertEqual('bad wolf', context.exception.message)
-
-    def test_juju_environ_var_set(self, mock_app, mock_open):
-        mock_app.bootstrap.return_value = (True, 'precise')
-        mock_app.check_environment.return_value = (
-            'cs:precise/juju-gui-42', '0', None, None)
-        options = self.make_options(env_type='aws')
-        juju_command = 'some/devel/path/juju'
-        with mock.patch('os.environ', {'JUJU': juju_command}):
-            manage.run(options)
-        mock_app.bootstrap.assert_called_once_with(
-            options.env_name, juju_command,
-            debug=options.debug,
-            upload_tools=options.upload_tools,
-            upload_series=options.upload_series,
-            constraints=options.constraints)
-        mock_app.get_api_url.assert_called_once_with(
-            options.env_name, juju_command)
 
=== added file 'quickstart/tests/test_netutils.py'
--- quickstart/tests/test_netutils.py	1970-01-01 00:00:00 +0000
+++ quickstart/tests/test_netutils.py	2014-11-12 16:41:04 +0000
@@ -0,0 +1,201 @@
+# 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) 2013-2014 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 network utility functions."""
+
+from __future__ import unicode_literals
+
+import httplib
+import json
+import socket
+import unittest
+import urllib2
+
+import mock
+
+from quickstart import netutils
+from quickstart.tests import helpers
+
+
+class TestCheckResolvable(unittest.TestCase):
+
+    def test_resolvable(self):
+        # None is returned if the hostname can be resolved.
+        expected_log = 'example.com resolved to 1.2.3.4'
+        with helpers.assert_logs([expected_log], level='debug'):
+            with mock.patch('socket.gethostbyname', return_value='1.2.3.4'):
+                error = netutils.check_resolvable('example.com')
+        self.assertIsNone(error)
+
+    def test_not_resolvable(self):
+        # An error message is returned if the hostname cannot be resolved.
+        exception = socket.gaierror('bad wolf')
+        with mock.patch('socket.gethostbyname', side_effect=exception):
+            error = netutils.check_resolvable('example.com')
+        self.assertEqual('bad wolf', error)
+
+
+class TestCheckListening(unittest.TestCase):
+
+    def test_listening(self):
+        # None is returned if the address can be connected to.
+        with helpers.patch_socket_create_connection() as mock_connection:
+            error = netutils.check_listening('1.2.3.4:17070')
+        self.assertIsNone(error)
+        mock_connection.assert_called_once_with(('1.2.3.4', 17070), 3)
+
+    def test_timeout(self):
+        # A customized timeout can be passed.
+        with helpers.patch_socket_create_connection() as mock_connection:
+            error = netutils.check_listening('1.2.3.4:17070', timeout=42)
+        self.assertIsNone(error)
+        mock_connection.assert_called_once_with(('1.2.3.4', 17070), 42)
+
+    def test_address_not_valid(self):
+        # An error message is returned if the address is not valid.
+        with helpers.patch_socket_create_connection() as mock_connection:
+            error = netutils.check_listening('1.2.3.4')
+        self.assertEqual(
+            'cannot connect to 1.2.3.4: need more than 1 value to unpack',
+            error)
+        self.assertFalse(mock_connection.called)
+
+    def test_port_not_valid(self):
+        # An error message is returned if the address port is not valid.
+        with helpers.patch_socket_create_connection() as mock_connection:
+            error = netutils.check_listening('1.2.3.4:bad-port')
+        self.assertEqual(
+            'cannot connect to 1.2.3.4:bad-port: '
+            "invalid literal for int() with base 10: 'bad-port'",
+            error)
+        self.assertFalse(mock_connection.called)
+
+    def test_not_listening(self):
+        # An error message is returned if the address is not reachable.
+        with helpers.patch_socket_create_connection('boo!') as mock_connection:
+            error = netutils.check_listening('1.2.3.4:17070')
+        self.assertEqual('cannot connect to 1.2.3.4:17070: boo!', error)
+        mock_connection.assert_called_once_with(('1.2.3.4', 17070), 3)
+
+    def test_closing(self):
+        # The socket connection is properly closed.
+        with helpers.patch_socket_create_connection() as mock_connection:
+            netutils.check_listening('1.2.3.4:17070')
+        mock_connection().close.assert_called_once_with()
+
+    def test_error_closing(self):
+        # Errors closing the socket connection are ignored.
+        with helpers.patch_socket_create_connection() as mock_connection:
+            mock_connection().close.side_effect = socket.error('bad wolf')
+            netutils.check_listening('1.2.3.4:17070')
+
+
+class TestGetCharmUrl(helpers.UrlReadTestsMixin, unittest.TestCase):
+
+    def test_charm_url(self):
+        # The Juju GUI charm URL is correctly returned.
+        contents = json.dumps({'charm': {'url': 'cs:trusty/juju-gui-42'}})
+        with self.patch_urlread(contents=contents) as mock_urlread:
+            charm_url = netutils.get_charm_url('trusty')
+        self.assertEqual('cs:trusty/juju-gui-42', charm_url)
+        mock_urlread.assert_called_once_with(
+            'http://manage.jujucharms.com/api/3/charm/trusty/juju-gui')
+
+    def test_io_error(self):
+        # IOErrors are properly propagated.
+        with self.patch_urlread(error=True) as mock_urlread:
+            with self.assertRaises(IOError) as context_manager:
+                netutils.get_charm_url('precise')
+        mock_urlread.assert_called_once_with(
+            'http://manage.jujucharms.com/api/3/charm/precise/juju-gui')
+        self.assertEqual('bad wolf', bytes(context_manager.exception))
+
+    def test_value_error(self):
+        # A ValueError is raised if the API response is not valid.
+        contents = json.dumps({'charm': {}})
+        with self.patch_urlread(contents=contents) as mock_urlread:
+            with self.assertRaises(ValueError) as context_manager:
+                netutils.get_charm_url('trusty')
+        mock_urlread.assert_called_once_with(
+            'http://manage.jujucharms.com/api/3/charm/trusty/juju-gui')
+        self.assertEqual(
+            'unable to find the charm URL', bytes(context_manager.exception))
+
+
+class TestUrlread(unittest.TestCase):
+
+    def patch_urlopen(self, contents=None, error=None, content_type=None):
+        """Patch the urllib2.urlopen function.
+
+        If contents is not None, the read() method of the returned mock object
+        returns the given contents.
+        If content_type is provided, the response includes the content type.
+        If an error is provided, the call raises the error.
+        """
+        mock_urlopen = mock.MagicMock()
+        if contents is not None:
+            mock_urlopen().read.return_value = contents
+        if content_type is not None:
+            mock_urlopen().headers = {'content-type': content_type}
+        if error is not None:
+            mock_urlopen.side_effect = error
+        mock_urlopen.reset_mock()
+        return mock.patch('urllib2.urlopen', mock_urlopen)
+
+    def test_contents(self):
+        # The URL contents are correctly returned.
+        with self.patch_urlopen(contents=b'URL contents') as mock_urlopen:
+            contents = netutils.urlread('http://example.com/path/')
+        self.assertEqual('URL contents', contents)
+        self.assertIsInstance(contents, unicode)
+        mock_urlopen.assert_called_once_with('http://example.com/path/')
+
+    def test_content_type(self):
+        # The URL contents are decoded using the site charset.
+        patch_urlopen = self.patch_urlopen(
+            contents=b'URL contents: \xf8',  # This is not a UTF-8 byte string.
+            content_type='text/html; charset=ISO-8859-1')
+        with patch_urlopen as mock_urlopen:
+            contents = netutils.urlread('http://example.com/path/')
+        self.assertEqual('URL contents: \xf8', contents)
+        self.assertIsInstance(contents, unicode)
+        mock_urlopen.assert_called_once_with('http://example.com/path/')
+
+    def test_no_content_type(self):
+        # The URL contents are decoded with UTF-8 by default.
+        patch_urlopen = self.patch_urlopen(
+            contents=b'URL contents: \xf8',  # This is not a UTF-8 byte string.
+            content_type='text/html')
+        with patch_urlopen as mock_urlopen:
+            contents = netutils.urlread('http://example.com/path/')
+        self.assertEqual('URL contents: ', contents)
+        self.assertIsInstance(contents, unicode)
+        mock_urlopen.assert_called_once_with('http://example.com/path/')
+
+    def test_errors(self):
+        # An IOError is raised if an error occurs connecting to the API.
+        errors = {
+            'httplib HTTPException': httplib.HTTPException,
+            'socket error': socket.error,
+            'urllib2 URLError': urllib2.URLError,
+        }
+        for message, exception_class in errors.items():
+            exception = exception_class(message)
+            with self.patch_urlopen(error=exception) as mock_urlopen:
+                with self.assertRaises(IOError) as context_manager:
+                    netutils.urlread('http://example.com/path/')
+            mock_urlopen.assert_called_once_with('http://example.com/path/')
+            self.assertEqual(message, bytes(context_manager.exception))
 
=== modified file 'quickstart/tests/test_utils.py'
--- quickstart/tests/test_utils.py	2014-11-10 09:08:44 +0000
+++ quickstart/tests/test_utils.py	2014-11-12 16:41:04 +0000
@@ -19,14 +19,11 @@
 from __future__ import unicode_literals
 
 import datetime
-import httplib
 import json
 import os
 import shutil
-import socket
 import tempfile
 import unittest
-import urllib2
 
 import mock
 import yaml
@@ -156,24 +153,6 @@
             utils.call('echo', 'we are the borg!')
 
 
-class TestCheckResolvable(unittest.TestCase):
-
-    def test_resolvable(self):
-        # None is returned if the hostname can be resolved.
-        expected_log = 'example.com resolved to 1.2.3.4'
-        with helpers.assert_logs([expected_log], level='debug'):
-            with mock.patch('socket.gethostbyname', return_value='1.2.3.4'):
-                error = utils.check_resolvable('example.com')
-        self.assertIsNone(error)
-
-    def test_not_resolvable(self):
-        # An error message is returned if the hostname cannot be resolved.
-        exception = socket.gaierror('bad wolf')
-        with mock.patch('socket.gethostbyname', side_effect=exception):
-            error = utils.check_resolvable('example.com')
-        self.assertEqual('bad wolf', error)
-
-
 @mock.patch('__builtin__.print', mock.Mock())
 class TestParseGuiCharmUrl(unittest.TestCase):
 
@@ -323,38 +302,6 @@
                 utils.convert_bundle_url(url)
 
 
-class TestGetCharmUrl(helpers.UrlReadTestsMixin, unittest.TestCase):
-
-    def test_charm_url(self):
-        # The Juju GUI charm URL is correctly returned.
-        contents = json.dumps({'charm': {'url': 'cs:trusty/juju-gui-42'}})
-        with self.patch_urlread(contents=contents) as mock_urlread:
-            charm_url = utils.get_charm_url('trusty')
-        self.assertEqual('cs:trusty/juju-gui-42', charm_url)
-        mock_urlread.assert_called_once_with(
-            'http://manage.jujucharms.com/api/3/charm/trusty/juju-gui')
-
-    def test_io_error(self):
-        # IOErrors are properly propagated.
-        with self.patch_urlread(error=True) as mock_urlread:
-            with self.assertRaises(IOError) as context_manager:
-                utils.get_charm_url('precise')
-        mock_urlread.assert_called_once_with(
-            'http://manage.jujucharms.com/api/3/charm/precise/juju-gui')
-        self.assertEqual('bad wolf', bytes(context_manager.exception))
-
-    def test_value_error(self):
-        # A ValueError is raised if the API response is not valid.
-        contents = json.dumps({'charm': {}})
-        with self.patch_urlread(contents=contents) as mock_urlread:
-            with self.assertRaises(ValueError) as context_manager:
-                utils.get_charm_url('trusty')
-        mock_urlread.assert_called_once_with(
-            'http://manage.jujucharms.com/api/3/charm/trusty/juju-gui')
-        self.assertEqual(
-            'unable to find the charm URL', bytes(context_manager.exception))
-
-
 class TestGetQuickstartBanner(unittest.TestCase):
 
     def patch_datetime(self):
@@ -704,72 +651,6 @@
         self.assertEqual(list.append.__doc__, self.func.__doc__)
 
 
-class TestUrlread(unittest.TestCase):
-
-    def patch_urlopen(self, contents=None, error=None, content_type=None):
-        """Patch the urllib2.urlopen function.
-
-        If contents is not None, the read() method of the returned mock object
-        returns the given contents.
-        If content_type is provided, the response includes the content type.
-        If an error is provided, the call raises the error.
-        """
-        mock_urlopen = mock.MagicMock()
-        if contents is not None:
-            mock_urlopen().read.return_value = contents
-        if content_type is not None:
-            mock_urlopen().headers = {'content-type': content_type}
-        if error is not None:
-            mock_urlopen.side_effect = error
-        mock_urlopen.reset_mock()
-        return mock.patch('urllib2.urlopen', mock_urlopen)
-
-    def test_contents(self):
-        # The URL contents are correctly returned.
-        with self.patch_urlopen(contents=b'URL contents') as mock_urlopen:
-            contents = utils.urlread('http://example.com/path/')
-        self.assertEqual('URL contents', contents)
-        self.assertIsInstance(contents, unicode)
-        mock_urlopen.assert_called_once_with('http://example.com/path/')
-
-    def test_content_type(self):
-        # The URL contents are decoded using the site charset.
-        patch_urlopen = self.patch_urlopen(
-            contents=b'URL contents: \xf8',  # This is not a UTF-8 byte string.
-            content_type='text/html; charset=ISO-8859-1')
-        with patch_urlopen as mock_urlopen:
-            contents = utils.urlread('http://example.com/path/')
-        self.assertEqual('URL contents: \xf8', contents)
-        self.assertIsInstance(contents, unicode)
-        mock_urlopen.assert_called_once_with('http://example.com/path/')
-
-    def test_no_content_type(self):
-        # The URL contents are decoded with UTF-8 by default.
-        patch_urlopen = self.patch_urlopen(
-            contents=b'URL contents: \xf8',  # This is not a UTF-8 byte string.
-            content_type='text/html')
-        with patch_urlopen as mock_urlopen:
-            contents = utils.urlread('http://example.com/path/')
-        self.assertEqual('URL contents: ', contents)
-        self.assertIsInstance(contents, unicode)
-        mock_urlopen.assert_called_once_with('http://example.com/path/')
-
-    def test_errors(self):
-        # An IOError is raised if an error occurs connecting to the API.
-        errors = {
-            'httplib HTTPException': httplib.HTTPException,
-            'socket error': socket.error,
-            'urllib2 URLError': urllib2.URLError,
-        }
-        for message, exception_class in errors.items():
-            exception = exception_class(message)
-            with self.patch_urlopen(error=exception) as mock_urlopen:
-                with self.assertRaises(IOError) as context_manager:
-                    utils.urlread('http://example.com/path/')
-            mock_urlopen.assert_called_once_with('http://example.com/path/')
-            self.assertEqual(message, bytes(context_manager.exception))
-
-
 class TestGetJujuVersion(
         helpers.CallTestsMixin, helpers.ValueErrorTestsMixin,
         unittest.TestCase):
 
=== modified file 'quickstart/utils.py'
--- quickstart/utils.py	2014-11-10 09:08:44 +0000
+++ quickstart/utils.py	2014-11-12 16:41:04 +0000
@@ -25,15 +25,11 @@
 import datetime
 import errno
 import functools
-import httplib
-import json
 import logging
 import os
 import pipes
 import re
-import socket
 import subprocess
-import urllib2
 
 import quickstart
 from quickstart import (
@@ -105,20 +101,6 @@
     return retcode, output.decode('utf-8'), error.decode('utf-8')
 
 
-def check_resolvable(hostname):
-    """Check that the hostname can be resolved to a numeric IP address.
-
-    Return an error message if the address cannot be resolved.
-    """
-    try:
-        address = socket.gethostbyname(hostname)
-    except socket.error as err:
-        return bytes(err).decode('utf-8')
-    logging.debug('{} resolved to {}'.format(
-        hostname, address.decode('utf-8')))
-    return None
-
-
 def parse_gui_charm_url(charm_url):
     """Parse the given charm URL.
 
@@ -164,21 +146,6 @@
             bundle_id)
 
 
-def get_charm_url(series):
-    """Return the charm URL of the latest Juju GUI charm revision.
-
-    Raise an IOError if any problems occur connecting to the API endpoint.
-    Raise a ValueError if the API returns invalid data.
-    """
-    url = settings.CHARMWORLD_API.format(
-        series=series, charm=settings.JUJU_GUI_CHARM_NAME)
-    charm_info = json.loads(urlread(url))
-    charm_url = charm_info.get('charm', {}).get('url')
-    if charm_url is None:
-        raise ValueError(b'unable to find the charm URL')
-    return charm_url
-
-
 def get_quickstart_banner():
     """Return a quickstart banner suitable for being included in files.
 
@@ -390,24 +357,3 @@
             return function(*args, **kwargs)
     decorated.called = False
     return decorated
-
-
-def urlread(url):
-    """Open the given URL and return the page contents.
-
-    Raise an IOError if any problems occur.
-    """
-    try:
-        response = urllib2.urlopen(url)
-    except urllib2.URLError as err:
-        raise IOError(err.reason)
-    except (httplib.HTTPException, socket.error, urllib2.HTTPError) as err:
-        raise IOError(bytes(err))
-    contents = response.read()
-    content_type = response.headers['content-type']
-    charset = 'utf-8'
-    if 'charset=' in content_type:
-        sent_charset = content_type.split('charset=')[-1].strip()
-        if sent_charset:
-            charset = sent_charset
-    return contents.decode(charset, 'ignore')
 
=== modified file 'quickstart/watchers.py'
--- quickstart/watchers.py	2014-11-10 10:28:19 +0000
+++ quickstart/watchers.py	2014-11-12 16:41:04 +0000
@@ -23,7 +23,7 @@
 
 import logging
 
-from quickstart import utils
+from quickstart import netutils
 
 
 IPV4_ADDRESS = 'ipv4'
@@ -150,7 +150,7 @@
     if not address:
         addresses = data.get('Addresses', [])
         public_address = retrieve_public_adddress(
-            addresses, utils.check_resolvable)
+            addresses, netutils.check_resolvable)
         if public_address is not None:
             address = public_address
             print('unit placed on {}'.format(address))