Merge ~mpontillo/maas:better-default-maas-url--bug-1418044 into maas:master

[Mike Pontillo]

LP: #1418044 - Improve heuristic for determining best MAAS URL if it is not specifically configured.

[MAAS Lander (maas-lander)]

UNIT TESTS
-b better-default-maas-url--bug-1418044 lp:~mpontillo/maas into -b master lp:~maas-committers/maas

STATUS: FAILED
LOG: http://maas-ci-jenkins.internal:8080/job/maas/job/branch-tester/618/console
COMMIT: 25861b7702b4a6a29f061ac0994a6f0f4d78703d

review: Needs Fixing

[Lee Trager (ltrager)]

LGTM!

review: Approve

c01a722... by Mike Pontillo on 2017-11-02

Fix tests.

diff --git a/src/maasserver/compose_preseed.py b/src/maasserver/compose_preseed.py
index 672a981..e15b3b2 100644
--- a/src/maasserver/compose_preseed.py
+++ b/src/maasserver/compose_preseed.py
@@ -31,7 +31,7 @@ import yaml
 RSYSLOG_PORT = 514
 
 
-def get_apt_proxy(rack_controller=None):
+def get_apt_proxy(rack_controller=None, default_region_ip=None):
     """Return the APT proxy for the `rack_controller`."""
     if Config.objects.get_config("enable_http_proxy"):
         http_proxy = Config.objects.get_config("http_proxy")
@@ -42,7 +42,8 @@ def get_apt_proxy(rack_controller=None):
             return http_proxy
         else:
             return compose_URL(
-                "http://:8000/", get_maas_facing_server_host(rack_controller))
+                "http://:8000/", get_maas_facing_server_host(
+                    rack_controller, default_region_ip=default_region_ip))
     else:
         return None
 
@@ -55,11 +56,12 @@ def make_clean_repo_name(repo):
     return repo_name.strip().replace(' ', '_').lower()
 
 
-def get_archive_config(node, preserve_sources=False):
+def get_archive_config(node, preserve_sources=False, default_region_ip=None):
     arch = node.split_arch()[0]
     archive = PackageRepository.objects.get_default_archive(arch)
     repositories = PackageRepository.objects.get_additional_repositories(arch)
-    apt_proxy = get_apt_proxy(node.get_boot_rack_controller())
+    apt_proxy = get_apt_proxy(
+        node.get_boot_rack_controller(), default_region_ip=default_region_ip)
 
     # Process the default Ubuntu Archives or Mirror.
     archives = {}
@@ -147,15 +149,15 @@ def get_archive_config(node, preserve_sources=False):
     return archives
 
 
-def get_cloud_init_reporting(node, token, base_url):
+def get_cloud_init_reporting(node, token, base_url, default_region_ip=None):
     """Return the cloud-init metadata to enable reporting"""
     return {
         'reporting': {
             'maas': {
                 'type': 'webhook',
                 'endpoint': absolute_reverse(
-                    'metadata-status', args=[node.system_id],
-                    base_url=base_url),
+                    'metadata-status', default_region_ip=default_region_ip,
+                    args=[node.system_id], base_url=base_url),
                 'consumer_key': token.consumer.key,
                 'token_key': token.key,
                 'token_secret': token.secret,
@@ -164,11 +166,11 @@ def get_cloud_init_reporting(node, token, base_url):
     }
 
 
-def get_rsyslog_host_port(node):
+def get_rsyslog_host_port(node, default_region_ip=None):
     """Return the rsyslog host and port to use."""
-    # TODO: In the future, we can make this configurable
-    return "%s:%d" % (get_maas_facing_server_host(
-        node.get_boot_rack_controller()), RSYSLOG_PORT)
+    host = get_maas_facing_server_host(
+        node.get_boot_rack_controller(), default_region_ip=default_region_ip)
+    return "%s:%d" % (host, RSYSLOG_PORT)
 
 
 def get_system_info():
@@ -207,7 +209,8 @@ def get_system_info():
     }
 
 
-def compose_cloud_init_preseed(node, token, base_url=''):
+def compose_cloud_init_preseed(
+        node, token, base_url='', default_region_ip=None):
     """Compose the preseed value for a node in any state but Commissioning.
 
     Returns cloud-config that's preseeded to cloud-init via debconf (It only
@@ -236,14 +239,20 @@ def compose_cloud_init_preseed(node, token, base_url=''):
     # This will allow cloud-init to be configured with reporting for
     # a node that has already been installed.
     config.update(
-        get_cloud_init_reporting(node=node, token=token, base_url=base_url))
+        get_cloud_init_reporting(
+            node=node, token=token, base_url=base_url,
+            default_region_ip=default_region_ip))
     # Add the system configuration information.
     config.update(get_system_info())
-    apt_proxy = get_apt_proxy(node.get_boot_rack_controller())
+    apt_proxy = get_apt_proxy(
+        node.get_boot_rack_controller(), default_region_ip=default_region_ip)
     if apt_proxy:
         config['apt_proxy'] = apt_proxy
     # Add APT configuration for new cloud-init (>= 0.7.7-17)
-    config.update(get_archive_config(node=node, preserve_sources=False))
+    config.update(
+        get_archive_config(
+            node=node, preserve_sources=False,
+            default_region_ip=default_region_ip))
 
     local_config_yaml = yaml.safe_dump(config)
     # this is debconf escaping
@@ -254,7 +263,8 @@ def compose_cloud_init_preseed(node, token, base_url=''):
     preseed_items = [
         ('datasources', 'multiselect', 'MAAS'),
         ('maas-metadata-url', 'string', absolute_reverse(
-            'metadata', base_url=base_url)),
+            'metadata', default_region_ip=default_region_ip,
+            base_url=base_url)),
         ('maas-metadata-credentials', 'string', credentials),
         ('local-cloud-config', 'string', local_config)
         ]
@@ -268,28 +278,34 @@ def compose_cloud_init_preseed(node, token, base_url=''):
         for item_name, item_type, item_value in preseed_items)
 
 
-def compose_commissioning_preseed(node, token, base_url=''):
+def compose_commissioning_preseed(
+        node, token, base_url='', default_region_ip=None):
     """Compose the preseed value for a Commissioning node."""
-    metadata_url = absolute_reverse('metadata', base_url=base_url)
+    metadata_url = absolute_reverse(
+        'metadata', default_region_ip=default_region_ip, base_url=base_url)
     if node.status == NODE_STATUS.DISK_ERASING:
         poweroff_timeout = timedelta(days=7).total_seconds()  # 1 week
     else:
         poweroff_timeout = timedelta(hours=1).total_seconds()  # 1 hour
     return _compose_cloud_init_preseed(
         node, token, metadata_url, base_url=base_url,
-        poweroff_timeout=int(poweroff_timeout))
+        poweroff_timeout=int(poweroff_timeout),
+        default_region_ip=default_region_ip)
 
 
-def compose_curtin_preseed(node, token, base_url=''):
+def compose_curtin_preseed(node, token, base_url='', default_region_ip=None):
     """Compose the preseed value for a node being installed with curtin."""
-    metadata_url = absolute_reverse('curtin-metadata', base_url=base_url)
+    metadata_url = absolute_reverse(
+        'curtin-metadata', default_region_ip=default_region_ip,
+        base_url=base_url)
     return _compose_cloud_init_preseed(
-        node, token, metadata_url, base_url=base_url)
+        node, token, metadata_url, base_url=base_url,
+        default_region_ip=default_region_ip)
 
 
 def _compose_cloud_init_preseed(
         node, token, metadata_url, base_url, poweroff_timeout=3600,
-        reboot_timeout=1800):
+        reboot_timeout=1800, default_region_ip=None):
     cloud_config = {
         'datasource': {
             'MAAS': {
@@ -302,7 +318,8 @@ def _compose_cloud_init_preseed(
         # This configure rsyslog for the ephemeral environment
         'rsyslog': {
             'remotes': {
-                'maas': get_rsyslog_host_port(node),
+                'maas': get_rsyslog_host_port(
+                    node, default_region_ip=default_region_ip),
             }
         },
         # The ephemeral environment doesn't have a domain search path set which
@@ -315,14 +332,19 @@ def _compose_cloud_init_preseed(
     }
     # This configures reporting for the ephemeral environment
     cloud_config.update(
-        get_cloud_init_reporting(node=node, token=token, base_url=base_url))
+        get_cloud_init_reporting(
+            node=node, token=token, base_url=base_url,
+            default_region_ip=default_region_ip))
     # Add the system configuration information.
     cloud_config.update(get_system_info())
-    apt_proxy = get_apt_proxy(node.get_boot_rack_controller())
+    apt_proxy = get_apt_proxy(
+        node.get_boot_rack_controller(), default_region_ip=default_region_ip)
     if apt_proxy:
         cloud_config['apt_proxy'] = apt_proxy
     # Add APT configuration for new cloud-init (>= 0.7.7-17)
-    cloud_config.update(get_archive_config(node=node, preserve_sources=False))
+    cloud_config.update(get_archive_config(
+        node=node, preserve_sources=False,
+        default_region_ip=default_region_ip))
 
     enable_ssh = (node.status in {
         NODE_STATUS.COMMISSIONING,
@@ -352,14 +374,17 @@ def _compose_cloud_init_preseed(
     return "#cloud-config\n%s" % yaml.safe_dump(cloud_config)
 
 
-def _get_metadata_url(preseed_type, base_url):
+def _get_metadata_url(preseed_type, base_url, default_region_ip=None):
     if preseed_type == PRESEED_TYPE.CURTIN:
-        return absolute_reverse('curtin-metadata', base_url=base_url)
+        return absolute_reverse(
+            'curtin-metadata', default_region_ip=default_region_ip,
+            base_url=base_url)
     else:
-        return absolute_reverse('metadata', base_url=base_url)
+        return absolute_reverse(
+            'metadata', default_region_ip=default_region_ip, base_url=base_url)
 
 
-def compose_preseed(preseed_type, node):
+def compose_preseed(preseed_type, node, default_region_ip=None):
     """Put together preseed data for `node`.
 
     This produces preseed data for the node in different formats depending
@@ -369,6 +394,8 @@ def compose_preseed(preseed_type, node):
     :type preseed_type: string
     :param node: The node to compose preseed data for.
     :type node: Node
+    :param default_region_ip: The default IP address to use for the region
+        controller (for example, when constructing URLs).
     :return: Preseed data containing the information the node needs in order
         to access the metadata service: its URL and auth token.
     """
@@ -380,9 +407,11 @@ def compose_preseed(preseed_type, node):
     base_url = rack_controller.url
 
     if preseed_type == PRESEED_TYPE.COMMISSIONING:
-        return compose_commissioning_preseed(node, token, base_url)
+        return compose_commissioning_preseed(
+            node, token, base_url, default_region_ip=default_region_ip)
     else:
-        metadata_url = _get_metadata_url(preseed_type, base_url)
+        metadata_url = _get_metadata_url(
+            preseed_type, base_url, default_region_ip=default_region_ip)
 
         try:
             return get_preseed_data(preseed_type, node, token, metadata_url)
@@ -410,6 +439,8 @@ def compose_preseed(preseed_type, node):
 
         # There is no OS-specific preseed data.
         if preseed_type == PRESEED_TYPE.CURTIN:
-            return compose_curtin_preseed(node, token, base_url)
+            return compose_curtin_preseed(
+                node, token, base_url, default_region_ip=default_region_ip)
         else:
-            return compose_cloud_init_preseed(node, token, base_url)
+            return compose_cloud_init_preseed(
+                node, token, base_url, default_region_ip=default_region_ip)
diff --git a/src/maasserver/preseed.py b/src/maasserver/preseed.py
index 3475dd0..f2ed29c 100644
--- a/src/maasserver/preseed.py
+++ b/src/maasserver/preseed.py
@@ -95,7 +95,7 @@ OS_WITH_IPv6_SUPPORT = ['ubuntu']
 CURTIN_INSTALL_LOG = "/tmp/install.log"
 
 
-def get_enlist_preseed(rack_controller=None):
+def get_enlist_preseed(rack_controller=None, default_region_ip=None):
     """Return the enlistment preseed.
 
     :param rack_controller: The rack controller used to generate the preseed.
@@ -103,17 +103,19 @@ def get_enlist_preseed(rack_controller=None):
     :rtype: unicode.
     """
     return render_enlistment_preseed(
-        PRESEED_TYPE.ENLIST, rack_controller=rack_controller)
+        PRESEED_TYPE.ENLIST, rack_controller=rack_controller,
+        default_region_ip=default_region_ip)
 
 
-def get_enlist_userdata(rack_controller=None):
+def get_enlist_userdata(rack_controller=None, default_region_ip=None):
     """Return the enlistment preseed.
 
     :param rack_controller: The rack controller used to generate the preseed.
     :return: The rendered enlistment user-data string.
     :rtype: unicode.
     """
-    http_proxy = get_apt_proxy(rack_controller=rack_controller)
+    http_proxy = get_apt_proxy(
+        rack_controller=rack_controller, default_region_ip=default_region_ip)
     enlist_userdata = render_enlistment_preseed(
         USERDATA_TYPE.ENLIST, rack_controller=rack_controller)
     config = get_system_info()
@@ -340,7 +342,7 @@ def compose_curtin_verbose_preseed():
         return []
 
 
-def get_curtin_yaml_config(node):
+def get_curtin_yaml_config(node, default_region_ip=None):
     """Return the curtin configration for the node."""
     main_config = get_curtin_config(node)
     cloud_config = compose_curtin_cloud_config(node)
@@ -401,7 +403,7 @@ def get_curtin_merged_config(node):
     return config
 
 
-def get_curtin_userdata(node):
+def get_curtin_userdata(node, default_region_ip=None):
     """Return the curtin user-data.
 
     :param node: The node for which to generate the user-data.
@@ -411,7 +413,7 @@ def get_curtin_userdata(node):
     # Pack the curtin and the configuration into a script to execute on the
     # deploying node.
     return pack_install(
-        configs=get_curtin_yaml_config(node),
+        configs=get_curtin_yaml_config(node, default_region_ip),
         args=[get_curtin_installer_url(node)])
 
 
@@ -473,7 +475,7 @@ def get_curtin_installer_url(node):
     return url_prepend + url
 
 
-def get_curtin_config(node):
+def get_curtin_config(node, default_region_ip=None):
     """Return the curtin configuration to be used by curtin.pack_install.
 
     :param node: The node for which to generate the configuration.
@@ -485,11 +487,16 @@ def get_curtin_config(node):
         node, USERDATA_TYPE.CURTIN, osystem, series)
     rack_controller = node.get_boot_rack_controller()
     context = get_preseed_context(
-        osystem, series, rack_controller=rack_controller)
+        osystem, series, rack_controller=rack_controller,
+        default_region_ip=default_region_ip)
     context.update(
         get_node_preseed_context(
-            node, osystem, series, rack_controller=rack_controller))
-    context.update(get_curtin_context(node, rack_controller=rack_controller))
+            node, osystem, series, rack_controller=rack_controller,
+            default_region_ip=default_region_ip))
+    context.update(
+        get_curtin_context(
+            node, rack_controller=rack_controller,
+            default_region_ip=default_region_ip))
     deprecated_context_variables = [
         'main_archive_hostname', 'main_archive_directory',
         'ports_archive_hostname', 'ports_archive_directory',
@@ -534,7 +541,7 @@ def get_curtin_config(node):
     return yaml.safe_dump(config)
 
 
-def get_curtin_context(node, rack_controller=None):
+def get_curtin_context(node, rack_controller=None, default_region_ip=None):
     """Return the curtin-specific context dictionary to be used to render
     user-data templates.
 
@@ -546,7 +553,8 @@ def get_curtin_context(node, rack_controller=None):
         rack_controller = node.get_boot_rack_controller()
     base_url = rack_controller.url
     return {
-        'curtin_preseed': compose_cloud_init_preseed(node, token, base_url)
+        'curtin_preseed': compose_cloud_init_preseed(
+            node, token, base_url, default_region_ip=default_region_ip)
     }
 
 
@@ -567,7 +575,7 @@ def get_preseed_type_for(node):
 
 
 @typed
-def get_preseed(node) -> bytes:
+def get_preseed(node, default_region_ip=None) -> bytes:
     """Return the preseed for a given node. Depending on the node's
     status this will be a commissioning preseed (if the node is
     commissioning or disk erasing) or an install preseed (normal
@@ -582,11 +590,13 @@ def get_preseed(node) -> bytes:
         return render_preseed(
             node, PRESEED_TYPE.COMMISSIONING,
             osystem=Config.objects.get_config('commissioning_osystem'),
-            release=Config.objects.get_config('commissioning_distro_series'))
+            release=Config.objects.get_config('commissioning_distro_series'),
+            default_region_ip=default_region_ip)
     else:
         return render_preseed(
             node, get_preseed_type_for(node),
-            osystem=node.get_osystem(), release=node.get_distro_series())
+            osystem=node.get_osystem(), release=node.get_distro_series(),
+            default_region_ip=default_region_ip)
 
 
 UBUNTU_NAME = UbuntuOS().name
@@ -769,7 +779,8 @@ def get_netloc_and_path(url):
     return parsed_url.netloc, parsed_url.path.lstrip("/")
 
 
-def get_preseed_context(osystem='', release='', rack_controller=None):
+def get_preseed_context(
+        osystem='', release='', rack_controller=None, default_region_ip=None):
     """Return the node-independent context dictionary to be used to render
     preseed templates.
 
@@ -779,7 +790,8 @@ def get_preseed_context(osystem='', release='', rack_controller=None):
     :return: The context dictionary.
     :rtype: dict.
     """
-    server_host = get_maas_facing_server_host(rack_controller=rack_controller)
+    server_host = get_maas_facing_server_host(
+        rack_controller=rack_controller, default_region_ip=default_region_ip)
     if rack_controller is None:
         base_url = None
     else:
@@ -789,14 +801,18 @@ def get_preseed_context(osystem='', release='', rack_controller=None):
         'osystem': osystem,
         'release': release,
         'server_host': server_host,
-        'server_url': absolute_reverse('machines_handler', base_url=base_url),
+        'server_url': absolute_reverse(
+            'machines_handler', default_region_ip=default_region_ip,
+            base_url=base_url),
         'syslog_host_port': '%s:%d' % (server_host, RSYSLOG_PORT),
-        'metadata_enlist_url': absolute_reverse('enlist', base_url=base_url),
+        'metadata_enlist_url': absolute_reverse(
+            'enlist', default_region_ip=default_region_ip, base_url=base_url),
         }
 
 
 def get_node_preseed_context(
-        node, osystem='', release='', rack_controller=None):
+        node, osystem='', release='', rack_controller=None,
+        default_region_ip=None):
     """Return the node-dependent context dictionary to be used to render
     preseed templates.
 
@@ -811,8 +827,8 @@ def get_node_preseed_context(
     # Create the url and the url-data (POST parameters) used to turn off
     # PXE booting once the install of the node is finished.
     node_disable_pxe_url = absolute_reverse(
-        'metadata-node-by-id', args=['latest', node.system_id],
-        base_url=rack_controller.url)
+        'metadata-node-by-id', default_region_ip=default_region_ip,
+        args=['latest', node.system_id], base_url=rack_controller.url)
     node_disable_pxe_data = urlencode({'op': 'netboot_off'})
     driver = get_third_party_driver(node)
     return {
@@ -821,7 +837,9 @@ def get_node_preseed_context(
         'driver': driver,
         'driver_package': driver.get('package', ''),
         'node': node,
-        'preseed_data': compose_preseed(get_preseed_type_for(node), node),
+        'preseed_data': compose_preseed(
+            get_preseed_type_for(node), node,
+            default_region_ip=default_region_ip),
         'node_disable_pxe_url': node_disable_pxe_url,
         'node_disable_pxe_data': node_disable_pxe_data,
         'license_key': node.get_effective_license_key(),
@@ -853,7 +871,8 @@ def get_node_deprecated_preseed_context():
 
 
 def render_enlistment_preseed(
-        prefix, osystem='', release='', rack_controller=None):
+        prefix, osystem='', release='', rack_controller=None,
+        default_region_ip=None):
     """Return the enlistment preseed.
 
     :param prefix: See `get_preseed_filenames`.
@@ -865,14 +884,16 @@ def render_enlistment_preseed(
     """
     template = load_preseed_template(None, prefix, osystem, release)
     context = get_preseed_context(
-        osystem, release, rack_controller=rack_controller)
+        osystem, release, rack_controller=rack_controller,
+        default_region_ip=default_region_ip)
     # Render the snippets in the main template.
     snippets = get_snippet_context()
     snippets.update(context)
     return template.substitute(**snippets).encode("utf-8")
 
 
-def render_preseed(node, prefix, osystem='', release=''):
+def render_preseed(
+        node, prefix, osystem='', release='', default_region_ip=None):
     """Return the preseed for the given node.
 
     :param node: See `get_preseed_filenames`.
@@ -885,17 +906,22 @@ def render_preseed(node, prefix, osystem='', release=''):
     template = load_preseed_template(node, prefix, osystem, release)
     rack_controller = node.get_boot_rack_controller()
     context = get_preseed_context(
-        osystem, release, rack_controller=rack_controller)
+        osystem, release, rack_controller=rack_controller,
+        default_region_ip=default_region_ip)
     context.update(
         get_node_preseed_context(
-            node, osystem, release, rack_controller=rack_controller))
+            node, osystem, release, rack_controller=rack_controller,
+            default_region_ip=default_region_ip))
     return template.substitute(**context).encode("utf-8")
 
 
-def compose_enlistment_preseed_url(rack_controller=None):
+def compose_enlistment_preseed_url(
+        rack_controller=None, default_region_ip=None):
     """Compose enlistment preseed URL.
 
     :param rack_controller: The rack controller used to generate the preseed.
+    :param default_region_ip: The preferred IP address this region should
+        communicate on.
     """
     # Always uses the latest version of the metadata API.
     base_url = (
@@ -904,14 +930,15 @@ def compose_enlistment_preseed_url(rack_controller=None):
         else None)
     version = 'latest'
     return absolute_reverse(
-        'metadata-enlist-preseed', args=[version],
-        query={'op': 'get_enlist_preseed'}, base_url=base_url)
+        'metadata-enlist-preseed', default_region_ip=default_region_ip,
+        args=[version], query={'op': 'get_enlist_preseed'}, base_url=base_url)
 
 
-def compose_preseed_url(node, rack_controller):
+def compose_preseed_url(node, rack_controller, default_region_ip=None):
     """Compose a metadata URL for `node`'s preseed data."""
     # Always uses the latest version of the metadata API.
     version = 'latest'
     return absolute_reverse(
-        'metadata-node-by-id', args=[version, node.system_id],
-        query={'op': 'get_preseed'}, base_url=rack_controller.url)
+        'metadata-node-by-id', default_region_ip=default_region_ip,
+        args=[version, node.system_id], query={'op': 'get_preseed'},
+        base_url=rack_controller.url)
diff --git a/src/maasserver/rpc/boot.py b/src/maasserver/rpc/boot.py
index 9d27d7b..e4c0acd 100644
--- a/src/maasserver/rpc/boot.py
+++ b/src/maasserver/rpc/boot.py
@@ -43,6 +43,7 @@ from maasserver.utils.orm import (
 from maasserver.utils.osystems import validate_hwe_kernel
 from provisioningserver.events import EVENT_TYPES
 from provisioningserver.rpc.exceptions import BootConfigNoResponse
+from provisioningserver.utils.network import get_source_address
 from provisioningserver.utils.twisted import synchronous
 
 
@@ -184,6 +185,9 @@ def get_config(
     Raises BootConfigNoResponse when booting machine should fail to next file.
     """
     rack_controller = RackController.objects.get(system_id=system_id)
+    region_ip = None
+    if remote_ip is not None:
+        region_ip = get_source_address(remote_ip)
     machine = get_node_from_mac_string(mac)
 
     # Fail with no response early so no extra work is performed.
@@ -232,7 +236,8 @@ def get_config(
                 machine.boot_interface.save()
 
         arch, subarch = machine.split_arch()
-        preseed_url = compose_preseed_url(machine, rack_controller)
+        preseed_url = compose_preseed_url(
+            machine, rack_controller, default_region_ip=region_ip)
         hostname = machine.hostname
         domain = machine.domain.name
         purpose = machine.get_boot_purpose()
@@ -305,7 +310,8 @@ def get_config(
                                                      extra_kernel_opts)
     else:
         purpose = "commissioning"  # enlistment
-        preseed_url = compose_enlistment_preseed_url(rack_controller)
+        preseed_url = compose_enlistment_preseed_url(
+            rack_controller, default_region_ip=region_ip)
         hostname = 'maas-enlist'
         domain = 'local'
         osystem = Config.objects.get_config('commissioning_osystem')
@@ -358,7 +364,7 @@ def get_config(
 
     # Get the service address to the region for that given rack controller.
     server_host = get_maas_facing_server_host(
-        rack_controller=rack_controller)
+        rack_controller=rack_controller, default_region_ip=region_ip)
 
     kernel, initrd, boot_dtb = get_boot_filenames(
         arch, subarch, osystem, series)
diff --git a/src/maasserver/rpc/tests/test_boot.py b/src/maasserver/rpc/tests/test_boot.py
index 04cc5d4..84dfcf8 100644
--- a/src/maasserver/rpc/tests/test_boot.py
+++ b/src/maasserver/rpc/tests/test_boot.py
@@ -43,6 +43,7 @@ from maastesting.matchers import (
 )
 from netaddr import IPNetwork
 from provisioningserver.rpc.exceptions import BootConfigNoResponse
+from provisioningserver.utils.network import get_source_address
 from testtools.matchers import (
     ContainsAll,
     StartsWith,
@@ -276,7 +277,8 @@ class TestGetConfig(MAASServerTestCase):
         observed_config = get_config(
             rack_controller.system_id, local_ip, remote_ip)
         self.assertEqual(
-            compose_enlistment_preseed_url(),
+            compose_enlistment_preseed_url(
+                default_region_ip=get_source_address(remote_ip)),
             observed_config["preseed_url"])
 
     def test__enlistment_checks_default_min_hwe_kernel(self):
@@ -306,15 +308,17 @@ class TestGetConfig(MAASServerTestCase):
         self.assertEqual('generic', observed_config['subarch'])
 
     def test__has_preseed_url_for_known_node(self):
-        rack_controller = factory.make_RackController()
+        rack_controller = factory.make_RackController(url='')
         local_ip = factory.make_ip_address()
         remote_ip = factory.make_ip_address()
         node = self.make_node(status=NODE_STATUS.DEPLOYING)
         mac = node.get_boot_interface().mac_address
+        self.patch(boot_module, 'get_source_address').return_value = local_ip
         observed_config = get_config(
             rack_controller.system_id, local_ip, remote_ip, mac=mac)
         self.assertEqual(
-            compose_preseed_url(node, rack_controller),
+            compose_preseed_url(
+                node, rack_controller, default_region_ip=local_ip),
             observed_config["preseed_url"])
 
     def test_preseed_url_for_known_node_uses_rack_url(self):
diff --git a/src/maasserver/server_address.py b/src/maasserver/server_address.py
index 855b90d..b543556 100644
--- a/src/maasserver/server_address.py
+++ b/src/maasserver/server_address.py
@@ -19,15 +19,19 @@ from provisioningserver.utils.env import get_maas_id
 from provisioningserver.utils.network import resolve_hostname
 
 
-def get_maas_facing_server_host(rack_controller=None):
+def get_maas_facing_server_host(rack_controller=None, default_region_ip=None):
     """Return configured MAAS server hostname, for use by nodes or workers.
 
     :param rack_controller: The `RackController` from the point of view of
         which the server host should be computed.
+    :param default_region_ip: The default source IP address to be used, if a
+        specific URL is not defined.
     :return: Hostname or IP address, as configured in the MAAS URL config
         setting or as configured on rack_controller.url.
     """
     if rack_controller is None or not rack_controller.url:
+        if default_region_ip is not None:
+            return default_region_ip
         with RegionConfiguration.open() as config:
             maas_url = config.maas_url
     else:
diff --git a/src/maasserver/tests/test_compose_preseed.py b/src/maasserver/tests/test_compose_preseed.py
index 7d868e0..62a9a39 100644
--- a/src/maasserver/tests/test_compose_preseed.py
+++ b/src/maasserver/tests/test_compose_preseed.py
@@ -48,41 +48,92 @@ class TestAptProxy(MAASServerTestCase):
 
     scenarios = (
         ("ipv6", dict(
+            default_region_ip=None,
             rack='2001:db8::1',
             result='http://[2001:db8::1]:8000/',
             enable=True,
             use_peer_proxy=False,
             http_proxy='')),
         ("ipv4", dict(
+            default_region_ip=None,
             rack='10.0.1.1',
             result='http://10.0.1.1:8000/',
             enable=True,
             use_peer_proxy=False,
             http_proxy='')),
         ("builtin", dict(
+            default_region_ip=None,
             rack='region.example.com',
             result='http://region.example.com:8000/',
             enable=True,
             use_peer_proxy=False,
             http_proxy='')),
         ("external", dict(
+            default_region_ip=None,
             rack='region.example.com',
             result='http://proxy.example.com:111/',
             enable=True,
             use_peer_proxy=False,
             http_proxy='http://proxy.example.com:111/')),
         ("peer-proxy", dict(
+            default_region_ip=None,
             rack='region.example.com',
             result='http://region.example.com:8000/',
             enable=True,
             use_peer_proxy=True,
             http_proxy='http://proxy.example.com:111/')),
         ("disabled", dict(
+            default_region_ip=None,
             rack='example.com',
             result=None,
             enable=False,
             use_peer_proxy=False,
             http_proxy='')),
+        # If a default IP address for the region is passed in and the rack's
+        # URL is empty, the default IP address that was provided should be
+        # preferred.
+        ("ipv6_default", dict(
+            default_region_ip='2001:db8::2',
+            rack='',
+            result='http://[2001:db8::2]:8000/',
+            enable=True,
+            use_peer_proxy=False,
+            http_proxy='')),
+        ("ipv4_default", dict(
+            default_region_ip='10.0.1.2',
+            rack='',
+            result='http://10.0.1.2:8000/',
+            enable=True,
+            use_peer_proxy=False,
+            http_proxy='')),
+        ("builtin_default", dict(
+            default_region_ip='region.example.com',
+            rack='',
+            result='http://region.example.com:8000/',
+            enable=True,
+            use_peer_proxy=False,
+            http_proxy='')),
+        ("external_default", dict(
+            default_region_ip='10.0.0.1',
+            rack='',
+            result='http://proxy.example.com:111/',
+            enable=True,
+            use_peer_proxy=False,
+            http_proxy='http://proxy.example.com:111/')),
+        ("peer-proxy_default", dict(
+            default_region_ip='region2.example.com',
+            rack='',
+            result='http://region2.example.com:8000/',
+            enable=True,
+            use_peer_proxy=True,
+            http_proxy='http://proxy.example.com:111/')),
+        ("disabled_default", dict(
+            default_region_ip='10.0.0.1',
+            rack='',
+            result=None,
+            enable=False,
+            use_peer_proxy=False,
+            http_proxy='')),
     )
 
     def test__returns_correct_url(self):
@@ -94,14 +145,17 @@ class TestAptProxy(MAASServerTestCase):
         # Force the server host to be our test data.
         self.patch(
             cp_module,
-            'get_maas_facing_server_host').return_value = self.rack
+            'get_maas_facing_server_host').return_value = (
+                self.rack if self.rack else self.default_region_ip)
         # Now setup the configuration and arguments, and see what we get back.
         node = factory.make_Node(
             interface=True, status=NODE_STATUS.COMMISSIONING)
         Config.objects.set_config("enable_http_proxy", self.enable)
         Config.objects.set_config("http_proxy", self.http_proxy)
         Config.objects.set_config("use_peer_proxy", self.use_peer_proxy)
-        actual = get_apt_proxy(node.get_boot_rack_controller())
+        actual = get_apt_proxy(
+            node.get_boot_rack_controller(),
+            default_region_ip=self.default_region_ip)
         self.assertEqual(self.result, actual)
 
 
@@ -241,20 +295,45 @@ class TestComposePreseed(MAASServerTestCase):
 
     def test_compose_preseed_for_commissioning_includes_metadata_status_url(
             self):
-        rack_controller = factory.make_RackController()
+        rack_controller = factory.make_RackController(url='')
         node = factory.make_Node(
             interface=True, status=NODE_STATUS.COMMISSIONING)
         nic = node.get_boot_interface()
         nic.vlan.dhcp_on = True
         nic.vlan.primary_rack = rack_controller
         nic.vlan.save()
+        region_ip = factory.make_ip_address()
         preseed = yaml.safe_load(
-            compose_preseed(PRESEED_TYPE.COMMISSIONING, node))
+            compose_preseed(
+                PRESEED_TYPE.COMMISSIONING, node, default_region_ip=region_ip))
+        self.assertEqual(
+            absolute_reverse('metadata', default_region_ip=region_ip),
+            preseed['datasource']['MAAS']['metadata_url'])
+        self.assertEqual(
+            absolute_reverse(
+                'metadata-status', default_region_ip=region_ip,
+                args=[node.system_id]),
+            preseed['reporting']['maas']['endpoint'])
+
+    def test_compose_preseed_uses_default_region_ip(self):
+        rack_controller = factory.make_RackController(url='')
+        node = factory.make_Node(
+            interface=True, status=NODE_STATUS.COMMISSIONING)
+        nic = node.get_boot_interface()
+        nic.vlan.dhcp_on = True
+        nic.vlan.primary_rack = rack_controller
+        nic.vlan.save()
+        preseed = yaml.safe_load(
+            compose_preseed(
+                PRESEED_TYPE.COMMISSIONING, node,
+                default_region_ip='10.0.0.1'))
         self.assertEqual(
-            absolute_reverse('metadata'),
+            absolute_reverse('metadata', default_region_ip='10.0.0.1'),
             preseed['datasource']['MAAS']['metadata_url'])
         self.assertEqual(
-            absolute_reverse('metadata-status', args=[node.system_id]),
+            absolute_reverse(
+                'metadata-status', default_region_ip='10.0.0.1',
+                args=[node.system_id]),
             preseed['reporting']['maas']['endpoint'])
 
     def test_compose_preseed_for_rescue_mode_does_not_include_poweroff(self):
@@ -369,7 +448,7 @@ class TestComposePreseed(MAASServerTestCase):
         self.assertEqual(token.secret, reporting_dict['token_secret'])
 
     def test_compose_preseed_with_curtin_installer(self):
-        rack_controller = factory.make_RackController()
+        rack_controller = factory.make_RackController(url='')
         node = factory.make_Node(
             interface=True, status=NODE_STATUS.DEPLOYING)
         nic = node.get_boot_interface()
@@ -377,9 +456,12 @@ class TestComposePreseed(MAASServerTestCase):
         nic.vlan.primary_rack = rack_controller
         nic.vlan.save()
         self.useFixture(RunningClusterRPCFixture())
-        apt_proxy = get_apt_proxy(node.get_boot_rack_controller())
+        region_ip = factory.make_ip_address()
+        expected_apt_proxy = get_apt_proxy(
+            node.get_boot_rack_controller(), default_region_ip=region_ip)
         preseed = yaml.safe_load(
-            compose_preseed(PRESEED_TYPE.CURTIN, node))
+            compose_preseed(
+                PRESEED_TYPE.CURTIN, node, default_region_ip=region_ip))
 
         self.assertIn('datasource', preseed)
         self.assertIn('MAAS', preseed['datasource'])
@@ -395,11 +477,11 @@ class TestComposePreseed(MAASServerTestCase):
                 'condition': 'test ! -e /tmp/block-reboot',
             }, preseed['power_state'])
         self.assertEqual(
-            absolute_reverse('curtin-metadata'),
+            absolute_reverse('curtin-metadata', default_region_ip=region_ip),
             preseed['datasource']['MAAS']['metadata_url'])
-        self.assertEqual(apt_proxy, preseed['apt_proxy'])
+        self.assertEqual(expected_apt_proxy, preseed['apt_proxy'])
         self.assertSystemInfo(preseed)
-        self.assertAptConfig(preseed, apt_proxy)
+        self.assertAptConfig(preseed, expected_apt_proxy)
 
     def test_compose_preseed_with_curtin_installer_skips_apt_proxy(self):
         # Disable boot source cache signals.
@@ -428,7 +510,7 @@ class TestComposePreseed(MAASServerTestCase):
         compose_preseed_mock = self.patch(osystem, 'compose_preseed')
         compose_preseed_mock.side_effect = compose_preseed_orig
 
-        rack_controller = factory.make_RackController()
+        rack_controller = factory.make_RackController(url='')
         node = factory.make_Node(
             interface=True, osystem=os_name, status=NODE_STATUS.READY)
         nic = node.get_boot_interface()
@@ -437,15 +519,18 @@ class TestComposePreseed(MAASServerTestCase):
         nic.vlan.save()
         self.useFixture(RunningClusterRPCFixture())
         token = NodeKey.objects.get_token_for_node(node)
-        url = absolute_reverse('curtin-metadata')
-        compose_preseed(PRESEED_TYPE.CURTIN, node)
+        region_ip = factory.make_ip_address()
+        expected_url = absolute_reverse(
+            'curtin-metadata', default_region_ip=region_ip)
+        compose_preseed(
+            PRESEED_TYPE.CURTIN, node, default_region_ip=region_ip)
         self.assertThat(
             compose_preseed_mock,
             MockCalledOnceWith(
                 PRESEED_TYPE.CURTIN,
                 (node.system_id, node.hostname),
                 (token.consumer.key, token.key, token.secret),
-                url))
+                expected_url))
 
     def test_compose_preseed_propagates_NoSuchOperatingSystem(self):
         # If the cluster controller replies that the node's OS is not known to
diff --git a/src/maasserver/tests/test_preseed.py b/src/maasserver/tests/test_preseed.py
index d78b267..6f5e7d6 100644
--- a/src/maasserver/tests/test_preseed.py
+++ b/src/maasserver/tests/test_preseed.py
@@ -1834,9 +1834,11 @@ class TestPreseedURLs(
     """Tests for functions that return preseed URLs."""
 
     def test_compose_enlistment_preseed_url_links_to_enlistment_preseed(self):
-        response = self.client.get(compose_enlistment_preseed_url())
+        response = self.client.get(compose_enlistment_preseed_url(
+            default_region_ip="127.0.0.1"))
         self.assertEqual(
-            (http.client.OK, get_enlist_preseed()),
+            (http.client.OK, get_enlist_preseed(
+                default_region_ip="127.0.0.1")),
             (response.status_code, response.content))
 
     def test_compose_enlistment_preseed_url_returns_absolute_link(self):
@@ -1846,7 +1848,7 @@ class TestPreseedURLs(
         self.assertThat(
             compose_enlistment_preseed_url(), StartsWith(maas_url))
 
-    def test_compose_enlistment_preseed_url_returns_abs_link_wth_nodegrp(self):
+    def test_compose_enlistment_preseed_url_returns_abs_link_wth_rack(self):
         maas_url = factory.make_simple_http_url(path='')
         self.useFixture(RegionConfigurationFixture(maas_url=maas_url))
         rack_controller = factory.make_RackController(url=maas_url)
@@ -1860,9 +1862,10 @@ class TestPreseedURLs(
             primary_rack=self.rpc_rack_controller)
         self.configure_get_boot_images_for_node(node, 'install')
         response = self.client.get(
-            compose_preseed_url(node, self.rpc_rack_controller))
+            compose_preseed_url(
+                node, self.rpc_rack_controller, default_region_ip='127.0.0.1'))
         self.assertEqual(
-            (http.client.OK, get_preseed(node)),
+            (http.client.OK, get_preseed(node, default_region_ip='127.0.0.1')),
             (response.status_code, response.content))
 
     def test_compose_preseed_url_returns_absolute_link(self):
diff --git a/src/maasserver/utils/__init__.py b/src/maasserver/utils/__init__.py
index 5963280..1c58859 100644
--- a/src/maasserver/utils/__init__.py
+++ b/src/maasserver/utils/__init__.py
@@ -27,6 +27,7 @@ from provisioningserver.config import (
     ClusterConfiguration,
     UUID_NOT_SET,
 )
+from provisioningserver.utils.url import compose_URL
 from provisioningserver.utils.version import get_maas_version_user_agent
 
 
@@ -39,7 +40,9 @@ def ignore_unused(*args):
     """
 
 
-def absolute_reverse(view_name, query=None, base_url=None, *args, **kwargs):
+def absolute_reverse(
+        view_name, default_region_ip=None, query=None, base_url=None,
+        *args, **kwargs):
     """Return the absolute URL (i.e. including the URL scheme specifier and
     the network location of the MAAS server).  Internally this method simply
     calls Django's 'reverse' method and prefixes the result of that call with
@@ -50,6 +53,8 @@ def absolute_reverse(view_name, query=None, base_url=None, *args, **kwargs):
 
     :param view_name: Django's view function name/reference or URL pattern
         name for which to compute the absolute URL.
+    :param default_region_ip: The default source IP address that should be
+        used for the region controller.
     :param query: Optional query argument which will be passed down to
         urllib.urlencode.  The result of that call will be appended to the
         resulting url.
@@ -57,11 +62,12 @@ def absolute_reverse(view_name, query=None, base_url=None, *args, **kwargs):
         configured MAAS URL will be used.
     :param args: Positional arguments for Django's 'reverse' method.
     :param kwargs: Named arguments for Django's 'reverse' method.
-
     """
     if not base_url:
         with RegionConfiguration.open() as config:
             base_url = config.maas_url
+        if default_region_ip is not None:
+            base_url = compose_URL(base_url, default_region_ip)
     url = urljoin(base_url, reverse(view_name, *args, **kwargs))
     if query is not None:
         url += '?%s' % urlencode(query, doseq=True)
@@ -135,6 +141,11 @@ def get_maas_user_agent():
     return user_agent
 
 
+def get_remote_ip(request):
+    """Returns the IP address of the host that initiated the request."""
+    return request.META.get('REMOTE_ADDR')
+
+
 def find_rack_controller(request):
     """Find the rack controller whose managing the subnet that contains the
     requester's address.
@@ -144,10 +155,7 @@ def find_rack_controller(request):
     """
     # Circular imports.
     from maasserver.models.subnet import Subnet
-    ip_address = request.META['REMOTE_ADDR']
-    if ip_address is None:
-        return None
-
+    ip_address = get_remote_ip(request)
     subnet = Subnet.objects.get_best_subnet_for_ip(ip_address)
     if subnet is None:
         return None
diff --git a/src/metadataserver/api.py b/src/metadataserver/api.py
index 18153ea..1466454 100644
--- a/src/metadataserver/api.py
+++ b/src/metadataserver/api.py
@@ -12,7 +12,7 @@ __all__ = [
     'MetaDataHandler',
     'UserDataHandler',
     'VersionIndexHandler',
-    ]
+]
 
 import base64
 from datetime import datetime
@@ -70,7 +70,10 @@ from maasserver.preseed import (
     get_enlist_userdata,
     get_preseed,
 )
-from maasserver.utils import find_rack_controller
+from maasserver.utils import (
+    find_rack_controller,
+    get_remote_ip,
+)
 from maasserver.utils.orm import (
     get_one,
     is_retryable_failure,
@@ -98,6 +101,7 @@ from provisioningserver.events import (
     EVENT_TYPES,
 )
 from provisioningserver.logger import LegacyLogger
+from provisioningserver.utils.network import get_source_address
 import yaml
 
 
@@ -162,6 +166,15 @@ def get_queried_node(request, for_mac=None):
         return get_node_for_mac(for_mac)
 
 
+def get_default_region_ip(request):
+    """Returns the default reply address for the given HTTP request."""
+    remote_ip = get_remote_ip(request)
+    default_region_ip = None
+    if remote_ip is not None:
+        default_region_ip = get_source_address(remote_ip)
+    return default_region_ip
+
+
 def make_text_response(contents):
     """Create a response containing `contents` as plain text."""
     # XXX: Set a charset for text/plain. Django automatically encodes
@@ -841,7 +854,8 @@ class CurtinUserDataHandler(MetadataViewHandler):
     def read(self, request, version, mac=None):
         check_version(version)
         node = get_queried_node(request, for_mac=mac)
-        user_data = get_curtin_userdata(node)
+        default_region_ip = get_default_region_ip(request)
+        user_data = get_curtin_userdata(node, default_region_ip)
         return HttpResponse(
             user_data,
             content_type='application/octet-stream')
@@ -1032,12 +1046,15 @@ class EnlistUserDataHandler(OperationsHandler):
     def read(self, request, version):
         check_version(version)
         rack_controller = find_rack_controller(request)
+        default_region_ip = get_default_region_ip(request)
         # XXX: Set a charset for text/plain. Django automatically encodes
         # non-binary content using DEFAULT_CHARSET (which is UTF-8 by default)
         # but only sets the charset parameter in the content-type header when
         # a content-type is NOT provided.
         return HttpResponse(
-            get_enlist_userdata(rack_controller=rack_controller),
+            get_enlist_userdata(
+                rack_controller=rack_controller,
+                default_region_ip=default_region_ip),
             content_type="text/plain")
 
 
@@ -1060,9 +1077,10 @@ class AnonMetaDataHandler(VersionIndexHandler):
         # non-binary content using DEFAULT_CHARSET (which is UTF-8 by default)
         # but only sets the charset parameter in the content-type header when
         # a content-type is NOT provided.
-        return HttpResponse(
-            get_enlist_preseed(rack_controller=rack_controller),
-            content_type="text/plain")
+        region_ip = get_default_region_ip(request)
+        preseed = get_enlist_preseed(
+            rack_controller=rack_controller, default_region_ip=region_ip)
+        return HttpResponse(preseed, content_type="text/plain")
 
     @operation(idempotent=True)
     def get_preseed(self, request, version=None, system_id=None):
@@ -1072,7 +1090,9 @@ class AnonMetaDataHandler(VersionIndexHandler):
         # non-binary content using DEFAULT_CHARSET (which is UTF-8 by default)
         # but only sets the charset parameter in the content-type header when
         # a content-type is NOT provided.
-        return HttpResponse(get_preseed(node), content_type="text/plain")
+        region_ip = get_default_region_ip(request)
+        preseed = get_preseed(node, region_ip)
+        return HttpResponse(preseed, content_type="text/plain")
 
     @operation(idempotent=False)
     def netboot_off(self, request, version=None, system_id=None):
diff --git a/src/metadataserver/tests/test_api.py b/src/metadataserver/tests/test_api.py
index bc6c8c7..140e99b 100644
--- a/src/metadataserver/tests/test_api.py
+++ b/src/metadataserver/tests/test_api.py
@@ -27,6 +27,7 @@ from unittest.mock import (
 
 from django.conf import settings
 from django.core.exceptions import PermissionDenied
+from provisioningserver.utils.network import get_source_address
 
 
 try:
@@ -2482,6 +2483,22 @@ class TestAnonymousAPI(MAASServerTestCase):
             response.content.decode(settings.DEFAULT_CHARSET),
             Contains(url))
 
+    def test_anonymous_get_enlist_preseed_uses_detected_region_ip(self):
+        request_ip = get_source_address('8.8.8.8')
+        expected_source_ip = get_source_address(request_ip)
+        rack = factory.make_RackController(url='')
+        find_rack_controller_mock = self.patch(api, "find_rack_controller")
+        find_rack_controller_mock.return_value = rack
+        get_default_region_ip_mock = self.patch(api, "get_default_region_ip")
+        get_default_region_ip_mock.return_value = expected_source_ip
+        anon_enlist_preseed_url = reverse(
+            'metadata-enlist-preseed', args=['latest'])
+        response = self.client.get(
+            anon_enlist_preseed_url, {'op': 'get_enlist_preseed'},
+            REMOTE_ADDR=request_ip)
+        self.assertThat(response.content.decode(
+            settings.DEFAULT_CHARSET), Contains(expected_source_ip))
+
     def test_anonymous_get_preseed(self):
         # The preseed for a node can be obtained anonymously.
         node = factory.make_Node()
@@ -2490,9 +2507,8 @@ class TestAnonymousAPI(MAASServerTestCase):
             args=['latest', node.system_id])
         # Fake the preseed so we're just exercising the view.
         fake_preseed = factory.make_string()
-        self.patch(api, "get_preseed", lambda node: fake_preseed)
-        response = self.client.get(
-            anon_node_url, {'op': 'get_preseed'})
+        self.patch(api, "get_preseed", lambda node, ip: fake_preseed)
+        response = self.client.get(anon_node_url, {'op': 'get_preseed'})
         self.assertEqual(
             (http.client.OK.value,
              "text/plain",
diff --git a/src/provisioningserver/utils/url.py b/src/provisioningserver/utils/url.py
index df83ffd..b841c80 100644
--- a/src/provisioningserver/utils/url.py
+++ b/src/provisioningserver/utils/url.py
@@ -18,13 +18,14 @@ import urllib.request
 
 
 def compose_URL(base_url, host):
-    """Produce a URL on a given hostname or IP address.
+    """Compose (or recompose) a URL, based on an existing URL and given host.
 
     This is straightforward if the IP address is a hostname or an IPv4
     address; but if it's an IPv6 address, the URL must contain the IP address
     in square brackets as per RFC 3986.
 
-    :param base_url: URL without the host part, e.g. `http:///path'.
+    :param base_url: URL with or without the host part; for example:
+        `http:///path`, `http://foo:5240/path`, or `http://:5240/path`.
     :param host: Host name or IP address to insert in the host part of the URL.
     :return: A URL string with the host part taken from `host`, and all others
         from `base_url`.