Merge lp:~blake-rouse/maas/fix-1519527-1.9 into lp:~maas-committers/maas/trunk

[Blake Rouse]

Prevent claim_static_ips from allocated more than one IP address per discovered subnet.

=== modified file '.idea/encodings.xml'
--- .idea/encodings.xml	2015-05-14 04:26:55 +0000
+++ .idea/encodings.xml	2015-12-04 17:04:56 +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 'Makefile'
--- Makefile	2015-11-23 17:48:38 +0000
+++ Makefile	2015-12-04 17:04:56 +0000
@@ -501,8 +501,8 @@
 # this.
 
 # Old names.
-PACKAGING := $(abspath ../packaging.trunk)
-PACKAGING_BRANCH := lp:~maas-maintainers/maas/packaging
+PACKAGING := $(abspath ../packaging-1.9)
+PACKAGING_BRANCH := lp:~maas-maintainers/maas/packaging-1.9
 
 packaging-tree = $(PACKAGING)
 packaging-branch = $(PACKAGING_BRANCH)

=== modified file 'src/maasserver/api/devices.py'
--- src/maasserver/api/devices.py	2015-11-21 16:53:24 +0000
+++ src/maasserver/api/devices.py	2015-12-04 17:04:56 +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-04 17:04:56 +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/api/vlans.py'
=== modified file 'src/maasserver/forms.py'
=== modified file 'src/maasserver/models/interface.py'
--- src/maasserver/models/interface.py	2015-11-20 16:20:38 +0000
+++ src/maasserver/models/interface.py	2015-12-04 17:04:56 +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,28 @@
                 if ngi is not None and ngi.subnet is not None:
                     discovered_subnets.append(ngi.subnet)
 
+        # This must be a set because it is highly possible that the parent
+        # has multiple subnets on the same interface or same subnet on multiple
+        # interfaces. We only want to allocate one ip address per subnet.
+        discovered_subnets = set(discovered_subnets)
+
+        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 +1353,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 +1376,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 16:54:43 +0000
+++ src/maasserver/models/node.py	2015-12-04 17:04:56 +0000
@@ -2539,7 +2539,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(
@@ -2584,6 +2586,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-11-18 15:44:23 +0000
+++ src/maasserver/models/nodegroupinterface.py	2015-12-04 17:04:56 +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-21 16:54:43 +0000
+++ src/maasserver/models/staticipaddress.py	2015-12-04 17:04:56 +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-18 15:44:23 +0000
+++ src/maasserver/models/subnet.py	2015-12-04 17:04:56 +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-18 15:44:23 +0000
+++ src/maasserver/models/tests/test_interface.py	2015-12-04 17:04:56 +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
@@ -2489,6 +2575,42 @@
                 call(INTERFACE_LINK_TYPE.STATIC, subnet_v4),
                 call(INTERFACE_LINK_TYPE.STATIC, subnet_v6)))
 
+    def test__without_address_calls_link_subnet_once_per_subnet(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
+        network_v4 = factory.make_ipv4_network()
+        subnet_v4 = factory.make_Subnet(cidr=unicode(network_v4.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet_v4)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v4, interface=interface)
+        # Make it have the same subnet twice.
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v4, interface=interface)
+        network_v6 = factory.make_ipv6_network()
+        subnet_v6 = factory.make_Subnet(cidr=unicode(network_v6.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet_v6)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v6, interface=interface)
+        # Make it have the same subnet twice.
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v6, interface=interface)
+
+        mock_link_subnet = self.patch_autospec(interface, "link_subnet")
+        interface.claim_static_ips()
+        self.assertThat(
+            mock_link_subnet,
+            MockCallsMatch(
+                call(INTERFACE_LINK_TYPE.STATIC, subnet_v4),
+                call(INTERFACE_LINK_TYPE.STATIC, subnet_v6)))
+
     def test__without_address_does_nothing_if_none_managed(self):
         interface = factory.make_Interface(INTERFACE_TYPE.PHYSICAL)
         network_v4 = factory.make_ipv4_network()
@@ -2518,7 +2640,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):
@@ -2573,6 +2695,49 @@
                 call(INTERFACE_LINK_TYPE.STATIC, subnet_v4),
                 call(INTERFACE_LINK_TYPE.STATIC, subnet_v6)))
 
+    def test__device_no_address_calls_link_subnet_once_per_subnet(self):
+        nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
+        parent = factory.make_Node()
+        parent_nic0 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent)
+        parent_nic1 = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=parent)
+        network_v4 = factory.make_ipv4_network()
+        subnet_v4 = factory.make_Subnet(cidr=unicode(network_v4.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet_v4)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v4, interface=parent_nic0)
+        # Make second interface on the parent have the same subnet.
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v4, interface=parent_nic1)
+        network_v6 = factory.make_ipv6_network()
+        subnet_v6 = factory.make_Subnet(cidr=unicode(network_v6.cidr))
+        factory.make_NodeGroupInterface(
+            nodegroup, management=NODEGROUPINTERFACE_MANAGEMENT.DHCP,
+            subnet=subnet_v6)
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v6, interface=parent_nic0)
+        # Make second interface on the parent have the same subnet.
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.DISCOVERED, ip="",
+            subnet=subnet_v6, interface=parent_nic1)
+        device = factory.make_Device(parent=parent)
+        device_interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=device)
+
+        mock_link_subnet = self.patch_autospec(device_interface, "link_subnet")
+        device_interface.claim_static_ips()
+        self.assertThat(
+            mock_link_subnet,
+            MockCallsMatch(
+                call(INTERFACE_LINK_TYPE.STATIC, subnet_v4),
+                call(INTERFACE_LINK_TYPE.STATIC, subnet_v6)))
+
     def test__device_with_address_calls_link_subnet_with_ip_address(self):
         parent = factory.make_Node()
         interface = factory.make_Interface(
@@ -2610,3 +2775,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_node.py'
=== 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-04 17:04:56 +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/models/tests/test_partition.py'
=== modified file 'src/maasserver/models/tests/test_partitiontable.py'
=== modified file 'src/maasserver/models/tests/test_staticipaddress.py'
=== modified file 'src/maasserver/node_constraint_filter_forms.py'
=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2015-11-17 23:03:36 +0000
+++ src/maasserver/testing/factory.py	2015-12-04 17:04:56 +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:

=== modified file 'src/maasserver/tests/test_storage_layouts.py'
=== modified file 'src/maasserver/utils/orm.py'
=== modified file 'src/maasserver/websockets/handlers/node.py'
=== modified file 'src/maasserver/websockets/handlers/tests/test_node.py'
=== modified file 'src/provisioningserver/drivers/power/__init__.py'
=== modified file 'src/provisioningserver/drivers/power/amt.py'
--- src/provisioningserver/drivers/power/amt.py	2015-11-17 02:05:20 +0000
+++ src/provisioningserver/drivers/power/amt.py	2015-12-04 17:04:56 +0000
@@ -53,6 +53,7 @@
                 missing_packages.append(package)
         return missing_packages
 
+<<<<<<< TREE
     def _render_wsman_state_xml(self, power_change):
         """Render wsman state XML."""
         wsman_state_filename = join(dirname(__file__), "amt.wsman-state.xml")
@@ -373,3 +374,13 @@
             return self.amttool_query_state(ip_address, power_pass)
         elif amt_command == 'wsman':
             return self.wsman_query_state(ip_address, power_pass)
+=======
+    def power_on(self, system_id, context):
+        raise NotImplementedError
+
+    def power_off(self, system_id, context):
+        raise NotImplementedError
+
+    def power_query(self, system_id, context):
+        raise NotImplementedError
+>>>>>>> MERGE-SOURCE

=== modified file 'src/provisioningserver/drivers/power/ipmi.py'
--- src/provisioningserver/drivers/power/ipmi.py	2015-11-20 21:08:27 +0000
+++ src/provisioningserver/drivers/power/ipmi.py	2015-12-04 17:04:56 +0000
@@ -44,7 +44,15 @@
 """
 
 
-maaslog = get_maas_logger("drivers.power.ipmi")
+<<<<<<< TREE
+maaslog = get_maas_logger("drivers.power.ipmi")
+=======
+maaslog = get_maas_logger("drivers.power.ipmi")
+
+
+def is_set(setting):
+    return not (setting is None or setting == "" or setting.isspace())
+>>>>>>> MERGE-SOURCE
 
 
 class IPMIPowerDriver(PowerDriver):

=== modified file 'src/provisioningserver/drivers/power/tests/test_amt.py'
--- src/provisioningserver/drivers/power/tests/test_amt.py	2015-11-17 02:05:20 +0000
+++ src/provisioningserver/drivers/power/tests/test_amt.py	2015-12-04 17:04:56 +0000
@@ -99,6 +99,7 @@
         missing = driver.detect_missing_packages()
         self.assertItemsEqual([], missing)
 
+<<<<<<< TREE
     def test__render_wsman_state_xml_renders_xml(self):
         amt_power_driver = AMTPowerDriver()
         power_change = choice(['on', 'off', 'restart'])
@@ -780,3 +781,19 @@
             wsman_query_state_mock, MockCalledOnceWith(
                 context['ip_address'], context['power_pass']))
         self.expectThat(state, Equals('on'))
+=======
+    def test_power_on(self):
+        driver = amt_module.AMTPowerDriver()
+        self.assertRaises(
+            NotImplementedError, driver.power_on, "fake_id", {})
+
+    def test_power_off(self):
+        driver = amt_module.AMTPowerDriver()
+        self.assertRaises(
+            NotImplementedError, driver.power_off, "fake_id", {})
+
+    def test_power_query(self):
+        driver = amt_module.AMTPowerDriver()
+        self.assertRaises(
+            NotImplementedError, driver.power_query, "fake_id", {})
+>>>>>>> MERGE-SOURCE

=== modified file 'src/provisioningserver/drivers/power/tests/test_ipmi.py'
--- src/provisioningserver/drivers/power/tests/test_ipmi.py	2015-11-20 21:08:27 +0000
+++ src/provisioningserver/drivers/power/tests/test_ipmi.py	2015-12-04 17:04:56 +0000
@@ -269,8 +269,13 @@
                 ipmipower_command, env=env))
         self.expectThat(result, Equals('other'))
 
+<<<<<<< TREE
     def test__issue_ipmi_command_issues_raises_power_auth_error(self):
         _, _, _, _, _, _, _, context = make_parameters()
+=======
+    def test__issue_ipmi_command_raises_power_fatal_error(self):
+        _, _, _, _, _, _, _, context = make_parameters()
+>>>>>>> MERGE-SOURCE
         ipmi_power_driver = IPMIPowerDriver()
         popen_mock = self.patch(ipmi_module, 'Popen')
         process = popen_mock.return_value

=== added file 'utilities/remote-reinstall'
--- utilities/remote-reinstall	1970-01-01 00:00:00 +0000
+++ utilities/remote-reinstall	2015-12-04 17:04:56 +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