Merge lp:~blake-rouse/maas/pick-best-gateway-ip into lp:~maas-committers/maas/trunk

[Blake Rouse]

Add method on node to return the best guess for the gateway_ip.

This method is not being used yet, but a following branch will use it.

[Mike Pontillo (mpontillo)]

Looks nice. I've got a few minor comments.

review: Approve

[Blake Rouse (blake-rouse)]

Thanks for the review.

[Mike Pontillo (mpontillo)]

Just one reply below.

I suspect our user story for disabling a nodegroup is not fully understood.

[Blake Rouse (blake-rouse)]

It means the its no longer managed, it doesnt mean that the subnets that are available on that subnet are dead.

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2015-09-11 03:31:23 +0000
+++ src/maasserver/models/node.py	2015-09-11 19:14:12 +0000
@@ -33,6 +33,7 @@
     PermissionDenied,
     ValidationError,
 )
+from django.db import connection
 from django.db.models import (
     BigIntegerField,
     BooleanField,
@@ -1844,6 +1845,84 @@
             if interface.enabled:
                 interface.ensure_link_up()
 
+    def get_best_guess_for_default_gateway_ips(self):
+        """Return the best guess for the default gateway IP addresses. This is
+        either one IPv4 address, one IPv6 address, or both.
+
+        This is determined by looking at all interfaces on the node and
+        selecting the best possible default gateway IP. The criteria below
+        is used to select the best possible gateway:
+            1. Managed subnets over unmanaged subnets.
+            2. Bond interfaces over physical interfaces.
+            3. Node's boot interface over all other interfaces except bonds.
+            4. Physical interfaces over VLAN interfaces.
+            5. Sticky IP links over user reserved IP links.
+            6. User reserved IP links over auto IP links.
+
+        :return: List of tuples with (interface ID, subnet ID, and gateway IP)
+        :rtype: list
+        """
+        cursor = connection.cursor()
+
+        # DISTINCT ON returns the first matching row for any given
+        # IP family. Using the query's ordering.
+        #
+        # For nodes that have disable_ipv4 set, leave out any IPv4 address.
+        cursor.execute("""
+            SELECT DISTINCT ON (family(subnet.gateway_ip))
+                interface.id, subnet.id, subnet.gateway_ip
+            FROM maasserver_node AS node
+            JOIN maasserver_interface AS interface ON
+                interface.node_id = node.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
+            JOIN maasserver_subnet AS subnet ON
+                subnet.id = staticip.subnet_id
+            LEFT JOIN maasserver_nodegroupinterface AS ngi ON
+                ngi.subnet_id = subnet.id
+            LEFT JOIN maasserver_nodegroup AS nodegroup ON
+                nodegroup.id = ngi.nodegroup_id
+            WHERE
+                node.id = %s AND
+                subnet.gateway_ip IS NOT NULL AND
+                host(subnet.gateway_ip) != '' AND
+                staticip.alloc_type != 5 AND /* Ignore DHCP */
+                staticip.alloc_type != 6 AND /* Ignore DISCOVERED */
+                (
+                    node.disable_ipv4 IS FALSE OR
+                    family(subnet.gateway_ip) <> 4
+                )
+            ORDER BY
+                family(subnet.gateway_ip),
+                nodegroup.status,
+                ngi.management DESC,
+                CASE
+                    WHEN interface.type = 'bond' THEN 1
+                    WHEN interface.type = 'physical' AND
+                        interface.id = node.boot_interface_id THEN 2
+                    WHEN interface.type = 'physical' THEN 3
+                    WHEN interface.type = 'vlan' THEN 4
+                    WHEN interface.type = 'alias' THEN 5
+                    ELSE 6
+                END,
+                CASE
+                    WHEN staticip.alloc_type = 1 /* STICKY */
+                        THEN 1
+                    WHEN staticip.alloc_type = 4 /* USER_RESERVED */
+                        THEN 2
+                    WHEN staticip.alloc_type = 0 /* AUTO */
+                        THEN 3
+                    ELSE staticip.alloc_type
+                END,
+                interface.id
+            """, (self.id,))
+        return [
+            (found[0], found[1], found[2])
+            for found in cursor.fetchall()
+        ]
+
     def get_boot_purpose(self):
         """
         Return a suitable "purpose" for this boot, e.g. "install".

=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2015-09-11 03:31:23 +0000
+++ src/maasserver/models/tests/test_node.py	2015-09-11 19:14:12 +0000
@@ -2614,6 +2614,228 @@
         self.assertItemsEqual(enabled_interfaces, observed_interfaces)
 
 
+class TestGetBestGuessForDefaultGatewayIPs(MAASServerTestCase):
+
+    def test__simple(self):
+        node = factory.make_Node_with_Interface_on_Subnet(
+            status=NODE_STATUS.READY, disable_ipv4=False)
+        boot_interface = node.get_boot_interface()
+        managed_subnet = boot_interface.ip_addresses.filter(
+            alloc_type=IPADDRESS_TYPE.AUTO).first().subnet
+        gateway_ip = managed_subnet.gateway_ip
+        self.assertEquals(
+            [(boot_interface.id, managed_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+    def test__ipv4_and_ipv6(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, nodegroup=nodegroup, disable_ipv4=False)
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        network_v4 = factory.make_ipv4_network()
+        subnet_v4 = factory.make_Subnet(cidr=unicode(network_v4.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet_v4)
+        network_v6 = factory.make_ipv6_network()
+        subnet_v6 = factory.make_Subnet(cidr=unicode(network_v6.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet_v6)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(network_v4),
+            subnet=subnet_v4, interface=interface)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(network_v6),
+            subnet=subnet_v6, interface=interface)
+        self.assertItemsEqual([
+            (interface.id, subnet_v4.id, subnet_v4.gateway_ip),
+            (interface.id, subnet_v6.id, subnet_v6.gateway_ip),
+            ], node.get_best_guess_for_default_gateway_ips())
+
+    def test__only_one(self):
+        node = factory.make_Node_with_Interface_on_Subnet(
+            status=NODE_STATUS.READY, disable_ipv4=False)
+        boot_interface = node.get_boot_interface()
+        managed_subnet = boot_interface.ip_addresses.filter(
+            alloc_type=IPADDRESS_TYPE.AUTO).first().subnet
+        # Give it two IP addresses on the same subnet.
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(managed_subnet.get_ipnetwork()),
+            subnet=managed_subnet, interface=boot_interface)
+        gateway_ip = managed_subnet.gateway_ip
+        self.assertEquals(
+            [(boot_interface.id, managed_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+    def test__managed_subnet_over_unmanaged(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, nodegroup=nodegroup, disable_ipv4=False)
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        unmanaged_network = factory.make_ipv4_network()
+        unmanaged_subnet = factory.make_Subnet(
+            cidr=unicode(unmanaged_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(unmanaged_network),
+            subnet=unmanaged_subnet, interface=interface)
+        managed_network = factory.make_ipv4_network()
+        managed_subnet = factory.make_Subnet(
+            cidr=unicode(managed_network.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=managed_subnet)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(managed_network),
+            subnet=managed_subnet, interface=interface)
+        gateway_ip = managed_subnet.gateway_ip
+        self.assertEquals(
+            [(interface.id, managed_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+    def test__bond_over_physical_interface(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, nodegroup=nodegroup, disable_ipv4=False)
+        physical_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        physical_network = factory.make_ipv4_network()
+        physical_subnet = factory.make_Subnet(
+            cidr=unicode(physical_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(physical_network),
+            subnet=physical_subnet, interface=physical_interface)
+        parent_interfaces = [
+            factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+            for _ in range(2)
+        ]
+        bond_interface = factory.make_Interface(
+            INTERFACE_TYPE.BOND, node=node, parents=parent_interfaces)
+        bond_network = factory.make_ipv4_network()
+        bond_subnet = factory.make_Subnet(
+            cidr=unicode(bond_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(bond_network),
+            subnet=bond_subnet, interface=bond_interface)
+        gateway_ip = bond_subnet.gateway_ip
+        self.assertEquals(
+            [(bond_interface.id, bond_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+    def test__physical_over_vlan_interface(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, nodegroup=nodegroup, disable_ipv4=False)
+        physical_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        physical_network = factory.make_ipv4_network()
+        physical_subnet = factory.make_Subnet(
+            cidr=unicode(physical_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(physical_network),
+            subnet=physical_subnet, interface=physical_interface)
+        vlan_interface = factory.make_Interface(
+            INTERFACE_TYPE.VLAN, node=node, parents=[physical_interface])
+        vlan_network = factory.make_ipv4_network()
+        vlan_subnet = factory.make_Subnet(
+            cidr=unicode(vlan_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(vlan_network),
+            subnet=vlan_subnet, interface=vlan_interface)
+        gateway_ip = physical_subnet.gateway_ip
+        self.assertEquals(
+            [(physical_interface.id, physical_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+    def test__boot_interface_over_other_interfaces(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, nodegroup=nodegroup, disable_ipv4=False)
+        physical_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        physical_network = factory.make_ipv4_network()
+        physical_subnet = factory.make_Subnet(
+            cidr=unicode(physical_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(physical_network),
+            subnet=physical_subnet, interface=physical_interface)
+        boot_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        boot_network = factory.make_ipv4_network()
+        boot_subnet = factory.make_Subnet(
+            cidr=unicode(boot_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(boot_network),
+            subnet=boot_subnet, interface=boot_interface)
+        node.boot_interface = boot_interface
+        node.save()
+        gateway_ip = boot_subnet.gateway_ip
+        self.assertEquals(
+            [(boot_interface.id, boot_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+    def test__sticky_ip_over_user_reserved(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, nodegroup=nodegroup, disable_ipv4=False)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        sticky_network = factory.make_ipv4_network()
+        sticky_subnet = factory.make_Subnet(
+            cidr=unicode(sticky_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_network(sticky_network),
+            subnet=sticky_subnet, interface=interface)
+        user_reserved_network = factory.make_ipv4_network()
+        user_reserved_subnet = factory.make_Subnet(
+            cidr=unicode(user_reserved_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=factory.make_User(),
+            ip=factory.pick_ip_in_network(user_reserved_network),
+            subnet=user_reserved_subnet, interface=interface)
+        gateway_ip = sticky_subnet.gateway_ip
+        self.assertEquals(
+            [(interface.id, sticky_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+    def test__user_reserved_ip_over_auto(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        node = factory.make_Node(
+            status=NODE_STATUS.READY, nodegroup=nodegroup, disable_ipv4=False)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=node)
+        user_reserved_network = factory.make_ipv4_network()
+        user_reserved_subnet = factory.make_Subnet(
+            cidr=unicode(user_reserved_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=factory.make_User(),
+            ip=factory.pick_ip_in_network(user_reserved_network),
+            subnet=user_reserved_subnet, interface=interface)
+        auto_network = factory.make_ipv4_network()
+        auto_subnet = factory.make_Subnet(
+            cidr=unicode(auto_network.cidr))
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO,
+            ip=factory.pick_ip_in_network(auto_network),
+            subnet=auto_subnet, interface=interface)
+        gateway_ip = user_reserved_subnet.gateway_ip
+        self.assertEquals(
+            [(interface.id, user_reserved_subnet.id, gateway_ip)],
+            node.get_best_guess_for_default_gateway_ips())
+
+
 class TestDeploymentStatus(MAASServerTestCase):
     """Tests for node.get_deployment_status."""