Merge lp:~lamont/maas/bug-1599223 into lp:~maas-committers/maas/trunk

[LaMont Jones]

Refactor get_hostname_ip_mapping() and stop generating multiple PTR RRs for node FQDNs.

Cleanup how IP Addresses get into the DNS, and reduce the overall number of SQL queries for that process significantly. All IP addresses wind up in the DNS, with the FQDN being what we expect it to be historically, and $IFACE.$FQDN for the other IPs, so that there is only the one PTR RR for the FQDN. ($IFACE.$FQDN may have many PTR RRs in the RRset.)

In the old world, we created forward/reverse DNS for the FQDN, and also created PTR RRs naming $IFACE.$FQDN for each address on each interface on each node that resided in the subnet that we were generating a PTR zone for.

With this change, $IFACE.$FQDN is promoted to first-class citizen, and we create forward and reverse DNS for the names. Any name properly given to the FQDN is omitted from the $IFACE.$FQDN collection, since that would cause us to generate multiple PTR RRs for the primary IPs for the domain. The admin who needs multiple PTR RRs for specific situations can use dnsresource-records to cause that to happen.

[Mike Pontillo (mpontillo)]

Looks good to me. Was this tested end-to-end on nodes deployed with more than one interface? We need to make sure to do that before backporting to 2.0. Let me know if I can help.

review: Approve

[LaMont Jones (lamont)]

Currently, there can be some disparity between forward and reverse zones (which predates this branch) wherein we might choose to return the FQDN for a PTR where there is a IFACE.FQDN A/AAAA RR. I'll file a separate bug report for that.

=== 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 00:18:04 +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 00:18:04 +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 (
@@ -260,7 +256,6 @@
         # 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
@@ -287,35 +282,6 @@
             # 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
-                        })
-
             # Use the default_domain as the name for the NS host in the reverse
             # zones.  If this network is actually a parent rfc2317 glue
             # network, then we need to generate the glue records.

=== 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 00:18:04 +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-07-01 12:23:35 +0000
+++ src/maasserver/models/staticipaddress.py	2016-07-08 00:18:04 +0000
@@ -377,7 +377,7 @@
                 )
             ORDER BY
                 node.hostname,
-                is_boot,
+                is_boot DESC,
                 family(staticip.ip),
                 CASE
                     WHEN interface.type = 'bond' AND
@@ -410,6 +410,42 @@
                 END,
                 interface.id
             """
+        iface_sql_query = """
+            SELECT
+                node.hostname,
+                node.system_id,
+                node.node_type,
+                """ + ttl_clause + """ AS ttl,
+                domain.name, 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
+            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
+                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,
+                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)
@@ -421,22 +457,31 @@
         # 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 (node_name, system_id, node_type, ttl, domain_name,
+                ip, is_boot) in cursor.fetchall():
+            fqdn = "%s.%s" % (strip_domain(node_name), domain_name)
+            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 (node_name, system_id, node_type, ttl,
+                domain_name, ip, iface_name) in cursor.fetchall():
+            fqdn = "%s.%s" % (strip_domain(node_name), domain_name)
+            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 00:18:04 +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-07-01 12:26:51 +0000
+++ src/maasserver/models/tests/test_staticipaddress.py	2016-07-08 00:18:04 +0000
@@ -356,23 +356,34 @@
         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_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:
@@ -480,12 +491,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(
@@ -499,12 +514,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)
@@ -583,13 +602,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(
@@ -604,7 +627,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(
@@ -618,8 +641,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(
@@ -642,8 +669,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(
@@ -665,13 +695,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(
@@ -680,7 +714,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(
@@ -693,8 +727,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(
@@ -703,7 +741,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(
@@ -716,8 +754,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(
@@ -731,13 +773,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):
@@ -790,8 +836,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):
@@ -837,8 +884,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)