Merge lp:~blake-rouse/maas/node-networking-link into lp:~maas-committers/maas/trunk

[Blake Rouse]

Add the ability to change the link mode of an interface or alias in the UI. Provide the backend work to allow making this changed without changing the link_id. Order the links for each interface by ID so the order never changes. Clean up the unmountFilesystem websocket handler name and fix the naming of subnets and vlans in the dropdowns.

This is a rather large change just because the backend could not handle the interaction that the UI wanted. Also includes some small fixes and HTML and JS.

I have fully tested this from packaging and it fully works.

[Andres Rodriguez (andreserl)]

lgtm! I have not done an indepth review but looks good so far!

review: Approve

=== modified file 'src/maasserver/models/interface.py'
--- src/maasserver/models/interface.py	2015-09-24 16:22:12 +0000
+++ src/maasserver/models/interface.py	2015-10-01 14:33:47 +0000
@@ -601,7 +601,8 @@
         return ip_address
 
     def _link_subnet_static(
-            self, subnet, ip_address=None, alloc_type=None, user=None):
+            self, subnet, ip_address=None, alloc_type=None, user=None,
+            swap_static_ip=None):
         """Link interface to subnet using STATIC."""
         valid_alloc_types = [
             IPADDRESS_TYPE.STICKY,
@@ -617,12 +618,8 @@
             user = None
 
         ngi = None
-        has_allocations = False
         if subnet is not None:
             ngi = subnet.get_managed_cluster_interface()
-            if ngi is not None:
-                has_allocations = self._has_static_allocation_on_cluster(
-                    ngi.nodegroup, get_subnet_family(subnet))
 
         if ip_address:
             ip_address = IPAddress(ip_address)
@@ -664,10 +661,20 @@
                 None, None, alloc_type=alloc_type, subnet=subnet, user=user)
             self.ip_addresses.add(static_ip)
 
+        # Swap the ID's that way it keeps the same ID as the swap object.
+        if swap_static_ip is not None:
+            static_ip.id, swap_static_ip.id = swap_static_ip.id, static_ip.id
+            swap_static_ip.delete()
+            static_ip.save()
+
         # Need to update the hostmaps on the cluster, if this subnet
         # has a managed interface.
-        if ngi is not None and not has_allocations:
-            self._update_host_maps(ngi.nodegroup, static_ip)
+        if ngi is not None:
+            allocated_ip = (
+                self._get_first_static_allocation_for_cluster(
+                    ngi.nodegroup, get_subnet_family(subnet)))
+            if allocated_ip is None or allocated_ip.id == static_ip.id:
+                self._update_host_maps(ngi.nodegroup, static_ip)
 
         # Was successful at creating the STATIC link. Remove the DHCP and
         # LINK_UP link if it exists.
@@ -756,7 +763,8 @@
                 subnet = None
             self.link_subnet(INTERFACE_LINK_TYPE.LINK_UP, subnet)
 
-    def _unlink_static_ip(self, static_ip, update_cluster=True):
+    def _unlink_static_ip(
+            self, static_ip, update_cluster=True, swap_alloc_type=None):
         """Unlink the STATIC IP address from the interface."""
         registered_on_cluster = False
         ngi = None
@@ -771,14 +779,23 @@
                 # Need to remove the hostmap on the cluster before it can
                 # be deleted.
                 self._remove_host_maps(ngi.nodegroup, static_ip)
-        static_ip.delete()
+
+        # If the allocation type is only changing then we don't need to delete
+        # the IP address it needs to be updated.
+        ip_version = IPAddress(static_ip.ip).version
+        if swap_alloc_type is not None:
+            static_ip.alloc_type = swap_alloc_type
+            static_ip.ip = None
+            static_ip.save()
+        else:
+            static_ip.delete()
 
         # If this IP address was registered on the cluster and now has been
         # deleted we need to register the next assigned IP address to the
         # cluster hostmap.
         if registered_on_cluster and ngi is not None and update_cluster:
             new_hostmap_ip = self._get_first_static_allocation_for_cluster(
-                ngi.nodegroup, IPAddress(static_ip.ip).version)
+                ngi.nodegroup, ip_version)
             if new_hostmap_ip is not None:
                 self._update_host_maps(ngi.nodegroup, new_hostmap_ip)
 
@@ -787,6 +804,7 @@
             self._update_dns_zones([ngi.nodegroup])
         else:
             self._update_dns_zones()
+        return static_ip
 
     def unlink_ip_address(
             self, ip_address, update_cluster=True, clearing_config=False):
@@ -815,6 +833,112 @@
         ip_address = self.ip_addresses.get(id=link_id)
         self.unlink_ip_address(ip_address)
 
+    def _swap_subnet(self, static_ip, subnet, ip_address=None):
+        """Swap the subnet for the `static_ip`."""
+        # Check that requested `ip_address` is available.
+        if ip_address is not None:
+            already_used = get_one(
+                StaticIPAddress.objects.filter(ip=ip_address))
+            if already_used is not None:
+                raise StaticIPAddressUnavailable(
+                    "IP address is already in use.")
+
+        # Remove the hostmap on the new subnet.
+        new_subnet_ngi = subnet.get_managed_cluster_interface()
+        if new_subnet_ngi is not None:
+            static_ip_on_new_subnet = (
+                self._get_first_static_allocation_for_cluster(
+                    new_subnet_ngi.nodegroup, get_subnet_family(subnet)))
+            if (static_ip_on_new_subnet is not None and
+                    static_ip_on_new_subnet.id > static_ip.id):
+                # The updated static_id should be registered over the other
+                # IP address registered on the new subnet.
+                self._remove_host_maps(
+                    new_subnet_ngi.nodegroup, static_ip_on_new_subnet)
+
+        # If the subnets are different then remove the hostmap from the old
+        # subnet as well.
+        if static_ip.subnet is not None and static_ip.subnet != subnet:
+            old_subnet_ngi = static_ip.subnet.get_managed_cluster_interface()
+            registered_on_cluster = False
+            if old_subnet_ngi is not None:
+                registered_on_cluster = (
+                    self._is_first_static_allocation_on_cluster(
+                        static_ip, old_subnet_ngi.nodegroup))
+                if registered_on_cluster:
+                    self._remove_host_maps(old_subnet_ngi.nodegroup, static_ip)
+
+            # Clear the subnet before checking which is the next hostmap.
+            static_ip.subnet = None
+            static_ip.save()
+
+            # Register the new STATIC IP address for the old subnet.
+            if registered_on_cluster and old_subnet_ngi is not None:
+                new_hostmap_ip = self._get_first_static_allocation_for_cluster(
+                    old_subnet_ngi.nodegroup, IPAddress(static_ip.ip).version)
+                if new_hostmap_ip is not None:
+                    self._update_host_maps(
+                        old_subnet_ngi.nodegroup, new_hostmap_ip)
+
+            # Update the DNS configuration for the old subnet if needed.
+            if old_subnet_ngi is not None:
+                self._update_dns_zones([old_subnet_ngi.nodegroup])
+
+        # If the IP addresses are on the same subnet but the IP's are
+        # different then we need to remove the hostmap.
+        if (static_ip.subnet == subnet and
+                new_subnet_ngi is not None and
+                static_ip.ip != ip_address):
+            self._remove_host_maps(
+                new_subnet_ngi.nodegroup, static_ip)
+
+        # Link to the new subnet, which will also update the hostmap.
+        return self._link_subnet_static(
+            subnet, ip_address=ip_address, swap_static_ip=static_ip)
+
+    def update_ip_address(
+            self, static_ip, mode, subnet, ip_address=None):
+        """Update an already existing link on interface to be the new data."""
+        if mode == INTERFACE_LINK_TYPE.AUTO:
+            new_alloc_type = IPADDRESS_TYPE.AUTO
+        elif mode == INTERFACE_LINK_TYPE.DHCP:
+            new_alloc_type = IPADDRESS_TYPE.DHCP
+        elif mode in [INTERFACE_LINK_TYPE.LINK_UP, INTERFACE_LINK_TYPE.STATIC]:
+            new_alloc_type = IPADDRESS_TYPE.STICKY
+
+        current_mode = static_ip.get_interface_link_type()
+        if current_mode == INTERFACE_LINK_TYPE.STATIC:
+            if mode == INTERFACE_LINK_TYPE.STATIC:
+                if (static_ip.subnet == subnet and (
+                        ip_address is None or static_ip.ip == ip_address)):
+                    # Same subnet and IP address nothing to do.
+                    return static_ip
+                # Update the subent and IP address for the static assignment.
+                return self._swap_subnet(
+                    static_ip, subnet, ip_address=ip_address)
+            else:
+                # Not staying in the same mode so we can just remove the
+                # static IP and change its alloc_type from STICKY.
+                static_ip = self._unlink_static_ip(
+                    static_ip, swap_alloc_type=new_alloc_type)
+        elif mode == INTERFACE_LINK_TYPE.STATIC:
+            # Linking to the subnet statically were the original was not a
+            # static link. Swap the objects so the object keeps the same ID.
+            return self._link_subnet_static(
+                subnet, ip_address=ip_address,
+                swap_static_ip=static_ip)
+        static_ip.alloc_type = new_alloc_type
+        static_ip.ip = None
+        static_ip.subnet = subnet
+        static_ip.save()
+        return static_ip
+
+    def update_link_by_id(self, link_id, mode, subnet, ip_address=None):
+        """Update the `IPAddress` link on interface by its ID."""
+        static_ip = self.ip_addresses.get(id=link_id)
+        return self.update_ip_address(
+            static_ip, mode, subnet, ip_address=ip_address)
+
     def clear_all_links(self, clearing_config=False):
         """Remove all the `IPAddress` link on the interface."""
         for ip_address in self.ip_addresses.exclude(
 
=== modified file 'src/maasserver/models/tests/test_interface.py'
--- src/maasserver/models/tests/test_interface.py	2015-09-24 16:22:12 +0000
+++ src/maasserver/models/tests/test_interface.py	2015-10-01 14:33:47 +0000
@@ -29,7 +29,10 @@
     NODEGROUP_STATUS,
     NODEGROUPINTERFACE_MANAGEMENT,
 )
-from maasserver.exceptions import StaticIPAddressOutOfRange
+from maasserver.exceptions import (
+    StaticIPAddressOutOfRange,
+    StaticIPAddressUnavailable,
+)
 from maasserver.models import (
     Fabric,
     interface as interface_module,
@@ -67,6 +70,7 @@
     IPNetwork,
     IPRange,
 )
+from testtools import ExpectedException
 from testtools.matchers import (
     Equals,
     MatchesDict,
@@ -1318,6 +1322,504 @@
                 alloc_type=IPADDRESS_TYPE.STICKY, ip=None).first())
 
 
+class TestUpdateIPAddress(MAASServerTestCase):
+    """Tests for `Interface.update_ip_address`."""
+
+    def test__switch_dhcp_to_auto(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DHCP, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.AUTO, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.AUTO, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+
+    def test__switch_dhcp_to_link_up(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DHCP, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.LINK_UP, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+
+    def test__switch_dhcp_to_static(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network_v4 = factory.make_ipv4_network(slash=24)
+        subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v4.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DHCP, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        network_v6 = factory.make_ipv6_network(slash=24)
+        new_subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v6.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=new_subnet)
+        mock_update_host_maps = self.patch_autospec(
+            interface, "_update_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.STATIC, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNotNone(static_ip.ip)
+        self.assertThat(
+            mock_update_host_maps, MockCalledOnceWith(nodegroup, static_ip))
+        self.assertThat(
+            mock_update_dns_zones, MockCalledOnceWith([nodegroup]))
+
+    def test__switch_auto_to_dhcp(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.DHCP, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.DHCP, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+
+    def test__switch_auto_to_link_up(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.LINK_UP, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+
+    def test__switch_auto_to_static(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network_v4 = factory.make_ipv4_network(slash=24)
+        subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v4.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        network_v6 = factory.make_ipv6_network(slash=24)
+        new_subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v6.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=new_subnet)
+        mock_update_host_maps = self.patch_autospec(
+            interface, "_update_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.STATIC, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNotNone(static_ip.ip)
+        self.assertThat(
+            mock_update_host_maps, MockCalledOnceWith(nodegroup, static_ip))
+        self.assertThat(
+            mock_update_dns_zones, MockCalledOnceWith([nodegroup]))
+
+    def test__switch_link_up_to_auto(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.AUTO, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.AUTO, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+
+    def test__switch_link_up_to_dhcp(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.DHCP, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.DHCP, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+
+    def test__switch_link_up_to_static(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network_v4 = factory.make_ipv4_network(slash=24)
+        subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v4.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY, ip="",
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        network_v6 = factory.make_ipv6_network(slash=24)
+        new_subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v6.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=new_subnet)
+        mock_update_host_maps = self.patch_autospec(
+            interface, "_update_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.STATIC, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNotNone(static_ip.ip)
+        self.assertThat(
+            mock_update_host_maps, MockCalledOnceWith(nodegroup, static_ip))
+        self.assertThat(
+            mock_update_dns_zones, MockCalledOnceWith([nodegroup]))
+
+    def test__switch_static_to_dhcp(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        mock_remove_host_maps = self.patch_autospec(
+            interface, "_remove_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.DHCP, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.DHCP, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+        self.assertThat(
+            mock_remove_host_maps, MockCalledOnceWith(nodegroup, static_ip))
+        self.assertThat(
+            mock_update_dns_zones, MockCalledOnceWith([nodegroup]))
+
+    def test__switch_static_to_auto(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        mock_remove_host_maps = self.patch_autospec(
+            interface, "_remove_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.AUTO, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.AUTO, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+        self.assertThat(
+            mock_remove_host_maps, MockCalledOnceWith(nodegroup, static_ip))
+        self.assertThat(
+            mock_update_dns_zones, MockCalledOnceWith([nodegroup]))
+
+    def test__switch_static_to_link_up(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        new_subnet = factory.make_Subnet(vlan=interface.vlan)
+        mock_remove_host_maps = self.patch_autospec(
+            interface, "_remove_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.LINK_UP, new_subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+        self.assertEquals(new_subnet, static_ip.subnet)
+        self.assertIsNone(static_ip.ip)
+        self.assertThat(
+            mock_remove_host_maps, MockCalledOnceWith(nodegroup, static_ip))
+        self.assertThat(
+            mock_update_dns_zones, MockCalledOnceWith([nodegroup]))
+
+    def test__switch_static_to_same_subnet_does_nothing(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        static_ip_address = static_ip.ip
+        mock_remove_host_maps = self.patch_autospec(
+            interface, "_remove_host_maps")
+        mock_update_host_maps = self.patch_autospec(
+            interface, "_update_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.STATIC, subnet)
+        self.assertEquals(static_id, static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+        self.assertEquals(subnet, static_ip.subnet)
+        self.assertEquals(static_ip_address, static_ip.ip)
+        self.assertThat(mock_remove_host_maps, MockNotCalled())
+        self.assertThat(mock_update_host_maps, MockNotCalled())
+        self.assertThat(mock_update_dns_zones, MockNotCalled())
+
+    def test__switch_static_to_already_used_ip_address(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        other_interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        used_ip_address = factory.pick_ip_in_static_range(
+            ngi, but_not=[static_ip.ip])
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=used_ip_address,
+            subnet=subnet, interface=other_interface)
+        with ExpectedException(StaticIPAddressUnavailable):
+            interface.update_ip_address(
+                static_ip, INTERFACE_LINK_TYPE.STATIC, subnet,
+                ip_address=used_ip_address)
+
+    def test__switch_static_to_same_subnet_with_different_ip(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network = factory.make_ipv4_network(slash=24)
+        subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network.cidr))
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        static_ip_address = static_ip.ip
+        new_ip_address = factory.pick_ip_in_static_range(
+            ngi, but_not=[static_ip_address])
+        mock_remove_host_maps = self.patch_autospec(
+            interface, "_remove_host_maps")
+        mock_update_host_maps = self.patch_autospec(
+            interface, "_update_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        new_static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.STATIC, subnet,
+            ip_address=new_ip_address)
+        self.assertEquals(static_id, new_static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, new_static_ip.alloc_type)
+        self.assertEquals(subnet, new_static_ip.subnet)
+        self.assertEquals(new_ip_address, new_static_ip.ip)
+        # The remove actual loads the IP address from the database so it
+        # is not the same object. We just need to check that the IP's match.
+        self.assertEquals(nodegroup, mock_remove_host_maps.call_args[0][0])
+        self.assertEquals(
+            static_ip_address, mock_remove_host_maps.call_args[0][1].ip)
+        self.assertThat(
+            mock_update_host_maps,
+            MockCalledOnceWith(nodegroup, new_static_ip))
+        self.assertThat(
+            mock_update_dns_zones, MockCalledOnceWith([nodegroup]))
+
+    def test__switch_static_to_another_subnet(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup_v4 = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network_v4 = factory.make_ipv4_network(slash=24)
+        subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v4.cidr))
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup_v4, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        other_static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi, but_not=[static_ip.id]),
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        nodegroup_v6 = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network_v6 = factory.make_ipv6_network(slash=24)
+        new_subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v6.cidr))
+        new_ngi = factory.make_NodeGroupInterface(
+            nodegroup_v6, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=new_subnet)
+        new_subnet_static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(new_ngi),
+            subnet=new_subnet, interface=interface)
+        mock_remove_host_maps = self.patch_autospec(
+            interface, "_remove_host_maps")
+        mock_update_host_maps = self.patch_autospec(
+            interface, "_update_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        new_static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.STATIC, new_subnet)
+        self.assertEquals(static_id, new_static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, new_static_ip.alloc_type)
+        self.assertEquals(new_subnet, new_static_ip.subnet)
+        self.assertIsNotNone(new_static_ip.ip)
+        self.assertThat(
+            mock_remove_host_maps,
+            MockCallsMatch(
+                call(nodegroup_v6, new_subnet_static_ip),
+                call(nodegroup_v4, static_ip),
+            ))
+        self.assertThat(
+            mock_update_host_maps,
+            MockCallsMatch(
+                call(nodegroup_v4, other_static_ip),
+                call(nodegroup_v6, new_static_ip),
+            ))
+        self.assertThat(
+            mock_update_dns_zones,
+            MockCallsMatch(
+                call([nodegroup_v4]),
+                call([nodegroup_v6]),
+            ))
+
+    def test__switch_static_to_another_subnet_with_ip_address(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        nodegroup_v4 = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network_v4 = factory.make_ipv4_network(slash=24)
+        subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v4.cidr))
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup_v4, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY,
+            ip=factory.pick_ip_in_static_range(ngi),
+            subnet=subnet, interface=interface)
+        static_id = static_ip.id
+        nodegroup_v6 = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        network_v6 = factory.make_ipv6_network(slash=24)
+        new_subnet = factory.make_Subnet(
+            vlan=interface.vlan, cidr=unicode(network_v6.cidr))
+        new_ngi = factory.make_NodeGroupInterface(
+            nodegroup_v6, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=new_subnet)
+        new_ip_address = factory.pick_ip_in_static_range(new_ngi)
+        mock_remove_host_maps = self.patch_autospec(
+            interface, "_remove_host_maps")
+        mock_update_host_maps = self.patch_autospec(
+            interface, "_update_host_maps")
+        mock_update_dns_zones = self.patch_autospec(
+            interface, "_update_dns_zones")
+        new_static_ip = interface.update_ip_address(
+            static_ip, INTERFACE_LINK_TYPE.STATIC, new_subnet,
+            ip_address=new_ip_address)
+        self.assertEquals(static_id, new_static_ip.id)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, new_static_ip.alloc_type)
+        self.assertEquals(new_subnet, new_static_ip.subnet)
+        self.assertEquals(new_ip_address, new_static_ip.ip)
+        self.assertThat(
+            mock_remove_host_maps,
+            MockCalledOnceWith(nodegroup_v4, static_ip))
+        self.assertThat(
+            mock_update_host_maps,
+            MockCalledOnceWith(nodegroup_v6, new_static_ip))
+        self.assertThat(
+            mock_update_dns_zones,
+            MockCallsMatch(
+                call([nodegroup_v4]),
+                call([nodegroup_v6]),
+            ))
+
+
+class TestUpdateLinkById(MAASServerTestCase):
+    """Tests for `Interface.update_link_by_id`."""
+
+    def test__calls_update_ip_address_with_ip_address(self):
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        static_ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DHCP, ip="",
+            subnet=subnet, interface=interface)
+        mock_update_ip_address = self.patch_autospec(
+            interface, "update_ip_address")
+        interface.update_link_by_id(
+            static_ip.id, INTERFACE_LINK_TYPE.AUTO, subnet)
+        self.expectThat(mock_update_ip_address, MockCalledOnceWith(
+            static_ip, INTERFACE_LINK_TYPE.AUTO, subnet, ip_address=None))
+
+
 class TestClaimAutoIPs(MAASServerTestCase):
     """Tests for `Interface.claim_auto_ips`."""
 
 
=== modified file 'src/maasserver/static/js/angular/controllers/node_details_networking.js'
--- src/maasserver/static/js/angular/controllers/node_details_networking.js	2015-09-29 15:19:25 +0000
+++ src/maasserver/static/js/angular/controllers/node_details_networking.js	2015-10-01 14:33:47 +0000
@@ -6,10 +6,10 @@
 
 angular.module('MAAS').controller('NodeNetworkingController', [
     '$scope', 'FabricsManager', 'VLANsManager', 'SubnetsManager',
-    'NodesManager', 'ManagerHelperService',
+    'NodesManager', 'ManagerHelperService', 'ValidationService',
     function(
         $scope, FabricsManager, VLANsManager, SubnetsManager, NodesManager,
-        ManagerHelperService) {
+        ManagerHelperService, ValidationService) {
 
         // Different interface types.
         var INTERFACE_TYPE = {
@@ -36,7 +36,7 @@
             "auto": "Auto assign",
             "static": "Static assign",
             "dhcp": "DHCP",
-            "link_up": "Unconfigured"
+            "link_up": "No IP"
         };
 
         // Set the initial values for this scope.
@@ -46,6 +46,7 @@
         $scope.column = 'name';
         $scope.fabrics = FabricsManager.getItems();
         $scope.vlans = VLANsManager.getItems();
+        $scope.subnets = SubnetsManager.getItems();
         $scope.interfaces = [];
         $scope.interfaceLinksMap = {};
         $scope.originalInterfaces = {};
@@ -119,7 +120,7 @@
                     // disabled or has no links (which means the interface
                     // is in LINK_UP mode).
                     nic.link_id = -1;
-                    nic.subnet_id = null;
+                    nic.subnet = null;
                     nic.mode = LINK_MODE.LINK_UP;
                     nic.ip_address = "";
                     interfaces.push(nic);
@@ -128,9 +129,13 @@
                     angular.forEach(nic.links, function(link) {
                         var nic_copy = angular.copy(nic);
                         nic_copy.link_id = link.id;
-                        nic_copy.subnet_id = link.subnet_id;
+                        nic_copy.subnet = SubnetsManager.getItemFromList(
+                            link.subnet_id);
                         nic_copy.mode = link.mode;
                         nic_copy.ip_address = link.ip_address;
+                        if(angular.isUndefined(nic_copy.ip_address)) {
+                            nic_copy.ip_address = "";
+                        }
                         // We don't want to deep copy the VLAN and fabric
                         // object so we set those back to the original.
                         nic_copy.vlan = nic.vlan;
@@ -176,6 +181,23 @@
             }
         }
 
+        // Return the original link object for the given interface.
+        function mapNICToOriginalLink(nic) {
+            var originalInteface = $scope.originalInterfaces[nic.id];
+            if(angular.isObject(originalInteface)) {
+                var i, link = null;
+                for(i = 0; i < originalInteface.links.length; i++) {
+                    link = originalInteface.links[i];
+                    if(link.id === nic.link_id) {
+                        break;
+                    }
+                }
+                return link;
+            } else {
+                return null;
+            }
+        }
+
         // Called by $parent when the node has been loaded.
         $scope.nodeLoaded = function() {
             $scope.$watch("node.interfaces", updateInterfaces);
@@ -203,22 +225,25 @@
             }
         };
 
-        // Get the subnet for the interface.
-        $scope.getSubnet = function(nic) {
-            return SubnetsManager.getItemFromList(nic.subnet_id);
-        };
-
-        // Get the name of the subnet for this interface.
-        $scope.getSubnetName = function(nic) {
-            if(angular.isNumber(nic.subnet_id)) {
-                var subnet = $scope.getSubnet(nic);
-                if(angular.isObject(subnet)) {
-                    return subnet.name;
-                } else {
-                    return "Unknown";
-                }
+        // Get the text to display in the VLAN dropdown.
+        $scope.getVLANText = function(vlan) {
+            if(angular.isString(vlan.name) && vlan.name.length > 0) {
+                return vlan.vid + " (" + vlan.name + ")";
             } else {
+                return vlan.vid;
+            }
+        };
+
+        // Get the text to display in the subnet dropdown.
+        $scope.getSubnetText = function(subnet) {
+            if(!angular.isObject(subnet)) {
                 return "Unconfigured";
+            } else if(angular.isString(subnet.name) &&
+                subnet.name.length > 0 &&
+                subnet.cidr !== subnet.name) {
+                return subnet.cidr + " (" + subnet.name + ")";
+            } else {
+                return subnet.cidr;
             }
         };
 
@@ -240,10 +265,10 @@
         // Save the following interface on the node. This will only save if
         // the interface has changed.
         $scope.saveInterface = function(nic) {
-            // If the name or vlan has changed then we need to update
-            // the interface.
             var originalInteface = $scope.originalInterfaces[nic.id];
-            if(originalInteface.name !== nic.name ||
+            if($scope.isInterfaceNameInvalid(nic)) {
+                nic.name = originalInteface.name;
+            } else if(originalInteface.name !== nic.name ||
                 originalInteface.vlan_id !== nic.vlan.id) {
                 var params = {
                     "name": nic.name,
@@ -255,6 +280,10 @@
                         // we need to expose this as a better message to the
                         // user.
                         console.log(error);
+
+                        // Update the interfaces so it is back to the way it
+                        // was before the user changed it.
+                        updateInterfaces();
                     });
             }
         };
@@ -268,10 +297,16 @@
         // if it has changed.
         $scope.clearFocusInterface = function(nic) {
             if(angular.isUndefined(nic)) {
-                $scope.saveInterface($scope.focusInterface);
+                if($scope.focusInterface.type !== INTERFACE_TYPE.ALIAS) {
+                    $scope.saveInterface($scope.focusInterface);
+                }
+                $scope.saveInterfaceIPAddress($scope.focusInterface);
                 $scope.focusInterface = null;
             } else if($scope.focusInterface === nic) {
-                $scope.saveInterface($scope.focusInterface);
+                if($scope.focusInterface.type !== INTERFACE_TYPE.ALIAS) {
+                    $scope.saveInterface($scope.focusInterface);
+                }
+                $scope.saveInterfaceIPAddress($scope.focusInterface);
                 $scope.focusInterface = null;
             }
         };
@@ -300,6 +335,122 @@
             $scope.saveInterface(nic);
         };
 
+        // Return True if the link mode select should be disabled.
+        $scope.isLinkModeDisabled = function(nic) {
+            // This is only disabled when a subnet has not been selected.
+            return !angular.isObject(nic.subnet);
+        };
+
+        // Get the available link modes for an interface.
+        $scope.getLinkModes = function(nic) {
+            modes = [];
+            if(!angular.isObject(nic.subnet)) {
+                // No subnet is configure so the only allowed mode
+                // is 'link_up'.
+                modes.push({
+                    "mode": LINK_MODE.LINK_UP,
+                    "text": LINK_MODE_TEXTS[LINK_MODE.LINK_UP]
+                });
+            } else {
+                angular.forEach(LINK_MODE_TEXTS, function(text, mode) {
+                    // Don't add LINK_UP  or DHCP if more than one link exists.
+                    if(nic.links.length > 1 && (
+                        mode === LINK_MODE.LINK_UP ||
+                        mode === LINK_MODE.DHCP)) {
+                        return;
+                    }
+                    modes.push({
+                        "mode": mode,
+                        "text": text
+                    });
+                });
+            }
+            return modes;
+        };
+
+        // Called when the link mode for this interface and link has been
+        // changed.
+        $scope.saveInterfaceLink = function(nic) {
+            var params = {
+                "mode": nic.mode
+            };
+            if(angular.isObject(nic.subnet)) {
+                params.subnet = nic.subnet.id;
+            }
+            if(nic.link_id >= 0) {
+                params.link_id = nic.link_id;
+            }
+            if(nic.mode === LINK_MODE.STATIC && nic.ip_address.length > 0) {
+                params.ip_address = nic.ip_address;
+            }
+            NodesManager.linkSubnet($scope.node, nic.id, params).then(
+                null, function(error) {
+                    // XXX blake_r: Just log the error in the console, but
+                    // we need to expose this as a better message to the
+                    // user.
+                    console.log(error);
+
+                    // Update the interfaces so it is back to the way it
+                    // was before the user changed it.
+                    updateInterfaces();
+                });
+        };
+
+        // Called when the user changes the subnet.
+        $scope.subnetChanged = function(nic) {
+            if(!angular.isObject(nic.subnet)) {
+                // Set to 'Unconfigured' so the link mode should be set to
+                // 'link_up'.
+                nic.mode = LINK_MODE.LINK_UP;
+            }
+            // Clear the IP address so a new one on the subnet is assigned.
+            nic.ip_address = "";
+            $scope.saveInterfaceLink(nic);
+        };
+
+        // Return True when the IP address input field should be shown.
+        $scope.shouldShowIPAddress = function(nic) {
+            if(nic.mode === LINK_MODE.STATIC) {
+                // Check that the original has an IP address if it doesn't then
+                // it should not be shown as the IP address still has not been
+                // loaded over the websocket. If the subnets have been switched
+                // then the IP address has been clear, don't show the IP
+                // address until the original subnet and nic subnet match.
+                var originalLink = mapNICToOriginalLink(nic);
+                return (
+                    angular.isObject(originalLink) &&
+                    angular.isString(originalLink.ip_address) &&
+                    originalLink.ip_address.length > 0 &&
+                    angular.isObject(nic.subnet) &&
+                    nic.subnet.id === originalLink.subnet_id);
+            } else if(angular.isString(nic.ip_address) &&
+                nic.ip_address.length > 0) {
+                return true;
+            } else {
+                return false;
+            }
+        };
+
+        // Return True if the interface IP address that the user typed is
+        // invalid.
+        $scope.isIPAddressInvalid = function(nic) {
+            return (nic.ip_address.length === 0 ||
+                !ValidationService.validateIP(nic.ip_address) ||
+                !ValidationService.validateIPInNetwork(
+                    nic.ip_address, nic.subnet.cidr));
+        };
+
+        // Save the interface IP address.
+        $scope.saveInterfaceIPAddress = function(nic) {
+            var originalLink = mapNICToOriginalLink(nic);
+            var prevIPAddress = originalLink.ip_address;
+            if($scope.isIPAddressInvalid(nic)) {
+                nic.ip_address = prevIPAddress;
+            } else if(nic.ip_address !== prevIPAddress) {
+                $scope.saveInterfaceLink(nic);
+            }
+        };
+
         // Load all the required managers.
         ManagerHelperService.loadManagers([
             FabricsManager,
 
=== modified file 'src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js'
--- src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js	2015-09-29 15:19:25 +0000
+++ src/maasserver/static/js/angular/controllers/tests/test_node_details_networking.js	2015-10-01 14:33:47 +0000
@@ -65,6 +65,9 @@
         expect($scope.nodeHasLoaded).toBe(false);
         expect($scope.managersHaveLoaded).toBe(false);
         expect($scope.column).toBe('name');
+        expect($scope.fabrics).toBe(FabricsManager.getItems());
+        expect($scope.vlans).toBe(VLANsManager.getItems());
+        expect($scope.subnets).toBe(SubnetsManager.getItems());
         expect($scope.interfaces).toEqual([]);
         expect($scope.interfaceLinksMap).toEqual({});
         expect($scope.originalInterfaces).toEqual({});
@@ -212,7 +215,7 @@
                 members: [parent1, parent2],
                 vlan: null,
                 link_id: -1,
-                subnet_id: null,
+                subnet: null,
                 mode: "link_up",
                 ip_address: ""
             }]);
@@ -297,13 +300,15 @@
                 links: [],
                 vlan: null,
                 link_id: -1,
-                subnet_id: null,
+                subnet: null,
                 mode: "link_up",
                 ip_address: ""
             }]);
         });
 
         it("duplicates links as alias interfaces", function() {
+            var subnet0 = { id: 0 }, subnet1 = { id: 1 }, subnet2 = { id: 2 };
+            SubnetsManager._items = [subnet0, subnet1, subnet2];
             var links = [
                 {
                     id: 0,
@@ -345,7 +350,7 @@
                     vlan: null,
                     fabric: undefined,
                     link_id: 0,
-                    subnet_id: 0,
+                    subnet: subnet0,
                     mode: "dhcp",
                     ip_address: ""
                 },
@@ -359,7 +364,7 @@
                     vlan: null,
                     fabric: undefined,
                     link_id: 1,
-                    subnet_id: 1,
+                    subnet: subnet1,
                     mode: "auto",
                     ip_address: ""
                 },
@@ -373,7 +378,7 @@
                     vlan: null,
                     fabric: undefined,
                     link_id: 2,
-                    subnet_id: 2,
+                    subnet: subnet2,
                     mode: "static",
                     ip_address: "192.168.122.10"
                 }
@@ -470,7 +475,7 @@
             "auto": "Auto assign",
             "static": "Static assign",
             "dhcp": "DHCP",
-            "link_up": "Unconfigured",
+            "link_up": "No IP",
             "missing_type": "missing_type"
         };
 
@@ -485,64 +490,63 @@
         });
     });
 
-    describe("getSubnet", function() {
+    describe("getVLANText", function() {
 
-        it("returns item from SubnetsManager", function() {
+        it("returns just vid", function() {
             var controller = makeController();
-            var subnet_id = makeInteger(0, 100);
-            var subnet = {
-                id: subnet_id
-            };
-            SubnetsManager._items = [subnet];
-
-            var nic = {
-                subnet_id: subnet_id
-            };
-            expect($scope.getSubnet(nic)).toBe(subnet);
+            var vlan = {
+                vid: 5
+            };
+            expect($scope.getVLANText(vlan)).toBe(5);
         });
 
-        it("returns null for missing subnet", function() {
+        it("returns vid + name", function() {
             var controller = makeController();
-            var subnet_id = makeInteger(0, 100);
-            var nic = {
-                subnet_id: subnet_id
+            var name = makeName("vlan");
+            var vlan = {
+                vid: 5,
+                name: name
             };
-            expect($scope.getSubnet(nic)).toBeNull();
+            expect($scope.getVLANText(vlan)).toBe("5 (" + name + ")");
         });
     });
 
-    describe("getSubnetName", function() {
-
-        it("returns name from item in SubnetsManager", function() {
-            var controller = makeController();
-            var subnet_id = makeInteger(0, 100);
-            var subnet_name = makeName("subnet");
-            var subnet = {
-                id: subnet_id,
-                name: subnet_name
-            };
-            SubnetsManager._items = [subnet];
-
-            var nic = {
-                subnet_id: subnet_id
-            };
-            expect($scope.getSubnetName(nic)).toBe(subnet_name);
-        });
-
-        it("returns 'Unknown' if item not in SubnetsManager", function() {
-            var controller = makeController();
-            var nic = {
-                subnet_id: makeInteger(0, 100)
-            };
-            expect($scope.getSubnetName(nic)).toBe("Unknown");
-        });
-
-        it("returns 'Unconfigured' if no subnet_id", function() {
-            var controller = makeController();
-            var nic = {
-                subnet_id: null
-            };
-            expect($scope.getSubnetName(nic)).toBe("Unconfigured");
+    describe("getSubnetText", function() {
+
+        it("returns 'Unconfigured' for null", function() {
+            var controller = makeController();
+            expect($scope.getSubnetText(null)).toBe("Unconfigured");
+        });
+
+        it("returns just cidr if no name", function() {
+            var controller = makeController();
+            var cidr = makeName("cidr");
+            var subnet = {
+                cidr: cidr
+            };
+            expect($scope.getSubnetText(subnet)).toBe(cidr);
+        });
+
+        it("returns just cidr if name same as cidr", function() {
+            var controller = makeController();
+            var cidr = makeName("cidr");
+            var subnet = {
+                cidr: cidr,
+                name: cidr
+            };
+            expect($scope.getSubnetText(subnet)).toBe(cidr);
+        });
+
+        it("returns cidr + name", function() {
+            var controller = makeController();
+            var cidr = makeName("cidr");
+            var name = makeName("name");
+            var subnet = {
+                cidr: cidr,
+                name: name
+            };
+            expect($scope.getSubnetText(subnet)).toBe(
+                cidr + " (" + name + ")");
         });
     });
 
@@ -615,6 +619,31 @@
             expect(NodesManager.updateInterface).not.toHaveBeenCalled();
         });
 
+        it("resets name if its invalid and doesn't call update", function() {
+            var controller = makeController();
+            var id = makeInteger(0, 100);
+            var name = makeName("nic");
+            var vlan = { id: makeInteger(0, 100) };
+            var original_nic = {
+                id: id,
+                name: name,
+                vlan_id: vlan.id
+            };
+            var nic = {
+                id: id,
+                name: "",
+                vlan: vlan
+            };
+            $scope.originalInterfaces[id] = original_nic;
+            $scope.interfaces = [nic];
+
+            spyOn(NodesManager, "updateInterface").and.returnValue(
+                $q.defer().promise);
+            $scope.saveInterface(nic);
+            expect(nic.name).toBe(name);
+            expect(NodesManager.updateInterface).not.toHaveBeenCalled();
+        });
+
         it("calls NodesManager.updateInterface if name changed", function() {
             var controller = makeController();
             var id = makeInteger(0, 100);
@@ -686,32 +715,72 @@
 
         it("clears focusInterface no arguments", function() {
             var controller = makeController();
-            var nic = {};
+            var nic = {
+                type: "physical"
+            };
             $scope.focusInterface = nic;
             spyOn($scope, "saveInterface");
+            spyOn($scope, "saveInterfaceIPAddress");
             $scope.clearFocusInterface();
             expect($scope.focusInterface).toBeNull();
             expect($scope.saveInterface).toHaveBeenCalledWith(nic);
+            expect($scope.saveInterfaceIPAddress).toHaveBeenCalledWith(nic);
         });
 
         it("clears focusInterface if same interface", function() {
             var controller = makeController();
-            var nic = {};
+            var nic = {
+                type: "physical"
+            };
             $scope.focusInterface = nic;
             spyOn($scope, "saveInterface");
+            spyOn($scope, "saveInterfaceIPAddress");
             $scope.clearFocusInterface(nic);
             expect($scope.focusInterface).toBeNull();
             expect($scope.saveInterface).toHaveBeenCalledWith(nic);
+            expect($scope.saveInterfaceIPAddress).toHaveBeenCalledWith(nic);
         });
 
         it("doesnt clear focusInterface if different interface", function() {
             var controller = makeController();
-            var nic = {};
+            var nic = {
+                type: "physical"
+            };
             $scope.focusInterface = nic;
             spyOn($scope, "saveInterface");
+            spyOn($scope, "saveInterfaceIPAddress");
             $scope.clearFocusInterface({});
             expect($scope.focusInterface).toBe(nic);
             expect($scope.saveInterface).not.toHaveBeenCalled();
+            expect($scope.saveInterfaceIPAddress).not.toHaveBeenCalled();
+        });
+
+        it("doesnt call save with focusInterface no arguments", function() {
+            var controller = makeController();
+            var nic = {
+                type: "alias"
+            };
+            $scope.focusInterface = nic;
+            spyOn($scope, "saveInterface");
+            spyOn($scope, "saveInterfaceIPAddress");
+            $scope.clearFocusInterface();
+            expect($scope.focusInterface).toBeNull();
+            expect($scope.saveInterface).not.toHaveBeenCalled();
+            expect($scope.saveInterfaceIPAddress).toHaveBeenCalledWith(nic);
+        });
+
+        it("doesnt call save with focusInterface if same nic", function() {
+            var controller = makeController();
+            var nic = {
+                type: "alias"
+            };
+            $scope.focusInterface = nic;
+            spyOn($scope, "saveInterface");
+            spyOn($scope, "saveInterfaceIPAddress");
+            $scope.clearFocusInterface(nic);
+            expect($scope.focusInterface).toBeNull();
+            expect($scope.saveInterface).not.toHaveBeenCalled();
+            expect($scope.saveInterfaceIPAddress).toHaveBeenCalledWith(nic);
         });
     });
 
@@ -812,4 +881,407 @@
             expect($scope.saveInterface).toHaveBeenCalledWith(nic);
         });
     });
+
+    describe("isLinkModeDisabled", function() {
+
+        it("enabled when subnet", function() {
+            var controller = makeController();
+            var nic = {
+                subnet : {}
+            };
+            expect($scope.isLinkModeDisabled(nic)).toBe(false);
+        });
+
+        it("disabled when not subnet", function() {
+            var controller = makeController();
+            var nic = {
+                subnet : null
+            };
+            expect($scope.isLinkModeDisabled(nic)).toBe(true);
+        });
+    });
+
+    describe("getLinkModes", function() {
+
+        it("only link_up when no subnet", function() {
+            var controller = makeController();
+            var nic = {
+                subnet : null
+            };
+            expect($scope.getLinkModes(nic)).toEqual([
+                {
+                    "mode": "link_up",
+                    "text": "No IP"
+                }
+            ]);
+        });
+
+        it("all modes if only one link", function() {
+            var controller = makeController();
+            var nic = {
+                subnet : {},
+                links: [{}]
+            };
+            expect($scope.getLinkModes(nic)).toEqual([
+                {
+                    "mode": "auto",
+                    "text": "Auto assign"
+                },
+                {
+                    "mode": "static",
+                    "text": "Static assign"
+                },
+                {
+                    "mode": "dhcp",
+                    "text": "DHCP"
+                },
+                {
+                    "mode": "link_up",
+                    "text": "No IP"
+                }
+            ]);
+        });
+
+        it("auto and static modes if more than one link", function() {
+            var controller = makeController();
+            var nic = {
+                subnet : {},
+                links: [{}, {}]
+            };
+            expect($scope.getLinkModes(nic)).toEqual([
+                {
+                    "mode": "auto",
+                    "text": "Auto assign"
+                },
+                {
+                    "mode": "static",
+                    "text": "Static assign"
+                }
+            ]);
+        });
+    });
+
+    describe("saveInterfaceLink", function() {
+
+        it("calls NodesManager.linkSubnet with params", function() {
+            var controller = makeController();
+            var nic = {
+                id: makeInteger(0, 100),
+                mode: "static",
+                subnet: { id: makeInteger(0, 100) },
+                link_id: makeInteger(0, 100),
+                ip_address: "192.168.122.1"
+            };
+            spyOn(NodesManager, "linkSubnet").and.returnValue(
+                $q.defer().promise);
+            $scope.saveInterfaceLink(nic);
+            expect(NodesManager.linkSubnet).toHaveBeenCalledWith(
+                node, nic.id, {
+                    "mode": "static",
+                    "subnet": nic.subnet.id,
+                    "link_id": nic.link_id,
+                    "ip_address": nic.ip_address
+                });
+        });
+    });
+
+    describe("subnetChanged", function() {
+
+        it("sets mode to link_up if set to no subnet", function() {
+            var controller = makeController();
+            var nic = {
+                subnet: null
+            };
+            spyOn($scope, "saveInterfaceLink");
+            $scope.subnetChanged(nic);
+            expect(nic.mode).toBe("link_up");
+            expect($scope.saveInterfaceLink).toHaveBeenCalledWith(nic);
+        });
+
+        it("doesnt set mode to link_up if set if subnet", function() {
+            var controller = makeController();
+            var nic = {
+                mode: "static",
+                subnet: {}
+            };
+            spyOn($scope, "saveInterfaceLink");
+            $scope.subnetChanged(nic);
+            expect(nic.mode).toBe("static");
+            expect($scope.saveInterfaceLink).toHaveBeenCalledWith(nic);
+        });
+
+        it("clears ip_address", function() {
+            var controller = makeController();
+            var nic = {
+                subnet: null,
+                ip_address: makeName("ip")
+            };
+            spyOn($scope, "saveInterfaceLink");
+            $scope.subnetChanged(nic);
+            expect(nic.ip_address).toBe("");
+        });
+    });
+
+    describe("shouldShowIPAddress", function() {
+
+        it("true if not static and has ip address", function() {
+            var controller = makeController();
+            var nic = {
+                mode: "auto",
+                ip_address: "192.168.122.1"
+            };
+            expect($scope.shouldShowIPAddress(nic)).toBe(true);
+        });
+
+        it("false if not static and doesn't have ip address", function() {
+            var controller = makeController();
+            var nic = {
+                mode: "dhcp",
+                ip_address: ""
+            };
+            expect($scope.shouldShowIPAddress(nic)).toBe(false);
+        });
+
+        describe("static", function() {
+
+            it("false if no orginial link", function() {
+                var controller = makeController();
+                var nic = {
+                    id: 0,
+                    mode: "static",
+                    link_id: -1,
+                    ip_address: ""
+                };
+                expect($scope.shouldShowIPAddress(nic)).toBe(false);
+            });
+
+            it("false if orginial link has no IP address", function() {
+                var controller = makeController();
+                var originalInterface = {
+                    id: 0,
+                    links: [
+                        {
+                            id: 0,
+                            mode: "static"
+                        }
+                    ]
+                };
+                $scope.originalInterfaces = [originalInterface];
+
+                var nic = {
+                    id: 0,
+                    mode: "static",
+                    link_id: 0,
+                    ip_address: ""
+                };
+                expect($scope.shouldShowIPAddress(nic)).toBe(false);
+            });
+
+            it("false if orginial link has empty IP address", function() {
+                var controller = makeController();
+                var originalInterface = {
+                    id: 0,
+                    links: [
+                        {
+                            id: 0,
+                            mode: "static",
+                            ip_address: ""
+                        }
+                    ]
+                };
+                $scope.originalInterfaces = [originalInterface];
+
+                var nic = {
+                    id: 0,
+                    mode: "static",
+                    link_id: 0,
+                    ip_address: ""
+                };
+                expect($scope.shouldShowIPAddress(nic)).toBe(false);
+            });
+
+            it("false if no subnet on nic", function() {
+                var controller = makeController();
+                var originalInterface = {
+                    id: 0,
+                    links: [
+                        {
+                            id: 0,
+                            mode: "static",
+                            ip_address: "192.168.122.2"
+                        }
+                    ]
+                };
+                $scope.originalInterfaces = [originalInterface];
+
+                var nic = {
+                    id: 0,
+                    mode: "static",
+                    link_id: 0,
+                    ip_address: ""
+                };
+                expect($scope.shouldShowIPAddress(nic)).toBe(false);
+            });
+
+            it("false if the subnets don't match", function() {
+                var controller = makeController();
+                var originalInterface = {
+                    id: 0,
+                    links: [
+                        {
+                            id: 0,
+                            mode: "static",
+                            ip_address: "192.168.122.2",
+                            subnet_id: 0
+                        }
+                    ]
+                };
+                $scope.originalInterfaces = [originalInterface];
+
+                var nic = {
+                    id: 0,
+                    mode: "static",
+                    link_id: 0,
+                    ip_address: "",
+                    subnet: {
+                        id: 1
+                    }
+                };
+                expect($scope.shouldShowIPAddress(nic)).toBe(false);
+            });
+
+            it("true if all condititions match", function() {
+                var controller = makeController();
+                var originalInterface = {
+                    id: 0,
+                    links: [
+                        {
+                            id: 0,
+                            mode: "static",
+                            ip_address: "192.168.122.2",
+                            subnet_id: 0
+                        }
+                    ]
+                };
+                $scope.originalInterfaces = [originalInterface];
+
+                var nic = {
+                    id: 0,
+                    mode: "static",
+                    link_id: 0,
+                    ip_address: "",
+                    subnet: {
+                        id: 0
+                    }
+                };
+                expect($scope.shouldShowIPAddress(nic)).toBe(true);
+            });
+        });
+    });
+
+    describe("isIPAddressInvalid", function() {
+
+        it("true if empty IP address", function() {
+            var controller = makeController();
+            var nic = {
+                ip_address: ""
+            };
+            expect($scope.isIPAddressInvalid(nic)).toBe(true);
+        });
+
+        it("true if not valid IP address", function() {
+            var controller = makeController();
+            var nic = {
+                ip_address: "192.168.260.5"
+            };
+            expect($scope.isIPAddressInvalid(nic)).toBe(true);
+        });
+
+        it("true if IP address not in subnet", function() {
+            var controller = makeController();
+            var nic = {
+                ip_address: "192.168.123.10",
+                subnet: {
+                    cidr: "192.168.122.0/24"
+                }
+            };
+            expect($scope.isIPAddressInvalid(nic)).toBe(true);
+        });
+
+        it("false if IP address in subnet", function() {
+            var controller = makeController();
+            var nic = {
+                ip_address: "192.168.122.10",
+                subnet: {
+                    cidr: "192.168.122.0/24"
+                }
+            };
+            expect($scope.isIPAddressInvalid(nic)).toBe(false);
+        });
+    });
+
+    describe("saveInterfaceIPAddress", function() {
+
+        it("resets IP address if invalid doesn't save", function() {
+            var controller = makeController();
+            var originalInterface = {
+                id: 0,
+                links: [
+                    {
+                        id: 0,
+                        mode: "static",
+                        ip_address: "192.168.122.10",
+                        subnet_id: 0
+                    }
+                ]
+            };
+            $scope.originalInterfaces = [originalInterface];
+
+            var nic = {
+                id: 0,
+                mode: "static",
+                link_id: 0,
+                ip_address: "192.168.123.10",
+                subnet: {
+                    id: 0,
+                    cidr: "192.168.122.0/24"
+                }
+            };
+            spyOn($scope, "saveInterfaceLink");
+            $scope.saveInterfaceIPAddress(nic);
+            expect(nic.ip_address).toBe("192.168.122.10");
+            expect($scope.saveInterfaceLink).not.toHaveBeenCalled();
+        });
+
+        it("saves the link if valid", function() {
+            var controller = makeController();
+            var originalInterface = {
+                id: 0,
+                links: [
+                    {
+                        id: 0,
+                        mode: "static",
+                        ip_address: "192.168.122.10",
+                        subnet_id: 0
+                    }
+                ]
+            };
+            $scope.originalInterfaces = [originalInterface];
+
+            var nic = {
+                id: 0,
+                mode: "static",
+                link_id: 0,
+                ip_address: "192.168.122.11",
+                subnet: {
+                    id: 0,
+                    cidr: "192.168.122.0/24"
+                }
+            };
+            spyOn($scope, "saveInterfaceLink");
+            $scope.saveInterfaceIPAddress(nic);
+            expect(nic.ip_address).toBe("192.168.122.11");
+            expect($scope.saveInterfaceLink).toHaveBeenCalledWith(nic);
+        });
+    });
 });
 
=== modified file 'src/maasserver/static/js/angular/factories/nodes.js'
--- src/maasserver/static/js/angular/factories/nodes.js	2015-09-30 22:40:08 +0000
+++ src/maasserver/static/js/angular/factories/nodes.js	2015-10-01 14:33:47 +0000
@@ -90,11 +90,23 @@
                     "node.update_interface", params);
             };
 
-        // Send the update information to the region.
+        // Create or update the link to the subnet for the interface.
+        NodesManager.prototype.linkSubnet = function(
+            node, interface_id, params) {
+                if(!angular.isObject(params)) {
+                    params = {};
+                }
+                params.system_id = node.system_id;
+                params.interface_id = interface_id;
+                return RegionConnection.callMethod(
+                    "node.link_subnet", params);
+            };
+
+        // Unmount the filesystem on the block device or partition.
         NodesManager.prototype.unmountFilesystem = function(
             system_id, block_id, partition_id) {
                 var self = this;
-                var method = this._handler + ".unmountFilesystem";
+                var method = this._handler + ".unmount_filesystem";
                 var params = {
                     system_id: system_id,
                     block_id: block_id,
 
=== modified file 'src/maasserver/static/js/angular/factories/tests/test_nodes.js'
--- src/maasserver/static/js/angular/factories/tests/test_nodes.js	2015-09-30 22:40:08 +0000
+++ src/maasserver/static/js/angular/factories/tests/test_nodes.js	2015-10-01 14:33:47 +0000
@@ -178,6 +178,49 @@
             });
     });
 
+    describe("linkSubnet", function() {
+
+        it("calls node.link_subnet with system_id and interface_id",
+            function(done) {
+                var node = makeNode(), interface_id = makeInteger(0, 100);
+                webSocket.returnData.push(makeFakeResponse("updated"));
+                NodesManager.linkSubnet(node, interface_id).then(
+                    function() {
+                        var sentObject = angular.fromJson(
+                            webSocket.sentData[0]);
+                        expect(sentObject.method).toBe(
+                            "node.link_subnet");
+                        expect(sentObject.params.system_id).toBe(
+                            node.system_id);
+                        expect(sentObject.params.interface_id).toBe(
+                            interface_id);
+                        done();
+                    });
+            });
+
+        it("calls node.link_subnet with params",
+            function(done) {
+                var node = makeNode(), interface_id = makeInteger(0, 100);
+                var params = {
+                    name: makeName("eth0")
+                };
+                webSocket.returnData.push(makeFakeResponse("updated"));
+                NodesManager.linkSubnet(node, interface_id, params).then(
+                    function() {
+                        var sentObject = angular.fromJson(
+                            webSocket.sentData[0]);
+                        expect(sentObject.method).toBe(
+                            "node.link_subnet");
+                        expect(sentObject.params.system_id).toBe(
+                            node.system_id);
+                        expect(sentObject.params.interface_id).toBe(
+                            interface_id);
+                        expect(sentObject.params.name).toBe(params.name);
+                        done();
+                    });
+            });
+    });
+
     describe("unmountFilesystem", function() {
 
         it("calls node.unmountFilesystem", function(done) {
@@ -186,7 +229,7 @@
             NodesManager.unmountFilesystem(
                     makeName("block_id"), null).then(function() {
                 var sentObject = angular.fromJson(webSocket.sentData[0]);
-                expect(sentObject.method).toBe("node.unmountFilesystem");
+                expect(sentObject.method).toBe("node.unmount_filesystem");
                 done();
             });
         });
@@ -200,6 +243,7 @@
                     fakeNode.system_id, block_id, partition_id).then(
                         function() {
                 var sentObject = angular.fromJson(webSocket.sentData[0]);
+                expect(sentObject.method).toBe("node.unmount_filesystem");
                 expect(sentObject.params.system_id).toBe(fakeNode.system_id);
                 expect(sentObject.params.block_id).toBe(block_id);
                 expect(sentObject.params.partition_id).toBe(partition_id);
 
=== modified file 'src/maasserver/static/partials/node-details.html'
--- src/maasserver/static/partials/node-details.html	2015-10-01 11:15:36 +0000
+++ src/maasserver/static/partials/node-details.html	2015-10-01 14:33:47 +0000
@@ -358,6 +358,7 @@
                                 <div class="table__data table__column--14">
                                     <select class="table__input" name="fabric" id="fabric"
                                         data-ng-model="interface.fabric"
+                                        data-ng-disabled="interface.type == 'alias'"
                                         data-ng-change="fabricChanged(interface)"
                                         data-ng-options="fabric as fabric.name for fabric in fabrics">
                                     </select>
@@ -365,39 +366,37 @@
                                 <div class="table__data table__column--14">
                                     <select class="table__input" name="vlan" id="vlan"
                                         data-ng-model="interface.vlan"
+                                        data-ng-disabled="interface.type == 'alias'"
                                         data-ng-change="saveInterface(interface)"
-                                        data-ng-options="vlan as vlan.name for vlan in vlans | filterByFabric:interface.fabric">
+                                        data-ng-options="vlan as getVLANText(vlan) for vlan in vlans | filterByFabric:interface.fabric">
                                     </select>
                                 </div>
                                 <div class="table__data table__column--18">
-                                    {$ getSubnetName(interface) $}
-                                    <!--
-                                    TODO: Use when editing is done.
-                                    <select class="table__input" name="range" id="range">
-                                        <option value="auto">10.10.10.1/6 (managed)</option>
+                                    <select class="table__input" name="subnet" id="subnet"
+                                        data-ng-model="interface.subnet"
+                                        data-ng-change="subnetChanged(interface)"
+                                        data-ng-options="subnet as getSubnetText(subnet) for subnet in subnets | filterByVLAN:interface.vlan">
+                                        <option value="" data-ng-hide="interface.links.length > 1">Unconfigured</option>
                                     </select>
-                                    -->
                                 </div>
                                 <div class="table__data table__column--14">
                                     <ul class="no-bullets">
                                         <li>
-                                            {$ getLinkModeText(interface) $}
-                                            <!--
-                                            TODO: Use when editing is done.
-                                            <select class="table__input" name="ip-address" id="ip-address">
-                                                <option value="auto">Auto assign</option>
-                                                <option value="manual" selected>Manual</option>
-                                                <option value="DHCP">DHCP</option>
-                                                <option value="unconfigured">Unconfigured</option>
+                                            <select class="table__input" name="link-mode" id="link-mode"
+                                                data-ng-model="interface.mode"
+                                                data-ng-change="saveInterfaceLink(interface)"
+                                                data-ng-disabled="isLinkModeDisabled(interface)"
+                                                data-ng-options="mode.mode as mode.text for mode in getLinkModes(interface)">
                                             </select>
-                                            -->
                                         </li>
-                                        <li class="margin-top--ten" data-ng-show="interface.ip_address">
-                                            {$ interface.ip_address $}
-                                            <!--
-                                            TODO: Use when editing is done.
-                                            <input type="text" class="table__input" value="127.0.0.1">
-                                            -->
+                                        <li class="margin-top--ten" data-ng-show="shouldShowIPAddress(interface)">
+                                            <input type="text" class="table__input"
+                                                data-ng-model="interface.ip_address"
+                                                data-ng-class="{ invalid: isIPAddressInvalid(interface) }"
+                                                data-maas-enter-blur
+                                                data-ng-focus="setFocusInterface(interface)"
+                                                data-ng-blur="clearFocusInterface(interface)"
+                                                data-ng-disabled="interface.mode != 'static'">
                                         </li>
                                     </ul>
                                 </div>
 
=== modified file 'src/maasserver/websockets/handlers/node.py'
--- src/maasserver/websockets/handlers/node.py	2015-09-30 22:40:08 +0000
+++ src/maasserver/websockets/handlers/node.py	2015-10-01 14:33:47 +0000
@@ -37,6 +37,7 @@
 from maasserver.models.nodeprobeddetails import get_single_probed_details
 from maasserver.models.partition import Partition
 from maasserver.models.physicalblockdevice import PhysicalBlockDevice
+from maasserver.models.subnet import Subnet
 from maasserver.models.tag import Tag
 from maasserver.node_action import compile_node_actions
 from maasserver.rpc import getClientFor
@@ -105,7 +106,8 @@
             'set_active',
             'check_power',
             'update_interface',
-            'unmountFilesystem',
+            'link_subnet',
+            'unmount_filesystem',
         ]
         form = AdminNodeWithMACAddressesForm
         exclude = [
@@ -348,7 +350,9 @@
 
     def dehydrate_interface(self, interface, obj):
         """Dehydrate a `interface` into a interface definition."""
-        links = interface.get_links()
+        # Sort the links by ID that way they show up in the same order in
+        # the UI.
+        links = sorted(interface.get_links(), key=itemgetter("id"))
         for link in links:
             # Replace the subnet object with the subnet_id. The client will
             # use this information to pull the subnet information from the
@@ -545,7 +549,7 @@
         node_obj.save()
         return self.full_dehydrate(node_obj)
 
-    def unmountFilesystem(self, params):
+    def unmount_filesystem(self, params):
         node = self.get_object(params)
         if params.get('partition_id') is not None:
             obj = Partition.objects.get(
@@ -601,6 +605,10 @@
 
     def update_interface(self, params):
         """Update the interface."""
+        # Only admin users can perform update.
+        if not self.user.is_superuser:
+            raise HandlerPermissionError()
+
         node = self.get_object(params)
         interface = Interface.objects.get(node=node, id=params["interface_id"])
         interface_form = InterfaceForm.get_interface_form(interface.type)
@@ -610,6 +618,28 @@
         else:
             raise ValidationError(form.errors)
 
+    def link_subnet(self, params):
+        """Create or update the link."""
+        # Only admin users can perform update.
+        if not self.user.is_superuser:
+            raise HandlerPermissionError()
+
+        node = self.get_object(params)
+        interface = Interface.objects.get(node=node, id=params["interface_id"])
+        subnet = None
+        if "subnet" in params:
+            subnet = Subnet.objects.get(id=params["subnet"])
+        if "link_id" in params:
+            # We are updating an already existing link.
+            interface.update_link_by_id(
+                params["link_id"], params["mode"], subnet,
+                ip_address=params.get("ip_address", None))
+        else:
+            # We are creating a new link.
+            interface.link_subnet(
+                params["mode"], subnet,
+                ip_address=params.get("ip_address", None))
+
     @asynchronous
     @inlineCallbacks
     def check_power(self, params):
 
=== modified file 'src/maasserver/websockets/handlers/tests/test_node.py'
--- src/maasserver/websockets/handlers/tests/test_node.py	2015-10-01 13:29:51 +0000
+++ src/maasserver/websockets/handlers/tests/test_node.py	2015-10-01 14:33:47 +0000
@@ -25,6 +25,7 @@
 from lxml import etree
 from maasserver.enum import (
     FILESYSTEM_FORMAT_TYPE_CHOICES_DICT,
+    INTERFACE_LINK_TYPE,
     INTERFACE_TYPE,
     IPADDRESS_TYPE,
     NODE_STATUS,
@@ -33,6 +34,7 @@
 from maasserver.forms import AdminNodeWithMACAddressesForm
 from maasserver.models import interface as interface_module
 from maasserver.models.config import Config
+from maasserver.models.interface import Interface
 from maasserver.models.nodeprobeddetails import get_single_probed_details
 from maasserver.node_action import compile_node_actions
 from maasserver.rpc.testing.fixtures import MockLiveRegionToClusterRPCFixture
@@ -79,7 +81,10 @@
     LIST_MODALIASES_OUTPUT_NAME,
     LLDP_OUTPUT_NAME,
 )
-from mock import sentinel
+from mock import (
+    ANY,
+    sentinel,
+)
 from netaddr import IPAddress
 from provisioningserver.power.poweraction import PowerActionFail
 from provisioningserver.rpc.cluster import PowerQuery
@@ -915,14 +920,14 @@
         updated_node = handler.update(node_data)
         self.assertItemsEqual([tag_name], updated_node["tags"])
 
-    def test_unmountFilesystem(self):
+    def test_unmount_filesystem(self):
         user = factory.make_admin()
         handler = NodeHandler(user, {})
         architecture = make_usable_architecture(self)
         node = factory.make_Node(interface=True, architecture=architecture)
         block_device = factory.make_PhysicalBlockDevice(node=node)
         factory.make_Filesystem(block_device=block_device)
-        handler.unmountFilesystem({
+        handler.unmount_filesystem({
             'system_id': node.system_id,
             'block_id': block_device.id
             })
@@ -1006,7 +1011,7 @@
             node.distro_series, Equals(osystem["releases"][0]["name"]))
 
     def test_update_interface(self):
-        user = factory.make_User()
+        user = factory.make_admin()
         node = factory.make_Node()
         handler = NodeHandler(user, {})
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
@@ -1023,7 +1028,7 @@
         self.assertEquals(new_vlan, interface.vlan)
 
     def test_update_interface_raises_ValidationError(self):
-        user = factory.make_User()
+        user = factory.make_admin()
         node = factory.make_Node()
         handler = NodeHandler(user, {})
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
@@ -1036,6 +1041,50 @@
                 "vlan": random.randint(1000, 5000),
                 })
 
+    def test_link_subnet_calls_update_link_by_id_if_link_id(self):
+        user = factory.make_admin()
+        node = factory.make_Node()
+        handler = NodeHandler(user, {})
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        subnet = factory.make_Subnet()
+        link_id = random.randint(0, 100)
+        mode = factory.pick_enum(INTERFACE_LINK_TYPE)
+        ip_address = factory.make_ip_address()
+        self.patch_autospec(Interface, "update_link_by_id")
+        handler.link_subnet({
+            "system_id": node.system_id,
+            "interface_id": interface.id,
+            "link_id": link_id,
+            "subnet": subnet.id,
+            "mode": mode,
+            "ip_address": ip_address,
+            })
+        self.assertThat(
+            Interface.update_link_by_id,
+            MockCalledOnceWith(
+                ANY, link_id, mode, subnet, ip_address=ip_address))
+
+    def test_link_subnet_calls_link_subnet_if_not_link_id(self):
+        user = factory.make_admin()
+        node = factory.make_Node()
+        handler = NodeHandler(user, {})
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=node)
+        subnet = factory.make_Subnet()
+        mode = factory.pick_enum(INTERFACE_LINK_TYPE)
+        ip_address = factory.make_ip_address()
+        self.patch_autospec(Interface, "link_subnet")
+        handler.link_subnet({
+            "system_id": node.system_id,
+            "interface_id": interface.id,
+            "subnet": subnet.id,
+            "mode": mode,
+            "ip_address": ip_address,
+            })
+        self.assertThat(
+            Interface.link_subnet,
+            MockCalledOnceWith(
+                ANY, mode, subnet, ip_address=ip_address))
+
 
 class TestNodeHandlerCheckPower(MAASTransactionServerTestCase):
 
 
=== modified file 'src/maastesting/factory.py'
--- src/maastesting/factory.py	2015-09-24 16:22:12 +0000
+++ src/maastesting/factory.py	2015-10-01 14:33:47 +0000
@@ -276,15 +276,31 @@
                 slash = 128 - host_bits
             return self.make_ipv6_network(slash=slash)
 
-    def pick_ip_in_dynamic_range(self, ngi):
+    def pick_ip_in_dynamic_range(self, ngi, but_not=None):
+        if but_not is None:
+            but_not = []
         first = ngi.get_dynamic_ip_range().first
         last = ngi.get_dynamic_ip_range().last
-        return unicode(IPAddress(random.randrange(first, last)))
+        but_not = [IPAddress(but) for but in but_not if but is not None]
+        for _ in range(100):
+            address = IPAddress(random.randint(first, last))
+            if address not in but_not:
+                return bytes(address)
+        raise TooManyRandomRetries(
+            "Could not find available IP in static range")
 
-    def pick_ip_in_static_range(self, ngi):
+    def pick_ip_in_static_range(self, ngi, but_not=None):
+        if but_not is None:
+            but_not = []
         first = ngi.get_static_ip_range().first
         last = ngi.get_static_ip_range().last
-        return unicode(IPAddress(random.randrange(first, last)))
+        but_not = [IPAddress(but) for but in but_not if but is not None]
+        for _ in range(100):
+            address = IPAddress(random.randint(first, last))
+            if address not in but_not:
+                return bytes(address)
+        raise TooManyRandomRetries(
+            "Could not find available IP in static range")
 
     def pick_ip_in_network(self, network, but_not=None):
         if but_not is None: