Merge lp:~frankban/juju-quickstart/handle-gui-ports into lp:juju-quickstart

[Francesco Banconi]

Handle Juju GUI server port.

The Juju GUI charm can be configured to listen
to customized ports (juju set juju-gui port=n).
This branch adds to quickstart the ability to
detect the port used by the GUI server, and
therefore connect to the right WebSocket and
Web URLs. Additionally handle the cases in which
the GUI is run in non secure mode.

Also add an option to deploy the GUI on a
customized port directly using quickstart.

Also add an hidden options (--gui-source)
intended for development use only. This allows
for building a specific GUI github branch
(e.g. frankban/my-feature-branch or juju/develop)
when installing the Juju GUI, and can be useful
while coding/QAing GUI branches.

Tests: `make check`.

QA:
- use the GUI as usual, to check for regressions:
  `devenv/bin/juju-quickstart`;
- change the juju-gui port and secure mode:
  `juju set juju-gui port=4242 secure=false`
- wait for the changes to take effect;
- use quickstart again to check that insecure mode
  and customized ports are detected:
  `devenv/bin/juju-quickstart`;
- destroy the environment;
- use quickstart again to server the GUI develop
  branch on a customized port:
  `devenv/bin/juju-quickstart --gui-port 8000 --gui-source juju/develop`;
- check that everything works correctly;
- destroy the environment;
- done, thank you!

https://codereview.appspot.com/238540043/

[Francesco Banconi (frankban)]

Reviewers: mp+260032_code.launchpad.net,

Message:
Please take a look.

Description:
Handle Juju GUI server port.

The Juju GUI charm can be configured to listen
to customized ports (juju set juju-gui port=n).
This branch adds to quickstart the ability to
detect the port used by the GUI server, and
therefore connect to the right WebSocket and
Web URLs. Additionally handle the cases in which
the GUI is run in non secure mode.

Also add an option to deploy the GUI on a
customized port directly using quickstart.

Also add an hidden options (--gui-source)
intended for development use only. This allows
for building a specific GUI github branch
(e.g. frankban/my-feature-branch or juju/develop)
when installing the Juju GUI, and can be useful
while coding/QAing GUI branches.

Tests: `make check`.

QA:
- use the GUI as usual, to check for regressions:
   `devenv/bin/juju-quickstart`;
- change the juju-gui port and secure mode:
   `juju set juju-gui port=4242 secure=false`
- wait for the changes to take effect;
- use quickstart again to check that insecure mode
   and customized ports are detected:
   `devenv/bin/juju-quickstart`;
- destroy the environment;
- use quickstart again to server the GUI develop
   branch on a customized port:
   `devenv/bin/juju-quickstart --gui-port 8000 --gui-source
juju/develop`;
- check that everything works correctly;
- destroy the environment;
- done, thank you!

https://code.launchpad.net/~frankban/juju-quickstart/handle-gui-ports/+merge/260032

(do not edit description out of merge proposal)

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

Affected files (+642, -133 lines):
   A [revision details]
   M quickstart/__init__.py
   M quickstart/app.py
   A quickstart/jujugui.py
   M quickstart/jujutools.py
   M quickstart/manage.py
   M quickstart/platform_support.py
   M quickstart/tests/test_app.py
   M quickstart/tests/test_juju.py
   A quickstart/tests/test_jujugui.py
   M quickstart/tests/test_jujutools.py
   M quickstart/tests/test_manage.py
   M quickstart/tests/test_utils.py
   M quickstart/utils.py

[lp:~frankban/juju-quickstart/handle-gui-ports]

141. By Francesco Banconi on 2015-05-25

Fix typo.

[Francesco Banconi (frankban)]

Please take a look.

https://codereview.appspot.com/238540043/diff/1/quickstart/jujugui.py
File quickstart/jujugui.py (right):

https://codereview.appspot.com/238540043/diff/1/quickstart/jujugui.py#newcode59
quickstart/jujugui.py:59: def parse_charm_url(charm_url):
This function was just moved.

https://codereview.appspot.com/238540043/

[Madison Scott-Clary (makyo)]

LGTM QA okay! Thanks for the work on this

https://codereview.appspot.com/238540043/

[Francesco Banconi (frankban)]

*** Submitted:

Handle Juju GUI server port.

The Juju GUI charm can be configured to listen
to customized ports (juju set juju-gui port=n).
This branch adds to quickstart the ability to
detect the port used by the GUI server, and
therefore connect to the right WebSocket and
Web URLs. Additionally handle the cases in which
the GUI is run in non secure mode.

Also add an option to deploy the GUI on a
customized port directly using quickstart.

Also add an hidden options (--gui-source)
intended for development use only. This allows
for building a specific GUI github branch
(e.g. frankban/my-feature-branch or juju/develop)
when installing the Juju GUI, and can be useful
while coding/QAing GUI branches.

Tests: `make check`.

QA:
- use the GUI as usual, to check for regressions:
   `devenv/bin/juju-quickstart`;
- change the juju-gui port and secure mode:
   `juju set juju-gui port=4242 secure=false`
- wait for the changes to take effect;
- use quickstart again to check that insecure mode
   and customized ports are detected:
   `devenv/bin/juju-quickstart`;
- destroy the environment;
- use quickstart again to server the GUI develop
   branch on a customized port:
   `devenv/bin/juju-quickstart --gui-port 8000 --gui-source
juju/develop`;
- check that everything works correctly;
- destroy the environment;
- done, thank you!

R=
CC=
https://codereview.appspot.com/238540043

https://codereview.appspot.com/238540043/

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

=== modified file 'quickstart/app.py'
--- quickstart/app.py	2015-04-21 10:22:46 +0000
+++ quickstart/app.py	2015-05-25 08:11:40 +0000
@@ -31,6 +31,7 @@
 from quickstart import (
     charmstore,
     juju,
+    jujugui,
     jujutools,
     netutils,
     platform_support,
@@ -452,7 +453,7 @@
         # A deployed service already exists in the environment: ignore the
         # provided charm URL and just use the already deployed charm.
         charm_url = service_data['CharmURL']
-    charm_ref = jujutools.parse_gui_charm_url(charm_url)
+    charm_ref = jujugui.parse_charm_url(charm_url)
     # Deploy on the bootstrap node if the following conditions are satisfied:
     # - we are not using the local provider (which uses localhost);
     # - we are not using the azure provider (in which availability sets prevent
@@ -466,7 +467,9 @@
     return charm_ref, machine, service_data, unit_data
 
 
-def deploy_gui(env, service_name, charm_url, machine, service_data, unit_data):
+def deploy_gui(
+        env, service_name, charm_url, machine, options,
+        service_data, unit_data):
     """Deploy and expose the given service to the given machine.
 
     Only deploy the service if not already present in the environment.
@@ -479,6 +482,9 @@
           service;
         - machine: the machine where to deploy to (e.g. "0") or None if a new
           machine must be created;
+        - options: GUI charm options used when the Juju GUI service is not
+          present in the environment, or None if no customized options are
+          required;
         - service_data: the service info as returned by the mega-watcher for
           services, or None if the service is not present in the environment;
         - unit_data: the unit info as returned by the mega-watcher for units,
@@ -487,11 +493,18 @@
     Return the name of the first running unit belonging to the given service.
     Raise a ProgramExit if the API server returns an error response.
     """
+    option_str = None
+    if options:
+        option_str = '\n'.join(
+            '  {}="{}"'.format(k, v) for k, v in sorted(options.items()))
     if service_data is None:
         # The service is not in the environment: deploy it without units.
         print('requesting {} deployment'.format(service_name))
+        if option_str:
+            print('using customized {} options:\n{}'.format(
+                service_name, option_str))
         try:
-            env.deploy(service_name, charm_url, num_units=0)
+            env.deploy(service_name, charm_url, num_units=0, config=options)
         except jujuclient.EnvError as err:
             raise ProgramExit('bad API response: {}'.format(err.message))
         print('{} deployment request accepted'.format(service_name))
@@ -500,6 +513,9 @@
         # We already have the service in the environment.
         print('service {} already deployed'.format(service_name))
         service_exposed = service_data.get('Exposed', False)
+        if option_str:
+            logging.warn('ignoring customized {} options:\n{}'.format(
+                service_name, option_str))
     # At this point the service is surely deployed in the environment: expose
     # it if necessary and add a unit if it is missing.
     if not service_exposed:
@@ -590,6 +606,21 @@
             return address
 
 
+def get_service_config(env, service_name):
+    """Return the configuration options for the given service name.
+
+    The options are returned as a dict mapping option names to values.
+    If an option is unset, its value is None.
+
+    Raise a ProgramExit if the API server returns an error response.
+    """
+    try:
+        config = env.get_config(service_name)
+    except jujuclient.EnvError as err:
+        raise ProgramExit('bad API server response: {}'.format(err.message))
+    return dict((k, v.get('value')) for k, v in config.items())
+
+
 def deploy_bundle(env, bundle):
     """Deploy the given bundle connecting to the given environment.
 

=== added file 'quickstart/jujugui.py'
--- quickstart/jujugui.py	1970-01-01 00:00:00 +0000
+++ quickstart/jujugui.py	2015-05-25 08:11:40 +0000
@@ -0,0 +1,84 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Quickstart helpers for working with the Juju GUI charm and service."""
+
+from __future__ import (
+    print_function,
+    unicode_literals,
+)
+
+import logging
+
+from jujubundlelib import references
+
+from quickstart import settings
+
+
+def build_options(port, source):
+    """Create a configuration dict suitable to be used when deploying the GUI.
+
+    Return None if no customized options are present.
+    """
+    options = {}
+    if port is not None:
+        options['port'] = port
+    if source is not None:
+        user, branch = source
+        value = 'https://github.com/{}/juju-gui.git {}'.format(user, branch)
+        options['juju-gui-source'] = value
+    return options or None
+
+
+def normalize_config(options):
+    """Normalize the Juju GUI configuration options.
+
+    For instance, set the default port if none is set in the given options.
+    """
+    options = options.copy()
+    if not options['secure']:
+        logging.warn('the Juju GUI is running in insecure mode')
+    if options['port'] is None:
+        options['port'] = 443
+    return options
+
+
+def parse_charm_url(charm_url):
+    """Parse the given charm URL.
+
+    Check if the charm URL seems to refer to a Juju GUI charm.
+    Print (to stdout or to logs) info and warnings about the charm URL.
+
+    Return the parsed charm reference object as an instance of
+    "jujubundlelib.references.Reference".
+    """
+    print('charm URL: {}'.format(charm_url))
+    ref = references.Reference.from_fully_qualified_url(charm_url)
+    charm_name = settings.JUJU_GUI_CHARM_NAME
+    if ref.name != charm_name:
+        # This does not seem to be a Juju GUI charm.
+        logging.warn(
+            'unexpected URL for the {} charm: '
+            'the service may not work as expected'.format(charm_name))
+        return ref
+    if ref.user or ref.is_local():
+        # This is not the official Juju GUI charm.
+        logging.warn('using a customized {} charm'.format(charm_name))
+    elif ref.revision < settings.MINIMUM_REVISIONS_FOR_BUNDLES[ref.series]:
+        # This is the official Juju GUI charm, but it is outdated.
+        logging.warn(
+            'charm is outdated and may not support bundle deployments')
+    return ref

=== modified file 'quickstart/jujutools.py'
--- quickstart/jujutools.py	2015-04-21 10:22:46 +0000
+++ quickstart/jujutools.py	2015-05-25 08:11:40 +0000
@@ -16,14 +16,7 @@
 
 """Quickstart utility functions for managing Juju environments and entities."""
 
-from __future__ import (
-    print_function,
-    unicode_literals,
-)
-
-import logging
-
-from jujubundlelib import references
+from __future__ import unicode_literals
 
 from quickstart import (
     serializers,
@@ -32,13 +25,15 @@
 
 
 def get_api_url(
-        api_address, juju_version, env_uuid, prefix='', charm_ref=None):
+        api_address, juju_version, env_uuid,
+        path_prefix='', charm_ref=None, insecure=False):
     """Return the Juju WebSocket API endpoint.
 
     Receives the Juju API server address, the Juju version and the unique
     identifier of the current environment.
 
-    Optionally receive a prefix to be used in the path.
+    Optionally a prefix to be used in the path and a flag indicating whether
+    to use secure or insecure WebSockets.
 
     Optionally also receive the Juju GUI charm reference as an instance of
     "jujubundlelib.references.Reference". If provided, the function checks that
@@ -48,10 +43,11 @@
     The environment UUID can be None, in which case the old-style API URL
     (not including the environment UUID) is returned.
     """
-    base_url = 'wss://{}'.format(api_address)
-    prefix = prefix.strip('/')
-    if prefix:
-        base_url = '{}/{}'.format(base_url, prefix)
+    schema = 'ws' if insecure else 'wss'
+    base_url = '{}://{}'.format(schema, api_address)
+    path_prefix = path_prefix.strip('/')
+    if path_prefix:
+        base_url = '{}/{}'.format(base_url, path_prefix)
     if (env_uuid is None) or (juju_version < (1, 22, 0)):
         return base_url
     complete_url = '{}/environment/{}/api'.format(base_url, env_uuid)
@@ -98,34 +94,6 @@
     return services[0], units[0] if units else None
 
 
-def parse_gui_charm_url(charm_url):
-    """Parse the given charm URL.
-
-    Check if the charm URL seems to refer to a Juju GUI charm.
-    Print (to stdout or to logs) info and warnings about the charm URL.
-
-    Return the parsed charm reference object as an instance of
-    "jujubundlelib.references.Reference".
-    """
-    print('charm URL: {}'.format(charm_url))
-    ref = references.Reference.from_fully_qualified_url(charm_url)
-    charm_name = settings.JUJU_GUI_CHARM_NAME
-    if ref.name != charm_name:
-        # This does not seem to be a Juju GUI charm.
-        logging.warn(
-            'unexpected URL for the {} charm: '
-            'the service may not work as expected'.format(charm_name))
-        return ref
-    if ref.user or ref.is_local():
-        # This is not the official Juju GUI charm.
-        logging.warn('using a customized {} charm'.format(charm_name))
-    elif ref.revision < settings.MINIMUM_REVISIONS_FOR_BUNDLES[ref.series]:
-        # This is the official Juju GUI charm, but it is outdated.
-        logging.warn(
-            'charm is outdated and may not support bundle deployments')
-    return ref
-
-
 def parse_status_output(output, keys=None):
     """Parse the output of juju status.
 

=== modified file 'quickstart/manage.py'
--- quickstart/manage.py	2015-04-24 13:31:28 +0000
+++ quickstart/manage.py	2015-05-25 08:11:40 +0000
@@ -33,6 +33,7 @@
 import quickstart
 from quickstart import (
     app,
+    jujugui,
     jujutools,
     packaging,
     platform_support,
@@ -142,6 +143,46 @@
             'revision: {}'.format(ref))
 
 
+def _validate_gui_source(options, parser):
+    """Validate the optional Juju GUI branch source.
+
+    Convert the GUI source value to be a tuple (user, branch).
+    Exit with an error if the source is not well formed.
+    """
+    gui_source = options.gui_source
+    if gui_source is None:
+        return
+    error = 'invalid Juju GUI source: {}'.format(gui_source).encode('utf-8')
+    try:
+        user, branch = [i.strip() for i in gui_source.split('/')]
+    except ValueError:
+        return parser.error(error)
+    if not (user and branch):
+        return parser.error(error)
+    options.gui_source = (user, branch)
+
+
+def _validate_platform(platform, parser):
+    """Validate the platform.
+
+    Exit with an error if platform is not supported by quickstart or is
+    missing files.
+    """
+    try:
+        platform_support.validate_platform(platform)
+    except ValueError as err:
+        return parser.error(bytes(err))
+
+
+def _validate_port(port, parser):
+    """Validate the given port if it is not None.
+
+    Exit with an error if the port is not in the TCP range.
+    """
+    if (port is not None) and (port < 1 or port > 65535):
+        return parser.error(b'invalid Juju GUI port: not in range 1-65535')
+
+
 def _retrieve_env_db(parser, env_file=None):
     """Retrieve the environment database (or create an in-memory empty one)."""
     if env_file is None:
@@ -313,17 +354,6 @@
             setattr(options, key, value.decode(encoding))
 
 
-def _validate_platform(parser, platform):
-    """Validate the platform.
-    Exit with an error if platform is not supported by quickstart or is
-    missing files.
-    """
-    try:
-        platform_support.validate_platform(platform)
-    except ValueError as err:
-        return parser.error(bytes(err))
-
-
 def setup():
     """Set up the application options and logger.
 
@@ -339,9 +369,11 @@
         - env_file: the absolute path of the Juju environments.yaml file;
         - env_name: the name of the Juju environment to use;
         - env_type: the provider type of the selected Juju environment;
+        - gui_source: the optional Juju GUI branch source on github, or None;
         - interactive: whether to start the interactive session;
         - open_browser: whether the GUI browser must be opened;
         - platform: The host platform;
+        - port: the optional Juju GUI port, or None;
         - upload_tools: whether to upload local version of tools;
         - upload_series: the comma-separated series list for which tools will
           be uploaded, or None if not set.
@@ -423,9 +455,16 @@
              'e.g. "cs:~juju-gui/precise/juju-gui-162". This option is\n'
              'ignored if the GUI is already present in the environment')
     parser.add_argument(
+        '--gui-port', dest='port', type=int,
+        help='The Juju GUI service port. By default, the GUI listens on\n'
+             'ports 80 and 443, and insecure connections to port 80 are\n'
+             'redirected to port 443. If a port is specified then the\n'
+             'GUI service will only accept secure connections to that\n'
+             'port. This option is ignored if the GUI is already\n'
+             'present in the environment')
+    parser.add_argument(
         '--no-browser', action='store_false', dest='open_browser',
         help='Avoid opening the browser to the GUI at the end of the\nprocess')
-
     parser.add_argument(
         '--distro-only', action='store_true', dest='distro_only',
         default=default_distro_only, help=distro_only_help)
@@ -457,6 +496,15 @@
              'They will also be set as default constraints on the\n'
              'environment for all future machines, exactly as if the\n'
              'constraints were set with "juju set-constraints".\n')
+    # Hidden options.
+    parser.add_argument(
+        # The Juju GUI source branch (in github) to use when building the GUI.
+        # It has the form "<user>/<branch>", e.g. "juju/develop".
+        # It defaults to the local release included in the Juju GUI charm.
+        # This option is present for development purposes only, and it is
+        # ignored if the GUI is already present in the environment.
+        '--gui-source', dest='gui_source', help=argparse.SUPPRESS)
+
     # Parse the provided arguments.
     options = parser.parse_args()
 
@@ -464,12 +512,14 @@
     _configure_logging(logging.DEBUG if options.debug else logging.INFO)
 
     # Validate and add in the platform for convenience.
-    _validate_platform(parser, platform)
+    _validate_platform(platform, parser)
     options.platform = platform
 
     # Convert the provided string arguments to unicode.
     _convert_options_to_unicode(options)
     # Validate and process the provided arguments.
+    _validate_port(options.port, parser)
+    _validate_gui_source(options, parser)
     _setup_env(options, parser)
     if options.bundle_source is not None:
         _validate_bundle(options, parser)
@@ -553,24 +603,31 @@
     charm_ref, machine, service_data, unit_data = app.check_environment(
         env, settings.JUJU_GUI_SERVICE_NAME, options.charm_url,
         env_type, bootstrap_node_series, already_bootstrapped)
+    gui_options = jujugui.build_options(options.port, options.gui_source)
     unit_name = app.deploy_gui(
         env, settings.JUJU_GUI_SERVICE_NAME, charm_ref.id(), machine,
-        service_data, unit_data)
+        gui_options, service_data, unit_data)
 
-    # Observe the deployment progress.
+    # Observe the deployment progress, and retrieve information for connecting
+    # to the Juju GUI.
     address = app.watch(env, unit_name)
+    print('the Juju GUI is ready: retrieving service configuration')
+    gui_config = jujugui.normalize_config(
+        app.get_service_config(env, settings.JUJU_GUI_SERVICE_NAME))
     env.close()
 
     # Print out Juju GUI unit and credential information.
-    url = 'https://{}'.format(address)
+    url = utils.build_web_url(
+        address, gui_config['port'], gui_config['secure'])
     print('\nJuju GUI URL: {}\nusername: {}\npassword: {}\n'.format(
         url, username, password))
 
     # Connect to the GUI server WebSocket API.
     print('connecting to the Juju GUI server')
     gui_api_url = jujutools.get_api_url(
-        address + ':443', juju_version, env_uuid,
-        prefix='ws', charm_ref=charm_ref)
+        '{}:{}'.format(address, gui_config['port']), juju_version, env_uuid,
+        path_prefix='ws', charm_ref=charm_ref,
+        insecure=not gui_config['secure'])
     gui_env = app.connect(gui_api_url, username, password)
 
     # Handle bundle deployment.

=== modified file 'quickstart/platform_support.py'
--- quickstart/platform_support.py	2015-03-10 10:46:46 +0000
+++ quickstart/platform_support.py	2015-05-25 08:11:40 +0000
@@ -44,7 +44,6 @@
         settings.WINDOWS: 'juju-quickstart on Windows is not yet supported',
         settings.UNKNOWN_PLATFORM: 'unable to determine the OS platform',
     }
-
     error_msg = unsupported_messages.get(pf)
     if error_msg is not None:
         raise ValueError(error_msg.encode('utf-8'))

=== modified file 'quickstart/tests/test_app.py'
--- quickstart/tests/test_app.py	2015-04-21 10:22:46 +0000
+++ quickstart/tests/test_app.py	2015-05-25 08:11:40 +0000
@@ -1226,6 +1226,7 @@
         unittest.TestCase):
 
     charm_url = 'cs:trusty/juju-gui-42'
+    options = None
 
     def make_env(self, unit_name=None):
         """Create and return a mock environment object.
@@ -1245,11 +1246,13 @@
         env = self.make_env(unit_name='my-gui/42')
         service_data = unit_data = None
         unit_name = app.deploy_gui(
-            env, 'my-gui', self.charm_url, '0', service_data, unit_data)
+            env, 'my-gui', self.charm_url, '0', self.options,
+            service_data, unit_data)
         self.assertEqual('my-gui/42', unit_name)
         env.assert_has_calls([
             # The service has been deployed.
-            mock.call.deploy('my-gui', self.charm_url, num_units=0),
+            mock.call.deploy(
+                'my-gui', self.charm_url, num_units=0, config=None),
             # The service has been exposed.
             mock.call.expose('my-gui'),
             # One service unit has been added.
@@ -1264,13 +1267,37 @@
             mock.call('my-gui/42 deployment request accepted'),
         ])
 
+    def test_deployment_with_options(self, mock_print):
+        # The function correctly deploys the service with the given
+        # configuration options in the case the service is not present in the
+        # environment.
+        env = self.make_env(unit_name='my-gui/42')
+        service_data = unit_data = None
+        options = {'port': 4242, 'sandbox': True}
+        app.deploy_gui(
+            env, 'my-gui', self.charm_url, '0', options,
+            service_data, unit_data)
+        env.deploy.assert_called_once_with(
+            'my-gui', self.charm_url, num_units=0, config=options)
+        self.assertEqual(6, mock_print.call_count)
+        mock_print.assert_has_calls([
+            mock.call('requesting my-gui deployment'),
+            mock.call('using customized my-gui options:\n'
+                      '  port="4242"\n  sandbox="True"'),
+            mock.call('my-gui deployment request accepted'),
+            mock.call('exposing service my-gui'),
+            mock.call('requesting new unit deployment'),
+            mock.call('my-gui/42 deployment request accepted'),
+        ])
+
     def test_existing_service(self, mock_print):
         # The deployment is executed reusing an already deployed service.
         env = self.make_env(unit_name='my-gui/42')
         service_data = self.make_service_data()
         unit_data = None
         unit_name = app.deploy_gui(
-            env, 'my-gui', self.charm_url, '0', service_data, unit_data)
+            env, 'my-gui', self.charm_url, '0', self.options,
+            service_data, unit_data)
         self.assertEqual('my-gui/42', unit_name)
         # One service unit has been added.
         env.add_unit.assert_called_once_with('my-gui', machine_spec='0')
@@ -1285,13 +1312,27 @@
             mock.call('my-gui/42 deployment request accepted'),
         ])
 
+    def test_existing_service_with_options(self, mock_print):
+        # The deployment is executed reusing an already deployed service.
+        # In this case, the provided Juju GUI options are ignored.
+        env = self.make_env(unit_name='my-gui/42')
+        service_data = self.make_service_data()
+        unit_data = None
+        options = {'port': 4242, 'sandbox': True}
+        app.deploy_gui(
+            env, 'my-gui', self.charm_url, '0', options,
+            service_data, unit_data)
+        # The service is not re-deployed.
+        self.assertFalse(env.deploy.called)
+
     def test_existing_service_unexposed(self, mock_print):
         # The existing service is exposed if required.
         env = self.make_env(unit_name='my-gui/42')
         service_data = self.make_service_data({'Exposed': False})
         unit_data = None
         unit_name = app.deploy_gui(
-            env, 'my-gui', self.charm_url, '1', service_data, unit_data)
+            env, 'my-gui', self.charm_url, '1', self.options,
+            service_data, unit_data)
         self.assertEqual('my-gui/42', unit_name)
         env.assert_has_calls([
             # The service has been exposed.
@@ -1315,7 +1356,8 @@
         service_data = self.make_service_data()
         unit_data = self.make_unit_data()
         unit_name = app.deploy_gui(
-            env, 'my-gui', self.charm_url, '0', service_data, unit_data)
+            env, 'my-gui', self.charm_url, '0', self.options,
+            service_data, unit_data)
         self.assertEqual('my-gui/47', unit_name)
         # The service is not re-deployed.
         self.assertFalse(env.deploy.called)
@@ -1334,11 +1376,13 @@
         env = self.make_env(unit_name='my-gui/42')
         service_data = unit_data = None
         unit_name = app.deploy_gui(
-            env, 'my-gui', self.charm_url, None, service_data, unit_data)
+            env, 'my-gui', self.charm_url, None, self.options,
+            service_data, unit_data)
         self.assertEqual('my-gui/42', unit_name)
         env.assert_has_calls([
             # The service has been deployed.
-            mock.call.deploy('my-gui', self.charm_url, num_units=0),
+            mock.call.deploy(
+                'my-gui', self.charm_url, num_units=0, config=None),
             # The service has been exposed.
             mock.call.expose('my-gui'),
             # One service unit has been added to a new machine.
@@ -1352,10 +1396,10 @@
         service_data = unit_data = None
         with self.assert_program_exit('bad API response: bad wolf'):
             app.deploy_gui(
-                env, 'another-gui', self.charm_url, '0',
+                env, 'another-gui', self.charm_url, '0', self.options,
                 service_data, unit_data)
         env.deploy.assert_called_once_with(
-            'another-gui', self.charm_url, num_units=0)
+            'another-gui', self.charm_url, num_units=0, config=None)
 
     def test_expose_error(self, mock_print):
         # A ProgramExit is raised if an error occurs in the expose API call.
@@ -1364,7 +1408,7 @@
         service_data = unit_data = None
         with self.assert_program_exit('bad API response: bad wolf'):
             app.deploy_gui(
-                env, 'another-gui', self.charm_url, '0',
+                env, 'another-gui', self.charm_url, '0', self.options,
                 service_data, unit_data)
         env.expose.assert_called_once_with('another-gui')
 
@@ -1375,7 +1419,7 @@
         service_data = unit_data = None
         with self.assert_program_exit('bad API response: bad wolf'):
             app.deploy_gui(
-                env, 'another-gui', self.charm_url, '0',
+                env, 'another-gui', self.charm_url, '0', self.options,
                 service_data, unit_data)
         env.add_unit.assert_called_once_with('another-gui', machine_spec='0')
 
@@ -1387,10 +1431,10 @@
         service_data = unit_data = None
         with self.assertRaises(ValueError) as context_manager:
             app.deploy_gui(
-                env, 'juju-gui', self.charm_url, '0',
+                env, 'juju-gui', self.charm_url, '0', self.options,
                 service_data, unit_data)
         env.deploy.assert_called_once_with(
-            'juju-gui', self.charm_url, num_units=0)
+            'juju-gui', self.charm_url, num_units=0, config=None)
         env.expose.assert_called_once_with('juju-gui')
         self.assertIs(error, context_manager.exception)
 
@@ -1667,6 +1711,42 @@
         self.assertFalse(mock_print.called)
 
 
+class TestGetServiceConfig(ProgramExitTestsMixin, unittest.TestCase):
+
+    def test_success(self):
+        # The configuration options for the service are correctly returned.
+        env = mock.Mock()
+        env.get_config.return_value = {
+            'port': {
+                'description': 'Supply a different port',
+                'type': 'int',
+                'value': 8080,
+            },
+            'login-help': {
+                'default': True,
+                'description': 'The help text shown to the user',
+                'type': u'string',
+            },
+            'secure': {
+                'description': 'Security mode',
+                'type': 'boolean',
+                'value': False,
+            },
+        }
+        expected_config = {'port': 8080, 'login-help': None, 'secure': False}
+        config = app.get_service_config(env, 'django')
+        self.assertEqual(expected_config, config)
+        env.get_config.assert_called_once_with('django')
+
+    def test_api_error(self):
+        # A ProgramExit is raised if an error occurs while interacting with the
+        # Juju API.
+        env = mock.Mock()
+        env.get_config.side_effect = self.make_env_error('bad wolf')
+        with self.assert_program_exit('bad API server response: bad wolf'):
+            app.get_service_config(env, 'my-service')
+
+
 class TestDeployBundle(ProgramExitTestsMixin, unittest.TestCase):
 
     bundle_data = {'services': {}}

=== modified file 'quickstart/tests/test_juju.py'
--- quickstart/tests/test_juju.py	2015-02-26 19:46:48 +0000
+++ quickstart/tests/test_juju.py	2015-05-25 08:11:40 +0000
@@ -222,6 +222,17 @@
         mock_rpc.assert_called_once_with(expected)
 
     @patch_rpc
+    def test_get_config(self, mock_rpc):
+        # The API call to retrieve service configuration is properly generated.
+        self.env.get_config(self.service_name)
+        expected = {
+            'Type': 'Client',
+            'Request': 'ServiceGet',
+            'Params': {'ServiceName': self.service_name},
+        }
+        mock_rpc.assert_called_once_with(expected)
+
+    @patch_rpc
     def test_get_watcher(self, mock_rpc):
         # Environment watching is correctly started.
         self.env.login('Secret!')

=== added file 'quickstart/tests/test_jujugui.py'
--- quickstart/tests/test_jujugui.py	1970-01-01 00:00:00 +0000
+++ quickstart/tests/test_jujugui.py	2015-05-25 08:11:40 +0000
@@ -0,0 +1,123 @@
+# This file is part of the Juju Quickstart Plugin, which lets users set up a
+# Juju environment in very few steps (https://launchpad.net/juju-quickstart).
+# Copyright (C) 2015 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License version 3, as published by
+# the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+# SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the Quickstart Juju GUI charm and service helpers."""
+
+from __future__ import unicode_literals
+
+import unittest
+
+from jujubundlelib import references
+import mock
+
+from quickstart import jujugui
+from quickstart.tests import helpers
+
+
+class TestBuildOptions(unittest.TestCase):
+
+    def test_no_options(self):
+        # None is returned if there are no customized options.
+        options = jujugui.build_options(None, None)
+        self.assertIsNone(options)
+
+    def test_port(self):
+        # The port option is correctly configured.
+        options = jujugui.build_options(42, None)
+        self.assertEqual({'port': 42}, options)
+
+    def test_gui_source(self):
+        # The GUI source option is correctly configured.
+        options = jujugui.build_options(None, ('who', 'develop'))
+        expected_options = {
+            'juju-gui-source': 'https://github.com/who/juju-gui.git develop',
+        }
+        self.assertEqual(expected_options, options)
+
+    def test_all_options(self):
+        # Multiple options are properly configured.
+        options = jujugui.build_options(443, ('juju', 'beta'))
+        expected_options = {
+            'juju-gui-source': 'https://github.com/juju/juju-gui.git beta',
+            'port': 443,
+        }
+        self.assertEqual(expected_options, options)
+
+
+class TestNormalizeConfig(unittest.TestCase):
+
+    def test_normal_options(self):
+        # The options are not modified if there is no need.
+        original_options = {'port': 8080, 'secure': True}
+        options = jujugui.normalize_config(original_options)
+        self.assertEqual(original_options, options)
+
+    def test_port(self):
+        # A default port is set if it is not present in the input options.
+        options = jujugui.normalize_config({'port': None, 'secure': True})
+        self.assertEqual({'port': 443, 'secure': True}, options)
+
+    def test_not_modified_in_place(self):
+        # The input options are not modified in place.
+        original_options = {'port': None, 'sandbox': False, 'secure': True}
+        options = jujugui.normalize_config(original_options)
+        options['sandbox'] = True
+        self.assertEqual(
+            {'port': 443, 'sandbox': True, 'secure': True}, options)
+        self.assertEqual(
+            {'port': None, 'sandbox': False, 'secure': True}, original_options)
+
+    def test_secure_warning(self):
+        # A warning is logged if the GUI service is running in insecure mode.
+        expected_log = 'the Juju GUI is running in insecure mode'
+        with helpers.assert_logs([expected_log], level='warn'):
+            jujugui.normalize_config({'port': 8080, 'secure': False})
+
+
[e-mail]('__builtin__.print', mock.Mock())
+class TestParseGuiCharmUrl(unittest.TestCase):
+
+    def test_charm_instance_returned(self):
+        # A charm reference instance is correctly returned.
+        ref = jujugui.parse_charm_url('cs:trusty/juju-gui-42')
+        self.assertIsInstance(ref, references.Reference)
+        self.assertEqual('cs:trusty/juju-gui-42', ref.id())
+
+    def test_customized(self):
+        # A customized charm reference is properly logged.
+        expected = 'using a customized juju-gui charm'
+        with helpers.assert_logs([expected], level='warn'):
+            jujugui.parse_charm_url('cs:~juju-gui/precise/juju-gui-28')
+
+    def test_outdated(self):
+        # An outdated charm reference is properly logged.
+        expected = 'charm is outdated and may not support bundle deployments'
+        with helpers.assert_logs([expected], level='warn'):
+            jujugui.parse_charm_url('cs:precise/juju-gui-1')
+
+    def test_unexpected(self):
+        # An unexpected charm reference is properly logged.
+        expected = (
+            'unexpected URL for the juju-gui charm: the service may not work '
+            'as expected')
+        with helpers.assert_logs([expected], level='warn'):
+            jujugui.parse_charm_url('cs:precise/another-gui-42')
+
+    def test_official(self):
+        # No warnings are logged if an up to date charm is passed.
+        with mock.patch('logging.warn') as mock_warn:
+            jujugui.parse_charm_url('cs:precise/juju-gui-100')
+        self.assertFalse(mock_warn.called)

=== modified file 'quickstart/tests/test_jujutools.py'
--- quickstart/tests/test_jujutools.py	2015-04-21 10:22:46 +0000
+++ quickstart/tests/test_jujutools.py	2015-05-25 08:11:40 +0000
@@ -21,7 +21,6 @@
 import unittest
 
 from jujubundlelib import references
-import mock
 import yaml
 
 from quickstart import jujutools
@@ -35,37 +34,57 @@
         url = jujutools.get_api_url('1.2.3.4:17070', (1, 22, 0), 'env-uuid')
         self.assertEqual('wss://1.2.3.4:17070/environment/env-uuid/api', url)
 
-    def test_new_url_with_prefix(self):
+    def test_new_url_with_path_prefix(self):
         # The new Juju API endpoint is returned with the given path prefix.
         url = jujutools.get_api_url(
-            '1.2.3.4:17070', (1, 22, 0), 'env-uuid', prefix='/my/path/')
+            '1.2.3.4:17070', (1, 22, 0), 'env-uuid', path_prefix='/my/path/')
         self.assertEqual(
             'wss://1.2.3.4:17070/my/path/environment/env-uuid/api', url)
 
+    def test_new_url_with_insecure(self):
+        # The new Juju API endpoint is returned with insecure schema.
+        url = jujutools.get_api_url(
+            '1.2.3.4:17070', (1, 22, 0), 'env-uuid', insecure=True)
+        self.assertEqual('ws://1.2.3.4:17070/environment/env-uuid/api', url)
+
     def test_old_juju(self):
         # The old Juju API endpoint is returned if the Juju in use is not a
         # recent version.
         url = jujutools.get_api_url('1.2.3.4:17070', (1, 21, 7), 'env-uuid')
         self.assertEqual('wss://1.2.3.4:17070', url)
 
-    def test_old_juju_with_prefix(self):
+    def test_old_juju_with_path_prefix(self):
         # The old Juju API endpoint is returned with the given path prefix.
         url = jujutools.get_api_url(
-            '1.2.3.4:8888', (1, 21, 7), 'env-uuid', 'proxy/')
+            '1.2.3.4:8888', (1, 21, 7), 'env-uuid', path_prefix='proxy/')
         self.assertEqual('wss://1.2.3.4:8888/proxy', url)
 
+    def test_old_juju_with_insecure(self):
+        # The old Juju API endpoint is returned with insecure schema.
+        url = jujutools.get_api_url(
+            '1.2.3.4:8888', (1, 21, 7), 'env-uuid', insecure=True)
+        self.assertEqual('ws://1.2.3.4:8888', url)
+
     def test_no_env_uuid(self):
         # The old Juju API endpoint is returned if the environment unique
         # identifier is unreachable.
         url = jujutools.get_api_url('1.2.3.4:17070', (1, 23, 42), None)
         self.assertEqual('wss://1.2.3.4:17070', url)
 
-    def test_no_env_uuid_with_prefix(self):
+    def test_no_env_uuid_with_path_prefix(self):
         # The old Juju API endpoint is returned with the given path prefix.
+        # In this case the environment unique identifier is unreachable.
         url = jujutools.get_api_url(
-            '1.2.3.4:17070', (1, 23, 42), None, 'my/prefix')
+            '1.2.3.4:17070', (1, 23, 42), None, path_prefix='my/prefix')
         self.assertEqual('wss://1.2.3.4:17070/my/prefix', url)
 
+    def test_no_env_uuid_with_customized_schema(self):
+        # The old Juju API endpoint is returned with insecure schema.
+        # In this case the environment unique identifier is unreachable.
+        url = jujutools.get_api_url(
+            '1.2.3.4:17070', (1, 23, 42), None, insecure=True)
+        self.assertEqual('ws://1.2.3.4:17070', url)
+
     def test_new_charm_old_juju(self):
         # The old Juju API endpoints are used if and old version of Juju is in
         # use, even if the Juju GUI charm is recent.
@@ -99,7 +118,8 @@
         ref = references.Reference.from_fully_qualified_url(
             'local:precise/juju-gui-0')
         url = jujutools.get_api_url(
-            'example.com:17070', (1, 22, 2), 'uuid', prefix='/', charm_ref=ref)
+            'example.com:17070', (1, 22, 2), 'uuid', path_prefix='/',
+            charm_ref=ref)
         self.assertEqual('wss://example.com:17070/environment/uuid/api', url)
 
     def test_customized_charm_unexpected_series(self):
@@ -108,7 +128,8 @@
         ref = references.Reference.from_fully_qualified_url(
             'cs:vivid/juju-gui-0')
         url = jujutools.get_api_url(
-            'example.com:22', (1, 22, 2), 'uuid', prefix='ws', charm_ref=ref)
+            'example.com:22', (1, 22, 2), 'uuid', path_prefix='ws',
+            charm_ref=ref)
         self.assertEqual('wss://example.com:22/ws/environment/uuid/api', url)
 
     def test_recent_precise_charm(self):
@@ -142,19 +163,33 @@
         ref = references.Reference.from_fully_qualified_url(
             'cs:trusty/juju-gui-18')
         url = jujutools.get_api_url(
-            '1.2.3.4:4747', (1, 42, 0), 'env-uuid', prefix='ws', charm_ref=ref)
+            '1.2.3.4:4747', (1, 42, 0), 'env-uuid', path_prefix='ws',
+            charm_ref=ref)
         self.assertEqual('wss://1.2.3.4:4747/ws', url)
 
-    def test_recent_charm_and_prefix(self):
+    def test_recent_charm_with_path_prefix(self):
         # The new API endpoint is returned if a recent charm and a prefix are
         # both provided. This test exercises the real case in which the GUI
         # server API endpoint is returned.
         ref = references.Reference.from_fully_qualified_url(
             'cs:trusty/juju-gui-42')
         url = jujutools.get_api_url(
-            '1.2.3.4:17070', (1, 22, 0), 'env-id', prefix='ws', charm_ref=ref)
+            '1.2.3.4:17070', (1, 22, 0), 'env-id', path_prefix='ws',
+            charm_ref=ref)
         self.assertEqual('wss://1.2.3.4:17070/ws/environment/env-id/api', url)
 
+    def test_recent_charm_with_path_prefix_and_schema(self):
+        # The new API endpoint is returned if a recent charm, a path prefix and
+        # insecure schema are provided. this test exercises the real case
+        # in which the GUI server API endpoint is returned, and the GUI is
+        # configured in insecure mode.
+        ref = references.Reference.from_fully_qualified_url(
+            'cs:trusty/juju-gui-42')
+        url = jujutools.get_api_url(
+            '1.2.3.4:80', (1, 22, 0), 'env-id', insecure=True,
+            path_prefix='ws', charm_ref=ref)
+        self.assertEqual('ws://1.2.3.4:80/ws/environment/env-id/api', url)
+
 
 class TestGetServiceInfo(helpers.WatcherDataTestsMixin, unittest.TestCase):
 
@@ -237,42 +272,6 @@
         self.assertEqual(expected, jujutools.get_service_info([], 'my-gui'))
 
 
[e-mail]('__builtin__.print', mock.Mock())
-class TestParseGuiCharmUrl(unittest.TestCase):
-
-    def test_charm_instance_returned(self):
-        # A charm reference instance is correctly returned.
-        ref = jujutools.parse_gui_charm_url('cs:trusty/juju-gui-42')
-        self.assertIsInstance(ref, references.Reference)
-        self.assertEqual('cs:trusty/juju-gui-42', ref.id())
-
-    def test_customized(self):
-        # A customized charm reference is properly logged.
-        expected = 'using a customized juju-gui charm'
-        with helpers.assert_logs([expected], level='warn'):
-            jujutools.parse_gui_charm_url('cs:~juju-gui/precise/juju-gui-28')
-
-    def test_outdated(self):
-        # An outdated charm reference is properly logged.
-        expected = 'charm is outdated and may not support bundle deployments'
-        with helpers.assert_logs([expected], level='warn'):
-            jujutools.parse_gui_charm_url('cs:precise/juju-gui-1')
-
-    def test_unexpected(self):
-        # An unexpected charm reference is properly logged.
-        expected = (
-            'unexpected URL for the juju-gui charm: the service may not work '
-            'as expected')
-        with helpers.assert_logs([expected], level='warn'):
-            jujutools.parse_gui_charm_url('cs:precise/another-gui-42')
-
-    def test_official(self):
-        # No warnings are logged if an up to date charm is passed.
-        with mock.patch('logging.warn') as mock_warn:
-            jujutools.parse_gui_charm_url('cs:precise/juju-gui-100')
-        self.assertFalse(mock_warn.called)
-
-
 class TestParseStatusOutput(helpers.ValueErrorTestsMixin, unittest.TestCase):
 
     def test_invalid_yaml(self):

=== modified file 'quickstart/tests/test_manage.py'
--- quickstart/tests/test_manage.py	2015-04-21 10:22:46 +0000
+++ quickstart/tests/test_manage.py	2015-05-25 08:11:40 +0000
@@ -334,19 +334,47 @@
             'the storage port field requires an integer value')
 
 
+class TestValidateGuiSource(unittest.TestCase):
+
+    def setUp(self):
+        # Set up a parser.
+        self.parser = mock.Mock()
+
+    def test_valid_source(self):
+        # The user and branch are stored if the source is valid.
+        options = mock.Mock(gui_source='juju/develop')
+        manage._validate_gui_source(options, self.parser)
+        self.assertFalse(self.parser.error.called)
+        self.assertEqual(('juju', 'develop'), options.gui_source)
+
+    def test_source_not_set(self):
+        # Nothing happens if the source is not set.
+        options = mock.Mock(gui_source=None)
+        manage._validate_gui_source(options, self.parser)
+        self.assertFalse(self.parser.error.called)
+        self.assertIsNone(options.gui_source)
+
+    def test_invalid_source(self):
+        # A parser error is invoked if the provided source is not valid.
+        for value in ('', 'develop', 'who/ ', '/value/not/valid', '/who'):
+            options = mock.Mock(gui_source=value)
+            manage._validate_gui_source(options, self.parser)
+            self.parser.error.assert_called_once_with(
+                'invalid Juju GUI source: {}'.format(value))
+            self.parser.error.reset_mock()
+
+
 class TestValidatePlatform(unittest.TestCase):
 
     def setUp(self):
-        # Set up a parser, the environments metadata and a testing env_db.
+        # Set up a parser.
         self.parser = mock.Mock()
-        self.env_type_db = envs.get_env_type_db()
-        self.env_db = helpers.make_env_db()
 
     def test_platform_validation_fails(self):
         # If the platform validation fails a parser error is given.
         path = 'quickstart.manage.platform_support.validate_platform'
         with mock.patch(path, side_effect=ValueError('Bad platform, yo')):
-            manage._validate_platform(self.parser, settings.LINUX_RPM)
+            manage._validate_platform(settings.LINUX_RPM, self.parser)
         self.parser.error.assert_called_once_with(
             'Bad platform, yo')
 
@@ -354,10 +382,33 @@
         # If the platform validation passes it returns None.
         path = 'quickstart.platform_support.validate_platform'
         with mock.patch(path, side_effect=None):
-            result = manage._validate_platform(self.parser, settings.LINUX_RPM)
+            result = manage._validate_platform(settings.LINUX_RPM, self.parser)
         self.assertIsNone(result)
 
 
+class TestValidatePort(unittest.TestCase):
+
+    def setUp(self):
+        # Set up a parser.
+        self.parser = mock.Mock()
+
+    def test_valid_port(self):
+        # Nothing happens if the provided port is valid.
+        manage._validate_port(80, self.parser)
+        self.assertFalse(self.parser.error.called)
+
+    def test_port_not_set(self):
+        # Nothing happens if the port is not set.
+        manage._validate_port(None, self.parser)
+        self.assertFalse(self.parser.error.called)
+
+    def test_port_not_in_range(self):
+        # A parser error is invoked if the provided port is not valid.
+        manage._validate_port(-1, self.parser)
+        self.parser.error.assert_called_once_with(
+            'invalid Juju GUI port: not in range 1-65535')
+
+
 class TestSetupEnv(
         helpers.EnvFileTestsMixin, helpers.JenvFileTestsMixin,
         unittest.TestCase):
@@ -645,10 +696,12 @@
             'bundle_source': None,
             'charm_url': None,
             'debug': False,
+            'default_series': None,
             'env_name': 'aws',
             'env_type': 'ec2',
+            'gui_source': None,
             'open_browser': True,
-            'default_series': None,
+            'port': None,
         }
         options.update(kwargs)
         return mock.Mock(**options)
@@ -696,6 +749,8 @@
             'deploy_gui': 'juju-gui/0',
             # Watch the deployment progress and return the unit address.
             'watch': '1.2.3.5',
+            # Retrieve the Juju GUI service configuration.
+            'get_service_config': {'port': None, 'secure': True},
             # Create the login token for the Juju GUI.
             'create_auth_token': 'TOKEN',
         }
@@ -751,7 +806,7 @@
             options.env_type, 'trusty', False)
         mock_app.deploy_gui.assert_called_once_with(
             env, settings.JUJU_GUI_SERVICE_NAME, 'cs:trusty/juju-gui-42',
-            '0', {'Name': 'juju-gui'}, {'Name': 'juju-gui/0'})
+            '0', None, {'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.5/?authtoken=TOKEN')
@@ -798,6 +853,54 @@
             mock.call().close(),
         ])
 
+    def test_customized_gui_service_port(self, mock_app, mock_open):
+        # The GUI API connection and the Web browser URL reflect the customized
+        # Juju GUI service port option.
+        self.configure_app(
+            mock_app, get_service_config={'port': 8080, 'secure': True})
+        # Run the application.
+        options = self.make_options()
+        with self.patch_get_juju_command():
+            manage.run(options)
+        mock_app.connect.assert_has_calls([
+            mock.call(
+                'wss://1.2.3.4:17070/environment/env-uuid/api',
+                'MyUser',
+                'Secret!'),
+            mock.call().close(),
+            mock.call(
+                'wss://1.2.3.5:8080/ws/environment/env-uuid/api',
+                'MyUser',
+                'Secret!'),
+            mock.call().close(),
+        ])
+        mock_open.assert_called_once_with(
+            'https://1.2.3.5:8080/?authtoken=TOKEN')
+
+    def test_insecure_gui_service(self, mock_app, mock_open):
+        # The GUI server API and the Web browser connections can be established
+        # in insecure mode.
+        self.configure_app(
+            mock_app, get_service_config={'port': 443, 'secure': False})
+        # Run the application.
+        options = self.make_options()
+        with self.patch_get_juju_command():
+            manage.run(options)
+        mock_app.connect.assert_has_calls([
+            mock.call(
+                'wss://1.2.3.4:17070/environment/env-uuid/api',
+                'MyUser',
+                'Secret!'),
+            mock.call().close(),
+            mock.call(
+                'ws://1.2.3.5:443/ws/environment/env-uuid/api',
+                'MyUser',
+                'Secret!'),
+            mock.call().close(),
+        ])
+        mock_open.assert_called_once_with(
+            'http://1.2.3.5:443/?authtoken=TOKEN')
+
     def test_already_bootstrapped(self, mock_app, mock_open):
         # The application correctly reuses an already bootstrapped environment.
         env = self.configure_app(mock_app, check_bootstrapped='example.com')
@@ -845,6 +948,21 @@
         mock_app.create_auth_token.assert_called_once_with(env)
         mock_open.assert_called_once_with('https://1.2.3.5')
 
+    def test_gui_options(self, mock_app, mock_open):
+        # The Juju GUI is deployed with customized options if required.
+        env = self.configure_app(mock_app)
+        # Run the application.
+        options = self.make_options(gui_source=('juju', 'develop'), port=4242)
+        with self.patch_get_juju_command():
+            manage.run(options)
+        expected_config = {
+            'port': 4242,
+            'juju-gui-source': u'https://github.com/juju/juju-gui.git develop',
+        }
+        mock_app.deploy_gui.assert_called_once_with(
+            env, settings.JUJU_GUI_SERVICE_NAME, 'cs:trusty/juju-gui-42',
+            '0', expected_config, {'Name': 'juju-gui'}, {'Name': 'juju-gui/0'})
+
     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)

=== modified file 'quickstart/tests/test_utils.py'
--- quickstart/tests/test_utils.py	2015-03-10 10:46:46 +0000
+++ quickstart/tests/test_utils.py	2015-05-25 08:11:40 +0000
@@ -112,6 +112,29 @@
             'apt-get install error', bytes(context_manager.exception))
 
 
+class TestBuildWebUrl(unittest.TestCase):
+
+    def test_https(self):
+        # A default secure URL is returned.
+        url = utils.build_web_url('1.2.3.4', 443, True)
+        self.assertEqual('https://1.2.3.4', url)
+
+    def test_http(self):
+        # A default insecure URL is returned.
+        url = utils.build_web_url('4.3.2.1', 80, False)
+        self.assertEqual('http://4.3.2.1', url)
+
+    def test_https_customized_port(self):
+        # A secure URL with customized port is returned.
+        url = utils.build_web_url('1.2.3.4', 4242, True)
+        self.assertEqual('https://1.2.3.4:4242', url)
+
+    def test_http_customized_port(self):
+        # An insecure URL with customized port is returned.
+        url = utils.build_web_url('example.com', 8000, False)
+        self.assertEqual('http://example.com:8000', url)
+
+
 class TestCall(unittest.TestCase):
 
     def test_success(self):

=== modified file 'quickstart/utils.py'
--- quickstart/utils.py	2015-03-10 10:46:46 +0000
+++ quickstart/utils.py	2015-05-25 08:11:40 +0000
@@ -59,6 +59,20 @@
             raise OSError(error.encode('utf-8'))
 
 
+def build_web_url(address, port, secure):
+    """Build a Web URL based on the given schemaless address, port, security.
+
+    The secure argument specifies whether to use HTTP or HTTPS protocol.
+
+    Return the URL as a string.
+    """
+    schema, default_port = 'http', 80
+    if secure:
+        schema, default_port = 'https', 443
+    port_part = '' if port == default_port else ':{}'.format(port)
+    return '{}://{}{}'.format(schema, address, port_part)
+
+
 def call(command, *args):
     """Call a subprocess passing the given arguments.