Merge lp:~frankban/juju-quickstart/maas-address into lp:juju-quickstart

[Francesco Banconi]

Unit address from the machines watcher only

Only use the mega-watcher for machines to retrieve
the Juju GUI unit address.
This change has several consequences:
- it allows us to apply some logic on how the
  right address is chosen. For instance, now
  we try to resolve public hostnames before
  proceeding, and this should fix the cases
  where a cloud dns is not configured on the
  machine running quickstart. This is the case
  of many maas environments;
- it simplifies parsing the mega-watcher changes;
- more importantly, it breaks compatibility
  with very old versions of juju (<1.18), in which
  the mega-watcher for machines did not include
  machine addresses.

For this reason, quickstart now explicitly
drops support for juju < 1.18.1
(1.18.1 is the version on trusty universe).

This also allows for removing some version
checks in the code, including sudo handling when
calling bootstrap on local envs, several special
cases on the watcher side, and other oddities.

For the reasons above, I bumped the quickstart
version up to 1.5.0.

PS: my apologies for the long diff, hope the code
is still easy to follow. Sorry.

Tests: `make check`

QA:
run quickstart as usual, on local and cloud envs,
check it works properly when run again, etc.
this branch has been already successfully QAed in
a maas environment by Adam (Landscape team).

https://codereview.appspot.com/174790043/

[Francesco Banconi (frankban)]

Reviewers: mp+241263_code.launchpad.net,

Message:
Please take a look.

Description:
Unit address from the machines watcher only

Only use the mega-watcher for machines to retrieve
the Juju GUI unit address.
This change has several consequences:
- it allows us to apply some logic on how the
   right address is chosen. For instance, now
   we try to resolve public hostnames before
   proceeding, and this should fix the cases
   where a cloud dns is not configured on the
   machine running quickstart. This is the case
   of many maas environments;
- it simplifies parsing the mega-watcher changes;
- more importantly, it breaks compatibility
   with very old versions of juju (<1.18), in which
   the mega-watcher for machines did not include
   machine addresses.

For this reason, quickstart now explicitly
drops support for juju < 1.18.1
(1.18.1 is the version on trusty universe).

This also allows for removing some version
checks in the code, including sudo handling when
calling bootstrap on local envs, several special
cases on the watcher side, and other oddities.

For the reasons above, I bumped the quickstart
version up to 1.5.0.

PS: my apologies for the long diff, hope the code
is still easy to follow. Sorry.

Tests: `make check`

QA:
run quickstart as usual, on local and cloud envs,
check it works properly when run again, etc.
this branch has been already successfully QAed in
a maas environment by Adam (Landscape team).

https://code.launchpad.net/~frankban/juju-quickstart/maas-address/+merge/241263

(do not edit description out of merge proposal)

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

Affected files (+334, -433 lines):
   M README.rst
   A [revision details]
   M quickstart/__init__.py
   M quickstart/app.py
   M quickstart/manage.py
   M quickstart/settings.py
   M quickstart/tests/helpers.py
   M quickstart/tests/test_app.py
   M quickstart/tests/test_manage.py
   M quickstart/tests/test_utils.py
   M quickstart/tests/test_watchers.py
   M quickstart/utils.py
   M quickstart/watchers.py

[Brad Crittenden (bac)]

On 2014/11/10 12:30:34, frankban wrote:
> Please take a look.

LGTM. Have not done QA yet.

https://codereview.appspot.com/174790043/

[Brad Crittenden (bac)]

QA OK

https://codereview.appspot.com/174790043/

[Richard Harding (rharding)]

LGTM ty for the updates!

https://codereview.appspot.com/174790043/diff/1/quickstart/app.py
File quickstart/app.py (left):

https://codereview.appspot.com/174790043/diff/1/quickstart/app.py#oldcode188
quickstart/app.py:188: if requires_sudo:
is this because of the new juju requirement?

https://codereview.appspot.com/174790043/

[Francesco Banconi (frankban)]

Thank you both for the reviews of this long diff!

https://codereview.appspot.com/174790043/diff/1/quickstart/app.py
File quickstart/app.py (left):

https://codereview.appspot.com/174790043/diff/1/quickstart/app.py#oldcode188
quickstart/app.py:188: if requires_sudo:
On 2014/11/10 15:25:20, rharding wrote:
> is this because of the new juju requirement?

Yes! We got rid of very old versions of juju requiring an explicit sudo
on the command line.

https://codereview.appspot.com/174790043/

[Francesco Banconi (frankban)]

*** Submitted:

Unit address from the machines watcher only

Only use the mega-watcher for machines to retrieve
the Juju GUI unit address.
This change has several consequences:
- it allows us to apply some logic on how the
   right address is chosen. For instance, now
   we try to resolve public hostnames before
   proceeding, and this should fix the cases
   where a cloud dns is not configured on the
   machine running quickstart. This is the case
   of many maas environments;
- it simplifies parsing the mega-watcher changes;
- more importantly, it breaks compatibility
   with very old versions of juju (<1.18), in which
   the mega-watcher for machines did not include
   machine addresses.

For this reason, quickstart now explicitly
drops support for juju < 1.18.1
(1.18.1 is the version on trusty universe).

This also allows for removing some version
checks in the code, including sudo handling when
calling bootstrap on local envs, several special
cases on the watcher side, and other oddities.

For the reasons above, I bumped the quickstart
version up to 1.5.0.

PS: my apologies for the long diff, hope the code
is still easy to follow. Sorry.

Tests: `make check`

QA:
run quickstart as usual, on local and cloud envs,
check it works properly when run again, etc.
this branch has been already successfully QAed in
a maas environment by Adam (Landscape team).

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

https://codereview.appspot.com/174790043/

=== modified file 'README.rst'
--- README.rst	2014-09-01 14:44:39 +0000
+++ README.rst	2014-11-10 12:30:00 +0000
@@ -36,6 +36,8 @@
 Juju Quickstart is available on Ubuntu releases 12.04 LTS (precise), 14.04 LTS
 (trusty), 14.10 (utopic) and on OS X (10.7 and later).
 
+Starting from version 1.5.0, Juju Quickstart only supports Juju >= 1.18.1.
+
 Ubuntu Installation
 ~~~~~~~~~~~~~~~~~~~
 

=== modified file 'quickstart/__init__.py'
--- quickstart/__init__.py	2014-10-01 13:43:17 +0000
+++ quickstart/__init__.py	2014-11-10 12:30:00 +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 = (1, 4, 4)
+VERSION = (1, 5, 0)
 
 
 def get_version():

=== modified file 'quickstart/app.py'
--- quickstart/app.py	2014-08-25 16:57:41 +0000
+++ quickstart/app.py	2014-11-10 12:30:00 +0000
@@ -116,6 +116,19 @@
     return juju_version
 
 
+def check_juju_supported(juju_version):
+    """Ensure the given Juju version is supported by Quickstart.
+
+    Raise a ProgramExit if Juju is not supported.
+    """
+    if juju_version < settings.JUJU_SUPPORTED_VERSION:
+        current = b'.'.join(map(bytes, juju_version))
+        supported = b'.'.join(map(bytes, settings.JUJU_SUPPORTED_VERSION))
+        raise ProgramExit(
+            b'the current Juju version ({}) is not supported: '
+            b'please upgrade to Juju >= {}'.format(current, supported))
+
+
 def ensure_ssh_keys():
     """Ensure that SSH keys are available.
 
@@ -163,8 +176,9 @@
         raise ProgramExit(bytes(err))
 
 
-def bootstrap(env_name, juju_command, requires_sudo=False, debug=False,
-              upload_tools=False, upload_series=None, constraints=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.
 
     Do not bootstrap the environment if already bootstrapped.
@@ -185,8 +199,6 @@
     """
     already_bootstrapped = False
     cmd = [juju_command, 'bootstrap', '-e', env_name]
-    if requires_sudo:
-        cmd.insert(0, 'sudo')
     if debug:
         cmd.append('--debug')
     if upload_tools:
@@ -497,14 +509,10 @@
         for action, data in unit_changes:
             if data['Name'] == unit_name:
                 try:
-                    data = watchers.parse_unit_change(
-                        action, data, unit_status, address)
+                    unit_status, machine_id = watchers.parse_unit_change(
+                        action, data, unit_status)
                 except ValueError as err:
                     raise ProgramExit(bytes(err))
-                unit_status, address, machine_id = data
-                if address and unit_status == 'started':
-                    # We can exit this loop.
-                    return address
                 # The mega-watcher contains a single change for each specific
                 # unit. For this reason, we can exit the for loop here.
                 break
@@ -528,12 +536,12 @@
                         action, data, machine_status, address)
                 except ValueError as err:
                     raise ProgramExit(bytes(err))
-                if address and unit_status == 'started':
-                    # We can exit this loop.
-                    return address
                 # The mega-watcher contains a single change for each specific
                 # machine. For this reason, we can exit the for loop here.
                 break
+        if address and unit_status == 'started':
+            # We can exit this loop.
+            return address
 
 
 def deploy_bundle(env, bundle_yaml, bundle_name, bundle_id):
@@ -549,21 +557,3 @@
         env.deploy_bundle(bundle_yaml, name=bundle_name, bundle_id=bundle_id)
     except jujuclient.EnvError as err:
         raise ProgramExit('bad API server response: {}'.format(err.message))
-
-
-def juju_requires_sudo(env_type, juju_version, customized):
-    """Report whether the given Juju version requires "sudo".
-
-    The env_type argument is the current environment type.
-    "e.g. local, ec2, azure"
-
-    Raise a ProgramExit if a customized version of Juju is being used and Juju
-    itself requires "sudo"
-    """
-    # If the Juju version is less than 1.17.2 then use sudo for local envs.
-    if env_type == 'local' and juju_version < (1, 17, 2):
-        if customized:
-            raise ProgramExit(b'cannot use a customized Juju when it '
-                              'requires sudo')
-        return True
-    return False

=== modified file 'quickstart/manage.py'
--- quickstart/manage.py	2014-08-25 16:57:41 +0000
+++ quickstart/manage.py	2014-11-10 12:30:00 +0000
@@ -502,9 +502,7 @@
     logging.debug('ensuring juju and dependencies are installed')
     juju_version = app.ensure_dependencies(
         options.distro_only, options.platform, juju_command)
-
-    requires_sudo = app.juju_requires_sudo(
-        options.env_type, juju_version, custom_juju)
+    app.check_juju_supported(juju_version)
 
     logging.debug('ensuring SSH keys are available')
     app.ensure_ssh_keys()
@@ -513,13 +511,12 @@
         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 to bootstrap the application, even in newer Juju versions
-        # where "sudo" is invoked by juju-core itself.
+        # 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,
-        requires_sudo=requires_sudo, debug=options.debug,
+        debug=options.debug,
         upload_tools=options.upload_tools,
         upload_series=options.upload_series,
         constraints=options.constraints)
@@ -585,9 +582,7 @@
         'Run "juju quickstart -i" if you want to manage\n'
         'or bootstrap your Juju environments using the\n'
         'interactive session.\n'
-        'Run "{sudo}juju destroy-environment {eflag}{env_name} [-y]"\n'
-        'to destroy the environment you just bootstrapped.'.format(
-            env_name=options.env_name,
-            sudo='sudo ' if requires_sudo else '',
-            eflag='-e ' if juju_version < (1, 17, 2) else '')
+        'Run "juju destroy-environment {env_name} [-y]"\n'
+        'to destroy the environment you just bootstrapped.'
+        ''.format(env_name=options.env_name)
     )

=== modified file 'quickstart/settings.py'
--- quickstart/settings.py	2014-10-09 13:14:30 +0000
+++ quickstart/settings.py	2014-11-10 12:30:00 +0000
@@ -76,6 +76,9 @@
 # The set of series supported by the Juju GUI charm.
 JUJU_GUI_SUPPORTED_SERIES = tuple(DEFAULT_CHARM_URLS.keys())
 
+# The minimum Juju version supported by Juju Quickstart,
+JUJU_SUPPORTED_VERSION = (1, 18, 1)
+
 # The path to the MAAS command line interface.
 MAAS_CMD = '/usr/bin/maas'
 

=== modified file 'quickstart/tests/helpers.py'
--- quickstart/tests/helpers.py	2014-09-08 17:49:51 +0000
+++ quickstart/tests/helpers.py	2014-11-10 12:30:00 +0000
@@ -195,6 +195,17 @@
 mock_print = mock.patch('__builtin__.print')
 
 
+def patch_check_resolvable(error=None):
+    """Patch the utils.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',
+        lambda hostname: error,
+    )
+
+
 class UrlReadTestsMixin(object):
     """Expose a method to mock the quickstart.utils.urlread helper function."""
 

=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2014-08-25 16:57:41 +0000
+++ quickstart/tests/test_app.py	2014-11-10 12:30:00 +0000
@@ -298,6 +298,28 @@
             self.assertEqual(3, mock_call.call_count)
 
 
+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)]
+
+    def test_supported(self):
+        # No exceptions are raised if the Juju version is supported.
+        for version in self.supported_versions:
+            app.check_juju_supported(version)
+
+    def test_not_supported(self):
+        # A ProgramExit error is raised if the Juju version is not supported.
+        error = (
+            'the current Juju version ({}.{}.{}) is not supported: '
+            'please upgrade to Juju >= ' +
+            '.'.join(map(str, settings.JUJU_SUPPORTED_VERSION))
+        )
+        for version in self.unsupported_versions:
+            with self.assert_program_exit(error.format(*version)):
+                app.check_juju_supported(version)
+
+
 @helpers.mock_print
 class TestEnsureSSHKeys(
         helpers.CallTestsMixin, ProgramExitTestsMixin, unittest.TestCase):
@@ -484,19 +506,6 @@
         ] + self.make_status_calls(1))
         mock_print.assert_called_once_with(self.status_message)
 
-    def test_success_local_provider(self, mock_print):
-        # The environment is bootstrapped with sudo using the local provider.
-        with self.patch_multiple_calls(self.make_side_effects()) as mock_call:
-            already_bootstrapped, series = app.bootstrap(
-                self.env_name, self.juju_command, requires_sudo=True)
-        self.assertFalse(already_bootstrapped)
-        self.assertEqual(series, 'hoary')
-        mock_call.assert_has_calls([
-            mock.call(
-                'sudo', 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:
@@ -1275,16 +1284,16 @@
 
 
 @helpers.mock_print
[e-mail]_check_resolvable()
 class TestWatch(
         ProgramExitTestsMixin, helpers.ValueErrorTestsMixin,
         unittest.TestCase):
 
     address = 'unit.example.com'
     machine_pending_call = mock.call('machine 0 provisioning is pending')
-    unit_placed_machine_call = mock.call('unit placed on unit.example.com')
+    unit_placed_call = mock.call('unit placed on {}'.format(address))
     machine_started_call = mock.call('machine 0 is started')
     unit_pending_call = mock.call('django/42 deployment is pending')
-    unit_placed_unit_call = mock.call('django/42 placed on {}'.format(address))
     unit_installed_call = mock.call('django/42 is installed')
     unit_started_call = mock.call('django/42 is ready on machine 0')
 
@@ -1314,16 +1323,9 @@
             }]
         return 'change', data
 
-    def make_unit_change(self, status, name='django/42', address=None):
-        """Create and return a unit change.
-
-        If the address argument is None, the change does not include the
-        corresponding address field.
-        """
-        data = {'MachineId': '0', 'Name': name, 'Status': status}
-        if address is not None:
-            data['PublicAddress'] = address
-        return 'change', data
+    def make_unit_change(self, status, name='django/42'):
+        """Create and return a unit change."""
+        return 'change', {'MachineId': '0', 'Name': name, 'Status': status}
 
     # The following group of tests exercises both the function return value and
     # the function output, even if the output is handled by sub-functions.
@@ -1334,35 +1336,10 @@
         # The glorious moments in the unit's life are properly highlighted.
         # The machine achievements are also celebrated.
         env = self.make_env([
-            ([self.make_unit_change('pending', address='')],
+            ([self.make_unit_change('pending')],
              [self.make_machine_change('pending')]),
             ([], [self.make_machine_change('started')]),
-            ([self.make_unit_change('pending', address=self.address)], []),
-            ([self.make_unit_change('installed', address=self.address)], []),
-            ([self.make_unit_change('started', address=self.address)], []),
-        ])
-        address = app.watch(env, 'django/42')
-        self.assertEqual(self.address, address)
-        self.assertEqual(6, mock_print.call_count)
-        mock_print.assert_has_calls([
-            self.unit_pending_call,
-            self.machine_pending_call,
-            self.machine_started_call,
-            self.unit_placed_unit_call,
-            self.unit_installed_call,
-            self.unit_started_call,
-        ])
-
-    def test_unit_life_with_machine_address(self, mock_print):
-        # The glorious moments in the unit's life are properly highlighted.
-        # The machine achievements are also celebrated.
-        # This time the new mega-watcher behavior is simulated, in which
-        # addresses are included in the machine change.
-        env = self.make_env([
-            ([self.make_unit_change('pending')],
-             [self.make_machine_change('pending', address='')]),
             ([], [self.make_machine_change('started', address=self.address)]),
-            ([self.make_unit_change('pending')], []),
             ([self.make_unit_change('installed')], []),
             ([self.make_unit_change('started')], []),
         ])
@@ -1372,8 +1349,8 @@
         mock_print.assert_has_calls([
             self.unit_pending_call,
             self.machine_pending_call,
-            self.unit_placed_machine_call,
             self.machine_started_call,
+            self.unit_placed_call,
             self.unit_installed_call,
             self.unit_started_call,
         ])
@@ -1382,21 +1359,23 @@
         # Strange unit evolutions are handled.
         env = self.make_env([
             # The unit is first reachable and then pending. The machine starts
-            # when the unit is already installed. All of this makes no sense
-            # and should never happen, but if it does, we deal with it.
-            ([self.make_unit_change('pending', address=self.address)], []),
-            ([self.make_unit_change('pending', address='')],
-             [self.make_machine_change('pending')]),
-            ([self.make_unit_change('installed', address=self.address)], []),
-            ([], [self.make_machine_change('started')]),
-            ([self.make_unit_change('started', address=self.address)], []),
+            # when the unit is already installed. The machine has an address
+            # when still provisioning. All of this makes no sense and should
+            # never happen, but if it does, we deal with it.
+            ([self.make_unit_change('pending')], []),
+            ([], [self.make_machine_change('pending', address=self.address)]),
+            ([self.make_unit_change('pending')],
+             [self.make_machine_change('pending', address='')]),
+            ([self.make_unit_change('installed')], []),
+            ([], [self.make_machine_change('started', address=self.address)]),
+            ([self.make_unit_change('started')], []),
         ])
         address = app.watch(env, 'django/42')
         self.assertEqual(self.address, address)
         self.assertEqual(6, mock_print.call_count)
         mock_print.assert_has_calls([
-            self.unit_placed_unit_call,
             self.unit_pending_call,
+            self.unit_placed_call,
             self.machine_pending_call,
             self.unit_installed_call,
             self.machine_started_call,
@@ -1404,22 +1383,8 @@
         ])
 
     def test_missing_changes(self, mock_print):
-        # Only the unit started change is strictly required when the unit
-        # change includes the public address.
-        env = self.make_env([
-            ([self.make_unit_change('started', address=self.address)], []),
-        ])
-        address = app.watch(env, 'django/42')
-        self.assertEqual(self.address, address)
-        self.assertEqual(2, mock_print.call_count)
-        mock_print.assert_has_calls([
-            self.unit_placed_unit_call,
-            self.unit_started_call,
-        ])
-
-    def test_missing_changes_with_machine_address(self, mock_print):
-        # When using the new mega-watcher, a machine change including its
-        # public address is also required.
+        # Only the unit started change is strictly required when the machine
+        # change includes the addresses.
         env = self.make_env([
             ([self.make_unit_change('started')], []),
             ([], [self.make_machine_change('started', address=self.address)]),
@@ -1429,29 +1394,12 @@
         self.assertEqual(3, mock_print.call_count)
         mock_print.assert_has_calls([
             self.unit_started_call,
-            self.unit_placed_machine_call,
+            self.unit_placed_call,
             self.machine_started_call,
         ])
 
     def test_ignored_machine_changes(self, mock_print):
         # All machine changes are ignored until the application knows what
-        # machine the unit belongs to.
-        env = self.make_env([
-            ([], [self.make_machine_change('pending')]),
-            ([], [self.make_machine_change('started')]),
-            ([self.make_unit_change('started', address=self.address)], []),
-        ])
-        address = app.watch(env, 'django/42')
-        self.assertEqual(self.address, address)
-        # No machine related messages have been printed.
-        self.assertEqual(2, mock_print.call_count)
-        mock_print.assert_has_calls([
-            self.unit_placed_unit_call,
-            self.unit_started_call,
-        ])
-
-    def test_ignored_machine_changes_with_machine_address(self, mock_print):
-        # All machine changes are ignored until the application knows what
         # machine the unit belongs to. When the above happens, previously
         # collected machine changes are still parsed in the case the address
         # is not yet known.
@@ -1468,7 +1416,7 @@
         self.assertEqual(3, mock_print.call_count)
         mock_print.assert_has_calls([
             self.unit_started_call,
-            self.unit_placed_machine_call,
+            self.unit_placed_call,
             self.machine_started_call,
         ])
 
@@ -1477,20 +1425,6 @@
         # This happens, e.g., when executing Quickstart a second time, and both
         # the unit and the machine are already started.
         env = self.make_env([
-            ([self.make_unit_change('started', address=self.address)],
-             [self.make_machine_change('started')]),
-        ])
-        address = app.watch(env, 'django/42')
-        self.assertEqual(self.address, address)
-        self.assertEqual(2, mock_print.call_count)
-
-    def test_unit_already_deployed_with_machine_address(self, mock_print):
-        # Simulate the unit we are observing has been already deployed.
-        # This happens, e.g., when executing Quickstart a second time, and both
-        # the unit and the machine are already started.
-        # This time the new mega-watcher behavior is simulated, in which
-        # addresses are included in the machine change.
-        env = self.make_env([
             ([self.make_unit_change('started')],
              [self.make_machine_change('started', address=self.address)]),
         ])
@@ -1499,7 +1433,7 @@
         self.assertEqual(3, mock_print.call_count)
         mock_print.assert_has_calls([
             self.unit_started_call,
-            self.unit_placed_machine_call,
+            self.unit_placed_call,
             self.machine_started_call,
         ])
 
@@ -1509,31 +1443,6 @@
         # environment type: the unit is deployed on the bootstrap node, which
         # is assumed to be started.
         env = self.make_env([
-            ([self.make_unit_change('pending', address='')],
-             [self.make_machine_change('started')]),
-            ([self.make_unit_change('pending', address=self.address)], []),
-            ([self.make_unit_change('installed', address=self.address)], []),
-            ([self.make_unit_change('started', address=self.address)], []),
-        ])
-        address = app.watch(env, 'django/42')
-        self.assertEqual(self.address, address)
-        self.assertEqual(5, mock_print.call_count)
-        mock_print.assert_has_calls([
-            self.unit_pending_call,
-            self.machine_started_call,
-            self.unit_placed_unit_call,
-            self.unit_installed_call,
-            self.unit_started_call,
-        ])
-
-    def test_machine_already_started_with_machine_address(self, mock_print):
-        # Simulate the unit is being deployed on an already started machine.
-        # This happens, e.g., when running Quickstart on a non-local
-        # environment type: the unit is deployed on the bootstrap node, which
-        # is assumed to be started.
-        # This time the new mega-watcher behavior is simulated, in which
-        # addresses are included in the machine change.
-        env = self.make_env([
             ([self.make_unit_change('pending')],
              [self.make_machine_change('started', address=self.address)]),
             ([self.make_unit_change('pending')], []),
@@ -1545,7 +1454,7 @@
         self.assertEqual(5, mock_print.call_count)
         mock_print.assert_has_calls([
             self.unit_pending_call,
-            self.unit_placed_machine_call,
+            self.unit_placed_call,
             self.machine_started_call,
             self.unit_installed_call,
             self.unit_started_call,
@@ -1555,24 +1464,26 @@
         # Changes to units or machines we are not observing are ignored. Also
         # ensure that repeated changes to a single entity are ignored, even if
         # they are unlikely to happen.
-        pending_unit_change = self.make_unit_change('pending', address='')
-        started_unit_change = self.make_unit_change(
-            'started', address=self.address)
+        pending_unit_change = self.make_unit_change('pending')
+        started_unit_change = self.make_unit_change('started')
+        pending_machine_change = self.make_machine_change('pending')
         env = self.make_env([
-            # Add a repeated change.
+            # Add a repeated unit change.
             ([pending_unit_change, pending_unit_change],
-             [self.make_machine_change('pending')]),
+             [pending_machine_change]),
             # Add extraneous unit and machine changes.
             ([self.make_unit_change('pending', name='haproxy/0')],
              [self.make_machine_change('pending', name='42')]),
+            # Add a repeated machine change.
+            ([], [pending_machine_change, pending_machine_change]),
             # Add a change to an extraneous machine.
             ([], [self.make_machine_change('started', name='42'),
-                  self.make_machine_change('started')]),
+                  self.make_machine_change('started', address=self.address)]),
             # Add a change to an extraneous unit.
             ([self.make_unit_change('started', name='haproxy/0'),
-              self.make_unit_change('pending', address=self.address)], []),
-            ([self.make_unit_change('installed', address=self.address)], []),
-            # Add another repeated change.
+              self.make_unit_change('pending')], []),
+            ([self.make_unit_change('installed')], []),
+            # Add another repeated unit change.
             ([started_unit_change, started_unit_change], []),
         ])
         address = app.watch(env, 'django/42')
@@ -1581,8 +1492,8 @@
         mock_print.assert_has_calls([
             self.unit_pending_call,
             self.machine_pending_call,
+            self.unit_placed_call,
             self.machine_started_call,
-            self.unit_placed_unit_call,
             self.unit_installed_call,
             self.unit_started_call,
         ])
@@ -1590,7 +1501,7 @@
     def test_api_error(self, mock_print):
         # A ProgramExit is raised if an error occurs in one of the API calls.
         env = self.make_env([
-            ([self.make_unit_change('pending', address='')], []),
+            ([self.make_unit_change('pending')], []),
             self.make_env_error('next returned an error'),
         ])
         expected = 'bad API server response: next returned an error'
@@ -1602,14 +1513,13 @@
     def test_other_errors(self, mock_print):
         # Any other errors occurred during the process are not trapped.
         env = self.make_env([
-            ([self.make_unit_change('installed', address=self.address)], []),
+            ([self.make_unit_change('installed')], []),
             ValueError('explode!'),
         ])
         with self.assert_value_error('explode!'):
             app.watch(env, 'django/42')
-        self.assertEqual(2, mock_print.call_count)
-        mock_print.assert_has_calls([
-            self.unit_placed_unit_call, self.unit_installed_call])
+        self.assertEqual(1, mock_print.call_count)
+        mock_print.assert_has_calls([self.unit_installed_call])
 
     def test_machine_status_error(self, mock_print):
         # A ProgramExit is raised if an the machine is found in an error state.
@@ -1622,8 +1532,7 @@
         # The unit pending change is required to make the function know which
         # machine to observe.
         env = self.make_env([
-            ([self.make_unit_change('pending', address='')],
-             [change_machine_error]),
+            ([self.make_unit_change('pending')], [change_machine_error]),
         ])
         expected = 'machine 0 is in an error state: error: oddities'
         with self.assert_program_exit(expected):
@@ -1677,32 +1586,3 @@
         with self.assertRaises(ValueError) as context_manager:
             app.deploy_bundle(env, self.yaml, self.name, None)
         self.assertIs(error, context_manager.exception)
-
-
-class TestJujuRequiresSudo(ProgramExitTestsMixin, unittest.TestCase):
-    no_sudo_versions = [
-        (1, 17, 2), (1, 17, 10), (1, 18, 0), (1, 18, 2), (2, 16, 1)]
-    sudo_versions = [(0, 7, 9), (1, 0, 0), (1, 16, 42), (1, 17, 0), (1, 17, 1)]
-
-    def test_non_local_returns_false(self):
-        # A non-local provider does not require sudo.
-        actual = app.juju_requires_sudo('aws', None, None)
-        self.assertFalse(actual)
-
-    def test_local_old_juju_returns_true(self):
-        # A juju previous to 1.17.2 requires sudo.
-        for version in self.sudo_versions:
-            self.assertTrue(app.juju_requires_sudo('local', version, False),
-                            version)
-
-    def test_local_newer_juju_returns_false(self):
-        # A juju 1.17.2 and newer does not require sudo.
-        for version in self.no_sudo_versions:
-            self.assertFalse(app.juju_requires_sudo('local', version, False),
-                             version)
-
-    def test_raises_programexit(self):
-        for version in self.sudo_versions:
-            with self.assert_program_exit('cannot use a customized Juju when '
-                                          'it requires sudo'):
-                app.juju_requires_sudo('local', version, True)

=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2014-08-25 16:57:41 +0000
+++ quickstart/tests/test_manage.py	2014-11-10 12:30:00 +0000
@@ -795,7 +795,6 @@
         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'
-        mock_app.juju_requires_sudo.return_value = False
         options = self.make_options()
         with mock.patch('quickstart.manage.platform_support.get_juju_command',
                         side_effect=[(self.juju_command, False)]):
@@ -803,8 +802,9 @@
         mock_app.ensure_dependencies.assert_called()
         mock_app.ensure_ssh_keys.assert_called()
         mock_app.bootstrap.assert_called_once_with(
-            options.env_name, self.juju_command, requires_sudo=False,
-            debug=options.debug, upload_tools=options.upload_tools,
+            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(
@@ -879,68 +879,19 @@
         # where to deploy the charm, the service and unit data.
         mock_app.check_environment.return_value = (
             'cs:precise/juju-gui-42', '0', None, None)
-        mock_app.juju_requires_sudo.return_value = False
-        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, requires_sudo=False,
-                debug=options.debug, upload_tools=options.upload_tools,
-                upload_series=options.upload_series,
-                constraints=options.constraints)
-            mock_app.bootstrap.reset_mock()
-
-    def test_local_provider_requiring_sudo(self, mock_app, mock_open):
-        # The application correctly handles working with local providers when
-        # Juju requires an external "sudo" call to bootstrap the environment.
-        # Sudo privileges are required if the Juju version is < 1.17.2.
-        options = self.make_options(env_type='local')
-        versions = [(0, 7, 9), (1, 0, 0), (1, 16, 42), (1, 17, 0), (1, 17, 1)]
-        # 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)
-        mock_app.juju_requires_sudo.return_value = True
-        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, requires_sudo=True,
-                debug=options.debug, upload_tools=options.upload_tools,
-                upload_series=options.upload_series,
-                constraints=options.constraints)
-            mock_app.bootstrap.reset_mock()
-
-    def test_no_local_no_sudo(self, mock_app, mock_open):
-        # Sudo privileges are never required for non-local environments.
-        options = self.make_options(env_type='ec2')
-        mock_app.ensure_dependencies.return_value = (1, 14, 0)
-        # 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)
-        mock_app.juju_requires_sudo.return_value = False
-        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,
-            requires_sudo=False,
-            debug=options.debug, upload_tools=options.upload_tools,
-            upload_series=options.upload_series,
-            constraints=options.constraints)
+        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()
 
     def test_no_browser(self, mock_app, mock_open):
         # It is possible to avoid opening the GUI in the browser.
@@ -1015,14 +966,14 @@
         mock_app.bootstrap.return_value = (True, 'precise')
         mock_app.check_environment.return_value = (
             'cs:precise/juju-gui-42', '0', None, None)
-        mock_app.juju_requires_sudo.return_value = False
         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, requires_sudo=False,
-            debug=options.debug, upload_tools=options.upload_tools,
+            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(

=== modified file 'quickstart/tests/test_utils.py'
--- quickstart/tests/test_utils.py	2014-08-22 16:38:23 +0000
+++ quickstart/tests/test_utils.py	2014-11-10 12:30:00 +0000
@@ -156,6 +156,24 @@
             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):
 

=== modified file 'quickstart/tests/test_watchers.py'
--- quickstart/tests/test_watchers.py	2014-07-04 13:09:11 +0000
+++ quickstart/tests/test_watchers.py	2014-11-10 12:30:00 +0000
@@ -63,23 +63,29 @@
 
 class TestRetrievePublicAddress(unittest.TestCase):
 
+    def resolver(self, hostname):
+        """A fake resolver returning no errors."""
+        return None
+
     def test_empty_addresses(self):
         # None is returned if there are no available addresses.
-        self.assertIsNone(watchers.retrieve_public_adddress([]))
+        address = watchers.retrieve_public_adddress([], self.resolver)
+        self.assertIsNone(address)
 
     def test_cloud_address_not_found(self):
         # None is returned if a cloud machine public address is not available.
         addresses = [
             {'NetworkName': '',
-             'Scope': 'local-cloud',
-             'Type': 'hostname',
-             'Value': 'eu-west-1.example.internal'},
+             'Scope': 'public',
+             'Type': 'ipv6',
+             'Value': 'fe80::92b8:d0ff:fe94:8f8c'},
             {'NetworkName': '',
              'Scope': 'local-cloud',
-             'Type': 'ipv4',
-             'Value': '10.42.47.10'},
+             'Type': 'ipv6',
+             'Value': 'fe80::216:3eff:fefd:787e'},
         ]
-        self.assertIsNone(watchers.retrieve_public_adddress(addresses))
+        address = watchers.retrieve_public_adddress(addresses, self.resolver)
+        self.assertIsNone(address)
 
     def test_container_address_not_found(self):
         # None is returned if an LXC public address is not available.
@@ -89,7 +95,8 @@
             'Type': 'ipv6',
             'Value': 'fe80::216:3eff:fefd:787e',
         }]
-        self.assertIsNone(watchers.retrieve_public_adddress(addresses))
+        address = watchers.retrieve_public_adddress(addresses, self.resolver)
+        self.assertIsNone(address)
 
     def test_empty_public_address(self):
         # None is returned if the public address has no value.
@@ -103,17 +110,20 @@
              'Type': 'ipv4',
              'Value': ''},
         ]
-        self.assertIsNone(watchers.retrieve_public_adddress(addresses))
+        address = watchers.retrieve_public_adddress(addresses, self.resolver)
+        self.assertIsNone(address)
 
     def test_cloud_addresses(self):
         # The public address of a cloud machine is properly returned.
-        public_address = watchers.retrieve_public_adddress(cloud_addresses)
-        self.assertEqual('eu-west-1.compute.example.com', public_address)
+        address = watchers.retrieve_public_adddress(
+            cloud_addresses, self.resolver)
+        self.assertEqual('eu-west-1.compute.example.com', address)
 
     def test_container_addresses(self):
         # The public address of an LXC instance is properly returned.
-        public_address = watchers.retrieve_public_adddress(container_addresses)
-        self.assertEqual('10.0.3.42', public_address)
+        address = watchers.retrieve_public_adddress(
+            container_addresses, self.resolver)
+        self.assertEqual('10.0.3.42', address)
 
     def test_old_juju_version(self):
         # The public address is properly returned when using Juju < 1.20.
@@ -129,11 +139,32 @@
              'Type': 'hostname',
              'Value': 'eu-west-1.example.internal'},
         ]
-        public_address = watchers.retrieve_public_adddress(addresses)
-        self.assertEqual('eu-west-1.compute.example.com', public_address)
-
-    def test_last_unknown_address(self):
-        # If the scope of multiple addresses is unknown, the last one is taken.
+        address = watchers.retrieve_public_adddress(addresses, self.resolver)
+        self.assertEqual('eu-west-1.compute.example.com', address)
+
+    def test_local_cloud_address(self):
+        # If there are no available public addresses the first ipv4 address
+        # with cloud-local scope is returned.
+        addresses = [
+            {'NetworkName': '',
+             'Scope': 'local-cloud',
+             'Type': 'hostname',
+             'Value': 'eu-west-1.example.internal'},
+            {'NetworkName': '',
+             'Scope': 'local-cloud',
+             'Type': 'ipv4',
+             'Value': '10.42.47.10'},
+            {'NetworkName': '',
+             'Scope': 'local-cloud',
+             'Type': 'ipv4',
+             'Value': '1.2.3.4'},
+        ]
+        address = watchers.retrieve_public_adddress(addresses, self.resolver)
+        self.assertEqual('10.42.47.10', address)
+
+    def test_unknown_address(self):
+        # If there are no available public or local-cloud addresses, the first
+        # address with unknown scope is returned.
         addresses = [
             {'NetworkName': '',
              'Scope': '',
@@ -144,8 +175,52 @@
              'Type': 'ipv4',
              'Value': '10.0.3.47'},
         ]
-        public_address = watchers.retrieve_public_adddress(addresses)
-        self.assertEqual('10.0.3.47', public_address)
+        address = watchers.retrieve_public_adddress(addresses, self.resolver)
+        self.assertEqual('10.0.3.42', address)
+
+    def test_preferred_fallback_address(self):
+        # If there are no available public addresses the first fallback address
+        # in the list is returned.
+        addresses = [
+            {'NetworkName': '',
+             'Scope': '',
+             'Type': 'ipv4',
+             'Value': '10.0.3.47'},
+            {'NetworkName': '',
+             'Scope': 'local-cloud',
+             'Type': 'ipv4',
+             'Value': '10.42.47.10'},
+
+        ]
+        address = watchers.retrieve_public_adddress(addresses, self.resolver)
+        self.assertEqual('10.0.3.47', address)
+        # Now test with a reversed order.
+        address = watchers.retrieve_public_adddress(
+            reversed(addresses), self.resolver)
+        self.assertEqual('10.42.47.10', address)
+
+    def test_unresolvable_public_address(self):
+        # None is returned if a public cloud is found but it is not resolvable.
+        addresses = [
+            {'NetworkName': '',
+             'Scope': 'public',
+             'Type': 'hostname',
+             'Value': 'eu-west-1.example.internal'},
+        ]
+        expected_warning = (
+            'cannot resolve public eu-west-1.example.internal address, '
+            'looking for another candidate: bad wolf')
+        with helpers.assert_logs([expected_warning], level='warn'):
+            address = watchers.retrieve_public_adddress(
+                addresses, lambda hostname: 'bad wolf')
+        self.assertIsNone(address)
+
+    def test_unresolvable_public_address_fallback(self):
+        # If there are no resolvable public addresses the first ipv4 address
+        # with cloud-local scope is returned.
+        address = watchers.retrieve_public_adddress(
+            cloud_addresses, lambda hostname: 'bad wolf')
+        self.assertEqual('10.42.47.10', address)
 
 
 class TestParseMachineChange(helpers.ValueErrorTestsMixin, unittest.TestCase):
@@ -205,8 +280,12 @@
         # A message is printed to stdout when the machine obtains a public
         # address.
         data = {'Addresses': cloud_addresses, 'Id': '1', 'Status': 'pending'}
-        status, address = watchers.parse_machine_change(
-            'change', data, 'pending', '')
+        # Patch the hostname resolver used to check hostname addresses.
+        # Note that resolve error cases are properly exercised by the
+        # watchers.retrieve_public_adddress tests.
+        with helpers.patch_check_resolvable():
+            status, address = watchers.parse_machine_change(
+                'change', data, 'pending', '')
         self.assertEqual('pending', status)
         self.assertEqual('eu-west-1.compute.example.com', address)
         mock_print.assert_called_once_with(
@@ -248,8 +327,8 @@
         # A ValueError is raised if the change represents a unit removal.
         data = {'Name': 'django/42', 'Status': 'started'}
         with self.assert_value_error('django/42 unexpectedly removed'):
-            # The last two arguments are the current status and address.
-            watchers.parse_unit_change('remove', data, '', '')
+            # The last argument is the current status.
+            watchers.parse_unit_change('remove', data, '')
 
     def test_unit_error(self):
         # A ValueError is raised if the unit is in an error state.
@@ -260,120 +339,55 @@
         }
         expected_error = 'django/0 is in an error state: start error: bad wolf'
         with self.assert_value_error(expected_error):
-            # The last two arguments are the current status and address.
-            watchers.parse_unit_change('change', data, '', '')
-
-    @helpers.mock_print
-    def test_address_notified(self, mock_print):
-        # A message is printed to stdout when the unit obtains a public
-        # address. The function returns the status, the new address and the
-        # machine identifier.
-        data = {
-            'Name': 'haproxy/2',
-            'Status': 'pending',
-            'PublicAddress': 'haproxy2.example.com',
-            'MachineId': '42',
-        }
-        status, address, machine_id = watchers.parse_unit_change(
-            'change', data, 'pending', '')
-        self.assertEqual('pending', status)
-        self.assertEqual('haproxy2.example.com', address)
-        self.assertEqual('42', machine_id)
-        mock_print.assert_called_once_with(
-            'haproxy/2 placed on haproxy2.example.com')
+            # The last argument is the current status.
+            watchers.parse_unit_change('change', data, '')
 
     @helpers.mock_print
     def test_pending_status_notified(self, mock_print):
         # A message is printed to stdout when the unit changes its status to
-        # "pending". The function returns the new status, the address and the
-        # machine identifier. The last two values are empty strings if the unit
-        # has not yet been assigned to a machine.
-        data = {'Name': 'django/1', 'Status': 'pending', 'PublicAddress': ''}
-        # The last two arguments are the current status and address.
-        status, address, machine_id = watchers.parse_unit_change(
-            'change', data, '', '')
+        # "pending". The function returns the new status and the machine
+        # identifier, which is empty if the unit has not yet been assigned to a
+        # machine.
+        data = {'Name': 'django/1', 'Status': 'pending'}
+        # The last argument is the current status.
+        status, machine_id = watchers.parse_unit_change('change', data, '')
         self.assertEqual('pending', status)
-        self.assertEqual('', address)
         self.assertEqual('', machine_id)
         mock_print.assert_called_once_with('django/1 deployment is pending')
 
     @helpers.mock_print
     def test_installed_status_notified(self, mock_print):
         # A message is printed to stdout when the unit changes its status to
-        # "installed". The function returns the new status, the address and the
-        # machine identifier.
-        data = {
-            'Name': 'django/42',
-            'Status': 'installed',
-            'PublicAddress': 'django42.example.com',
-            'MachineId': '1',
-        }
-        status, address, machine_id = watchers.parse_unit_change(
-            'change', data, 'pending', 'django42.example.com')
+        # "installed".
+        data = {'Name': 'django/42', 'Status': 'installed', 'MachineId': '1'}
+        status, machine_id = watchers.parse_unit_change(
+            'change', data, 'pending')
         self.assertEqual('installed', status)
-        self.assertEqual('django42.example.com', address)
         self.assertEqual('1', machine_id)
         mock_print.assert_called_once_with('django/42 is installed')
 
     @helpers.mock_print
     def test_started_status_notified(self, mock_print):
         # A message is printed to stdout when the unit changes its status to
-        # "started". The function returns the new status, the address and the
-        # machine identifier.
-        data = {
-            'Name': 'wordpress/0',
-            'Status': 'started',
-            'PublicAddress': 'wordpress0.example.com',
-            'MachineId': '0',
-        }
-        status, address, machine_id = watchers.parse_unit_change(
-            'change', data, '', 'wordpress0.example.com')
+        # "started".
+        data = {'Name': 'wordpress/0', 'Status': 'started', 'MachineId': '0'}
+        # The last argument is the current status.
+        status, machine_id = watchers.parse_unit_change('change', data, '')
         self.assertEqual('started', status)
-        self.assertEqual('wordpress0.example.com', address)
         self.assertEqual('0', machine_id)
         mock_print.assert_called_once_with('wordpress/0 is ready on machine 0')
 
     @helpers.mock_print
-    def test_both_status_and_address_notified(self, mock_print):
-        # Both status and public address changes are notified if required.
-        data = {
-            'Name': 'django/0',
-            'Status': 'started',
-            'PublicAddress': 'django42.example.com',
-            'MachineId': '0',
-        }
-        # The last two arguments are the current status and address.
-        watchers.parse_unit_change('change', data, '', '')
-        self.assertEqual(2, mock_print.call_count)
-        mock_print.assert_has_calls([
-            mock.call('django/0 placed on django42.example.com'),
-            mock.call('django/0 is ready on machine 0'),
-        ])
-
-    @helpers.mock_print
     def test_status_not_changed(self, mock_print):
         # If the status in the unit change and the given current status are the
         # same value, nothing is printed and the current values are returned.
-        data = {'Name': 'django/1', 'Status': 'pending', 'PublicAddress': ''}
-        status, address, machine_id = watchers.parse_unit_change(
-            'change', data, 'pending', '')
+        data = {'Name': 'django/1', 'Status': 'pending'}
+        status, machine_id = watchers.parse_unit_change(
+            'change', data, 'pending')
         self.assertEqual('pending', status)
-        self.assertEqual('', address)
         self.assertEqual('', machine_id)
         self.assertFalse(mock_print.called)
 
-    @helpers.mock_print
-    def test_address_not_available(self, mock_print):
-        # An empty address is returned when the public address field is not
-        # included in the change data.
-        data = {'Name': 'haproxy/2', 'Status': 'pending', 'MachineId': '42'}
-        status, address, machine_id = watchers.parse_unit_change(
-            'change', data, 'pending', '')
-        self.assertEqual('pending', status)
-        self.assertEqual('', address)
-        self.assertEqual('42', machine_id)
-        self.assertFalse(mock_print.called)
-
 
 class TestUnitMachineChanges(unittest.TestCase):
 

=== modified file 'quickstart/utils.py'
--- quickstart/utils.py	2014-08-22 18:32:15 +0000
+++ quickstart/utils.py	2014-11-10 12:30:00 +0000
@@ -105,6 +105,20 @@
     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.
 

=== modified file 'quickstart/watchers.py'
--- quickstart/watchers.py	2014-07-04 13:09:11 +0000
+++ quickstart/watchers.py	2014-11-10 12:30:00 +0000
@@ -21,15 +21,25 @@
     unicode_literals,
 )
 
-
+import logging
+
+from quickstart import utils
+
+
+IPV4_ADDRESS = 'ipv4'
 IPV6_ADDRESS = 'ipv6'
-NETWORK_PUBLIC = 'public'
-NETWORK_UNKNOWN = ''
-
-
-def retrieve_public_adddress(addresses):
+SCOPE_CLOUD_LOCAL = 'local-cloud'
+SCOPE_PUBLIC = 'public'
+SCOPE_UNKNOWN = ''
+
+
+def retrieve_public_adddress(addresses, hostname_resolver):
     """Parse the given addresses and return a public address if available.
 
+    Use the given hostname_resolver callable to ensure a candidate address can
+    be resolved. The given function must accept an hostname/ip address and
+    return None if the address is resolvable, or an error string otherwise.
+
     The addresses argument is a list of address dictionaries.
     Cloud addresses look like the following:
 
@@ -73,8 +83,8 @@
     found, this function returns None.
     """
     # This implementation reflects how the public address is retrieved in Juju:
-    # see juju-core/instance/address.go:SelectPublicAddress.
-    public_address = None
+    # see juju-core/network/address.go:SelectPublicAddress.
+    fallback_address = None
     for address in addresses:
         value = address['Value']
         # Exclude empty values and ipv6 addresses.
@@ -82,14 +92,33 @@
             # The address scope was called "NetworkScope" prior to juju 1.20.0.
             scope = address.get('Scope', address.get('NetworkScope'))
             # If the scope is public then we have found the address.
-            if scope == NETWORK_PUBLIC:
-                return value
-            # If the scope is unknown then store the value. This way the last
-            # address with unknown scope will be returned, and we are able to
-            # return the right LXC address.
-            if scope == NETWORK_UNKNOWN:
-                public_address = value
-    return public_address
+            if scope == SCOPE_PUBLIC:
+                error = hostname_resolver(value)
+                if error is None:
+                    return value
+                # If the address is not resolvable, fall back to the next
+                # candidate, whether it is another public address, a
+                # local-cloud one or an unknown one. The local-cloud case, for
+                # instance, would happen when using the maas provider and the
+                # maas DNS server is not configured locally.
+                logging.warn(
+                    'cannot resolve public {} address, looking for another '
+                    'candidate: {}'.format(value, error))
+            if fallback_address is not None:
+                # If we already have a fallback address then we can jump to the
+                # next candidate.
+                continue
+            address_type = address.get('Type')
+            if scope == SCOPE_CLOUD_LOCAL and address_type == IPV4_ADDRESS:
+                # Use the local cloud scoped address as fallback value: the
+                # current environment is probably maas and the public address
+                # of the instance is not resolvable by local DNS.
+                fallback_address = value
+            elif scope == SCOPE_UNKNOWN:
+                # Use the unknown scoped address as fallback value: the current
+                # environment is probably local.
+                fallback_address = value
+    return fallback_address
 
 
 def parse_machine_change(action, data, current_status, address):
@@ -120,7 +149,8 @@
     # of units hosted by a specific machine.
     if not address:
         addresses = data.get('Addresses', [])
-        public_address = retrieve_public_adddress(addresses)
+        public_address = retrieve_public_adddress(
+            addresses, utils.check_resolvable)
         if public_address is not None:
             address = public_address
             print('unit placed on {}'.format(address))
@@ -134,16 +164,16 @@
     return status, address
 
 
-def parse_unit_change(action, data, current_status, address):
+def parse_unit_change(action, data, current_status):
     """Parse the given unit change.
 
     The change is represented by the given action/data pair.
-    Also receive the last known unit status and address, which can be empty
-    strings if those pieces of information are unknown.
+    Also receive the last known unit status which can be empty if the unit
+    status is not yet known.
 
     Output a human readable message each time a relevant change is found.
 
-    Return the unit status, address and machine identifier.
+    Return the unit status and the identifier of the machine hosting the unit.
     Raise a ValueError if the service unit is removed or in an error state.
     """
     unit_name = data['Name']
@@ -157,15 +187,6 @@
         msg = '{} is in an error state: {}: {}'.format(
             unit_name, status, data['StatusInfo'])
         raise ValueError(msg.encode('utf-8'))
-    # Notify when the unit becomes reachable. Up to juju-core 1.18, the
-    # mega-watcher for units includes the public address for each unit. This
-    # info is likely to be deprecated in favor of addresses as included in the
-    # mega-watcher for machines, but we still try to retrieve the address here
-    # for backward compatibility.
-    if not address:
-        address = data.get('PublicAddress', '')
-        if address:
-            print('{} placed on {}'.format(unit_name, address))
     # Notify status changes.
     if status != current_status:
         if status == 'pending':
@@ -175,7 +196,7 @@
         elif status == 'started':
             print('{} is ready on machine {}'.format(
                 unit_name, data['MachineId']))
-    return status, address, data.get('MachineId', '')
+    return status, data.get('MachineId', '')
 
 
 def unit_machine_changes(changeset):