Merge lp:~blake-rouse/maas/node-gateway-api into lp:~maas-committers/maas/trunk

[Blake Rouse]

Add API to set the default gateway for IPv4 and IPv6 on the node. Add API to clear the default gatway allowing MAAS to pick the best gateway. Includes drive-by fix for the InterfaceLinkForm and the new AUTO link type.

[Andres Rodriguez (andreserl)]

lgtm! However, the only question / suggestion I have... and I think this is something we've kind of discussed in the past:

Wouldn't it be better to simply say "Subnetwork A, is the Internet" (or the one that provides upstream connectivity), and that would simply automatically mean that the interface with the internet subnet would be the one with the default gateway?

review: Approve

[Blake Rouse (blake-rouse)]

Thanks for the review.

That might be a good addition we want to add, but I think in general this is way more flexible. This should allow anyone using MAAS to get there network configuration just right.

If we fell that is something that should be added to the subnet model, please file a bug and we can adjust the pick_best_default_gateway code to use that attribute.

[MAAS Lander (maas-lander)]

The attempt to merge lp:~blake-rouse/maas/node-gateway-api into lp:maas failed. Below is the output from the failed tests.

Ign http://security.ubuntu.com trusty-security InRelease
Ign http://nova.clouds.archive.ubuntu.com trusty InRelease
Hit http://security.ubuntu.com trusty-security Release.gpg
Ign http://nova.clouds.archive.ubuntu.com trusty-updates InRelease
Hit http://security.ubuntu.com trusty-security Release
Hit http://nova.clouds.archive.ubuntu.com trusty Release.gpg
Get:1 http://nova.clouds.archive.ubuntu.com trusty-updates Release.gpg [933 B]
Hit http://nova.clouds.archive.ubuntu.com trusty Release
Get:2 http://nova.clouds.archive.ubuntu.com trusty-updates Release [63.5 kB]
Hit http://security.ubuntu.com trusty-security/main Sources
Hit http://security.ubuntu.com trusty-security/universe Sources
Hit http://nova.clouds.archive.ubuntu.com trusty/main Sources
Hit http://security.ubuntu.com trusty-security/main amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty/universe Sources
Hit http://security.ubuntu.com trusty-security/universe amd64 Packages
Hit http://nova.clouds.archive.ubuntu.com trusty/main amd64 Packages
Hit http://security.ubuntu.com trusty-security/main Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty/universe amd64 Packages
Hit http://security.ubuntu.com trusty-security/universe Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty/main Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty/universe Translation-en
Get:3 http://nova.clouds.archive.ubuntu.com trusty-updates/main Sources [234 kB]
Get:4 http://nova.clouds.archive.ubuntu.com trusty-updates/universe Sources [135 kB]
Get:5 http://nova.clouds.archive.ubuntu.com trusty-updates/main amd64 Packages [619 kB]
Get:6 http://nova.clouds.archive.ubuntu.com trusty-updates/universe amd64 Packages [312 kB]
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/main Translation-en
Hit http://nova.clouds.archive.ubuntu.com trusty-updates/universe Translation-en
Ign http://nova.clouds.archive.ubuntu.com trusty/main Translation-en_US
Ign http://nova.clouds.archive.ubuntu.com trusty/universe Translation-en_US
Fetched 1,365 kB in 3s (373 kB/s)
Reading package lists...
sudo DEBIAN_FRONTEND=noninteractive apt-get -y \
     --no-install-recommends install apache2 authbind bind9 bind9utils build-essential bzr-builddeb chromium-browser chromium-chromedriver curl daemontools debhelper dh-apport dh-systemd distro-info dnsutils firefox freeipmi-tools git gjs ipython isc-dhcp-common libjs-angularjs libjs-jquery libjs-jquery-hotkeys libjs-yui3-full libjs-yui3-min libpq-dev make nodejs-legacy npm pep8 phantomjs postgresql pyflakes python-apt python-bson python-bzrlib python-convoy python-coverage python-crochet python-cssselect python-curtin python-dev python-distro-info python-django python-django-piston python-django-south python-djorm-ext-pgarray python-docutils python-extras python-fixtures python-flake8 python-formencode python-hivex python-httplib2 python-jinja2 python-jsonschema python-lxml python-mock python-netaddr python-netifaces python-nose python-oauth python-openssl python-paramiko python-pexpect python-pip python-pocket-lint py...

=== modified file 'src/maasserver/api/interfaces.py'
--- src/maasserver/api/interfaces.py	2015-09-15 03:14:28 +0000
+++ src/maasserver/api/interfaces.py	2015-09-15 19:08:34 +0000
@@ -30,6 +30,7 @@
 )
 from maasserver.forms_interface_link import (
     InterfaceLinkForm,
+    InterfaceSetDefaultGatwayForm,
     InterfaceUnlinkForm,
 )
 from maasserver.models.interface import (
@@ -268,6 +269,9 @@
         :param ip_address: IP address for the interface in subnet. Only used
             when mode is STATIC. If not provided an IP address from subnet
             will be auto selected.
+        :param default_gateway: True sets the gateway IP address for the subnet
+            as the default gateway for the node this interface belongs to.
+            Option can only be used with the AUTO and STATIC modes.
 
         Mode definitions:
         AUTO - Assign this interface a static IP address from the provided
@@ -311,6 +315,29 @@
         else:
             raise MAASAPIValidationError(form.errors)
 
+    @operation(idempotent=False)
+    def set_default_gateway(self, request, system_id, interface_id):
+        """Set the node to use this interface as the default gateway.
+
+        If this interface has more than one subnet with a gateway IP in the
+        same IP address family then specifying the ID of the link on
+        this interface is required.
+
+        :param link_id: ID of the link on this interface to select the
+            default gateway IP address from.
+
+        Returns 400 if the interface has not AUTO or STATIC links.
+        Returns 404 if the node or interface is not found.
+        """
+        interface = Interface.objects.get_interface_or_404(
+            system_id, interface_id, request.user, NODE_PERMISSION.ADMIN)
+        form = InterfaceSetDefaultGatwayForm(
+            instance=interface, data=request.data)
+        if form.is_valid():
+            return form.save()
+        else:
+            raise MAASAPIValidationError(form.errors)
+
 
 class PhysicalInterfaceHandler(NodeInterfaceHandler):
     """

=== modified file 'src/maasserver/api/nodes.py'
--- src/maasserver/api/nodes.py	2015-09-15 13:25:33 +0000
+++ src/maasserver/api/nodes.py	2015-09-15 19:08:34 +0000
@@ -855,6 +855,32 @@
                     storage_layout, e.message))
         return node
 
+    @operation(idempotent=False)
+    def clear_default_gateways(self, request, system_id):
+        """Clear any set default gateways on the node.
+
+        This will clear both IPv4 and IPv6 gateways on the node. This will
+        transition the logic of identifing the best gateway to MAAS. This logic
+        is determined based the following criteria:
+
+        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.
+
+        If the default gateways need to be specific for this node you can set
+        which interface and subnet's gateway to use when this node is deployed
+        with the `node-interfaces set-default-gateway` API.
+        """
+        node = Node.nodes.get_node_or_404(
+            system_id=system_id, user=request.user, perm=NODE_PERMISSION.ADMIN)
+        node.gateway_link_ipv4 = None
+        node.gateway_link_ipv6 = None
+        node.save()
+        return node
+
 
 def create_node(request):
     """Service an http request to create a node.

=== modified file 'src/maasserver/api/tests/test_doc.py'
--- src/maasserver/api/tests/test_doc.py	2015-08-21 13:59:15 +0000
+++ src/maasserver/api/tests/test_doc.py	2015-09-15 19:08:34 +0000
@@ -317,10 +317,12 @@
             "restful=False",
             "POST release_sticky_ip_address op=release_sticky_ip_address "
             "restful=False",
-            'POST mark_fixed op=mark_fixed restful=False',
-            'POST mark_broken op=mark_broken restful=False',
-            'POST abort_operation op=abort_operation restful=False',
-            'POST set_storage_layout op=set_storage_layout restful=False',
+            "POST mark_fixed op=mark_fixed restful=False",
+            "POST mark_broken op=mark_broken restful=False",
+            "POST abort_operation op=abort_operation restful=False",
+            "POST set_storage_layout op=set_storage_layout restful=False",
+            "POST clear_default_gateways op=clear_default_gateways "
+            "restful=False",
             }
         observed_actions = {
             "%(method)s %(name)s op=%(op)s restful=%(restful)s" % action

=== modified file 'src/maasserver/api/tests/test_interfaces.py'
--- src/maasserver/api/tests/test_interfaces.py	2015-09-09 18:35:17 +0000
+++ src/maasserver/api/tests/test_interfaces.py	2015-09-15 19:08:34 +0000
@@ -611,3 +611,67 @@
             })
         self.assertEqual(
             httplib.FORBIDDEN, response.status_code, response.content)
+
+    def test_set_default_gateway_sets_gateway_link_ipv4_on_node(self):
+        # The form that is used is fully tested in test_forms_interface_link.
+        # This just tests that the form is saved and the node link is created.
+        self.become_admin()
+        node = factory.make_Node(interface=True)
+        interface = node.get_boot_interface()
+        network = factory.make_ipv4_network()
+        subnet = factory.make_Subnet(
+            cidr=unicode(network.cidr), vlan=interface.vlan)
+        link_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        uri = get_node_interface_uri(interface)
+        response = self.client.post(uri, {
+            "op": "set_default_gateway",
+            "link_id": link_ip.id
+            })
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        self.assertEqual(link_ip, reload_object(node).gateway_link_ipv4)
+
+    def test_set_default_gateway_sets_gateway_link_ipv6_on_node(self):
+        # The form that is used is fully tested in test_forms_interface_link.
+        # This just tests that the form is saved and the node link is created.
+        self.become_admin()
+        node = factory.make_Node(interface=True)
+        interface = node.get_boot_interface()
+        network = factory.make_ipv6_network()
+        subnet = factory.make_Subnet(
+            cidr=unicode(network.cidr), vlan=interface.vlan)
+        link_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        uri = get_node_interface_uri(interface)
+        response = self.client.post(uri, {
+            "op": "set_default_gateway",
+            "link_id": link_ip.id
+            })
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        self.assertEqual(link_ip, reload_object(node).gateway_link_ipv6)
+
+    def test_set_default_gateway_raises_error(self):
+        self.become_admin()
+        node = factory.make_Node(interface=True)
+        interface = node.get_boot_interface()
+        uri = get_node_interface_uri(interface)
+        response = self.client.post(uri, {
+            "op": "set_default_gateway",
+            })
+        self.assertEqual(
+            httplib.BAD_REQUEST, response.status_code, response.content)
+        self.assertEquals({
+            "__all__": ["This interface has no usable gateways."]
+            }, json.loads(response.content))
+
+    def test_set_default_gateway_requries_admin(self):
+        node = factory.make_Node(interface=True)
+        interface = node.get_boot_interface()
+        uri = get_node_interface_uri(interface)
+        response = self.client.post(uri, {
+            "op": "set_default_gateway",
+            })
+        self.assertEqual(
+            httplib.FORBIDDEN, response.status_code, response.content)

=== modified file 'src/maasserver/api/tests/test_node.py'
--- src/maasserver/api/tests/test_node.py	2015-09-08 21:59:19 +0000
+++ src/maasserver/api/tests/test_node.py	2015-09-15 19:08:34 +0000
@@ -1810,3 +1810,46 @@
         self.assertThat(
             mock_set_storage_layout,
             MockCalledOnceWith('flat', params=ANY, allow_fallback=False))
+
+
+class TestClearDefaultGateways(APITestCase):
+
+    def get_node_uri(self, node):
+        """Get the API URI for `node`."""
+        return reverse('node_handler', args=[node.system_id])
+
+    def test__403_when_not_admin(self):
+        node = factory.make_Node(
+            owner=self.logged_in_user, status=NODE_STATUS.ALLOCATED)
+        response = self.client.post(
+            self.get_node_uri(node), {'op': 'clear_default_gateways'})
+        self.assertEquals(
+            httplib.FORBIDDEN, response.status_code, response.content)
+
+    def test__clears_default_gateways(self):
+        self.become_admin()
+        node = factory.make_Node(
+            owner=self.logged_in_user, status=NODE_STATUS.ALLOCATED)
+        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), vlan=interface.vlan)
+        link_v4 = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet_v4, interface=interface)
+        node.gateway_link_ipv4 = link_v4
+        network_v6 = factory.make_ipv6_network()
+        subnet_v6 = factory.make_Subnet(
+            cidr=unicode(network_v6.cidr), vlan=interface.vlan)
+        link_v6 = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet_v6, interface=interface)
+        node.gateway_link_ipv6 = link_v6
+        node.save()
+        response = self.client.post(
+            self.get_node_uri(node), {'op': 'clear_default_gateways'})
+        self.assertEquals(
+            httplib.OK, response.status_code, response.content)
+        node = reload_object(node)
+        self.assertIsNone(node.gateway_link_ipv4)
+        self.assertIsNone(node.gateway_link_ipv6)

=== modified file 'src/maasserver/forms_interface_link.py'
--- src/maasserver/forms_interface_link.py	2015-09-15 14:15:07 +0000
+++ src/maasserver/forms_interface_link.py	2015-09-15 19:08:34 +0000
@@ -16,14 +16,19 @@
     "InterfaceLinkForm",
 ]
 
+from collections import Counter
+
 from django import forms
+from django.core.exceptions import ValidationError
 from maasserver.enum import (
     INTERFACE_LINK_TYPE,
     INTERFACE_LINK_TYPE_CHOICES,
+    IPADDRESS_FAMILY,
     IPADDRESS_TYPE,
 )
 from maasserver.fields import CaseInsensitiveChoiceField
 from maasserver.models.interface import Interface
+from maasserver.models.staticipaddress import StaticIPAddress
 from maasserver.utils.forms import (
     compose_invalid_choice_text,
     set_form_error,
@@ -31,6 +36,12 @@
 from maasserver.utils.orm import get_one
 from netaddr import IPAddress
 
+# Link modes that support the default_gateway option.
+GATEWAY_OPTION_MODES = [
+    INTERFACE_LINK_TYPE.AUTO,
+    INTERFACE_LINK_TYPE.STATIC,
+]
+
 
 class InterfaceLinkForm(forms.Form):
     """Interface link form."""
@@ -46,6 +57,8 @@
 
     ip_address = forms.GenericIPAddressField(required=False)
 
+    default_gateway = forms.BooleanField(initial=False, required=False)
+
     def __init__(self, *args, **kwargs):
         self.instance = kwargs.pop("instance")
         super(InterfaceLinkForm, self).__init__(*args, **kwargs)
@@ -54,14 +67,24 @@
     def clean(self):
         cleaned_data = super(InterfaceLinkForm, self).clean()
         mode = cleaned_data.get("mode", None)
-        if mode == INTERFACE_LINK_TYPE.DHCP:
+        if mode is None:
+            return cleaned_data
+        elif mode == INTERFACE_LINK_TYPE.AUTO:
+            self._clean_mode_auto(cleaned_data)
+        elif mode == INTERFACE_LINK_TYPE.DHCP:
             self._clean_mode_dhcp()
         elif mode == INTERFACE_LINK_TYPE.STATIC:
             self._clean_mode_static(cleaned_data)
         elif mode == INTERFACE_LINK_TYPE.LINK_UP:
             self._clean_mode_link_up()
+        self._clean_default_gateway(cleaned_data)
         return cleaned_data
 
+    def _clean_mode_auto(self, cleaned_data):
+        subnet = cleaned_data.get("subnet", None)
+        if subnet is None:
+            set_form_error(self, "subnet", "This field is required.")
+
     def _clean_mode_dhcp(self):
         # Can only have one DHCP link on an interface.
         dhcp_address = get_one(
@@ -102,29 +125,55 @@
         if self.instance.ip_addresses.count() > 0:
             set_form_error(
                 self, "mode",
-                "Cannot configure interface to link up (with no IP address)"
+                "Cannot configure interface to link up (with no IP address) "
                 "while other links are already configured.")
 
+    def _clean_default_gateway(self, cleaned_data):
+        mode = cleaned_data.get("mode", None)
+        subnet = cleaned_data.get("subnet", None)
+        default_gateway = cleaned_data.get("default_gateway", False)
+        if not default_gateway:
+            return
+        if mode not in GATEWAY_OPTION_MODES:
+            set_form_error(
+                self, "default_gateway", "Cannot use in mode '%s'." % mode)
+        else:
+            if subnet is None:
+                set_form_error(
+                    self, "default_gateway",
+                    "Subnet is required when default_gateway is True.")
+            elif not subnet.gateway_ip:
+                set_form_error(
+                    self, "default_gateway",
+                    "Cannot set as default gateway because subnet "
+                    "%s doesn't provide a gateway IP address." % subnet)
+
     def save(self):
         mode = self.cleaned_data.get("mode", None)
         subnet = self.cleaned_data.get("subnet", None)
         ip_address = self.cleaned_data.get("ip_address", None)
+        default_gateway = self.cleaned_data.get("default_gateway", False)
         if not ip_address:
             ip_address = None
-        self.instance.link_subnet(mode, subnet, ip_address=ip_address)
+        link_ip = self.instance.link_subnet(
+            mode, subnet, ip_address=ip_address)
+        if default_gateway:
+            node = self.instance.get_node()
+            network = subnet.get_ipnetwork()
+            if network.version == IPADDRESS_FAMILY.IPv4:
+                node.gateway_link_ipv4 = link_ip
+            elif network.version == IPADDRESS_FAMILY.IPv6:
+                node.gateway_link_ipv6 = link_ip
+            else:
+                raise ValueError(
+                    "Unknown subnet IP version: %s" % network.version)
+            node.save()
         return Interface.objects.get(id=self.instance.id)
 
 
 class InterfaceUnlinkForm(forms.Form):
     """Interface unlink form."""
 
-    id = forms.ChoiceField(
-        choices=INTERFACE_LINK_TYPE_CHOICES, required=True,
-        error_messages={
-            'invalid_choice': compose_invalid_choice_text(
-                'mode', INTERFACE_LINK_TYPE_CHOICES),
-        })
-
     def __init__(self, *args, **kwargs):
         self.instance = kwargs.pop("instance")
         super(InterfaceUnlinkForm, self).__init__(*args, **kwargs)
@@ -148,3 +197,106 @@
         link_id = self.cleaned_data.get("id", None)
         self.instance.unlink_subnet_by_id(link_id)
         return Interface.objects.get(id=self.instance.id)
+
+
+class InterfaceSetDefaultGatwayForm(forms.Form):
+    """Interface set default gateway form."""
+
+    def __init__(self, *args, **kwargs):
+        self.instance = kwargs.pop("instance")
+        super(InterfaceSetDefaultGatwayForm, self).__init__(*args, **kwargs)
+        self.links = self.get_valid_links()
+        self.set_up_link_id_field()
+
+    def get_valid_links(self):
+        """Return IP links on the instance that are of the correct type,
+        have a subnet, and has a gateway_ip set."""
+        links = self.instance.ip_addresses.filter(
+            alloc_type__in=[IPADDRESS_TYPE.AUTO, IPADDRESS_TYPE.STICKY],
+            subnet__isnull=False, subnet__gateway_ip__isnull=False)
+        links = links.select_related("subnet")
+        return [
+            link
+            for link in links.all()
+            if link.subnet.gateway_ip
+        ]
+
+    def set_up_link_id_field(self):
+        link_choices = [
+            (link.id, link.id)
+            for link in self.links
+        ]
+        invalid_choice = compose_invalid_choice_text('link_id', link_choices)
+        self.fields["link_id"] = forms.ChoiceField(
+            choices=link_choices, required=False,
+            error_messages={
+                'invalid_choice': invalid_choice,
+            })
+
+    def _clean_has_gateways(self):
+        """Sets error if the interface has not available gateways."""
+        if len(self.links) == 0:
+            raise ValidationError("This interface has no usable gateways.")
+
+    def _clean_ipv4_and_ipv6_gateways(self):
+        """Sets error if the interface doesn't have only one IPv4 and one
+        IPv6 gateway."""
+        unique_gateways = set(
+            link.subnet.gateway_ip
+            for link in self.links
+            )
+        gateway_versions = Counter(
+            IPAddress(gateway).version
+            for gateway in unique_gateways
+            )
+        too_many = [
+            ip_family
+            for ip_family, count in gateway_versions.items()
+            if count > 1
+        ]
+        if len(too_many) > 0:
+            set_form_error(
+                self, "link_id",
+                "This field is required; Interface has more than "
+                "one usable %s gateway%s." % (
+                    ' and '.join(
+                        map(lambda version: "IPv%d" % version, too_many)),
+                    "s" if len(too_many) > 1 else ""))
+
+    def clean(self):
+        self._clean_has_gateways()
+        cleaned_data = super(InterfaceSetDefaultGatwayForm, self).clean()
+        link_id = cleaned_data.get("link_id", None)
+        if not link_id:
+            self._clean_ipv4_and_ipv6_gateways()
+        return cleaned_data
+
+    def get_first_link_by_ip_family(self, ip_family):
+        for link in self.links:
+            if link.subnet.get_ipnetwork().version == ip_family:
+                return link
+        return None
+
+    def save(self):
+        link_id = self.cleaned_data.get("link_id", None)
+        node = self.instance.get_node()
+        if link_id:
+            link = StaticIPAddress.objects.get(id=int(link_id))
+            network = link.subnet.get_ipnetwork()
+            if network.version == IPADDRESS_FAMILY.IPv4:
+                node.gateway_link_ipv4 = link
+            elif network.version == IPADDRESS_FAMILY.IPv6:
+                node.gateway_link_ipv6 = link
+            else:
+                raise ValueError(
+                    "Unknown subnet IP version: %s" % network.version)
+            node.save()
+        else:
+            ipv4_link = self.get_first_link_by_ip_family(IPADDRESS_FAMILY.IPv4)
+            if ipv4_link is not None:
+                node.gateway_link_ipv4 = ipv4_link
+            ipv6_link = self.get_first_link_by_ip_family(IPADDRESS_FAMILY.IPv6)
+            if ipv6_link is not None:
+                node.gateway_link_ipv6 = ipv6_link
+            node.save()
+        return self.instance

=== modified file 'src/maasserver/tests/test_forms_interface_link.py'
--- src/maasserver/tests/test_forms_interface_link.py	2015-09-15 14:15:07 +0000
+++ src/maasserver/tests/test_forms_interface_link.py	2015-09-15 19:08:34 +0000
@@ -25,6 +25,7 @@
 )
 from maasserver.forms_interface_link import (
     InterfaceLinkForm,
+    InterfaceSetDefaultGatwayForm,
     InterfaceUnlinkForm,
 )
 from maasserver.models import interface as interface_module
@@ -61,6 +62,90 @@
         form = InterfaceLinkForm(instance=interface, data={})
         self.assertItemsEqual(subnets, form.fields["subnet"].queryset)
 
+    def test__AUTO_requires_subnet(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.AUTO,
+        })
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertEquals({
+            "subnet": ["This field is required."],
+            }, form.errors)
+
+    def test__AUTO_creates_link_to_AUTO_with_subnet(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        auto_subnet = factory.make_Subnet(vlan=interface.vlan)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.AUTO,
+            "subnet": auto_subnet.id,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        auto_ip = interface.ip_addresses.get(alloc_type=IPADDRESS_TYPE.AUTO)
+        self.assertEquals(auto_subnet, auto_ip.subnet)
+
+    def test__AUTO_sets_node_gateway_link_v4(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        network = factory.make_ipv4_network()
+        auto_subnet = factory.make_Subnet(
+            cidr=unicode(network.cidr), vlan=interface.vlan)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.AUTO,
+            "subnet": auto_subnet.id,
+            "default_gateway": True,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        auto_ip = interface.ip_addresses.get(alloc_type=IPADDRESS_TYPE.AUTO)
+        node = interface.get_node()
+        self.assertEquals(auto_ip, node.gateway_link_ipv4)
+
+    def test__AUTO_sets_node_gateway_link_v6(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        network = factory.make_ipv6_network()
+        auto_subnet = factory.make_Subnet(
+            cidr=unicode(network.cidr), vlan=interface.vlan)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.AUTO,
+            "subnet": auto_subnet.id,
+            "default_gateway": True,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        auto_ip = interface.ip_addresses.get(alloc_type=IPADDRESS_TYPE.AUTO)
+        node = interface.get_node()
+        self.assertEquals(auto_ip, node.gateway_link_ipv6)
+
+    def test__AUTO_default_gateway_requires_subnet(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.AUTO,
+            "default_gateway": True,
+            })
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertEquals({
+            "default_gateway": [
+                "Subnet is required when default_gateway is True."],
+            "subnet": ["This field is required."],
+            }, form.errors)
+
+    def test__AUTO_default_gateway_requires_subnet_with_gateway_ip(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        auto_subnet = factory.make_Subnet(vlan=interface.vlan)
+        auto_subnet.gateway_ip = None
+        auto_subnet.save()
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.AUTO,
+            "subnet": auto_subnet.id,
+            "default_gateway": True,
+            })
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertEquals({
+            "default_gateway": [
+                "Cannot set as default gateway because subnet "
+                "%s doesn't provide a gateway IP address." % auto_subnet],
+            }, form.errors)
+
     def test__DHCP_not_allowed_if_already_DHCP_with_subnet(self):
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
         dhcp_subnet = factory.make_Subnet()
@@ -92,6 +177,18 @@
                 "Interface is already set to DHCP."]
             }, form.errors)
 
+    def test__DHCP_not_allowed_default_gateway(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.DHCP,
+            "default_gateway": True,
+            })
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertEquals({
+            "default_gateway": [
+                "Cannot use in mode '%s'." % (INTERFACE_LINK_TYPE.DHCP)]
+            }, form.errors)
+
     def test__DHCP_creates_link_to_DHCP_with_subnet(self):
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
         dhcp_subnet = factory.make_Subnet(vlan=interface.vlan)
@@ -237,6 +334,54 @@
         self.assertIsNotNone(ip_address)
         self.assertIn(IPAddress(ip_address.ip), ngi.get_static_ip_range())
 
+    def test__STATIC_sets_node_gateway_link_ipv4(self):
+        # Silence update_host_maps.
+        self.patch_autospec(interface_module, "update_host_maps")
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        network = factory.make_ipv4_network()
+        subnet = factory.make_Subnet(
+            cidr=unicode(network.cidr), vlan=interface.vlan)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.STATIC,
+            "subnet": subnet.id,
+            "default_gateway": True,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        ip_address = get_one(
+            interface.ip_addresses.filter(
+                alloc_type=IPADDRESS_TYPE.STICKY, subnet=subnet))
+        node = interface.get_node()
+        self.assertEquals(ip_address, node.gateway_link_ipv4)
+
+    def test__STATIC_sets_node_gateway_link_ipv6(self):
+        # Silence update_host_maps.
+        self.patch_autospec(interface_module, "update_host_maps")
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        network = factory.make_ipv6_network()
+        subnet = factory.make_Subnet(
+            cidr=unicode(network.cidr), vlan=interface.vlan)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.STATIC,
+            "subnet": subnet.id,
+            "default_gateway": True,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        ip_address = get_one(
+            interface.ip_addresses.filter(
+                alloc_type=IPADDRESS_TYPE.STICKY, subnet=subnet))
+        node = interface.get_node()
+        self.assertEquals(ip_address, node.gateway_link_ipv6)
+
     def test__LINK_UP_not_allowed_with_other_ip_addresses(self):
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
         factory.make_StaticIPAddress(
@@ -247,7 +392,7 @@
         self.assertFalse(form.is_valid(), form.errors)
         self.assertEquals({
             "mode": [
-                "Cannot configure interface to link up (with no IP address)"
+                "Cannot configure interface to link up (with no IP address) "
                 "while other links are already configured."]
             }, form.errors)
 
@@ -276,6 +421,18 @@
         self.assertIsNotNone(link_ip)
         self.assertIsNone(link_ip.ip)
 
+    def test__LINK_UP_not_allowed_default_gateway(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        form = InterfaceLinkForm(instance=interface, data={
+            "mode": INTERFACE_LINK_TYPE.LINK_UP,
+            "default_gateway": True,
+            })
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertEquals({
+            "default_gateway": [
+                "Cannot use in mode '%s'." % (INTERFACE_LINK_TYPE.LINK_UP)]
+            }, form.errors)
+
 
 class TestInterfaceUnlinkForm(MAASServerTestCase):
 
@@ -382,3 +539,107 @@
         self.assertTrue(form.is_valid(), form.errors)
         form.save()
         self.assertIsNone(reload_object(link_ip))
+
+
+class TestInterfaceSetDefaultGatwayForm(MAASServerTestCase):
+
+    def make_ip_family_link(
+            self, interface, network, alloc_type=IPADDRESS_TYPE.STICKY):
+        subnet = factory.make_Subnet(
+            cidr=unicode(network.cidr), vlan=interface.vlan)
+        if alloc_type == IPADDRESS_TYPE.STICKY:
+            ip = factory.pick_ip_in_network(network)
+        else:
+            ip = ""
+        return factory.make_StaticIPAddress(
+            alloc_type=alloc_type, ip=ip, subnet=subnet, interface=interface)
+
+    def test__interface_needs_gateways(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        form = InterfaceSetDefaultGatwayForm(instance=interface, data={})
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertEquals({
+            "__all__": ["This interface has no usable gateways."],
+            }, form.errors)
+
+    def test__doesnt_require_link_id_if_only_one_gateway_per_family(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        self.make_ip_family_link(interface, factory.make_ipv4_network())
+        self.make_ip_family_link(interface, factory.make_ipv6_network())
+        form = InterfaceSetDefaultGatwayForm(instance=interface, data={})
+        self.assertTrue(form.is_valid(), form.errors)
+
+    def test__requires_link_id_if_more_than_one_gateway_per_family(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        self.make_ip_family_link(interface, factory.make_ipv4_network())
+        self.make_ip_family_link(interface, factory.make_ipv6_network())
+        self.make_ip_family_link(interface, factory.make_ipv4_network())
+        self.make_ip_family_link(interface, factory.make_ipv6_network())
+        form = InterfaceSetDefaultGatwayForm(instance=interface, data={})
+        self.assertFalse(form.is_valid(), form.errors)
+        self.assertEquals({
+            "link_id": [
+                "This field is required; Interface has more than one "
+                "usable IPv4 and IPv6 gateways."],
+            }, form.errors)
+
+    def test__link_id_fields_setup_correctly(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        links = []
+        for _ in range(2):
+            links.append(
+                self.make_ip_family_link(
+                    interface, factory.make_ipv4_network()))
+        for _ in range(2):
+            links.append(
+                self.make_ip_family_link(
+                    interface, factory.make_ipv6_network()))
+        link_ids = [
+            link.id
+            for link in links
+        ]
+        form = InterfaceSetDefaultGatwayForm(instance=interface, data={})
+        choice_ids = [
+            choice[0]
+            for choice in form.fields["link_id"].choices
+        ]
+        self.assertItemsEqual(link_ids, choice_ids)
+
+    def test__sets_gateway_links_on_node_when_no_link_id(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        ipv4_link = self.make_ip_family_link(
+            interface, factory.make_ipv4_network())
+        ipv6_link = self.make_ip_family_link(
+            interface, factory.make_ipv6_network())
+        form = InterfaceSetDefaultGatwayForm(instance=interface, data={})
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        node = interface.get_node()
+        self.assertEquals(ipv4_link, node.gateway_link_ipv4)
+        self.assertEquals(ipv6_link, node.gateway_link_ipv6)
+
+    def test__sets_gateway_link_v4_on_node_when_link_id(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        ipv4_link = self.make_ip_family_link(
+            interface, factory.make_ipv4_network())
+        self.make_ip_family_link(interface, factory.make_ipv4_network())
+        form = InterfaceSetDefaultGatwayForm(instance=interface, data={
+            "link_id": ipv4_link.id,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        node = interface.get_node()
+        self.assertEquals(ipv4_link, node.gateway_link_ipv4)
+
+    def test__sets_gateway_link_v6_on_node_when_link_id(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        ipv6_link = self.make_ip_family_link(
+            interface, factory.make_ipv6_network())
+        self.make_ip_family_link(interface, factory.make_ipv6_network())
+        form = InterfaceSetDefaultGatwayForm(instance=interface, data={
+            "link_id": ipv6_link.id,
+            })
+        self.assertTrue(form.is_valid(), form.errors)
+        interface = form.save()
+        node = interface.get_node()
+        self.assertEquals(ipv6_link, node.gateway_link_ipv6)