Merge lp:~mpontillo/maas/ip-allocation-bugs-1.9 into lp:maas/1.9

[Mike Pontillo]

Clean up the claiming of AUTO IP addresses.

 * In the case of an UNMANAGED subnet which could not be linked to its NodeGroupInterface at migration time (for example, due to the lack of having a subnet mask), add a query to check if any NodeGroupInterface has static or dynamic ranges within the subnet we are about to allocate for.
 * Throw an error if a NodeGroupInterface being deployed with an AUTO IP address has a dynamic range without a static range. (this means the user needs to define a static range, or select a different IP allocation method.) Note that subnets can still be fully MAAS-managed if no dynamic range is defined.
 * Throw an error if the linked Subnet for an AUTO IP address cannot be found. (this should not happen, but if it does, we want a nicer error.)
 * Run the algorithm to determine ancillary IP addresses on a subnet before handing out an AUTO IP address on a managed or unmanaged subnet. (this fixes the issue where a known router address will be used on a fully unmanaged network)
 * Add logging in maas.log for when an AUTO IP address is allocated.
 * Fix typo in function name (dyanamic -> dynamic)
 * Add a utility script (remote-reinstall) to easily overwrite an installed version of MAAS on a remote host with a development version of MAAS. Requires SSH access to the root account on that host. (This greatly speeds development when iterative manual testing is required.)

[Mike Pontillo (mpontillo)]

I'm going to put this up for review feedback even though I haven't done the unit tests, because I've spent most of the afternoon manually testing and iterating on this.

This will have unit tests before I land it.

[Mike Pontillo (mpontillo)]

Also, I plan to test and review this on 1.9 first. But I will merge and land this on trunk before landing this on 1.9.

[Blake Rouse (blake-rouse)]

Looks good. Just a few comments that need looking at. Please change the WebUI adjustment before landing.

Also make sure that you land this in trunk as well. We need to be very sure that every branch we land in 1.9 without going through trunk first also lands in trunk. Without it, it means a regression in the next release of MAAS. I would prefer to see this land in trunk first.

review: Approve

[Blake Rouse (blake-rouse)]

Ah just hit me right after I set it to approved. You have not added any tests, so this needs to have unit tests before this can land. Silly me.

review: Needs Fixing

[Mike Pontillo (mpontillo)]

Thanks for the review. Yeah, I'll get those tests in so this can land. (but first I want to finish triaging that juju issue)

[Mike Pontillo (mpontillo)]

Blake, I've added some unit tests. I think this is ready for another look. Thanks!

[Blake Rouse (blake-rouse)]

Looks good. Don't forget to land this in trunk as well.

review: Approve

[Mike Pontillo (mpontillo)]

It looks like the juju bug may need further triage work; I'm going to land this now so I can base any additional fixes on top of this.

=== modified file '.idea/encodings.xml'
--- .idea/encodings.xml	2015-05-14 04:26:55 +0000
+++ .idea/encodings.xml	2015-12-03 19:55:35 +0000
@@ -1,4 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false" />
+  <component name="Encoding" useUTFGuessing="true" native2AsciiForPropertiesFiles="false">
+    <file url="PROJECT" charset="UTF-8" />
+  </component>
 </project>
\ No newline at end of file

=== removed file '.idea/vcs.xml'
--- .idea/vcs.xml	2015-05-14 04:26:55 +0000
+++ .idea/vcs.xml	1970-01-01 00:00:00 +0000
@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="" />
-  </component>
-</project>
\ No newline at end of file

=== modified file 'src/maasserver/api/devices.py'
--- src/maasserver/api/devices.py	2015-09-10 18:28:45 +0000
+++ src/maasserver/api/devices.py	2015-12-03 19:55:35 +0000
@@ -29,6 +29,7 @@
 from maasserver.exceptions import (
     MAASAPIBadRequest,
     MAASAPIValidationError,
+    StaticIPAddressExhaustion,
 )
 from maasserver.fields import MAC_RE
 from maasserver.forms import (
@@ -169,7 +170,7 @@
         Returns 400 if the mac_address is not found on the device.
         Returns 503 if there are not enough IPs left on the cluster interface
         to which the mac_address is linked.
-        Returns 503 if the requested_address falls in a dynamic range.
+        Returns 503 if the interface does not have an associated subnet.
         Returns 503 if the requested_address falls in a dynamic range.
         Returns 503 if the requested_address is already allocated.
         """
@@ -192,8 +193,7 @@
                         "mac_address %s not found on the device" % raw_mac)
             requested_address = request.POST.get('requested_address', None)
             if requested_address is None:
-                sticky_ips = interface.claim_static_ips(
-                    requested_address=requested_address)
+                sticky_ips = interface.claim_static_ips()
             else:
                 subnet = Subnet.objects.get_best_subnet_for_ip(
                     requested_address)
@@ -203,9 +203,16 @@
                         ip_address=requested_address),
                 ]
 
-            maaslog.info(
-                "%s: Sticky IP address(es) allocated: %s", device.hostname,
-                ', '.join(allocation.ip for allocation in sticky_ips))
+            if len(sticky_ips) == 0:
+                raise StaticIPAddressExhaustion(
+                    "%s: An IP address could not be claimed at this time. "
+                    "Check your subnet ranges and utilization and try again." %
+                    device.hostname)
+            else:
+                maaslog.info(
+                    "%s: Sticky IP address(es) allocated: %s", device.hostname,
+                    ', '.join(allocation.ip for allocation in sticky_ips))
+
             return device
 
     @operation(idempotent=False)
@@ -272,7 +279,10 @@
         form = DeviceWithMACsForm(data=request.data, request=request)
         if form.is_valid():
             device = form.save()
-            maaslog.info("%s: Added new device", device.hostname)
+            parent = device.parent
+            maaslog.info(
+                "%s: Added new device%s", device.hostname,
+                "" if not parent else " (parent: %s)" % parent.hostname)
             return device
         else:
             raise MAASAPIValidationError(form.errors)

=== modified file 'src/maasserver/api/tests/test_devices.py'
--- src/maasserver/api/tests/test_devices.py	2015-09-10 18:28:45 +0000
+++ src/maasserver/api/tests/test_devices.py	2015-12-03 19:55:35 +0000
@@ -24,8 +24,12 @@
     INTERFACE_TYPE,
     IPADDRESS_TYPE,
     NODE_STATUS,
+    NODEGROUP_STATUS,
+    NODEGROUPINTERFACE_MANAGEMENT,
 )
 from maasserver.models import (
+    Device,
+    Interface,
     interface as interface_module,
     Node,
     NodeGroup,
@@ -37,6 +41,7 @@
 )
 from maasserver.testing.factory import factory
 from maasserver.testing.orm import reload_object
+from mock import patch
 from testtools.matchers import (
     HasLength,
     Not,
@@ -285,17 +290,93 @@
 class TestClaimStickyIpAddressAPI(APITestCase):
     """Tests for /api/1.0/devices/?op=claim_sticky_ip_address."""
 
-    def test__claims_ip_address_from_cluster_interface(self):
-        parent = factory.make_Node_with_Interface_on_Subnet()
-        device = factory.make_Node(
-            installable=False, parent=parent, interface=True,
-            disable_ipv4=False, owner=self.logged_in_user)
-        # Silence 'update_host_maps'.
-        self.patch_autospec(interface_module, "update_host_maps")
-        response = self.client.post(
-            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
-        self.assertEqual(httplib.OK, response.status_code, response.content)
-        parsed_device = json.loads(response.content)
+    def test__claims_ip_address_from_cluster_interface_static_range(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=ngi.subnet)
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
+        self.assertIsNotNone(static_ip)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+
+    def test__claims_ip_address_from_unmanaged_cluster_interface(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=ngi.subnet)
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
+        self.assertIsNotNone(static_ip)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+
+    def test__claims_ip_address_from_detached_cluster_interface(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
+        subnet = ngi.subnet
+        ngi.subnet = None
+        ngi.save()
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=subnet, unmanaged=True)
+        device = factory.make_Node(
+            installable=False, parent=parent, interface=True,
+            disable_ipv4=False, owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        [returned_ip] = parsed_device["ip_addresses"]
+        static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
+        self.assertIsNotNone(static_ip)
+        self.assertEquals(IPADDRESS_TYPE.STICKY, static_ip.alloc_type)
+
+    def test__claims_ip_address_after_devices_new(self):
+        ng = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            ng, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS)
+        parent = factory.make_Node_with_Interface_on_Subnet(
+            nodegroup=ng, subnet=ngi.subnet)
+        # Run 'devices new', as a sanity check to ensure the object is created
+        # the same way as it is when juju does it.
+        self.client.post(
+            reverse('devices_handler'),
+            {
+                'op': 'new',
+                'hostname': "lxc-1",
+                'mac_addresses': "01:02:03:04:05:06",
+                'parent': parent.system_id,
+            })
+        # Silence 'update_host_maps'.
+        device = Device.objects.first()
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device), {'op': 'claim_sticky_ip_address'})
+        self.assertEqual(httplib.OK, response.status_code, response.content)
+        parsed_device = json.loads(response.content)
+        # import pdb; pdb.set_trace()
         [returned_ip] = parsed_device["ip_addresses"]
         static_ip = StaticIPAddress.objects.filter(ip=returned_ip).first()
         self.assertIsNotNone(static_ip)
@@ -333,6 +414,39 @@
             (returned_ip, returned_ip, given_ip.alloc_type)
         )
 
+    def test_503_if_no_subnet_found(self):
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+            })
+        self.assertEqual(
+            httplib.SERVICE_UNAVAILABLE, response.status_code,
+            response.content)
+
+    @patch.object(Interface, 'claim_static_ips')
+    def test_503_if_no_ip_found(self, claim_static_ips):
+        claim_static_ips.side_effect = [list()]
+
+        device = factory.make_Node(
+            installable=False, interface=True, disable_ipv4=False,
+            owner=self.logged_in_user)
+        # Silence 'update_host_maps'.
+        self.patch_autospec(interface_module, "update_host_maps")
+        response = self.client.post(
+            get_device_uri(device),
+            {
+                'op': 'claim_sticky_ip_address',
+            })
+        self.assertEqual(
+            httplib.SERVICE_UNAVAILABLE, response.status_code,
+            response.content)
+
     def test_creates_ip_for_specific_mac(self):
         requested_address = factory.make_ip_address()
         device = factory.make_Node(

=== modified file 'src/maasserver/models/interface.py'
--- src/maasserver/models/interface.py	2015-11-11 01:11:12 +0000
+++ src/maasserver/models/interface.py	2015-12-03 19:55:35 +0000
@@ -52,6 +52,7 @@
     NODEGROUPINTERFACE_MANAGEMENT,
 )
 from maasserver.exceptions import (
+    StaticIPAddressExhaustion,
     StaticIPAddressOutOfRange,
     StaticIPAddressUnavailable,
 )
@@ -350,6 +351,13 @@
     def get_node(self):
         return self.node
 
+    def get_log_string(self):
+        hostname = "<unknown-node>"
+        node = self.get_node()
+        if node is not None:
+            hostname = node.hostname
+        return "%s on %s" % (self.get_name(), hostname)
+
     def get_name(self):
         return self.name
 
@@ -879,6 +887,10 @@
         be identified then its just set to DHCP.
         """
         found_subnet = None
+        # XXX mpontillo 2015-11-29: since we tend to dump a large number of
+        # subnets into the default VLAN, this assumption might be incorrect in
+        # many cases, leading to interfaces being configured as AUTO when
+        # they should be configured as DHCP.
         for subnet in self.vlan.subnet_set.all():
             ngi = subnet.get_managed_cluster_interface()
             if ngi is not None:
@@ -1109,44 +1121,92 @@
                     auto_ip, exclude_addresses)
                 if ngi is not None:
                     affected_nodegroups.add(ngi.nodegroup)
-                assigned_addresses.append(assigned_ip)
-                exclude_addresses.add(unicode(assigned_ip.ip))
+                if assigned_ip is not None:
+                    assigned_addresses.append(assigned_ip)
+                    exclude_addresses.add(unicode(assigned_ip.ip))
         self._update_dns_zones(affected_nodegroups)
         return assigned_addresses
 
     def _claim_auto_ip(self, auto_ip, exclude_addresses=[]):
-        """Claim an IP address for the `auto_ip`."""
+        """Claim an IP address for the `auto_ip`.
+
+        :returns:NodeGroupInterface, new_ip_address
+        """
         # Check if already has a hostmap allocated for this MAC address.
         subnet = auto_ip.subnet
+        if subnet is None:
+            maaslog.error(
+                "Could not find subnet for interface %s." %
+                (self.get_log_string()))
+            raise StaticIPAddressUnavailable(
+                "Automatic IP address cannot be configured on interface %s "
+                "without an associated subnet." % self.get_name())
+
         ngi = subnet.get_managed_cluster_interface()
+        if ngi is None:
+            # Couldn't find a managed cluster interface for this node. So look
+            # for any interface (must be an UNMANAGED interface, since any
+            # managed NodeGroupInterface MUST have a Subnet link) whose
+            # static or dynamic range is within the given subnet.
+            ngi = NodeGroupInterface.objects.get_by_managed_range_for_subnet(
+                subnet)
+
+        has_existing_mapping = False
+        has_static_range = False
+        has_dynamic_range = False
+
         if ngi is not None:
-            has_allocations = self._has_static_allocation_on_cluster(
+            has_existing_mapping = self._has_static_allocation_on_cluster(
                 ngi.nodegroup, get_subnet_family(subnet))
-        else:
-            has_allocations = False
-
-        # Create a new AUTO IP.
-        if ngi is not None:
+            has_static_range = ngi.has_static_ip_range()
+            has_dynamic_range = ngi.has_dynamic_ip_range()
+
+        if not has_static_range and has_dynamic_range:
+            # This means we found a matching NodeGroupInterface, but only its
+            # dynamic range is defined. Since a dynamic range is defined, that
+            # means this subnet is NOT managed by MAAS (or it's misconfigured),
+            # so we cannot just hand out a random IP address and risk a
+            # duplicate IP address.
+            maaslog.error(
+                "Found matching NodeGroupInterface, but no static range has "
+                "been defined for %s. (did you mean to configure DHCP?) " %
+                (self.get_log_string()))
+            raise StaticIPAddressUnavailable(
+                "Cluster interface for %s only has a dynamic range. Configure "
+                "a static range, or reconfigure the interface." %
+                (self.get_name()))
+
+        if has_static_range:
+            # Allocate a new AUTO address from the static range.
             network = ngi.network
             static_ip_range_low = ngi.static_ip_range_low
             static_ip_range_high = ngi.static_ip_range_high
         else:
+            # We either found a NodeGroupInterface with no static or dynamic
+            # range, or we have a Subnet not associated with a
+            # NodeGroupInterface. This implies that it's okay to assign any
+            # unused IP address on the subnet.
             network = subnet.get_ipnetwork()
             static_ip_range_low, static_ip_range_high = (
                 get_first_and_last_usable_host_in_network(network))
+        in_use_ipset = subnet.get_ipranges_in_use()
         new_ip = StaticIPAddress.objects.allocate_new(
             network, static_ip_range_low, static_ip_range_high,
             None, None, alloc_type=IPADDRESS_TYPE.AUTO,
-            subnet=subnet, exclude_addresses=exclude_addresses)
+            subnet=subnet, exclude_addresses=exclude_addresses,
+            in_use_ipset=in_use_ipset)
         self.ip_addresses.add(new_ip)
+        maaslog.info("Allocated automatic%s IP address %s for %s." % (
+            " static" if has_static_range else "", new_ip.ip,
+            self.get_log_string()))
 
-        # Update the hostmap for the new IP address if needed.
-        if ngi is not None and not has_allocations:
+        if ngi is not None and not has_existing_mapping:
+            # Update DHCP (if needed).
             self._update_host_maps(ngi.nodegroup, new_ip)
 
-        # Made it this far then the AUTO IP address has been assigned and the
-        # hostmap has been updated if needed. We can now remove the original
-        # empty AUTO IP address.
+        # If we made it this far, then the AUTO IP address has been assigned
+        # and the hostmap has been updated if needed. We can now remove the
+        # original empty AUTO IP address.
         auto_ip.delete()
         return ngi, new_ip
 
@@ -1257,6 +1317,23 @@
                 if ngi is not None and ngi.subnet is not None:
                     discovered_subnets.append(ngi.subnet)
 
+        if len(discovered_subnets) == 0:
+            node = self.node
+            if parent is not None:
+                node = parent
+            if node is None:
+                hostname = "<unknown>"
+            else:
+                hostname = "'%s'" % node.hostname
+            log_string = (
+                "%s: Attempted to claim a static IP address, but no "
+                "associated subnet could be found. (Recommission node %s "
+                "in order for MAAS to discover the subnet.)" %
+                (self.get_log_string(), hostname)
+            )
+            maaslog.warning(log_string)
+            raise StaticIPAddressExhaustion(log_string)
+
         if requested_address is None:
             # No requested address so claim a STATIC IP on all DISCOVERED
             # subnets for this interface.
@@ -1271,8 +1348,8 @@
             # No valid subnets could be used to claim a STATIC IP address.
             if not any(static_ips):
                 maaslog.error(
-                    "Tried to allocate an IP to interface <%s>, but its "
-                    "cluster interface is not known.", unicode(self))
+                    "Attempted sticky IP allocation failed for %s: could not "
+                    "find a cluster interface.", self.get_log_string())
                 return []
             else:
                 return static_ips
@@ -1294,7 +1371,8 @@
             else:
                 raise StaticIPAddressOutOfRange(
                     "requested_address '%s' is not in a managed subnet for "
-                    "this interface '%s'" % (requested_address, self.name))
+                    "interface '%s'." % (
+                        requested_address, self.get_name()))
 
     def _get_parent_node(self):
         """Return the parent node for this interface, if it exists (and this

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2015-11-21 02:16:17 +0000
+++ src/maasserver/models/node.py	2015-12-03 19:55:35 +0000
@@ -2530,7 +2530,9 @@
             # You can't start a node you don't own unless you're an admin.
             raise PermissionDenied()
         event = EVENT_TYPES.REQUEST_NODE_START
-        # if status is ALLOCATED, this start is actually for a deployment
+        # If status is ALLOCATED, this start is actually for a deployment.
+        # (Note: this is true even when nodes are being deployed from READY
+        # state. See node_action.py; the node is acquired and then started.)
         if self.status == NODE_STATUS.ALLOCATED:
             event = EVENT_TYPES.REQUEST_NODE_START_DEPLOYMENT
         self._register_request_event(
@@ -2575,6 +2577,8 @@
 
         if self.status == NODE_STATUS.ALLOCATED:
             # Claim AUTO IP addresses for the node if it's ALLOCATED.
+            # The current state being ALLOCATED is our indication that the node
+            # is being deployed for the first time.
             self.claim_auto_ips()
             transition_monitor = (
                 TransitionMonitor.fromNode(self)

=== modified file 'src/maasserver/models/nodegroupinterface.py'
--- src/maasserver/models/nodegroupinterface.py	2015-10-29 19:10:30 +0000
+++ src/maasserver/models/nodegroupinterface.py	2015-12-03 19:55:35 +0000
@@ -172,6 +172,40 @@
         else:
             return None
 
+    find_by_managed_range_for_subnet_query = dedent("""\
+    SELECT ngi.*
+        FROM
+            maasserver_subnet AS subnet,
+            maasserver_nodegroupinterface AS ngi,
+            maasserver_nodegroup AS ng
+        WHERE
+            ngi.nodegroup_id = ng.id AND
+            ng.status = 1 AND /* NodeGroup must be ENABLED */
+            ((inet(ngi.ip_range_low) << network(subnet.cidr) AND
+            inet(ngi.ip_range_high) << network(subnet.cidr))
+            OR (inet(ngi.static_ip_range_low) << network(subnet.cidr) AND
+            inet(ngi.static_ip_range_high) << network(subnet.cidr)))
+            AND subnet.id = %s
+        /* Prefer static ranges, since that's how we'll allocate addresses. */
+        ORDER BY ngi.static_ip_range_low DESC NULLS LAST, ngi.id
+    """)
+
+    def get_by_managed_range_for_subnet(self, subnet):
+        """Return the first interface that could contain `address` in its
+        dynamic or static range. (Prefer interfaces static ranges.)
+        """
+        # Circular imports
+        from maasserver.models import Subnet
+        assert isinstance(subnet, Subnet), (
+            "%r is not a Subnet" % (subnet,))
+        interfaces = self.raw(
+            self.find_by_managed_range_for_subnet_query + " LIMIT 1",
+            [subnet.id])
+        for interface in interfaces:
+            return interface  # This is stable because the query is ordered.
+        else:
+            return None
+
 
 def get_default_vlan():
     from maasserver.models.vlan import VLAN
@@ -437,7 +471,7 @@
             exclude = []
         self.check_for_network_interface_clashes(exclude)
 
-    def has_dyanamic_ip_range(self):
+    def has_dynamic_ip_range(self):
         """Returns `True` if this `NodeGroupInterface` has a dynamic IP
         range specified."""
         return self.ip_range_low and self.ip_range_high
@@ -445,7 +479,7 @@
     def get_dynamic_ip_range(self):
         """Returns a `MAASIPRange` for this `NodeGroupInterface`, if a dynamic
         range is specified. Otherwise, returns `None`."""
-        if self.has_dyanamic_ip_range():
+        if self.has_dynamic_ip_range():
             return make_iprange(
                 self.ip_range_low, self.ip_range_high,
                 purpose='dynamic-range')
@@ -645,7 +679,7 @@
         assert isinstance(ipnetwork, IPNetwork)
 
         ranges = set()
-        if self.has_dyanamic_ip_range():
+        if self.has_dynamic_ip_range():
             dynamic_range = self.get_dynamic_ip_range()
             if dynamic_range in ipnetwork:
                 ranges.add(dynamic_range)

=== modified file 'src/maasserver/models/staticipaddress.py'
--- src/maasserver/models/staticipaddress.py	2015-11-17 00:33:35 +0000
+++ src/maasserver/models/staticipaddress.py	2015-12-03 19:55:35 +0000
@@ -166,7 +166,7 @@
             dynamic_range_low, dynamic_range_high,
             alloc_type=IPADDRESS_TYPE.AUTO, user=None,
             requested_address=None, hostname=None, subnet=None,
-            exclude_addresses=[]):
+            exclude_addresses=[], in_use_ipset=set()):
         """Return a new StaticIPAddress.
 
         :param network: The network the address should be allocated in.
@@ -226,7 +226,8 @@
                 requested_address = self._async_find_free_ip(
                     static_range_low, static_range_high, static_range,
                     alloc_type, user,
-                    exclude_addresses=exclude_addresses).wait(30)
+                    exclude_addresses=exclude_addresses,
+                    in_use_ipset=in_use_ipset).wait(30)
                 try:
                     return self._attempt_allocation(
                         requested_address, alloc_type, user,
@@ -272,7 +273,7 @@
 
     def _find_free_ip(
             self, range_low, range_high, static_range, alloc_type,
-            user, exclude_addresses):
+            user, exclude_addresses, in_use_ipset=set()):
         """Helper function that finds a free IP address using a lock."""
         # The set of _allocated_ addresses in the range is going to be
         # smaller or at least no bigger than the set of addresses in the
@@ -297,7 +298,8 @@
             })
         # Now find the first free address in the range.
         for requested_address in static_range:
-            if requested_address not in existing:
+            if (requested_address not in existing and
+                    requested_address not in in_use_ipset):
                 return requested_address
         else:
             raise StaticIPAddressExhaustion(
@@ -840,4 +842,7 @@
             else:
                 # (2) and (3): the Subnet has changed (could be to None)
                 subnet = Subnet.objects.get_best_subnet_for_ip(ipaddr)
+                # We must save here, otherwise it's possible that we can't
+                # traverse the interface_set many-to-many.
+                self.save()
                 self._set_subnet(subnet, interfaces=self.interface_set.all())

=== modified file 'src/maasserver/models/subnet.py'
--- src/maasserver/models/subnet.py	2015-11-09 22:20:01 +0000
+++ src/maasserver/models/subnet.py	2015-12-03 19:55:35 +0000
@@ -389,11 +389,18 @@
 
     def get_managed_cluster_interface(self):
         """Return the cluster interface that manages this subnet."""
+        # Prefer enabled, non-UNMANAGED networks.
         interfaces = self.nodegroupinterface_set.filter(
             nodegroup__status=NODEGROUP_STATUS.ENABLED)
         interfaces = interfaces.exclude(
             management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
-        return interfaces.first()
+        ngi = interfaces.first()
+        if ngi is None:
+            # Circular imports
+            from maasserver.models import NodeGroupInterface
+            ngi = NodeGroupInterface.objects.get_by_managed_range_for_subnet(
+                self)
+        return ngi
 
     def clean(self, *args, **kwargs):
         self.validate_gateway_ip()

=== modified file 'src/maasserver/models/tests/test_interface.py'
--- src/maasserver/models/tests/test_interface.py	2015-11-11 01:04:18 +0000
+++ src/maasserver/models/tests/test_interface.py	2015-12-03 19:55:35 +0000
@@ -31,6 +31,7 @@
     NODEGROUPINTERFACE_MANAGEMENT,
 )
 from maasserver.exceptions import (
+    StaticIPAddressExhaustion,
     StaticIPAddressOutOfRange,
     StaticIPAddressUnavailable,
 )
@@ -80,6 +81,7 @@
     MatchesDict,
     MatchesListwise,
     MatchesStructure,
+    Not,
 )
 
 
@@ -2224,9 +2226,93 @@
         self.assertEquals(subnet, observed[0].subnet)
         self.assertTrue(
             IPAddress(observed[0].ip) in (
-                IPRange(ngi.static_ip_range_low, ngi.static_ip_range_low)),
-            "Assigned IP address should be inside the static range "
-            "on the cluster.")
+                IPRange(ngi.static_ip_range_low, ngi.static_ip_range_high)),
+            "Assigned IP address %s should be inside the static range "
+            "on the cluster (%s - %s)." % (
+                observed[0].ip, ngi.static_ip_range_low,
+                ngi.static_ip_range_high))
+
+    def test__claims_ip_address_in_static_ip_range_skips_gateway_ip(self):
+        from maasserver.dns import config
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(config, "dns_update_zones")
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
+            subnet=subnet)
+        # Make it a really small range, just to be safe.
+        ngi.static_ip_range_high = unicode(
+            IPAddress(ngi.static_ip_range_low) + 1)
+        ngi.save()
+        ngi.subnet.gateway_ip = ngi.static_ip_range_low
+        ngi.subnet.dns_servers = []
+        ngi.subnet.save()
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        observed = interface.claim_auto_ips()
+        self.assertEquals(
+            1, len(observed),
+            "Should have 1 AUTO IP addresses with an IP address assigned.")
+        self.assertEquals(subnet, observed[0].subnet)
+        self.assertTrue(
+            IPAddress(observed[0].ip) in (
+                IPRange(ngi.static_ip_range_low, ngi.static_ip_range_high)),
+            "Assigned IP address %s should be inside the static range "
+            "on the cluster (%s - %s)." % (
+                observed[0].ip, ngi.static_ip_range_low,
+                ngi.static_ip_range_high))
+        self.assertThat(
+            IPAddress(observed[0].ip), Not(Equals(IPAddress(
+                ngi.subnet.gateway_ip))))
+
+    def test__claim_fails_if_subnet_missing(self):
+        from maasserver.dns import config
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(config, "dns_update_zones")
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
+            subnet=subnet)
+        ip = factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        ip.subnet = None
+        ip.save()
+        maaslog = self.patch_autospec(interface_module, "maaslog")
+        with ExpectedException(StaticIPAddressUnavailable):
+            interface.claim_auto_ips()
+        self.expectThat(maaslog.error, MockCalledOnceWith(
+            "Could not find subnet for interface %s." %
+            interface.get_log_string()))
+
+    def test__claim_fails_if_no_static_range(self):
+        from maasserver.dns import config
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(config, "dns_update_zones")
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        subnet = factory.make_Subnet(vlan=interface.vlan)
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
+            subnet=subnet)
+        ngi.static_ip_range_low = ""
+        ngi.static_ip_range_high = ""
+        ngi.save()
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.AUTO, ip="",
+            subnet=subnet, interface=interface)
+        maaslog = self.patch_autospec(interface_module, "maaslog")
+        with ExpectedException(StaticIPAddressUnavailable):
+            interface.claim_auto_ips()
+        self.expectThat(maaslog.error, MockCalledOnceWith(
+            "Found matching NodeGroupInterface, but no static range has "
+            "been defined for %s. (did you mean to configure DHCP?) " %
+            interface.get_log_string()))
 
     def test__calls_update_host_maps(self):
         from maasserver.dns import config
@@ -2518,7 +2604,7 @@
             StaticIPAddressOutOfRange, interface.claim_static_ips, ip_v6)
         self.assertEquals(
             "requested_address '%s' is not in a managed subnet for "
-            "this interface '%s'" % (ip_v6, interface.name),
+            "interface '%s'." % (ip_v6, interface.name),
             error.message)
 
     def test__with_address_calls_link_subnet_with_ip_address(self):
@@ -2610,3 +2696,27 @@
         self.patch_autospec(iface, "link_subnet")
         claimed_ips = iface.claim_static_ips()
         self.assertThat(claimed_ips, HasLength(1))
+
+    def test__claim_static_fails_if_parent_subnet_cannot_be_found(self):
+        from maasserver.dns import config
+        self.patch_autospec(interface_module, "update_host_maps")
+        self.patch_autospec(config, "dns_update_zones")
+        subnet = factory.make_Subnet()
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
+            subnet=subnet)
+        node = factory.make_Node_with_Interface_on_Subnet(
+            subnet=subnet, unmanaged=True, status=NODE_STATUS.READY)
+        # Simulate an unmanaged network without association to a subnet.
+        # (this could happen after a migration)
+        StaticIPAddress.objects.all().delete()
+        interface = node.get_boot_interface()
+        maaslog = self.patch_autospec(interface_module, "maaslog")
+        with ExpectedException(StaticIPAddressExhaustion):
+            interface.claim_static_ips()
+        self.expectThat(maaslog.warning, MockCalledOnceWith(
+            "%s: Attempted to claim a static IP address, but no associated "
+            "subnet could be found. (Recommission node '%s' in order for "
+            "MAAS to discover the subnet.)" %
+            (interface.get_log_string(), node.hostname)))

=== modified file 'src/maasserver/models/tests/test_nodegroupinterface.py'
--- src/maasserver/models/tests/test_nodegroupinterface.py	2015-10-29 19:10:30 +0000
+++ src/maasserver/models/tests/test_nodegroupinterface.py	2015-12-03 19:55:35 +0000
@@ -217,6 +217,41 @@
         self.assertEqual(if2, get_by_address(address))
 
 
+class TestGetManagedRangeForSubnet(MAASServerTestCase):
+
+    def test__finds_interface_using_static_range(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        factory.make_NodeGroupInterface(nodegroup, network=IPNetwork(
+            '192.168.2.0/24'))
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
+            ip='192.168.0.1', subnet_mask='', ip_range_low='',
+            ip_range_high='', static_ip_range_low='192.168.1.10',
+            static_ip_range_high='192.168.1.20')
+        factory.make_NodeGroupInterface(nodegroup, network=IPNetwork(
+            '192.168.3.0/24'))
+        subnet = factory.make_Subnet(cidr='192.168.1.0/24')
+        self.assertEqual(
+            ngi, NodeGroupInterface.objects.get_by_managed_range_for_subnet(
+                subnet))
+
+    def test__finds_interface_using_dynamic_range(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        factory.make_NodeGroupInterface(nodegroup, network=IPNetwork(
+            '192.168.2.0/24'))
+        ngi = factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED,
+            ip='192.168.0.1', subnet_mask='', static_ip_range_low='',
+            static_ip_range_high='', ip_range_low='192.168.1.10',
+            ip_range_high='192.168.1.20')
+        factory.make_NodeGroupInterface(nodegroup, network=IPNetwork(
+            '192.168.3.0/24'))
+        subnet = factory.make_Subnet(cidr=IPNetwork('192.168.1.0/24'))
+        result = NodeGroupInterface.objects.get_by_managed_range_for_subnet(
+            subnet)
+        self.assertEqual(ngi, result)
+
+
 class TestNodeGroupInterface(MAASServerTestCase):
 
     def test_network(self):

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2015-11-18 18:14:30 +0000
+++ src/maasserver/testing/factory.py	2015-12-03 19:55:35 +0000
@@ -565,7 +565,7 @@
     def make_Node_with_Interface_on_Subnet(
             self, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
             interface_count=1, nodegroup=None, vlan=None, subnet=None,
-            cidr=None, fabric=None, ifname=None, **kwargs):
+            cidr=None, fabric=None, ifname=None, unmanaged=False, **kwargs):
         """Create a Node that has a Interface which is on a Subnet that has a
         NodeGroupInterface.
 
@@ -592,7 +592,7 @@
         ngis = subnet.nodegroupinterface_set.filter(nodegroup=nodegroup)
         ngis = ngis.exclude(management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
         ngi = ngis.first()
-        if ngi is None:
+        if ngi is None and not unmanaged:
             self.make_NodeGroupInterface(
                 nodegroup, vlan=vlan, management=management, subnet=subnet)
         boot_interface = self.make_Interface(
@@ -765,8 +765,18 @@
             self, iftype=INTERFACE_TYPE.PHYSICAL, node=None, mac_address=None,
             vlan=None, parents=None, name=None, cluster_interface=None,
             ip=None, enabled=True, fabric=None):
-        if name is None and iftype != INTERFACE_TYPE.VLAN:
-            name = self.make_name('name')
+        if name is None:
+            if iftype in (INTERFACE_TYPE.PHYSICAL, INTERFACE_TYPE.UNKNOWN):
+                name = self.make_name('eth')
+            elif iftype == INTERFACE_TYPE.ALIAS:
+                name = self.make_name('eth', sep=':')
+            elif iftype == INTERFACE_TYPE.BOND:
+                name = self.make_name('bond')
+            elif iftype == INTERFACE_TYPE.UNKNOWN:
+                name = self.make_name('eth')
+            elif iftype == INTERFACE_TYPE.VLAN:
+                # This will be determined by the VLAN's VID.
+                name = None
         if iftype is None:
             iftype = INTERFACE_TYPE.PHYSICAL
         if vlan is None:

=== added file 'utilities/remote-reinstall'
--- utilities/remote-reinstall	1970-01-01 00:00:00 +0000
+++ utilities/remote-reinstall	2015-12-03 19:55:35 +0000
@@ -0,0 +1,70 @@
+#!/bin/bash
+cd $(dirname $0)
+cd ..
+
+get_ip() {
+    ping -c 1 "$1" | head -1 | tr '(' ')' | cut -d')' -f 2
+}
+
+trim () {
+    read -rd '' $1 <<<"${!1}"
+}
+
+die () {
+    echo "$@"
+    exit 1
+}
+
+if [ "$1" == "" ]; then
+    die "You must supply a hostname."
+fi
+
+hostname="$1"
+shift
+
+remote_basedir=/usr/lib/python2.7/dist-packages
+directories="maascli maasserver provisioningserver metadataserver"
+rsync_options=rlptv
+ssh_run="ssh -oBatchMode=yes -l root $hostname"
+
+echo "Checking $hostname..."
+maas_version=$($ssh_run "dpkg -s maas-region-controller-min | grep ^Version") \
+    || die "Cannot SSH to root@$hostname."
+ip_address=$(get_ip $hostname)
+maas_version=$(echo $maas_version | cut -d':' -f 2)
+trim maas_version
+trim hostname
+trim ip_address
+echo ""
+echo "Current MAAS version is: $maas_version"
+echo ""
+echo "WARNING: This will LIVE UPDATE the MAAS server at:"
+if [ $hostname == $ip_address ]; then
+    echo "    $hostname"
+else
+    echo "    $hostname ($ip_address)"
+fi
+echo ""
+echo "This is a DESTRUCTIVE script that will OVERWRITE files installed by the"
+echo "MAAS packages, and DELETE any extra files found on the server."
+echo ""
+echo "Destination directory:"
+echo "    $remote_basedir"
+echo ""
+echo "The following directories (under src/ in this sandbox) will be copied:"
+echo "    $directories"
+echo ""
+echo "Press <enter> to continue, ^C to cancel."
+read
+
+echo "Synchronizing files..."
+for dir in $directories; do
+    remote_dir=${remote_basedir}/${dir}
+    rsync -${rsync_options} --delete-after --exclude 'tests/' src/${dir}/ \
+        root@${hostname}:${remote_dir} \
+        && echo "Success." || die "Syncrhonization failed."
+    $ssh_run "python -c \"import compileall; compileall.compile_dir('$remote_dir', force=True)\""
+done
+$ssh_run service maas-regiond restart
+$ssh_run service apache2 restart
+$ssh_run service maas-clusterd restart