Merge ~ltrager/maas:lp1847537_2.6 into maas:2.6

[Lee Trager]

Backport of ad87cfa LP: #1847537 - Respect the allow_dns field when generating V1 network config.

[Lee Trager (ltrager)]

Approved in https://code.launchpad.net/~ltrager/maas/+git/maas/+merge/375057

review: Approve

diff --git a/src/maasserver/dns/tests/test_zonegenerator.py b/src/maasserver/dns/tests/test_zonegenerator.py
index f10aec4..757a8a4 100644
--- a/src/maasserver/dns/tests/test_zonegenerator.py
+++ b/src/maasserver/dns/tests/test_zonegenerator.py
@@ -1,4 +1,4 @@
-# Copyright 2014-2016 Canonical Ltd.  This software is licensed under the
+# Copyright 2014-2019 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Tests for `ZoneGenerator` and supporting cast."""
@@ -131,6 +131,17 @@ class TestGetDNSServerAddress(MAASServerTestCase):
         self.expectThat(ip, Equals(result))
         self.expectThat(resolver, MockAnyCall(hostname, 0))
 
+    def test_get_dns_server_address_ignores_unallowed_dns(self):
+        # Regression test for LP:1847537
+        subnet = factory.make_Subnet(cidr="10.0.0.0/24", allow_dns=False)
+        ip = factory.make_StaticIPAddress(subnet=subnet)
+        resolver = self.patch(server_address, "resolve_hostname")
+        resolver.return_value = {IPAddress(ip.ip)}
+        rack_controller = factory.make_RackController(
+            subnet=subnet, url="http://%s" % ip.ip
+        )
+        self.assertIsNone(get_dns_server_address(rack_controller))
+
 
 class TestGetDNSSearchPaths(MAASServerTestCase):
 
diff --git a/src/maasserver/dns/zonegenerator.py b/src/maasserver/dns/zonegenerator.py
index 054c5b4..6713382 100644
--- a/src/maasserver/dns/zonegenerator.py
+++ b/src/maasserver/dns/zonegenerator.py
@@ -1,4 +1,4 @@
-# Copyright 2014-2016 Canonical Ltd.  This software is licensed under the
+# Copyright 2014-2019 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """DNS zone generator."""
@@ -118,7 +118,10 @@ def get_dns_server_address(rack_controller=None, ipv4=True, ipv6=True):
 
     """
     iplist = get_dns_server_addresses(rack_controller, ipv4, ipv6)
-    return min(iplist).format()
+    if iplist:
+        return min(iplist).format()
+    else:
+        return None
 
 
 def get_dns_server_addresses(
@@ -157,13 +160,22 @@ def get_dns_server_addresses(
             "local_config_set --maas-url' command."
             % e.strerror)
 
-    non_loop = [ip for ip in iplist if not ip.is_loopback()]
+    # LP:1847537 - Filter out MAAS DNS servers running on subnets which do not
+    # allow DNS to be provided from MAAS.
+    filtered_list = [
+        ip
+        for ip in iplist
+        if getattr(
+            Subnet.objects.get_best_subnet_for_ip(ip), "allow_dns", True
+        )
+    ]
+    non_loop = [ip for ip in filtered_list if not ip.is_loopback()]
     if len(non_loop) > 0:
         return non_loop
     else:
-        for ip in iplist:
+        for ip in filtered_list:
             warn_loopback(ip)
-        return iplist
+        return filtered_list
 
 
 def get_dns_search_paths():
diff --git a/src/maasserver/models/node.py b/src/maasserver/models/node.py
index 316b751..c33d630 100644
--- a/src/maasserver/models/node.py
+++ b/src/maasserver/models/node.py
@@ -4151,9 +4151,24 @@ class Node(CleanSave, TimestampedModel):
         # Get the routable addresses between the node and all rack controllers,
         # when the rack proxy should be used (default).
         routable_addrs_map = {}
-        if Config.objects.get_config('use_rack_proxy'):
-            routable_addrs_map = get_routable_address_map(
-                RackController.objects.all(), self)
+        if Config.objects.get_config("use_rack_proxy"):
+            # LP:1847537 - Filter out MAAS DNS servers running on subnets
+            # which do not allow DNS to be provided from MAAS.
+            routable_addrs_map = {}
+            for node, addresses in get_routable_address_map(
+                RackController.objects.all(), self
+            ).items():
+                filtered_addresses = [
+                    address
+                    for address in addresses
+                    if getattr(
+                        Subnet.objects.get_best_subnet_for_ip(address),
+                        "allow_dns",
+                        True,
+                    )
+                ]
+                if filtered_addresses:
+                    routable_addrs_map[node] = filtered_addresses
 
         # No default gateway subnet has specific DNS servers defined, so
         # use MAAS for the default DNS server.
diff --git a/src/maasserver/models/tests/test_node.py b/src/maasserver/models/tests/test_node.py
index a1739bd..194abe2 100644
--- a/src/maasserver/models/tests/test_node.py
+++ b/src/maasserver/models/tests/test_node.py
@@ -6922,6 +6922,12 @@ class TestGetDefaultDNSServers(MAASServerTestCase):
         self.assertItemsEqual(
             node.get_default_dns_servers(), rack_ips)
 
+    def test__ignores_dns_servers_on_unallowed_subnets(self):
+        # Regression test for LP:1847537
+        rack_v4, rack_v6, node = self.make_Node_with_RackController()
+        Subnet.objects.update(allow_dns=False)
+        self.assertThat(node.get_default_dns_servers(), Equals([]))
+
 
 class TestNode_Start(MAASTransactionServerTestCase):
     """Tests for Node.start()."""
diff --git a/src/maasserver/preseed_network.py b/src/maasserver/preseed_network.py
index c91b74b..d3f50d1 100644
--- a/src/maasserver/preseed_network.py
+++ b/src/maasserver/preseed_network.py
@@ -567,13 +567,18 @@ class NodeNetworkConfiguration:
         if not self.addr_family_present[6]:
             self.addr_family_present[4] = True
         self.default_dns_servers = self.node.get_default_dns_servers(
-            ipv4=self.addr_family_present[4], ipv6=self.addr_family_present[6],
-            default_region_ip=default_source_ip)
-        self.v1_config.append({
-            "type": "nameserver",
-            "address": self.default_dns_servers,
-            "search": self.default_search_list,
-        })
+            ipv4=self.addr_family_present[4],
+            ipv6=self.addr_family_present[6],
+            default_region_ip=default_source_ip,
+        )
+        if self.default_dns_servers:
+            self.v1_config.append(
+                {
+                    "type": "nameserver",
+                    "address": self.default_dns_servers,
+                    "search": self.default_search_list,
+                }
+            )
         if version == 1:
             network_config = {
                 "network": {
diff --git a/src/maasserver/tests/test_preseed_network.py b/src/maasserver/tests/test_preseed_network.py
index c45b04b..e5db3cc 100644
--- a/src/maasserver/tests/test_preseed_network.py
+++ b/src/maasserver/tests/test_preseed_network.py
@@ -1149,6 +1149,98 @@ class TestNetplan(MAASServerTestCase):
         }
         self.expectThat(v1, Equals(expected_v1))
 
+    def test__multiple_ethernet_interfaces_without_dns(self):
+        node = factory.make_Node()
+        vlan = factory.make_VLAN()
+        subnet = factory.make_Subnet(
+            cidr="10.0.0.0/24",
+            gateway_ip="10.0.0.1",
+            dns_servers=["10.0.0.2"],
+            allow_dns=False,
+        )
+        subnet2 = factory.make_Subnet(
+            cidr="10.0.1.0/24",
+            gateway_ip="10.0.1.1",
+            dns_servers=["10.0.1.2"],
+            allow_dns=False,
+        )
+        eth0 = factory.make_Interface(
+            node=node, name="eth0", mac_address="00:01:02:03:04:05", vlan=vlan
+        )
+        eth1 = factory.make_Interface(
+            node=node, name="eth1", mac_address="02:01:02:03:04:05"
+        )
+        node.boot_interface = eth0
+        node.save()
+        factory.make_StaticIPAddress(
+            interface=eth0,
+            subnet=subnet,
+            ip="10.0.0.4",
+            alloc_type=IPADDRESS_TYPE.DHCP,
+        )
+        factory.make_StaticIPAddress(
+            interface=eth1,
+            subnet=subnet2,
+            ip="10.0.1.4",
+            alloc_type=IPADDRESS_TYPE.DHCP,
+        )
+        # Make sure we know when and where the default DNS server will be used.
+        get_default_dns_servers_mock = self.patch(
+            node, "get_default_dns_servers"
+        )
+        get_default_dns_servers_mock.return_value = []
+        netplan = self._render_netplan_dict(node)
+        expected_netplan = {
+            "network": OrderedDict(
+                [
+                    ("version", 2),
+                    (
+                        "ethernets",
+                        {
+                            "eth0": {
+                                "match": {"macaddress": "00:01:02:03:04:05"},
+                                "mtu": 1500,
+                                "set-name": "eth0",
+                                "dhcp4": True,
+                            },
+                            "eth1": {
+                                "match": {"macaddress": "02:01:02:03:04:05"},
+                                "mtu": 1500,
+                                "set-name": "eth1",
+                                "dhcp4": True,
+                            },
+                        },
+                    ),
+                ]
+            )
+        }
+        self.expectThat(netplan, Equals(expected_netplan))
+        v1 = self._render_v1_dict(node)
+        expected_v1 = {
+            "network": {
+                "version": 1,
+                "config": [
+                    {
+                        "id": "eth0",
+                        "mac_address": "00:01:02:03:04:05",
+                        "mtu": 1500,
+                        "name": "eth0",
+                        "subnets": [{"type": "dhcp4"}],
+                        "type": "physical",
+                    },
+                    {
+                        "id": "eth1",
+                        "mac_address": "02:01:02:03:04:05",
+                        "mtu": 1500,
+                        "name": "eth1",
+                        "subnets": [{"type": "dhcp4"}],
+                        "type": "physical",
+                    },
+                ],
+            }
+        }
+        self.expectThat(v1, Equals(expected_v1))
+
     def test__ha__default_dns(self):
         node = factory.make_Node()
         mock_get_source_address = self.patch(