Merge lp:~lamont/maas/bug-1599223-2.0 into lp:maas/2.0

[LaMont Jones]

Refactor get_hostname_ip_mapping() to also return interface-named rows.
When generating reverse DNS, we have to consider all of the forward zones, not just our subnet.

Refactor get_hostname_ip_mapping() to also return interface-named rows.
When generating reverse DNS, we have to consider all of the forward zones, not just our subnet.

[LaMont Jones (lamont)]

Simple backport from trunk to 2.0.

review: Approve

=== modified file 'src/maasserver/dns/tests/test_zonegenerator.py'
--- src/maasserver/dns/tests/test_zonegenerator.py	2016-05-12 19:07:37 +0000
+++ src/maasserver/dns/tests/test_zonegenerator.py	2016-07-08 20:46:18 +0000
@@ -371,10 +371,15 @@
                 forward_zone("henry"),
                 reverse_zone(default_domain, "10/29"),
                 reverse_zone(default_domain, "10/24")))
-        self.assertEqual(
-            {node.hostname: HostnameIPMapping(
+        self.assertEqual({
+            node.hostname: HostnameIPMapping(
                 node.system_id, default_ttl,
-                {'%s' % boot_ip.ip}, node.node_type)}, zones[0]._mapping)
+                {'%s' % boot_ip.ip}, node.node_type),
+            "%s.%s" % (interfaces[0].name, node.hostname):
+                HostnameIPMapping(
+                    node.system_id, default_ttl,
+                    {'%s' % sip.ip}, node.node_type)},
+            zones[0]._mapping)
         self.assertEqual(
             {dnsdata.dnsresource.name: HostnameRRsetMapping(
                 None,
@@ -384,9 +389,7 @@
             node.fqdn: HostnameIPMapping(
                 node.system_id, 30, {'%s' % boot_ip.ip}, node.node_type),
             '%s.%s' % (interfaces[0].name, node.fqdn): HostnameIPMapping(
-                None, default_ttl, {'%s' % sip.ip}, None),
-            '%s.%s' % (boot_iface.name, node.fqdn): HostnameIPMapping(
-                None, default_ttl, {'%s' % boot_ip.ip}, None)},
+                None, default_ttl, {'%s' % sip.ip}, None)},
             zones[1]._mapping)
 
     def rfc2317_network(self, network):
@@ -517,8 +520,6 @@
                 node.system_id, domain.ttl, {boot_ip.ip}, node.node_type)}
         expected_reverse = {
             node.fqdn: HostnameIPMapping(
-                node.system_id, domain.ttl, {boot_ip.ip}, node.node_type),
-            "%s.%s" % (boot_iface.name, node.fqdn): HostnameIPMapping(
                 node.system_id, domain.ttl, {boot_ip.ip}, node.node_type)}
         zones = ZoneGenerator(
             domain, subnet, default_ttl=global_ttl,
@@ -545,10 +546,6 @@
         expected_reverse = {
             node.fqdn: HostnameIPMapping(
                 node.system_id, node.address_ttl, {boot_ip.ip},
-                node.node_type),
-            "%s.%s" % (boot_iface.name, node.fqdn):
-            HostnameIPMapping(
-                node.system_id, node.address_ttl, {boot_ip.ip},
                 node.node_type)}
         zones = ZoneGenerator(
             domain, subnet, default_ttl=global_ttl,
@@ -581,11 +578,7 @@
             node.system_id, node.address_ttl, ips, node.node_type)}
         expected_reverse = {
             node.fqdn: HostnameIPMapping(
-                node.system_id, node.address_ttl, ips, node.node_type),
-            "%s.%s" % (boot_iface.name, node.fqdn):
-            HostnameIPMapping(
-                node.system_id, node.address_ttl, {boot_ip.ip},
-                node.node_type)}
+                node.system_id, node.address_ttl, ips, node.node_type)}
         zones = ZoneGenerator(
             domain, subnet, default_ttl=global_ttl,
             serial=random.randint(0, 65535)).as_list()
@@ -621,11 +614,7 @@
             node.fqdn: HostnameIPMapping(
                 node.system_id, node.address_ttl, node_ips, node.node_type),
             dnsrr.fqdn: HostnameIPMapping(
-                None, dnsrr.address_ttl, dnsrr_ips, None),
-            "%s.%s" % (boot_iface.name, node.fqdn):
-            HostnameIPMapping(
-                node.system_id, node.address_ttl, {boot_ip.ip},
-                node.node_type)}
+                None, dnsrr.address_ttl, dnsrr_ips, None)}
         zones = ZoneGenerator(
             domain, subnet, default_ttl=global_ttl,
             serial=random.randint(0, 65535)).as_list()
 
=== modified file 'src/maasserver/dns/zonegenerator.py'
--- src/maasserver/dns/zonegenerator.py	2016-04-21 19:13:47 +0000
+++ src/maasserver/dns/zonegenerator.py	2016-07-08 20:46:18 +0000
@@ -22,11 +22,7 @@
 from maasserver.models.dnsdata import DNSData
 from maasserver.models.dnsresource import separate_fqdn
 from maasserver.models.domain import Domain
-from maasserver.models.node import Node
-from maasserver.models.staticipaddress import (
-    HostnameIPMapping,
-    StaticIPAddress,
-)
+from maasserver.models.staticipaddress import StaticIPAddress
 from maasserver.models.subnet import Subnet
 from maasserver.server_address import get_maas_facing_server_address
 from netaddr import (
@@ -255,12 +251,16 @@
                         IPNetwork("%s/124" % network.network).network)
                     rfc2317_glue.setdefault(basenet, set()).add(network)
 
+        # Since get_hostname_ip_mapping(Subnet) ignores Subnet.id, so we can
+        # just do it once and be happy.  LP#1600259
+        if len(subnets):
+            mappings['reverse'] = mappings[Subnet.objects.first()]
+
         # For each of the zones that we are generating (one or more per
         # subnet), compile the zone from:
         # 1. Dynamic ranges on this subnet.
         # 2. Node: ip mapping(subnet), including DNSResource records for
         #    StaticIPAddresses in this subnet.
-        # 3. Interfaces on any node that have IP addresses in this subnet.
         # All of this needs to be done smallest to largest so that we can
         # correctly gather the rfc2317 glue that we need.  Failure to sort
         # means that we wind up grabbing (and deleting) the rfc2317 glue info
@@ -283,38 +283,12 @@
                 for ip_range in subnet.get_dynamic_ranges()
             ]
 
-            # 2. Start with the map of all of the nodes on this subnet,
-            # including all DNSResource-associated addresses.
-            mapping = mappings[subnet]
-
-            # 3. Add all of the interface named records.
-            # 2015-12-18 lamont N.B., these are not found in the forward zone,
-            # on purpose.  If someone eventually calls this a bug, we can
-            # revisit the size increase this would create in the forward zone.
-            # This will also include any discovered addresses on such
-            # interfaces.
-            nodes = Node.objects.filter(
-                interface__ip_addresses__subnet_id=subnet.id,
-                interface__ip_addresses__ip__isnull=False).prefetch_related(
-                "interface_set__ip_addresses")
-            for node in nodes:
-                if node.address_ttl is not None:
-                    ttl = node.address_ttl
-                elif node.domain.ttl is not None:
-                    ttl = node.domain.ttl
-                else:
-                    ttl = default_ttl
-                for iface in node.interface_set.all():
-                    ips_in_subnet = {
-                        ip.ip
-                        for ip in iface.ip_addresses.all()
-                        if (ip.ip is not None and ip.subnet_id == subnet.id)}
-                    if len(ips_in_subnet) > 0:
-                        iface_map = HostnameIPMapping(
-                            node.system_id, ttl, ips_in_subnet, node.node_type)
-                        mapping.update({
-                            "%s.%s" % (iface.name, iface.node.fqdn): iface_map
-                        })
+            # 2. Start with the map of all of the nodes, including all
+            # DNSResource-associated addresses.  We will prune this to just
+            # entries for the subnet when we actually generate the zonefile.
+            # If we get here, then we have subnets, so we noticed that above
+            # and created mappings['reverse'].  LP#1600259
+            mapping = mappings['reverse']
 
             # Use the default_domain as the name for the NS host in the reverse
             # zones.  If this network is actually a parent rfc2317 glue
 
=== modified file 'src/maasserver/models/dnsresource.py'
--- src/maasserver/models/dnsresource.py	2016-05-11 19:01:48 +0000
+++ src/maasserver/models/dnsresource.py	2016-07-08 20:46:18 +0000
@@ -75,14 +75,17 @@
     """
     if fqdn is None or fqdn == '' or fqdn == '@':
         return (fqdn, None)
-    elif Domain.objects.filter(name=fqdn).exists():
-        if domainname == fqdn or domainname is None:
+    if domainname is not None:
+        if domainname == fqdn:
             return ('@', fqdn)
         else:
             # strip off the passed in ".$domainname" from the fqdn.
             name = fqdn[:-len(domainname) - 1]
             return (name, domainname)
-    elif rrtype == 'SRV':
+    else:
+        if Domain.objects.filter(name=fqdn).exists():
+            return ('@', fqdn)
+    if rrtype == 'SRV':
         spec = SRV_LHS
     else:
         spec = LABEL
 
=== modified file 'src/maasserver/models/staticipaddress.py'
--- src/maasserver/models/staticipaddress.py	2016-05-26 17:50:49 +0000
+++ src/maasserver/models/staticipaddress.py	2016-07-08 20:46:18 +0000
@@ -51,7 +51,6 @@
 from maasserver.models.domain import Domain
 from maasserver.models.subnet import Subnet
 from maasserver.models.timestampedmodel import TimestampedModel
-from maasserver.utils import strip_domain
 from maasserver.utils.dns import get_ip_based_hostname
 from maasserver.utils.orm import (
     make_serialization_failure,
@@ -226,8 +225,10 @@
         qs = self.filter(
             Q(alloc_type=IPADDRESS_TYPE.USER_RESERVED) |
             Q(dnsresource__isnull=False))
+        # If this is a subnet, we need to ignore subnet.id, as per
+        # get_hostname_ip_mapping().  LP#1600259
         if isinstance(domain_or_subnet, Subnet):
-            qs = qs.filter(subnet_id=domain_or_subnet.id)
+            pass
         elif isinstance(domain_or_subnet, Domain):
             qs = qs.filter(dnsresource__domain_id=domain_or_subnet.id)
         qs = qs.prefetch_related("dnsresource_set")
@@ -307,20 +308,6 @@
         # return the IPs for the oldest Interface address.
         #
         # For nodes that have disable_ipv4 set, leave out any IPv4 address.
-        if isinstance(domain_or_subnet, Subnet):
-            search_term = "staticip.subnet_id"
-        elif isinstance(domain_or_subnet, Domain):
-            # The model has nodes in the parent domain, but they actually live
-            # in the child domain.  And the parent needs the glue.  So we
-            # return such nodes addresses in _BOTH_ the parent and the child
-            # domains. domain2.name will be non-null if this host's fqdn is the
-            # name of a domain in MAAS.
-            # n.b.  The SQL says: WHERE ... $search_term = %s ...
-            # we overload that to accomplish our objectives.
-            search_term = """domain2.name IS NOT NULL OR node.domain_id"""
-        else:
-            raise ValueError('bad object passed to get_hostname_ip_mapping')
-
         default_ttl = "%d" % Config.objects.get_config('default_dns_ttl')
         if raw_ttl:
             ttl_clause = """node.address_ttl"""
@@ -332,11 +319,11 @@
                     %s)""" % default_ttl
         sql_query = """
             SELECT DISTINCT ON (node.hostname, is_boot, family(staticip.ip))
-                node.hostname,
+                CONCAT(node.hostname, '.', domain.name) AS fqdn,
                 node.system_id,
                 node.node_type,
                 """ + ttl_clause + """ AS ttl,
-                domain.name, staticip.ip,
+                staticip.ip,
                 COALESCE(
                     node.boot_interface_id IS NOT NULL AND
                     (
@@ -359,22 +346,42 @@
                 link.interface_id = interface.id
             JOIN maasserver_staticipaddress AS staticip ON
                 staticip.id = link.staticipaddress_id
+            """
+        if isinstance(domain_or_subnet, Domain):
+            # The model has nodes in the parent domain, but they actually live
+            # in the child domain.  And the parent needs the glue.  So we
+            # return such nodes addresses in _BOTH_ the parent and the child
+            # domains. domain2.name will be non-null if this host's fqdn is the
+            # name of a domain in MAAS.
+            sql_query += """
             LEFT JOIN maasserver_domain as domain2 ON
                 /* Pick up another copy of domain looking for instances of
                  * nodes a the top of a domain.
                  */
                 domain2.name = CONCAT(node.hostname, '.', domain.name)
             WHERE
+                (domain2.name IS NOT NULL OR node.domain_id = %s) AND
+            """
+            query_parms = [domain_or_subnet.id, ]
+        else:
+            # For subnets, we need ALL the names, so that we can correctly
+            # identify which ones should have the FQDN.  dns/zonegenerator.py
+            # optimizes based on this, and only calls once with a subnet,
+            # expecting to get all the subnets back in one table.
+            sql_query += """
+            WHERE
+            """
+            query_parms = []
+        sql_query += """
                 staticip.ip IS NOT NULL AND
                 host(staticip.ip) != '' AND
-                (""" + search_term + """ = %s) AND
                 (
                     node.disable_ipv4 IS FALSE OR
                     family(staticip.ip) <> 4
                 )
             ORDER BY
                 node.hostname,
-                is_boot,
+                is_boot DESC,
                 family(staticip.ip),
                 CASE
                     WHEN interface.type = 'bond' AND
@@ -407,33 +414,92 @@
                 END,
                 interface.id
             """
+        iface_sql_query = """
+            SELECT
+                CONCAT(node.hostname, '.', domain.name) AS fqdn,
+                node.system_id,
+                node.node_type,
+                """ + ttl_clause + """ AS ttl,
+                staticip.ip,
+                interface.name
+            FROM
+                maasserver_interface AS interface
+            JOIN maasserver_node AS node ON
+                node.id = interface.node_id
+            JOIN maasserver_domain as domain ON
+                domain.id = node.domain_id
+            JOIN maasserver_interface_ip_addresses AS link ON
+                link.interface_id = interface.id
+            JOIN maasserver_staticipaddress AS staticip ON
+                staticip.id = link.staticipaddress_id
+            """
+        if isinstance(domain_or_subnet, Domain):
+            # This logic is similar to the logic in sql_query above.
+            iface_sql_query += """
+            LEFT JOIN maasserver_domain as domain2 ON
+                /* Pick up another copy of domain looking for instances of
+                 * the name as the top of a domain.
+                 */
+                domain2.name = CONCAT(
+                    interface.name, '.', node.hostname, '.', domain.name)
+            WHERE
+                (domain2.name IS NOT NULL OR node.domain_id = %s) AND
+            """
+        else:
+            # For subnets, we need ALL the names, so that we can correctly
+            # identify which ones should have the FQDN.  dns/zonegenerator.py
+            # optimizes based on this, and only calls once with a subnet,
+            # expecting to get all the subnets back in one table.
+            iface_sql_query += """
+            WHERE
+            """
+        iface_sql_query += """
+                staticip.ip IS NOT NULL AND
+                host(staticip.ip) != '' AND
+                (
+                    node.disable_ipv4 IS FALSE OR
+                    family(staticip.ip) <> 4
+                )
+            ORDER BY
+                node.hostname,
+                interface.id
+            """
         # We get user reserved et al mappings first, so that we can overwrite
         # TTL as we process the return from the SQL horror above.
         mapping = self._get_user_reserved_mappings(domain_or_subnet)
+        # All of the mappings that we got mean that we will only want to add
+        # addresses for the boot interface (is_boot == True).
         iface_is_boot = defaultdict(bool, {
             hostname: True for hostname in mapping.keys()
         })
-        cursor.execute(sql_query, (domain_or_subnet.id,))
+        cursor.execute(sql_query, query_parms)
         # The records from the query provide, for each hostname (after
         # stripping domain), the boot and non-boot interface ip address in ipv4
         # and ipv6.  Our task: if there are boot interace IPs, they win.  If
         # there are none, then whatever we got wins.  The ORDER BY means that
-        # we will see all of the non-boot interfaces before we see any boot
+        # we will see all of the boot interfaces before we see any non-boot
         # interface IPs.  See Bug#1584850
-        for (node_name, system_id, node_type,
-                ttl, domain_name, ip, is_boot) in cursor.fetchall():
-            hostname = "%s.%s" % (strip_domain(node_name), domain_name)
-            mapping[hostname].node_type = node_type
-            mapping[hostname].system_id = system_id
-            mapping[hostname].ttl = ttl
-            # If this is a boot interface, and we have previously only found
-            # non-boot interface IPs, discard them. See also Bug#1584850.
-            if is_boot and not iface_is_boot[hostname]:
-                mapping[hostname].ips = set()
-                iface_is_boot[hostname] = True
-            # At this point, if the interface type is correct, keep the IP.
-            if is_boot == iface_is_boot[hostname]:
-                mapping[hostname].ips.add(ip)
+        for (fqdn, system_id, node_type, ttl,
+                ip, is_boot) in cursor.fetchall():
+            mapping[fqdn].node_type = node_type
+            mapping[fqdn].system_id = system_id
+            mapping[fqdn].ttl = ttl
+            if is_boot:
+                iface_is_boot[fqdn] = True
+            # If we have an IP on the right interface type, save it.
+            if is_boot == iface_is_boot[fqdn]:
+                mapping[fqdn].ips.add(ip)
+        # Next, get all the addresses, on all the interfaces, and add the ones
+        # that are not already present on the FQDN as $IFACE.$FQDN.
+        cursor.execute(iface_sql_query, (domain_or_subnet.id,))
+        for (fqdn, system_id, node_type, ttl,
+                ip, iface_name) in cursor.fetchall():
+            if ip not in mapping[fqdn].ips:
+                name = "%s.%s" % (iface_name, fqdn)
+                mapping[name].node_type = node_type
+                mapping[name].system_id = system_id
+                mapping[name].ttl = ttl
+                mapping[name].ips.add(ip)
         return mapping
 
     def filter_by_ip_family(self, family):
 
=== modified file 'src/maasserver/models/tests/test_dnsresource.py'
--- src/maasserver/models/tests/test_dnsresource.py	2016-04-22 01:56:28 +0000
+++ src/maasserver/models/tests/test_dnsresource.py	2016-07-08 20:46:18 +0000
@@ -131,9 +131,9 @@
         parent = "%s.%s" % (
             factory.make_name("b"),
             factory.make_name("c"))
-        label = factory.make_name("a")
+        label = "%s.%s" % (factory.make_name("a"), factory.make_name("d"))
         name = "%s.%s" % (label, parent)
-        factory.make_Domain(name=name)
+        factory.make_Domain(name=parent)
         self.assertEqual(
             (label, parent), separate_fqdn(name, domainname=parent))
 
 
=== modified file 'src/maasserver/models/tests/test_staticipaddress.py'
--- src/maasserver/models/tests/test_staticipaddress.py	2016-05-26 17:50:49 +0000
+++ src/maasserver/models/tests/test_staticipaddress.py	2016-07-08 20:46:18 +0000
@@ -33,6 +33,7 @@
     HostnameIPMapping,
     StaticIPAddress,
 )
+from maasserver.models.subnet import Subnet
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import (
     MAASServerTestCase,
@@ -357,23 +358,54 @@
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(domain)
         self.assertEqual(expected_mapping, mapping)
 
-    def test_get_hostname_ip_mapping_returns_fqdn(self):
+    def test_get_hostname_ip_mapping_returns_all_mappings_for_subnet(self):
+        domain = Domain.objects.get_default_domain()
+        expected_mapping = {}
+        for _ in range(3):
+            node = factory.make_Node(interface=True, disable_ipv4=False)
+            boot_interface = node.get_boot_interface()
+            subnet = factory.make_Subnet()
+            staticip = factory.make_StaticIPAddress(
+                alloc_type=IPADDRESS_TYPE.STICKY,
+                ip=factory.pick_ip_in_Subnet(subnet),
+                subnet=subnet, interface=boot_interface)
+            full_hostname = "%s.%s" % (node.hostname, domain.name)
+            expected_mapping[full_hostname] = HostnameIPMapping(
+                node.system_id, 30, {staticip.ip}, node.node_type)
+        # See also LP#1600259.  It doesn't matter what subnet is passed in, you
+        # get all of them.
+        mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
+            Subnet.objects.first())
+        self.assertEqual(expected_mapping, mapping)
+
+    def test_get_hostname_ip_mapping_returns_fqdn_and_other(self):
         hostname = factory.make_name('hostname')
         domainname = factory.make_name('domain')
         factory.make_Domain(name=domainname)
         full_hostname = "%s.%s" % (hostname, domainname)
         subnet = factory.make_Subnet()
         node = factory.make_Node_with_Interface_on_Subnet(
-            interface=True, hostname=full_hostname,
+            interface=True, hostname=full_hostname, interface_count=3,
             subnet=subnet, disable_ipv4=False)
         boot_interface = node.get_boot_interface()
         staticip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY,
             ip=factory.pick_ip_in_Subnet(subnet),
             subnet=subnet, interface=boot_interface)
+        ifaces = node.interface_set.exclude(interface=boot_interface)
+        sip2 = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_Subnet(subnet),
+            subnet=subnet, interface=ifaces[0])
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(subnet)
-        self.assertEqual({full_hostname: HostnameIPMapping(
-            node.system_id, 30, {staticip.ip}, node.node_type)}, mapping)
+        self.assertEqual({
+            full_hostname:
+                HostnameIPMapping(
+                    node.system_id, 30, {staticip.ip}, node.node_type),
+            "%s.%s" % (ifaces[0].name, full_hostname):
+                HostnameIPMapping(
+                    node.system_id, 30, {sip2.ip}, node.node_type),
+            }, mapping)
 
     def make_mapping(self, node, raw_ttl=False):
         if raw_ttl or node.address_ttl is not None:
@@ -481,12 +513,16 @@
             ip=factory.pick_ip_in_Subnet(subnet),
             subnet=subnet, interface=boot_interface)
         newer_nic = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
-        factory.make_StaticIPAddress(
+        newer_ip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=newer_nic)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {staticip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {staticip.ip}, node.node_type),
+            "%s.%s" % (newer_nic.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {newer_ip.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_picks_sticky_over_auto(self):
         subnet = factory.make_Subnet(
@@ -500,12 +536,16 @@
             ip=factory.pick_ip_in_Subnet(subnet),
             subnet=subnet, interface=boot_interface)
         nic = node.get_boot_interface()
-        factory.make_StaticIPAddress(
+        auto_ip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.AUTO, interface=nic)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {staticip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {staticip.ip}, node.node_type),
+            "%s.%s" % (nic.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {auto_ip.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_combines_IPv4_and_IPv6_addresses(self):
         node = factory.make_Node(interface=True, disable_ipv4=False)
@@ -584,13 +624,17 @@
         staticip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.AUTO, interface=iface,
             subnet=subnet)
-        factory.make_StaticIPAddress(
+        discovered = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.DISCOVERED, interface=iface,
             subnet=subnet)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {staticip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {staticip.ip}, node.node_type),
+            "%s.%s" % (iface.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {discovered.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_prefers_bond_with_no_boot_interface(self):
         subnet = factory.make_Subnet(
@@ -605,7 +649,7 @@
         iface3 = factory.make_Interface(node=node)
         bondif = factory.make_Interface(
             INTERFACE_TYPE.BOND, node=node, parents=[iface2, iface3])
-        factory.make_StaticIPAddress(
+        iface_ip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=iface,
             subnet=subnet)
         factory.make_StaticIPAddress(
@@ -619,8 +663,12 @@
             subnet=subnet)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {bond_staticip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {bond_staticip.ip}, node.node_type),
+            "%s.%s" % (iface.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {iface_ip.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_prefers_bond_with_boot_interface(self):
         subnet = factory.make_Subnet(
@@ -643,8 +691,11 @@
             subnet=subnet)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {bond_staticip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {bond_staticip.ip}, node.node_type),
+            }
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_ignores_bond_without_boot_interface(self):
         subnet = factory.make_Subnet(
@@ -666,13 +717,17 @@
         factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=iface3,
             subnet=subnet)
-        factory.make_StaticIPAddress(
+        bondip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=bondif,
             subnet=subnet)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {boot_staticip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {boot_staticip.ip}, node.node_type),
+            "%s.%s" % (bondif.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {bondip.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_prefers_boot_interface(self):
         subnet = factory.make_Subnet(
@@ -681,7 +736,7 @@
             hostname=factory.make_name('host'), subnet=subnet,
             disable_ipv4=False)
         iface = node.get_boot_interface()
-        factory.make_StaticIPAddress(
+        iface_ip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=iface,
             subnet=subnet)
         new_boot_interface = factory.make_Interface(
@@ -694,8 +749,12 @@
             subnet=subnet)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {boot_sip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {boot_sip.ip}, node.node_type),
+            "%s.%s" % (iface.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {iface_ip.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_prefers_boot_interface_to_alias(self):
         subnet = factory.make_Subnet(
@@ -704,7 +763,7 @@
             hostname=factory.make_name('host'), subnet=subnet,
             disable_ipv4=False)
         iface = node.get_boot_interface()
-        factory.make_StaticIPAddress(
+        iface_ip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=iface,
             subnet=subnet)
         new_boot_interface = factory.make_Interface(
@@ -717,8 +776,12 @@
             subnet=subnet)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {boot_sip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {boot_sip.ip}, node.node_type),
+            "%s.%s" % (iface.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {iface_ip.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_prefers_physical_interfaces_to_vlan(self):
         subnet = factory.make_Subnet(
@@ -732,13 +795,17 @@
         phy_staticip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=iface,
             subnet=subnet)
-        factory.make_StaticIPAddress(
+        vlanip = factory.make_StaticIPAddress(
             alloc_type=IPADDRESS_TYPE.STICKY, interface=vlanif,
             subnet=subnet)
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(
             node.domain)
-        self.assertEqual({node.fqdn: HostnameIPMapping(
-            node.system_id, 30, {phy_staticip.ip}, node.node_type)}, mapping)
+        expected_mapping = {
+            node.fqdn: HostnameIPMapping(
+                node.system_id, 30, {phy_staticip.ip}, node.node_type),
+            "%s.%s" % (vlanif.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {vlanip.ip}, node.node_type)}
+        self.assertEqual(expected_mapping, mapping)
 
     @skip("XXX: GavinPanella 2016-04-27 bug=1556188: Fails spuriously.")
     def test_get_hostname_ip_mapping_returns_domain_head_ips(self):
@@ -791,8 +858,9 @@
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(domain)
         expected_mapping = {
             node.fqdn: HostnameIPMapping(
-                node.system_id, 30, {sip0.ip}, node.node_type
-            )}
+                node.system_id, 30, {sip0.ip}, node.node_type),
+            "%s.%s" % (iface1.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {sip1.ip}, node.node_type)}
         self.assertEqual(expected_mapping, mapping)
 
     def test_get_hostname_ip_mapping_returns_correct_bond_ip(self):
@@ -838,8 +906,10 @@
         mapping = StaticIPAddress.objects.get_hostname_ip_mapping(domain)
         expected_mapping = {
             node.fqdn: HostnameIPMapping(
-                node.system_id, 30, {bond_sip.ip}, node.node_type
-            )}
+                node.system_id, 30, {bond_sip.ip}, node.node_type),
+            "%s.%s" % (iface1.name, node.fqdn): HostnameIPMapping(
+                node.system_id, 30, {sip1.ip}, node.node_type),
+            }
         self.assertEqual(expected_mapping, mapping)