Merge lp:~mpontillo/maas/update-host-maps-cleanup-bug-1440102 into lp:~maas-committers/maas/trunk

[Mike Pontillo]

Move responsibility for calling update_host_maps() and update_dns_zones() away from the caller, and into the model.

[Mike Pontillo (mpontillo)]

I'm putting this up for review even though there is a little more cleanup to be done, so people can get started looking at it. All the test cases are passing in this iteration, though I'll be doing some manual testing and running it through CI as well, to ensure it's okay.

This change consolidates the logic for updating host maps and DNS zones within the claim_static_ips() and set_static_ip() methods inside macaddress.py. (Sounds easy? Not really, because lots of tests depend on using a mock to forego updating DNS and/or host maps, depending on their particular use case.)

I'm not completely happy with this change, mainly because moving around dozens of mocks makes it extremely hard to refactor this code.

What I'd like to do, given the time, is to change all callers of update_host_maps(), update_dns_zones() (and any related functions) to call via a module, instead of importing a function. This way when we mock the calls, we already know what to mock, and we can refactor as much as we like without impacting the dozens of tests that care about it.

Also on the TODO list is changing the signature of the update_nodegroup_host_maps() function, which is currently an awkward (nodegroup, claims, nodegroups=None). (I extracted the method in a hurry.)

[Mike Pontillo (mpontillo)]

Updated update_nodegroup_host_maps() signature. (it now just takes a list of nodegroups, but the old update_host_maps() will remain the same and ignore the node's nodegroup if passed in, because it breaks test cases without that behavior; even though I'm not positive the behavior is correct, I don't want to risk it.)

[Mike Pontillo (mpontillo)]

The other thing I don't like about this change is that updating the model suddenly has far-reaching side effects.

I made the side effect explicit by passing in the "update_host_maps" boolean to a few functions. I might have preferred a "dependency injection" style approach, but at least this gives callers (especially tests) the option to avoid the side effect.

If the side-effect was easy to mock in a consistent way (as I suggested by saying it should be called via its own module), I think it would be okay to remove the boolean. But in this case, adding the boolean prevented an even worse explosion in terms of test cases that needed to be updated.

[Mike Pontillo (mpontillo)]

Note: CI failed with the following errors:

2015-06-11 18:40:58 ERROR juju.provider.common bootstrap.go:122 bootstrap failed: cannot start bootstrap instance: gomaasapi: got error back from server: 500 INTERNAL SERVER ERROR ('MAC' object has no attribute 'encode')
2015-06-11 18:40:58 INFO juju.cmd cmd.go:113 Bootstrap failed, destroying environment
2015-06-11 18:40:58 INFO juju.provider.common destroy.go:15 destroying environment "maas"
2015-06-11 18:41:02 ERROR juju.cmd supercommand.go:323 cannot start bootstrap instance: gomaasapi: got error back from server: 500 INTERNAL SERVER ERROR ('MAC' object has no attribute 'encode')

I'm looking into this...

[Raphaël Badin (rvb)]

> Note: CI failed with the following errors:
>
> 2015-06-11 18:40:58 ERROR juju.provider.common bootstrap.go:122 bootstrap
> failed: cannot start bootstrap instance: gomaasapi: got error back from
> server: 500 INTERNAL SERVER ERROR ('MAC' object has no attribute 'encode')
> 2015-06-11 18:40:58 INFO juju.cmd cmd.go:113 Bootstrap failed, destroying
> environment
> 2015-06-11 18:40:58 INFO juju.provider.common destroy.go:15 destroying
> environment "maas"
> 2015-06-11 18:41:02 ERROR juju.cmd supercommand.go:323 cannot start bootstrap
> instance: gomaasapi: got error back from server: 500 INTERNAL SERVER ERROR
> ('MAC' object has no attribute 'encode')
>
> I'm looking into this...

I found the problem: CreateHostMaps expects its 'mac_address' parameter(s)to be something that can be converted into unicode (see CreateHostMaps's signature in ps/rpc/cluster.py). But here you're passing the raw MAC (maasserver/fields.py) object instead of passing the mac address as a string. That is because you removed the code http://paste.ubuntu.com/11700836/. I assume the same problem will happen for the IP address.

[Gavin Panella (allenap)]

No objections, but I don't understand what the problem was and how this improves the situation. Some background please :)

review: Needs Information

[Raphaël Badin (rvb)]

@Gavin: have a look at the related bug for some context. But in a nutshell this is trying to reduce some code duplication that was added at the end of last cycle. The code in question is the code that does: claim_ip/update host map. It's duplicated in a couple of places, we've got a bunch of slightly different code that does very similar things at different levels in the tree (similar code in the API and in the model). This code will be changed when we move to the networking model and this is an attempt at rationalizing it before we even have to change it.

[Raphaël Badin (rvb)]

@Mike: you missed the create() method in websockets/handlers/device.py. It needs refactoring as well. There is even a mention of the bug you're fixing in that code. If applying your refactoring there improves this code, this is definitely proof that this change is all for the better.

[Gavin Panella (allenap)]

I don't much like the update_host_maps boolean flag, but it's okay; if we figure out a better way it'll be easy to change.

review: Approve

[Mike Pontillo (mpontillo)]

@Gavin, yes, I don't like it either, but I think it's a step in the right direction. There are a couple of places where we need it still; specifically where we combine the use of this function with "commit_within_atomic_block()" and try to make (for example) the creation of an IP address + reservation "atomic" (manually).

Another thing I noticed is, this code would be much easier to refactor if we didn't import *specific functions* so much. If we call via indirection (i.e. import maasserver.dhcp, dhcp.update_host_maps) it would have made it orders of magnitude easier to update all these tests. (and update them again in the future.)

[Mike Pontillo (mpontillo)]

I think this is ready to land, but I'm doing some final testing first.

I've changed the way the mocks are done for most of the affected tests; rather than using string constants, I've added a way to "self.patch()" using just a symbol. This requires importing a module instead of a function, but I think it's worth it. (When I first joined the MAAS team, the way mocks were used really violated the principle of least surprise for me... and the alternatives don't seem DRY-compliant.)

[Mike Pontillo (mpontillo)]

This version didn't pass CI. I think I missed a spot where I need to do MAC(...) instead of assuming it's the proper type. (and not, say, unicode). Line 716 in the current diff:

ip_mapping = [(static_ip.ip, self.mac_address.get_raw())]

[MAAS Lander (maas-lander)]

The attempt to merge lp:~mpontillo/maas/update-host-maps-cleanup-bug-1440102 into lp:maas failed. Below is the output from the failed tests.

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

[Mike Pontillo (mpontillo)]

The failure was in:

provisioningserver.rpc.tests.test_clusterservice.TestClusterProtocol_PowerQuery.test_returns_power_state

This seems to be a flaky test case. It fails for me about ~10-20% of the time.

=== modified file 'src/maasserver/api/devices.py'
--- src/maasserver/api/devices.py	2015-04-23 17:15:45 +0000
+++ src/maasserver/api/devices.py	2015-06-15 08:11:13 +0000
@@ -21,7 +21,6 @@
     OperationsHandler,
 )
 from maasserver.api.utils import get_optional_list
-from maasserver.dns.config import dns_update_zones
 from maasserver.enum import (
     IPADDRESS_TYPE,
     NODE_PERMISSION,
@@ -37,10 +36,7 @@
     DeviceWithMACsForm,
     ReleaseIPForm,
 )
-from maasserver.models import (
-    MACAddress,
-    NodeGroup,
-)
+from maasserver.models import MACAddress
 from maasserver.models.node import Device
 from piston.utils import rc
 
@@ -185,27 +181,12 @@
             if requested_address is None:
                 sticky_ips = mac_address.claim_static_ips(
                     alloc_type=IPADDRESS_TYPE.STICKY,
-                    requested_address=requested_address)
-                claims = [
-                    (static_ip.ip, mac_address.mac_address.get_raw())
-                    for static_ip in sticky_ips]
-                device.update_host_maps(claims)
+                    requested_address=requested_address, update_host_maps=True)
             else:
                 sticky_ip = mac_address.set_static_ip(
-                    requested_address, request.user)
+                    requested_address, request.user, update_host_maps=True)
                 sticky_ips = [sticky_ip]
-                dhcp_managed_clusters = [
-                    cluster
-                    for cluster in NodeGroup.objects.all()
-                    if cluster.manages_dhcp()
-                ]
-                device.update_host_maps(
-                    [(sticky_ip.ip, mac_address.mac_address.get_raw())],
-                    dhcp_managed_clusters)
-            # Use the master cluster DNS zone for devices.
-            # This is a temporary measure until we support setting a specific
-            # zone for each MAC.
-            dns_update_zones([NodeGroup.objects.ensure_master()])
+
             maaslog.info(
                 "%s: Sticky IP address(es) allocated: %s", device.hostname,
                 ', '.join(allocation.ip for allocation in sticky_ips))
 
=== modified file 'src/maasserver/api/ip_addresses.py'
--- src/maasserver/api/ip_addresses.py	2015-06-10 11:20:09 +0000
+++ src/maasserver/api/ip_addresses.py	2015-06-15 08:11:13 +0000
@@ -26,10 +26,7 @@
     get_mandatory_param,
     get_optional_param,
 )
-from maasserver.clusterrpc.dhcp import (
-    remove_host_maps,
-    update_host_maps,
-)
+from maasserver.clusterrpc import dhcp
 from maasserver.enum import IPADDRESS_TYPE
 from maasserver.exceptions import (
     MAASAPIBadRequest,
@@ -89,6 +86,8 @@
                 alloc_type=IPADDRESS_TYPE.USER_RESERVED,
                 requested_address=requested_address,
                 user=user, hostname=hostname)
+            from maasserver.dns import config as dns_config
+            dns_config.dns_update_zones([interface.nodegroup])
             maaslog.info("User %s was allocated IP %s", user.username, sip.ip)
         else:
             # The user has requested a static IP linked to a MAC
@@ -116,10 +115,11 @@
                     sip.ip: mac_address.mac_address,
                 }
             }
+
             # Commit the DB changes before we do RPC calls.
             commit_within_atomic_block()
             update_host_maps_failures = list(
-                update_host_maps(host_map_updates))
+                dhcp.update_host_maps(host_map_updates))
             if len(update_host_maps_failures) > 0:
                 # Deallocate the static IPs and delete the MAC address
                 # if it doesn't have a Node attached.
@@ -130,6 +130,7 @@
 
                 # There will only ever be one error, so raise that.
                 raise update_host_maps_failures[0].value
+
             maaslog.info(
                 "User %s was allocated IP %s for MAC address %s",
                 user.username, sip.ip, mac_address.mac_address)
@@ -201,9 +202,6 @@
             request.user, ngi, requested_address, mac_address,
             hostname=hostname)
 
-        from maasserver.dns.config import dns_update_zones
-        dns_update_zones([ngi.nodegroup])
-
         return sip
 
     @operation(idempotent=False)
@@ -235,7 +233,7 @@
             for interface in linked_mac_address_interfaces
             }
         remove_host_maps_failures = list(
-            remove_host_maps(host_maps_to_remove))
+            dhcp.remove_host_maps(host_maps_to_remove))
         if len(remove_host_maps_failures) > 0:
             # There's only going to be one failure, so raise that.
             raise remove_host_maps_failures[0].value
 
=== modified file 'src/maasserver/api/nodes.py'
--- src/maasserver/api/nodes.py	2015-05-28 09:38:40 +0000
+++ src/maasserver/api/nodes.py	2015-06-15 08:11:13 +0000
@@ -40,7 +40,6 @@
     get_optional_param,
 )
 from maasserver.clusterrpc.power_parameters import get_power_types
-from maasserver.dns.config import dns_update_zones
 from maasserver.enum import (
     IPADDRESS_TYPE,
     NODE_PERMISSION,
@@ -549,12 +548,7 @@
 
         sticky_ips = mac_address.claim_static_ips(
             alloc_type=IPADDRESS_TYPE.STICKY,
-            requested_address=requested_address)
-        claims = [
-            (static_ip.ip, mac_address.mac_address.get_raw())
-            for static_ip in sticky_ips]
-        node.update_host_maps(claims)
-        dns_update_zones([node.nodegroup])
+            requested_address=requested_address, update_host_maps=True)
         maaslog.info(
             "%s: Sticky IP address(es) allocated: %s", node.hostname,
             ', '.join(allocation.ip for allocation in sticky_ips))
 
=== modified file 'src/maasserver/api/tests/test_devices.py'
--- src/maasserver/api/tests/test_devices.py	2015-05-16 06:21:20 +0000
+++ src/maasserver/api/tests/test_devices.py	2015-06-15 08:11:13 +0000
@@ -21,7 +21,7 @@
 
 from django.core.urlresolvers import reverse
 from django.db import transaction
-from maasserver.api import devices as api_devices
+from maasserver.dns import config as dns_config
 from maasserver.enum import (
     IPADDRESS_TYPE,
     NODE_STATUS,
@@ -281,7 +281,7 @@
             installable=False, parent=parent, mac=True, disable_ipv4=False,
             owner=self.logged_in_user)
         # Silence 'update_host_maps'.
-        self.patch(node_module, "update_host_maps")
+        self.patch(Node.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)
@@ -299,8 +299,8 @@
         device = factory.make_Node(
             installable=False, parent=parent, mac=True, disable_ipv4=False,
             owner=self.logged_in_user, nodegroup=parent.nodegroup)
-        dns_update_zones = self.patch(api_devices, 'dns_update_zones')
-        update_host_maps = self.patch(node_module, "update_host_maps")
+        dns_update_zones = self.patch(dns_config.dns_update_zones)
+        update_host_maps = self.patch(Node.update_host_maps)
         update_host_maps.return_value = []  # No failures.
         response = self.client.post(
             get_device_uri(device), {'op': 'claim_sticky_ip_address'})
@@ -327,7 +327,7 @@
         device = factory.make_Node(
             installable=False, parent=parent, mac=True, disable_ipv4=False,
             owner=factory.make_User())
-        self.patch(node_module, "update_host_maps")
+        self.patch(Node.update_host_maps)
         response = self.client.post(
             get_device_uri(device), {'op': 'claim_sticky_ip_address'})
         self.assertEqual(httplib.FORBIDDEN, response.status_code)
@@ -339,7 +339,7 @@
             installable=False, mac=True, disable_ipv4=False,
             owner=self.logged_in_user)
         # Silence 'update_host_maps'.
-        self.patch(node_module, "update_host_maps")
+        self.patch(Node.update_host_maps)
         response = self.client.post(
             get_device_uri(device),
             {
@@ -364,7 +364,7 @@
             owner=self.logged_in_user)
         second_mac = factory.make_MACAddress(node=device)
         # Silence 'update_host_maps'.
-        self.patch(node_module, "update_host_maps")
+        self.patch(Node.update_host_maps)
         response = self.client.post(
             get_device_uri(device),
             {
@@ -383,6 +383,8 @@
         self.assertItemsEqual([second_mac], given_ip.macaddress_set.all())
 
     def test_creates_host_DHCP_and_DNS_mappings_with_given_ip(self):
+        dns_update_zones = self.patch(dns_config.dns_update_zones)
+        update_host_maps = self.patch(Node.update_host_maps)
         # Create a nodegroup for which we manage DHCP.
         factory.make_NodeGroup(
             status=NODEGROUP_STATUS.ENABLED,
@@ -394,8 +396,6 @@
         device = factory.make_Node(
             installable=False, mac=True, disable_ipv4=False,
             owner=self.logged_in_user)
-        dns_update_zones = self.patch(api_devices, 'dns_update_zones')
-        update_host_maps = self.patch(node_module, "update_host_maps")
         update_host_maps.return_value = []  # No failures.
         requested_address = factory.make_ip_address()
         response = self.client.post(
@@ -473,7 +473,7 @@
             installable=False, mac=True, disable_ipv4=False,
             owner=self.logged_in_user)
         # Silence 'update_host_maps'.
-        self.patch(node_module, "update_host_maps")
+        self.patch(Node.update_host_maps)
         response = self.client.post(
             get_device_uri(device),
             {
@@ -494,8 +494,8 @@
             installable=False, parent=parent, mac=True, disable_ipv4=False,
             owner=self.logged_in_user)
         # Silence 'update_host_maps' and 'remove_host_maps'
-        self.patch(node_module, "update_host_maps")
-        self.patch(node_module, "remove_host_maps")
+        self.patch(Node.update_host_maps)
+        self.patch(node_module, node_module.remove_host_maps.__name__)
         response = self.client.post(
             get_device_uri(device), {'op': 'claim_sticky_ip_address'})
         self.assertEqual(httplib.OK, response.status_code, response.content)
@@ -549,8 +549,8 @@
             installable=False, mac_count=5, network=network,
             disable_ipv4=False, owner=self.logged_in_user)
         # Silence 'update_host_maps' and 'remove_host_maps'
-        self.patch(node_module, "update_host_maps")
-        self.patch(node_module, "remove_host_maps")
+        self.patch(Node.update_host_maps)
+        self.patch(node_module, node_module.remove_host_maps.__name__)
         self.assertThat(MACAddress.objects.all(), HasLength(5))
         for mac in MACAddress.objects.all():
             with transaction.atomic():
@@ -569,8 +569,8 @@
             installable=False, mac_count=2, network=network,
             disable_ipv4=False, owner=self.logged_in_user)
         # Silence 'update_host_maps' and 'remove_host_maps'
-        self.patch(node_module, "update_host_maps")
-        self.patch(node_module, "remove_host_maps")
+        self.patch(Node.update_host_maps)
+        self.patch(node_module, node_module.remove_host_maps.__name__)
         self.assertThat(MACAddress.objects.all(), HasLength(2))
         ips = []
         for mac in MACAddress.objects.all():
@@ -596,7 +596,7 @@
             installable=False, parent=parent, mac=True, disable_ipv4=False,
             owner=factory.make_User())
         # Silence 'update_host_maps' and 'remove_host_maps'
-        self.patch(node_module, "update_host_maps")
+        self.patch(Node.update_host_maps)
         self.patch(node_module, "remove_host_maps")
         with transaction.atomic():
             device.claim_static_ip_addresses(alloc_type=IPADDRESS_TYPE.STICKY)
 
=== modified file 'src/maasserver/api/tests/test_ipaddresses.py'
--- src/maasserver/api/tests/test_ipaddresses.py	2015-05-16 06:21:20 +0000
+++ src/maasserver/api/tests/test_ipaddresses.py	2015-06-15 08:11:13 +0000
@@ -18,7 +18,7 @@
 import json
 
 from django.core.urlresolvers import reverse
-from maasserver.api import ip_addresses as ip_addresses_module
+from maasserver.clusterrpc import dhcp as dhcp_module
 from maasserver.dns import config as dns_config_module
 from maasserver.enum import (
     IPADDRESS_TYPE,
@@ -104,7 +104,7 @@
         self.assertEqual(self.logged_in_user, staticipaddress.user)
 
     def test_POST_reserve_with_MAC_links_MAC_to_ip_address(self):
-        update_host_maps = self.patch(ip_addresses_module, 'update_host_maps')
+        update_host_maps = self.patch(dhcp_module, 'update_host_maps')
         interface = self.make_interface()
         net = interface.network
         mac = factory.make_mac_address()
@@ -124,7 +124,7 @@
                 {interface.nodegroup: {returned_address['ip']: mac}}))
 
     def test_POST_reserve_with_MAC_returns_503_if_hostmap_update_fails(self):
-        update_host_maps = self.patch(ip_addresses_module, 'update_host_maps')
+        update_host_maps = self.patch(dhcp_module, 'update_host_maps')
         # We a specific exception here because update_host_maps() will
         # fail with RPC-specific errors.
         update_host_maps.return_value = [
@@ -149,7 +149,7 @@
     def test_POST_returns_CONFLICT_when_static_ip_for_MAC_already_exists(self):
         interface = self.make_interface()
         mac = factory.make_MACAddress(cluster_interface=interface)
-        mac.claim_static_ips()
+        mac.claim_static_ips(update_host_maps=False)
         net = interface.network
 
         response = self.post_reservation_request(net=net, mac=mac.mac_address)
@@ -161,7 +161,7 @@
             Equals(1))
 
     def test_POST_allows_claiming_of_new_static_ips_for_existing_MAC(self):
-        self.patch(ip_addresses_module, 'update_host_maps')
+        self.patch(dhcp_module, 'update_host_maps')
 
         interface = self.make_interface()
         net = interface.network
@@ -363,36 +363,40 @@
         self.assertIsNone(reload_object(ipaddress))
 
     def test_POST_release_deletes_floating_MAC_address(self):
-        self.patch(ip_addresses_module, 'remove_host_maps')
+        self.patch(dhcp_module, dhcp_module.remove_host_maps.__name__)
 
         interface = self.make_interface()
         floating_mac = factory.make_MACAddress(cluster_interface=interface)
         [ipaddress] = floating_mac.claim_static_ips(
-            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user)
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user,
+            update_host_maps=False)
 
         self.post_release_request(ipaddress.ip)
         self.assertIsNone(reload_object(floating_mac))
 
     def test_POST_release_does_not_delete_MACs_linked_to_nodes(self):
-        self.patch(ip_addresses_module, 'remove_host_maps')
+        self.patch(dhcp_module, dhcp_module.remove_host_maps.__name__)
 
         interface = self.make_interface()
         node = factory.make_Node(nodegroup=interface.nodegroup)
         attached_mac = factory.make_MACAddress(
             node=node, cluster_interface=interface)
         [ipaddress] = attached_mac.claim_static_ips(
-            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user)
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user,
+            update_host_maps=False)
 
         self.post_release_request(ipaddress.ip)
         self.assertEqual(attached_mac, reload_object(attached_mac))
 
     def test_POST_release_updates_DNS_and_DHCP(self):
-        remove_host_maps = self.patch(ip_addresses_module, 'remove_host_maps')
+        remove_host_maps = self.patch(
+            dhcp_module, dhcp_module.remove_host_maps.__name__)
 
         interface = self.make_interface()
         floating_mac = factory.make_MACAddress(cluster_interface=interface)
         [ipaddress] = floating_mac.claim_static_ips(
-            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user)
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user,
+            update_host_maps=False)
 
         self.post_release_request(ipaddress.ip)
         self.expectThat(
@@ -400,7 +404,8 @@
                 {interface.nodegroup: [ipaddress.ip]}))
 
     def test_POST_release_raises_503_if_removing_host_maps_errors(self):
-        remove_host_maps = self.patch(ip_addresses_module, 'remove_host_maps')
+        remove_host_maps = self.patch(
+            dhcp_module, dhcp_module.remove_host_maps.__name__)
         # Failures in remove_host_maps() will be RPC-related exceptions,
         # so we use one of those explicitly.
         remove_host_maps.return_value = [
@@ -412,7 +417,8 @@
         interface = self.make_interface()
         floating_mac = factory.make_MACAddress(cluster_interface=interface)
         [ipaddress] = floating_mac.claim_static_ips(
-            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user)
+            alloc_type=IPADDRESS_TYPE.USER_RESERVED, user=self.logged_in_user,
+            update_host_maps=False)
 
         response = self.post_release_request(ipaddress.ip)
         self.expectThat(
 
=== modified file 'src/maasserver/api/tests/test_node.py'
--- src/maasserver/api/tests/test_node.py	2015-05-28 13:26:45 +0000
+++ src/maasserver/api/tests/test_node.py	2015-06-15 08:11:13 +0000
@@ -24,7 +24,7 @@
 from django.core.urlresolvers import reverse
 from django.db import transaction
 from maasserver import forms
-from maasserver.api import nodes as api_nodes
+from maasserver.dns import config as dns_config
 from maasserver.enum import (
     IPADDRESS_TYPE,
     NODE_BOOT,
@@ -1195,9 +1195,9 @@
         self.become_admin()
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
         # Silence 'update_host_maps'.
-        self.patch(node_module, "update_host_maps")
+        self.patch(Node.update_host_maps)
         [existing_ip] = node.get_primary_mac().claim_static_ips(
-            alloc_type=IPADDRESS_TYPE.STICKY)
+            alloc_type=IPADDRESS_TYPE.STICKY, update_host_maps=False)
         response = self.client.post(
             self.get_node_uri(node), {'op': 'claim_sticky_ip_address'})
         self.assertEqual(httplib.OK, response.status_code, response.content)
@@ -1214,7 +1214,8 @@
         random_alloc_type = factory.pick_enum(
             IPADDRESS_TYPE,
             but_not=[IPADDRESS_TYPE.STICKY, IPADDRESS_TYPE.USER_RESERVED])
-        node.get_primary_mac().claim_static_ips(alloc_type=random_alloc_type)
+        node.get_primary_mac().claim_static_ips(
+            alloc_type=random_alloc_type, update_host_maps=False)
         response = self.client.post(
             self.get_node_uri(node), {'op': 'claim_sticky_ip_address'})
         self.assertEqual(
@@ -1265,7 +1266,7 @@
     def test_claim_ip_address_creates_host_DHCP_and_DNS_mappings(self):
         self.become_admin()
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
-        dns_update_zones = self.patch(api_nodes, 'dns_update_zones')
+        dns_update_zones = self.patch(dns_config.dns_update_zones)
         update_host_maps = self.patch(node_module, "update_host_maps")
         update_host_maps.return_value = []  # No failures.
         response = self.client.post(
@@ -1371,7 +1372,7 @@
         requested_address = IPAddress(ngi.static_ip_range_low) + 1
         requested_address = requested_address.format()
         other_node.get_primary_mac().claim_static_ips(
-            requested_address=requested_address)
+            requested_address=requested_address, update_host_maps=False)
 
         # Use the API to try to duplicate the same IP on the other node.
         response = self.client.post(
 
=== modified file 'src/maasserver/models/macaddress.py'
--- src/maasserver/models/macaddress.py	2015-05-13 11:33:20 +0000
+++ src/maasserver/models/macaddress.py	2015-06-15 08:11:13 +0000
@@ -43,6 +43,7 @@
 from maasserver.models.macipaddresslink import MACStaticIPAddressLink
 from maasserver.models.managers import BulkManager
 from maasserver.models.network import Network
+from maasserver.models.nodegroup import NodeGroup
 from maasserver.models.nodegroupinterface import NodeGroupInterface
 from maasserver.models.staticipaddress import StaticIPAddress
 from maasserver.models.timestampedmodel import TimestampedModel
@@ -267,24 +268,48 @@
                 return self.node.parent.get_pxe_mac().cluster_interface
         return None
 
-    def claim_static_ips(self, alloc_type=IPADDRESS_TYPE.AUTO,
-                         requested_address=None, user=None):
+    def _get_attached_clusters_with_static_ranges(self):
+        """Returns a list of cluster interfaces attached to this MAC address,
+        where each cluster interface has a defined static range.
+        """
+        return [
+            interface
+            for interface in self.get_cluster_interfaces()
+            if interface.get_static_ip_range()
+            ]
+
+    def _get_hostname_log_prefix(self):
+        """Returns a string that represents the hostname for this MAC address,
+        suitable for prepending to a log statement.
+        """
+        if self.node is not None:
+            hostname_string = "%s: " % self.node.hostname
+        else:
+            hostname_string = ""
+        return hostname_string
+
+    def claim_static_ips(
+            self, alloc_type=IPADDRESS_TYPE.AUTO, requested_address=None,
+            fabric=None, user=None, update_host_maps=True):
         """Assign static IP addresses to this MAC.
 
         Allocates one address per managed cluster interface connected to this
-        MAC.  Typically this will be either just one IPv4 address, or an IPv4
+        MAC. Typically this will be either just one IPv4 address, or an IPv4
         address and an IPv6 address.
+        Calls update_host_maps() on the related Node in order to update
 
-        It is the caller's responsibility to update the DHCP server.
+        any DHCP mappings.
 
         :param alloc_type: See :class:`StaticIPAddress`.alloc_type.
             This parameter musn't be IPADDRESS_TYPE.USER_RESERVED.
         :param requested_address: Optional IP address to claim.  Must be in
             the range defined on some cluster interface to which this
-            MACAddress is related.  If given, no allocations will be made on
+            MACAddress is related. If given, no allocations will be made on
             any other cluster interfaces the MAC may be connected to.
         :param user: Optional User who will be given ownership of any
             `StaticIPAddress`es claimed.
+        :param update_host_maps: If True, will update any relevant DHCP
+            mappings in addition to allocating the address.
         :return: A list of :class:`StaticIPAddress`.  Returns empty if
             the cluster_interface is not yet known, or the
             static_ip_range_low/high values values are not set on the
@@ -297,7 +322,12 @@
             the cluster interface's defined range.
         :raises: StaticIPAddressUnavailable if the requested_address is already
             allocated.
+        :raises: StaticIPAddressForbidden if the address occurs within
+            an existing dynamic range within the specified fabric.
         """
+        if fabric is not None:
+            raise NotImplementedError("Fabrics are not yet supported.")
+
         # This method depends on a database isolation level of SERIALIZABLE
         # (or perhaps REPEATABLE READ) to avoid race conditions.
 
@@ -307,19 +337,12 @@
         # different representations for "none" values in IP addresses.
         if self.get_cluster_interface() is None:
             # No known cluster interface.  Nothing we can do.
-            if self.node is not None:
-                hostname_string = "%s: " % self.node.hostname
-            else:
-                hostname_string = ""
+            hostname_string = self._get_hostname_log_prefix()
             maaslog.error(
-                "%s tried to allocate an IP to MAC %s but its cluster "
+                "%sTried to allocate an IP to MAC %s, but its cluster "
                 "interface is not known", hostname_string, self)
             return []
-        cluster_interfaces = [
-            interface
-            for interface in self.get_cluster_interfaces()
-            if interface.get_static_ip_range()
-            ]
+        cluster_interfaces = self._get_attached_clusters_with_static_ranges()
         if len(cluster_interfaces) == 0:
             # There were cluster interfaces, but none of them had a static
             # range.  Can't allocate anything.
@@ -328,6 +351,10 @@
         if requested_address is not None:
             # A specific IP address was requested.  We restrict our attention
             # to the cluster interface that is responsible for that address.
+            # In addition, claiming addresses inside a dynamic range on the
+            # requested fabric is not allowed.
+            self._raise_if_address_inside_dynamic_range(
+                requested_address, fabric)
             cluster_interface = find_cluster_interface_responsible_for_ip(
                 cluster_interfaces, IPAddress(requested_address))
             if cluster_interface is None:
@@ -338,25 +365,34 @@
 
         allocations = self._map_allocated_addresses(cluster_interfaces)
 
-        if None not in allocations.values():
-            # We already have a full complement of static IP addresses
-            # allocated.  Check for a clash.
-            types = [sip.alloc_type for sip in allocations.values()]
-            if alloc_type not in types:
-                # None of the prior allocations are for the same type that's
-                # being requested now.  This is a complete clash.
-                raise StaticIPAddressTypeClash(
-                    "MAC address %s already has IP adresses of different "
-                    "types than the ones requested." % self)
+        # Check if we already have a full complement of static IP addresses
+        # allocated, none of which are the same type.
+        if (None not in allocations.values() and alloc_type not in
+                [a.alloc_type for a in allocations.values()]):
+            raise StaticIPAddressTypeClash(
+                "MAC address %s already has IP addresses of different "
+                "types than the ones requested." % self)
 
+        new_allocations = []
         # Allocate IP addresses on all relevant cluster interfaces where this
         # MAC does not have any address allocated yet.
         for interface in cluster_interfaces:
             if allocations[interface] is None:
-                # No IP address yet on this cluster interface.  Get one.
-                allocations[interface] = self._allocate_static_address(
+                # No IP address yet on this cluster interface. Get one.
+                static_ip = self._allocate_static_address(
                     interface, alloc_type, requested_address, user=user)
+                allocations[interface] = static_ip
+                mac_address = MAC(self.mac_address)
+                new_allocations.append(
+                    (static_ip.ip, mac_address.get_raw()))
 
+        # Note: the previous behavior of the product (MAAS < 1.8) was to
+        # update host maps with *every* address, not just changed addresses.
+        # This should only impact separately-claimed IPv6 and IPv4 addresses.
+        if update_host_maps:
+            if self.node is not None:
+                self.node.update_host_maps(new_allocations)
+            self.update_related_dns_zones()
         # We now have a static IP allocated to each of our cluster interfaces.
         # Ignore the clashes.  Return the ones that have the right type: those
         # are either matching pre-existing allocations or fresh ones.
@@ -366,14 +402,69 @@
             if sip.alloc_type == alloc_type
             ]
 
-    def set_static_ip(self, requested_address, user):
+    def _get_device_cluster_or_default(self):
+        """Returns a cluster interface for this MAC, first by checking for a
+        direct link, then by checking the parent node,
+        (via get_cluster_interface()) and finally by getting the default,
+        if all else fails.
+        """
+        cluster_interface = self.get_cluster_interface()
+        if cluster_interface is not None:
+            return cluster_interface.nodegroup
+        else:
+            return NodeGroup.objects.ensure_master()
+
+    def update_related_dns_zones(self):
+        """Updates DNS for the cluster related to this MAC."""
+        # Prevent circular imports
+        from maasserver.dns import config as dns_config
+        dns_config.dns_update_zones([self._get_device_cluster_or_default()])
+
+    def _raise_if_address_inside_dynamic_range(
+            self, requested_address, fabric=None):
+        """
+        Checks if the specified IP address, inside the specified fabric,
+        is inside a MAAS-managed dynamic range.
+
+        :raises: StaticIPAddressForbidden if the address occurs within
+            an existing dynamic range within the specified fabric.
+        """
+        if fabric is not None:
+            raise NotImplementedError("Fabrics are not yet supported.")
+
+        requested_address_ip = IPAddress(requested_address)
+        for interface in NodeGroupInterface.objects.all():
+            if interface.is_managed:
+                dynamic_range = interface.get_dynamic_ip_range()
+                if requested_address_ip in dynamic_range:
+                    raise StaticIPAddressForbidden(
+                        "Requested IP address %s is in a dynamic range." %
+                        requested_address)
+
+    def _get_dhcp_managed_clusters(self, fabric=None):
+        """Returns the DHCP-managed clusters relevant to the specified fabric.
+
+        :param fabric: The fabric whose DHCP-managed clusters to update.
+        """
+        if fabric is not None:
+            raise NotImplementedError("Fabrics are not yet supported.")
+
+        return [
+            cluster
+            for cluster in NodeGroup.objects.all()
+            if cluster.manages_dhcp()
+            ]
+
+    def set_static_ip(
+            self, requested_address, user, fabric=None, update_host_maps=True):
         """Assign a static (sticky) IP address to this MAC.
 
         This is meant to be called on a device's MAC address: the IP address
-        can be anything.  Only if the MAC is linked to a network will this
+        can be anything. Only if the MAC is linked to a network will this
         method enforce that the IP address if part of the referenced network.
 
-        It is the caller's responsibility to update the DHCP server.
+        Calls update_host_maps() on the related Node in order to update
+        any DHCP mappings.
 
         :param requested_address: IP address to claim.  Must not be in
             the dynamic range of any cluster interface.
@@ -390,6 +481,9 @@
         :raises: StaticIPAddressUnavailable if the requested_address is already
             allocated.
         """
+        if fabric is not None:
+            raise NotImplementedError("Fabrics are not yet supported.")
+
         # If this MAC is linked to a cluster interface, make sure the
         # requested_address is part of the cluster interface's network.
         cluster_interface = self.get_cluster_interface()
@@ -402,14 +496,7 @@
 
         # Raise a StaticIPAddressForbidden exception if the requested_address
         # is in a dynamic range.
-        requested_address_ip = IPAddress(requested_address)
-        for interface in NodeGroupInterface.objects.all():
-            if interface.is_managed:
-                dynamic_range = interface.get_dynamic_ip_range()
-                if requested_address_ip in dynamic_range:
-                    raise StaticIPAddressForbidden(
-                        "Requested IP address %s is in a dynamic range." %
-                        requested_address)
+        self._raise_if_address_inside_dynamic_range(requested_address, fabric)
 
         # Allocate IP if it isn't allocated already.
         static_ip, created = StaticIPAddress.objects.get_or_create(
@@ -434,4 +521,20 @@
                     "Requested IP address %s is already allocated "
                     "to a different MAC address." %
                     requested_address)
+
+        if update_host_maps:
+            # XXX:fabric We need to restrict this to cluster interfaces in the
+            # appropriate fabric!
+            if cluster_interface is not None:
+                relevant_clusters = [cluster_interface.nodegroup]
+            else:
+                relevant_clusters = self._get_dhcp_managed_clusters(fabric)
+
+            mac_address = MAC(self.mac_address)
+            ip_mapping = [(static_ip.ip, mac_address.get_raw())]
+
+            self.node.update_host_maps(
+                ip_mapping, nodegroups=relevant_clusters)
+            self.update_related_dns_zones()
+
         return static_ip
 
=== modified file 'src/maasserver/models/macipaddresslink.py'
--- src/maasserver/models/macipaddresslink.py	2015-05-07 18:14:38 +0000
+++ src/maasserver/models/macipaddresslink.py	2015-06-15 08:11:13 +0000
@@ -33,6 +33,8 @@
 
 class MACStaticIPAddressLink(CleanSave, TimestampedModel):
 
+    # XXX:fabric IP addresses are unique within each fabric, so this
+    # code needs to be updated.
     class Meta(DefaultMeta):
         unique_together = ('ip_address', 'mac_address')
 
 
=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2015-05-22 15:03:29 +0000
+++ src/maasserver/models/node.py	2015-06-15 08:11:13 +0000
@@ -1742,7 +1742,7 @@
 
     def claim_static_ip_addresses(
             self, mac=None, alloc_type=IPADDRESS_TYPE.AUTO,
-            requested_address=None):
+            requested_address=None, update_host_maps=True):
         """Assign static IPs to a node's MAC.
         If no MAC is specified, defaults to its PXE MAC.
 
@@ -1759,7 +1759,6 @@
         :raises: `StaticIPAddressUnavailable` if the supplied
         requested_address is already in use.
         """
-
         if mac is None:
             mac = self.get_pxe_mac()
             if mac is None:
@@ -1767,7 +1766,8 @@
 
         try:
             static_ips = mac.claim_static_ips(
-                alloc_type=alloc_type, requested_address=requested_address)
+                alloc_type=alloc_type, requested_address=requested_address,
+                update_host_maps=update_host_maps)
         except StaticIPAddressTypeClash:
             # There's already a non-AUTO IP.
             return []
@@ -1776,31 +1776,49 @@
         # because it's all-or-nothing (hence the atomic context).
         return [(static_ip.ip, unicode(mac)) for static_ip in static_ips]
 
-    def update_host_maps(self, claims, nodegroups=None):
+    @staticmethod
+    def update_nodegroup_host_maps(nodegroups, claims):
         """Update host maps for the given MAC->IP mappings.
 
         If a nodegroup list is given, update all of them.  If not, only
         update the nodegroup of the node.
         """
         static_mappings = defaultdict(dict)
-        if nodegroups is None:
-            static_mappings[self.nodegroup].update(claims)
-        else:
-            for nodegroup in nodegroups:
-                static_mappings[nodegroup].update(claims)
+        for nodegroup in nodegroups:
+            static_mappings[nodegroup].update(claims)
         update_host_maps_failures = list(
             update_host_maps(static_mappings))
-        if len(update_host_maps_failures) != 0:
+        num_failures = len(update_host_maps_failures)
+        if num_failures != 0:
             # We've hit an error, so release any IPs we've claimed
             # and then raise the error for the call site to
             # handle.
-            StaticIPAddress.objects.deallocate_by_node(self)
+            # StaticIPAddress.objects.deallocate_by_node(self)
+            # StaticIPAddress.objects.deallocate_by_node()
+            for claim in claims:
+                StaticIPAddress.objects.get(ip=claim[0]).deallocate()
+
             # We know there's only one error because we only
             # sent one mapping to update_host_maps(), so we
             # extract the exception from the Failure and raise
             # it.
             raise update_host_maps_failures[0].raiseException()
 
+    def update_host_maps(self, claims, nodegroups=None):
+        """Update host maps for the given MAC->IP mappings.
+
+        If a nodegroup list is given, update all of them.  If not, only
+        update the nodegroup of the node.
+        """
+
+        # For some reason, we can call this method on a Node, but the intent
+        # is to update nodegroups not on this node. That's why it's not
+        # an "append" here.
+        if nodegroups is None:
+            nodegroups = [self.nodegroup]
+
+        self.update_nodegroup_host_maps(nodegroups, claims)
+
     def deallocate_static_ip_addresses(
             self, alloc_type=IPADDRESS_TYPE.AUTO, ip=None):
         """Release the `StaticIPAddress` that is assigned to this node and
@@ -1813,9 +1831,10 @@
             self, alloc_type=alloc_type, ip=ip)
 
         if len(deallocated_ips) > 0:
+            # Prevent circular imports
+            from maasserver.dns import config as dns_config
             self.delete_host_maps(deallocated_ips)
-            from maasserver.dns.config import dns_update_zones
-            dns_update_zones([self.nodegroup])
+            dns_config.dns_update_zones([self.nodegroup])
 
         return deallocated_ips
 
@@ -1916,7 +1935,7 @@
         return False
 
     @transactional
-    def start(self, by_user, user_data=None):
+    def start(self, by_user, user_data=None, update_host_maps=True):
         """Request on given user's behalf that the node be started up.
 
         :param by_user: Requesting user.
@@ -1927,7 +1946,7 @@
         :type user_data: unicode
 
         :raise StaticIPAddressExhaustion: if there are not enough IP addresses
-            left in the static range for this node toget all the addresses it
+            left in the static range for this node to get all the addresses it
             needs.
         :raise PermissionDenied: If `by_user` does not have permission to
             start this node.
@@ -1941,7 +1960,6 @@
         """
         # Avoid circular imports.
         from metadataserver.models import NodeUserData
-        from maasserver.dns.config import dns_update_zones
 
         if not by_user.has_perm(NODE_PERMISSION.EDIT, self):
             # You can't start a node you don't own unless you're an admin.
@@ -1954,11 +1972,13 @@
 
         # Claim static IP addresses for the node if it's ALLOCATED.
         if self.status == NODE_STATUS.ALLOCATED:
-            claims = self.claim_static_ip_addresses()
-            # If the PXE mac is on a managed interface then we can ask
-            # the cluster to generate the DHCP host map(s).
-            if self.is_pxe_mac_on_managed_interface():
-                self.update_host_maps(claims)
+
+            # Don't update host maps if we're not on a managed interface.
+            if not self.is_pxe_mac_on_managed_interface() and update_host_maps:
+                update_host_maps = False
+
+            self.claim_static_ip_addresses(
+                update_host_maps=update_host_maps)
 
         if self.status == NODE_STATUS.ALLOCATED:
             transition_monitor = (
@@ -1969,9 +1989,6 @@
         else:
             transition_monitor = None
 
-        # Update the DNS zone with the new static IP info as necessary.
-        dns_update_zones(self.nodegroup)
-
         power_info = self.get_effective_power_info()
         if not power_info.can_be_started:
             # The node can't be powered on by MAAS, so return early.
 
=== modified file 'src/maasserver/models/signals/dns.py'
--- src/maasserver/models/signals/dns.py	2015-06-10 11:24:44 +0000
+++ src/maasserver/models/signals/dns.py	2015-06-15 08:11:13 +0000
@@ -81,8 +81,8 @@
 def dns_post_delete_Node(sender, instance, **kwargs):
     """When a Node is deleted, update the Node's zone file."""
     try:
-        from maasserver.dns.config import dns_update_zones
-        dns_update_zones(instance.nodegroup)
+        from maasserver.dns import config as dns_config
+        dns_config.dns_update_zones(instance.nodegroup)
     except NodeGroup.DoesNotExist:
         # If this Node is being deleted because the whole NodeGroup
         # has been deleted, no need to update the zone file because
@@ -92,29 +92,29 @@
 
 def dns_post_edit_hostname_Node(instance, old_values, **kwargs):
     """When a Node has been flagged, update the related zone."""
-    from maasserver.dns.config import dns_update_zones
-    dns_update_zones(instance.nodegroup)
+    from maasserver.dns import config as dns_config
+    dns_config.dns_update_zones(instance.nodegroup)
 
 
 connect_to_field_change(dns_post_edit_hostname_Node, Node, ['hostname'])
 
 
 def dns_setting_changed(sender, instance, created, **kwargs):
-    from maasserver.dns.config import dns_update_all_zones
-    dns_update_all_zones()
+    from maasserver.dns import config as dns_config
+    dns_config.dns_update_all_zones()
 
 
 @receiver(post_save, sender=Network)
 def dns_post_save_Network(sender, instance, **kwargs):
     """When a network is added/changed, put it in the DNS trusted networks."""
-    from maasserver.dns.config import dns_update_all_zones
-    dns_update_all_zones()
+    from maasserver.dns import config as dns_config
+    dns_config.dns_update_all_zones()
 
 
 @receiver(post_delete, sender=Network)
 def dns_post_delete_Network(sender, instance, **kwargs):
-    from maasserver.dns.config import dns_update_all_zones
-    dns_update_all_zones()
+    from maasserver.dns import config as dns_config
+    dns_config.dns_update_all_zones()
 
 
 Config.objects.config_changed_connect("upstream_dns", dns_setting_changed)
 
=== modified file 'src/maasserver/models/tests/test_macaddress.py'
--- src/maasserver/models/tests/test_macaddress.py	2015-05-16 06:21:20 +0000
+++ src/maasserver/models/tests/test_macaddress.py	2015-06-15 08:11:13 +0000
@@ -370,12 +370,12 @@
     def test__returns_empty_if_no_cluster_interface(self):
         # If mac.cluster_interface is None, we can't allocate any IP.
         mac = factory.make_MACAddress_with_Node()
-        self.assertEquals([], mac.claim_static_ips())
+        self.assertEquals([], mac.claim_static_ips(update_host_maps=False))
 
     def test__reserves_an_ip_address(self):
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
         mac = node.get_primary_mac()
-        [claimed_ip] = mac.claim_static_ips()
+        [claimed_ip] = mac.claim_static_ips(update_host_maps=False)
         self.assertIsInstance(claimed_ip, StaticIPAddress)
         self.assertNotEqual([], list(node.static_ip_addresses()))
         self.assertEqual(
@@ -387,7 +387,8 @@
         node = make_node_attached_to_cluster_interfaces(
             ipv4_network=ipv4_network, ipv6_network=ipv6_network)
 
-        allocation = node.get_primary_mac().claim_static_ips()
+        allocation = node.get_primary_mac().claim_static_ips(
+            update_host_maps=False)
 
         # Allocated one IPv4 address and one IPv6 address.
         self.assertThat(allocation, HasLength(2))
@@ -401,7 +402,8 @@
     def test__sets_type_as_required(self):
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
         mac = node.get_primary_mac()
-        [claimed_ip] = mac.claim_static_ips(alloc_type=IPADDRESS_TYPE.STICKY)
+        [claimed_ip] = mac.claim_static_ips(
+            alloc_type=IPADDRESS_TYPE.STICKY, update_host_maps=False)
         self.assertEqual(IPADDRESS_TYPE.STICKY, claimed_ip.alloc_type)
 
     def test__returns_empty_if_no_static_range_defined(self):
@@ -410,7 +412,7 @@
         mac.cluster_interface.static_ip_range_low = None
         mac.cluster_interface.static_ip_range_high = None
         mac.cluster_interface.save()
-        self.assertEqual([], mac.claim_static_ips())
+        self.assertEqual([], mac.claim_static_ips(update_host_maps=False))
 
     def test__returns_only_addresses_for_interfaces_with_static_ranges(self):
         ipv6_network = factory.make_ipv6_network()
@@ -423,7 +425,8 @@
         ipv6_interface.static_ip_range_high = None
         ipv6_interface.save()
 
-        allocation = node.get_primary_mac().claim_static_ips()
+        allocation = node.get_primary_mac().claim_static_ips(
+            update_host_maps=False)
         self.assertThat(allocation, HasLength(1))
         [sip] = allocation
         self.assertEqual(4, IPAddress(sip.ip).version)
@@ -432,7 +435,7 @@
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
         mac = node.get_primary_mac()
         iptype, iptype2 = pick_two_allocation_types()
-        mac.claim_static_ips(alloc_type=iptype)
+        mac.claim_static_ips(alloc_type=iptype, update_host_maps=False)
         self.assertRaises(
             StaticIPAddressTypeClash,
             mac.claim_static_ips, alloc_type=iptype2)
@@ -448,7 +451,8 @@
         iptype, iptype2 = pick_two_allocation_types()
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv4_interface.static_ip_range_low)
+            requested_address=ipv4_interface.static_ip_range_low,
+            update_host_maps=False)
 
         self.assertRaises(
             StaticIPAddressTypeClash,
@@ -467,7 +471,8 @@
         iptype, iptype2 = pick_two_allocation_types()
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv6_interface.static_ip_range_low)
+            requested_address=ipv6_interface.static_ip_range_low,
+            update_host_maps=False)
 
         self.assertRaises(
             StaticIPAddressTypeClash,
@@ -487,9 +492,11 @@
         iptype, iptype2 = pick_two_allocation_types()
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv4_interface.static_ip_range_low)
+            requested_address=ipv4_interface.static_ip_range_low,
+            update_host_maps=False)
 
-        allocation = mac.claim_static_ips(alloc_type=iptype2)
+        allocation = mac.claim_static_ips(
+            alloc_type=iptype2, update_host_maps=False)
 
         self.assertThat(allocation, HasLength(1))
         [sip] = allocation
@@ -507,9 +514,11 @@
         iptype, iptype2 = pick_two_allocation_types()
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv6_interface.static_ip_range_low)
+            requested_address=ipv6_interface.static_ip_range_low,
+            update_host_maps=False)
 
-        allocation = mac.claim_static_ips(alloc_type=iptype2)
+        allocation = mac.claim_static_ips(
+            alloc_type=iptype2, update_host_maps=False)
 
         self.assertThat(allocation, HasLength(1))
         [sip] = allocation
@@ -524,7 +533,7 @@
             ipv4_network=ipv4_network, ipv6_network=ipv6_network)
         mac = node.get_primary_mac()
         iptype, iptype2 = pick_two_allocation_types()
-        mac.claim_static_ips(alloc_type=iptype)
+        mac.claim_static_ips(alloc_type=iptype, update_host_maps=False)
 
         self.assertRaises(
             StaticIPAddressTypeClash,
@@ -542,15 +551,17 @@
         # Clashing IPv6 address:
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv6_interface.static_ip_range_low)
+            requested_address=ipv6_interface.static_ip_range_low,
+            update_host_maps=False)
         # Pre-existing, but non-clashing, IPv4 address:
         [ipv4_sip] = mac.claim_static_ips(
             alloc_type=iptype2,
-            requested_address=ipv4_interface.static_ip_range_low)
+            requested_address=ipv4_interface.static_ip_range_low,
+            update_host_maps=False)
 
         self.assertItemsEqual(
             [ipv4_sip],
-            mac.claim_static_ips(alloc_type=iptype2))
+            mac.claim_static_ips(alloc_type=iptype2, update_host_maps=False))
 
     def test__returns_existing_IPv6_if_IPv4_clashes(self):
         # If the MAC is attached to IPv4 and IPv6 cluster interfaces, there's
@@ -564,15 +575,17 @@
         # Clashing IPv4 address:
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv4_interface.static_ip_range_low)
+            requested_address=ipv4_interface.static_ip_range_low,
+            update_host_maps=False)
         # Pre-existing, but non-clashing, IPv6 address:
         [ipv6_sip] = mac.claim_static_ips(
             alloc_type=iptype2,
-            requested_address=ipv6_interface.static_ip_range_low)
+            requested_address=ipv6_interface.static_ip_range_low,
+            update_host_maps=False)
 
         self.assertItemsEqual(
             [ipv6_sip],
-            mac.claim_static_ips(alloc_type=iptype2))
+            mac.claim_static_ips(alloc_type=iptype2, update_host_maps=False))
 
     def test__ignores_clashing_IPv4_when_requesting_IPv6(self):
         node = make_node_attached_to_cluster_interfaces()
@@ -582,11 +595,13 @@
         iptype, iptype2 = pick_two_allocation_types()
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv4_interface.static_ip_range_low)
+            requested_address=ipv4_interface.static_ip_range_low,
+            update_host_maps=False)
 
         allocation = mac.claim_static_ips(
             alloc_type=iptype2,
-            requested_address=ipv6_interface.static_ip_range_low)
+            requested_address=ipv6_interface.static_ip_range_low,
+            update_host_maps=False)
 
         self.assertThat(allocation, HasLength(1))
         [ipv6_sip] = allocation
@@ -600,11 +615,13 @@
         iptype, iptype2 = pick_two_allocation_types()
         mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv6_interface.static_ip_range_low)
+            requested_address=ipv6_interface.static_ip_range_low,
+            update_host_maps=False)
 
         allocation = mac.claim_static_ips(
             alloc_type=iptype2,
-            requested_address=ipv4_interface.static_ip_range_low)
+            requested_address=ipv4_interface.static_ip_range_low,
+            update_host_maps=False)
 
         self.assertThat(allocation, HasLength(1))
         [ipv4_sip] = allocation
@@ -615,22 +632,24 @@
         mac = node.get_primary_mac()
         iptype = factory.pick_enum(
             IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED])
-        [ip] = mac.claim_static_ips(alloc_type=iptype)
+        [ip] = mac.claim_static_ips(alloc_type=iptype, update_host_maps=False)
         self.assertEqual(
-            [ip], mac.claim_static_ips(alloc_type=iptype))
+            [ip], mac.claim_static_ips(
+                alloc_type=iptype, update_host_maps=False))
 
     def test__combines_existing_and_new_addresses(self):
         node = make_node_attached_to_cluster_interfaces()
-        # node = factory.make_node_with_mac_attached_to_nodegroupinterface()
         mac = node.get_primary_mac()
         ipv4_interface = find_cluster_interface(node.nodegroup, 4)
         iptype = factory.pick_enum(
             IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED])
         [ipv4_sip] = mac.claim_static_ips(
             alloc_type=iptype,
-            requested_address=ipv4_interface.static_ip_range_low)
+            requested_address=ipv4_interface.static_ip_range_low,
+            update_host_maps=False)
 
-        allocation = mac.claim_static_ips(alloc_type=iptype)
+        allocation = mac.claim_static_ips(
+            alloc_type=iptype, update_host_maps=False)
 
         self.assertIn(ipv4_sip, allocation)
         self.assertThat(allocation, HasLength(2))
@@ -639,7 +658,8 @@
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
         mac = node.get_primary_mac()
         ip = node.get_primary_mac().cluster_interface.static_ip_range_high
-        [allocation] = mac.claim_static_ips(requested_address=ip)
+        [allocation] = mac.claim_static_ips(
+            requested_address=ip, update_host_maps=False)
         self.assertEqual(ip, allocation.ip)
 
     def test__allocates_only_IPv4_if_IPv4_address_requested(self):
@@ -648,7 +668,7 @@
         requested_ip = ipv4_interface.static_ip_range_low
 
         allocation = node.get_primary_mac().claim_static_ips(
-            requested_address=requested_ip)
+            requested_address=requested_ip, update_host_maps=False)
 
         self.assertThat(allocation, HasLength(1))
         [sip] = allocation
@@ -660,7 +680,7 @@
         requested_ip = ipv6_interface.static_ip_range_low
 
         allocation = node.get_primary_mac().claim_static_ips(
-            requested_address=requested_ip)
+            requested_address=requested_ip, update_host_maps=False)
 
         self.assertThat(allocation, HasLength(1))
         [sip] = allocation
@@ -673,7 +693,8 @@
             cluster_interface=cluster_interface)
         user = factory.make_User()
         [sip] = mac_address.claim_static_ips(
-            user=user, alloc_type=IPADDRESS_TYPE.USER_RESERVED)
+            user=user, alloc_type=IPADDRESS_TYPE.USER_RESERVED,
+            update_host_maps=False)
         self.assertEqual(sip.user, user)
 
 
@@ -881,7 +902,7 @@
         mac = factory.make_MACAddress_with_Node()
         user = factory.make_User()
         ip_address = factory.make_ip_address()
-        static_ip = mac.set_static_ip(ip_address, user)
+        static_ip = mac.set_static_ip(ip_address, user, update_host_maps=False)
 
         matcher = MatchesStructure(
             id=Not(Is(None)),  # IP persisted in the DB.
@@ -905,7 +926,7 @@
         static_range = IPRange(
             ngi.static_ip_range_low, ngi.static_ip_range_high)
         ip_address = factory.pick_ip_in_network(static_range)
-        static_ip = mac.set_static_ip(ip_address, user)
+        static_ip = mac.set_static_ip(ip_address, user, update_host_maps=False)
 
         matcher = MatchesStructure(
             id=Not(Is(None)),  # IP persisted in the DB.
@@ -927,7 +948,7 @@
         dynamic_range = IPRange(ngi.ip_range_low, ngi.ip_range_high)
         ip_address = factory.pick_ip_in_network(dynamic_range)
         with ExpectedException(StaticIPAddressForbidden):
-            mac.set_static_ip(ip_address, user)
+            mac.set_static_ip(ip_address, user, update_host_maps=False)
 
     def test_rejects_ip_if_ip_not_part_of_connected_network(self):
         node = factory.make_Node(mac=True)
@@ -945,15 +966,16 @@
         other_network = factory.make_ipv4_network(disjoint_from=[network])
         ip_address = factory.pick_ip_in_network(other_network)
         with ExpectedException(StaticIPAddressConflict):
-            mac.set_static_ip(ip_address, user)
+            mac.set_static_ip(ip_address, user, update_host_maps=False)
 
     def test_returns_existing_allocation_if_it_exists(self):
         mac = factory.make_MACAddress_with_Node()
         user = factory.make_User()
         ip_address = factory.make_ip_address()
-        static_ip = mac.set_static_ip(ip_address, user)
+        static_ip = mac.set_static_ip(ip_address, user, update_host_maps=False)
 
-        static_ip2 = mac.set_static_ip(ip_address, user)
+        static_ip2 = mac.set_static_ip(
+            ip_address, user, update_host_maps=False)
 
         self.assertEquals(static_ip.id, static_ip2.id)
 
@@ -961,11 +983,11 @@
         other_mac = factory.make_MACAddress_with_Node()
         user = factory.make_User()
         ip_address = factory.make_ip_address()
-        other_mac.set_static_ip(ip_address, user)
+        other_mac.set_static_ip(ip_address, user, update_host_maps=False)
 
         mac = factory.make_MACAddress_with_Node()
         with ExpectedException(StaticIPAddressUnavailable):
-            mac.set_static_ip(ip_address, user)
+            mac.set_static_ip(ip_address, user, update_host_maps=False)
 
     def test_rejects_ip_if_allocation_with_other_type_already_exists(self):
         nodegroup = factory.make_NodeGroup(status=NODEGROUP_STATUS.ENABLED)
@@ -977,7 +999,7 @@
         mac.cluster_interface = ngi
         mac.save()
         # Create an AUTO IP allocation.
-        static_ip = mac.claim_static_ips()[0]
+        static_ip = mac.claim_static_ips(update_host_maps=False)[0]
 
         with ExpectedException(StaticIPAddressUnavailable):
-            mac.set_static_ip(static_ip.ip, user)
+            mac.set_static_ip(static_ip.ip, user, update_host_maps=False)
 
=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2015-06-10 11:24:44 +0000
+++ src/maasserver/models/tests/test_node.py	2015-06-15 08:11:13 +0000
@@ -92,7 +92,6 @@
 )
 from maastesting.djangotestcase import count_queries
 from maastesting.matchers import (
-    MockAnyCall,
     MockCalledOnceWith,
     MockNotCalled,
 )
@@ -351,7 +350,8 @@
         primary_mac = node.get_primary_mac()
         random_alloc_type = factory.pick_enum(
             IPADDRESS_TYPE, but_not=[IPADDRESS_TYPE.USER_RESERVED])
-        primary_mac.claim_static_ips(alloc_type=random_alloc_type)
+        primary_mac.claim_static_ips(
+            alloc_type=random_alloc_type, update_host_maps=False)
         node.delete()
         self.assertItemsEqual([], StaticIPAddress.objects.all())
 
@@ -362,7 +362,8 @@
         primary_mac = node.get_primary_mac()
         static_ip_addresses = set(
             static_ip_address.ip for static_ip_address in
-            primary_mac.claim_static_ips(alloc_type=IPADDRESS_TYPE.STICKY))
+            primary_mac.claim_static_ips(
+                alloc_type=IPADDRESS_TYPE.STICKY, update_host_maps=False))
         node.delete()
         self.assertThat(
             remove_host_maps, MockCalledOnceWith(
@@ -1244,7 +1245,7 @@
         user = factory.make_User()
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface(
             owner=user, status=NODE_STATUS.ALLOCATED)
-        sips = node.get_primary_mac().claim_static_ips()
+        sips = node.get_primary_mac().claim_static_ips(update_host_maps=False)
         node.deallocate_static_ip_addresses()
         expected = {sip.ip.format() for sip in sips}
         self.assertThat(
@@ -1254,14 +1255,14 @@
     def test_deallocate_static_ip_updates_dns(self):
         # silence remove_host_maps
         self.patch_autospec(node_module, "remove_host_maps")
-        dns_update_zones = self.patch(dns_config, 'dns_update_zones')
+        dns_update_zones = self.patch(dns_config.dns_update_zones)
         nodegroup = factory.make_NodeGroup(
             management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
             status=NODEGROUP_STATUS.ENABLED)
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface(
             nodegroup=nodegroup, status=NODE_STATUS.ALLOCATED,
             owner=factory.make_User(), power_type='ether_wake')
-        node.get_primary_mac().claim_static_ips()
+        node.get_primary_mac().claim_static_ips(update_host_maps=False)
         node.deallocate_static_ip_addresses()
         self.assertThat(dns_update_zones, MockCalledOnceWith([node.nodegroup]))
 
@@ -2422,7 +2423,8 @@
 
     def test__returns_mapping_for_iface_on_managed_network(self):
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
-        static_mappings = node.claim_static_ip_addresses()
+        static_mappings = node.claim_static_ip_addresses(
+            update_host_maps=False)
         [static_ip] = node.static_ip_addresses()
         [mac_address] = node.macaddress_set.all()
         self.assertEqual(
@@ -2436,7 +2438,8 @@
         [managed_interface] = node.nodegroup.get_managed_interfaces()
         node.pxe_mac.cluster_interface = managed_interface
         node.pxe_mac.save()
-        static_mappings = node.claim_static_ip_addresses()
+        static_mappings = node.claim_static_ip_addresses(
+            update_host_maps=False)
         [static_ip] = node.static_ip_addresses()
         mac_address = node.get_pxe_mac()
         self.assertEqual(
@@ -2446,7 +2449,8 @@
     def test__ignores_mac_address_with_non_auto_addresses(self):
         node = factory.make_Node_with_MACAddress_and_NodeGroupInterface()
         mac_address = node.macaddress_set.first()
-        mac_address.claim_static_ips(IPADDRESS_TYPE.STICKY)
+        mac_address.claim_static_ips(
+            IPADDRESS_TYPE.STICKY, update_host_maps=False)
         self.assertRaises(
             StaticIPAddressTypeClash, mac_address.claim_static_ips)
         static_mappings = node.claim_static_ip_addresses()
@@ -2464,7 +2468,7 @@
         static_range = ngi.get_static_ip_range()
 
         pxe_ip, pxe_mac = node.claim_static_ip_addresses(
-            alloc_type=IPADDRESS_TYPE.STICKY)[0]
+            alloc_type=IPADDRESS_TYPE.STICKY, update_host_maps=False)[0]
 
         self.expectThat(static_range, Contains(IPAddress(pxe_ip)))
 
@@ -2489,7 +2493,8 @@
         first_ip = ngi.get_static_ip_range()[0]
 
         pxe_ip, pxe_mac = node.claim_static_ip_addresses(
-            alloc_type=IPADDRESS_TYPE.STICKY, requested_address=first_ip)[0]
+            alloc_type=IPADDRESS_TYPE.STICKY, requested_address=first_ip,
+            update_host_maps=False)[0]
         mac = MACAddress.objects.get(mac_address=pxe_mac)
         ip = mac.ip_addresses.first()
         self.expectThat(IPAddress(ip.ip), Equals(first_ip))
@@ -2507,10 +2512,12 @@
         first_ip = ngi.get_static_ip_range()[0]
 
         node.claim_static_ip_addresses(
-            alloc_type=IPADDRESS_TYPE.STICKY, requested_address=first_ip)
+            alloc_type=IPADDRESS_TYPE.STICKY, requested_address=first_ip,
+            update_host_maps=False)
         with ExpectedException(StaticIPAddressUnavailable):
             node2.claim_static_ip_addresses(
-                alloc_type=IPADDRESS_TYPE.STICKY, requested_address=first_ip)
+                alloc_type=IPADDRESS_TYPE.STICKY, requested_address=first_ip,
+                update_host_maps=False)
 
 
 class TestAsyncDellocateStaticIPAddress(MAASTransactionServerTestCase):
@@ -2554,7 +2561,7 @@
 
         with transaction.atomic():
             pxe_ip, pxe_mac = node.claim_static_ip_addresses(
-                alloc_type=IPADDRESS_TYPE.STICKY)[0]
+                alloc_type=IPADDRESS_TYPE.STICKY, update_host_maps=False)[0]
 
         mac = MACAddress.objects.get(mac_address=pxe_mac)
         ip = mac.ip_addresses.all()[0]
@@ -2565,7 +2572,8 @@
         for mac in macs:
             with transaction.atomic():
                 sips.append(node.claim_static_ip_addresses(
-                    mac=mac, alloc_type=IPADDRESS_TYPE.STICKY)[0])
+                    mac=mac, alloc_type=IPADDRESS_TYPE.STICKY,
+                    update_host_maps=False)[0])
 
         # try removing just the IP on the PXE MAC first
         deallocated = node.deallocate_static_ip_addresses(
@@ -2639,7 +2647,7 @@
         user_data = factory.make_bytes()
 
         with post_commit_hooks:
-            node.start(user, user_data=user_data)
+            node.start(user, user_data=user_data, update_host_maps=False)
 
         nud = NodeUserData.objects.get(node=node)
         self.assertEqual(user_data, nud.data)
@@ -2653,7 +2661,7 @@
         NodeUserData.objects.set_user_data(node, user_data)
 
         with post_commit_hooks:
-            node.start(user, user_data=None)
+            node.start(user, user_data=None, update_host_maps=False)
 
         self.assertFalse(NodeUserData.objects.filter(node=node).exists())
 
@@ -2664,13 +2672,15 @@
         node = self.make_acquired_node_with_mac(user, nodegroup)
 
         claim_static_ip_addresses = self.patch_autospec(
-            node, "claim_static_ip_addresses", spec_set=False)
+            node, "claim_static_ip_addresses")
         claim_static_ip_addresses.return_value = {}
 
         with post_commit_hooks:
             node.start(user)
 
-        self.expectThat(node.claim_static_ip_addresses, MockAnyCall())
+        self.expectThat(
+            claim_static_ip_addresses, MockCalledOnceWith(
+                update_host_maps=True))
 
     def test__only_claims_static_addresses_when_allocated(self):
         user = factory.make_User()
@@ -2685,7 +2695,7 @@
         claim_static_ip_addresses.return_value = {}
 
         with post_commit_hooks:
-            node.start(user)
+            node.start(user, update_host_maps=False)
 
         # No calls are made to claim_static_ip_addresses, since the node
         # isn't ALLOCATED.
@@ -2734,16 +2744,17 @@
         self.assertRaises(exception_type, node.start, user)
 
     def test__updates_dns(self):
+        dns_update_zones = self.patch(dns_config.dns_update_zones)
+        self.patch(Node, "update_host_maps")
+
         user = factory.make_User()
         node = self.make_acquired_node_with_mac(user)
 
-        dns_update_zones = self.patch(dns_config, "dns_update_zones")
-
         with post_commit_hooks:
             node.start(user)
 
         self.assertThat(
-            dns_update_zones, MockCalledOnceWith(node.nodegroup))
+            dns_update_zones, MockCalledOnceWith([node.nodegroup]))
 
     def test__set_zone(self):
         """Verifies whether the set_zone sets the node's zone"""
@@ -2762,7 +2773,7 @@
         self.patch_autospec(node, '_start_transition_monitor_async')
 
         with post_commit_hooks:
-            node.start(user)
+            node.start(user, update_host_maps=False)
 
         # If the following fails the diff is big, but it's useful.
         self.maxDiff = None
@@ -2792,13 +2803,13 @@
 
         with ExpectedException(PraiseBeToJTVException):
             with post_commit_hooks:
-                node.start(user)
+                node.start(user, update_host_maps=False)
 
     def test__marks_allocated_node_as_deploying(self):
         user = factory.make_User()
         node = self.make_acquired_node_with_mac(user)
         with post_commit_hooks:
-            node.start(user)
+            node.start(user, update_host_maps=False)
         self.assertEqual(
             NODE_STATUS.DEPLOYING, reload_object(node).status)
 
@@ -2813,7 +2824,7 @@
         power_on_node = self.patch(node_module, "power_on_node")
         power_on_node.return_value = defer.succeed(None)
         with post_commit_hooks:
-            node.start(user)
+            node.start(user, update_host_maps=False)
         self.assertEqual(
             NODE_STATUS.DEPLOYED, reload_object(node).status)
 
@@ -2829,7 +2840,7 @@
         )
         self.patch(node, 'get_effective_power_info').return_value = power_info
         power_on_node = self.patch(node_module, "power_on_node")
-        node.start(user)
+        node.start(user, update_host_maps=False)
         self.assertThat(power_on_node, MockNotCalled())
 
     def test__does_not_start_nodes_the_user_cannot_edit(self):
@@ -2838,8 +2849,9 @@
         node = self.make_acquired_node_with_mac(owner)
 
         user = factory.make_User()
-        self.assertRaises(PermissionDenied, node.start, user)
-        self.assertThat(power_on_node, MockNotCalled())
+        with ExpectedException(PermissionDenied):
+            node.start(user, update_host_maps=False)
+            self.assertThat(power_on_node, MockNotCalled())
 
     def test__allows_admin_to_start_any_node(self):
         power_on_node = self.patch_autospec(node_module, "power_on_node")
@@ -2848,7 +2860,7 @@
 
         admin = factory.make_admin()
         with post_commit_hooks:
-            node.start(admin)
+            node.start(admin, update_host_maps=False)
 
         self.expectThat(
             power_on_node, MockCalledOnceWith(
@@ -2870,7 +2882,7 @@
 
         with ExpectedException(exception_type):
             with post_commit_hooks:
-                node.start(user)
+                node.start(user, update_host_maps=False)
 
         self.assertThat(deallocate_ips, MockCalledOnceWith(node))
 
@@ -2880,8 +2892,8 @@
         update_host_maps.return_value = [
             Failure(exception_type("You steaming nit, you!"))
         ]
-        deallocate_ips = self.patch(
-            node_module.StaticIPAddress.objects, 'deallocate_by_node')
+        deallocate = self.patch(
+            node_module.StaticIPAddress, 'deallocate')
 
         user = factory.make_User()
         node = self.make_acquired_node_with_mac(user)
@@ -2890,7 +2902,8 @@
             with post_commit_hooks:
                 node.start(user)
 
-        self.assertThat(deallocate_ips, MockCalledOnceWith(node))
+        self.assertThat(
+            deallocate, MockCalledOnceWith())
 
     def test_update_host_maps_updates_given_nodegroup_list(self):
         user = factory.make_User()
 
=== modified file 'src/maasserver/websockets/handlers/device.py'
--- src/maasserver/websockets/handlers/device.py	2015-05-27 16:17:55 +0000
+++ src/maasserver/websockets/handlers/device.py	2015-06-15 08:11:13 +0000
@@ -17,7 +17,6 @@
     ]
 
 from maasserver.clusterrpc import dhcp
-from maasserver.dns.config import dns_update_zones
 from maasserver.enum import (
     IPADDRESS_TYPE,
     NODE_PERMISSION,
@@ -312,7 +311,7 @@
             ip_assignment = nic["ip_assignment"]
             if ip_assignment == DEVICE_IP_ASSIGNMENT.EXTERNAL:
                 sticky_ip = mac_address.set_static_ip(
-                    nic["ip_address"], self.user)
+                    nic["ip_address"], self.user, update_host_maps=False)
                 external_static_ips.append(
                     (sticky_ip, mac_address))
             elif ip_assignment == DEVICE_IP_ASSIGNMENT.DYNAMIC:
@@ -335,7 +334,7 @@
                 # Claim the static ip.
                 sticky_ips = mac_address.claim_static_ips(
                     alloc_type=IPADDRESS_TYPE.STICKY,
-                    requested_address=ip_address)
+                    requested_address=ip_address, update_host_maps=False)
                 assigned_sticky_ips.extend([
                     (static_ip, mac_address)
                     for static_ip in sticky_ips
@@ -393,7 +392,8 @@
         log_static_allocations(
             device_obj, external_static_ips, assigned_sticky_ips)
         if len(external_static_ips) > 0 or len(assigned_sticky_ips) > 0:
-            dns_update_zones([NodeGroup.objects.ensure_master()])
+            from maasserver.dns import config as dns_config
+            dns_config.dns_update_zones([NodeGroup.objects.ensure_master()])
 
         return self.full_dehydrate(device_obj)
 
 
=== modified file 'src/maasserver/websockets/handlers/tests/test_device.py'
--- src/maasserver/websockets/handlers/tests/test_device.py	2015-05-26 23:55:25 +0000
+++ src/maasserver/websockets/handlers/tests/test_device.py	2015-06-15 08:11:13 +0000
@@ -17,6 +17,7 @@
 import re
 
 from maasserver.clusterrpc import dhcp as dhcp_module
+from maasserver.dns import config as dns_config
 from maasserver.exceptions import NodeActionError
 from maasserver.fields import MAC
 from maasserver.forms import (
@@ -155,7 +156,7 @@
             interface = factory.make_NodeGroupInterface(nodegroup)
             primary_mac.cluster_interface = interface
             primary_mac.save()
-            primary_mac.claim_static_ips()
+            primary_mac.claim_static_ips(update_host_maps=False)
         return device
 
     def make_devices(self, nodegroup, number, owner=None):
@@ -190,6 +191,7 @@
             handler.list({}))
 
     def test_list_num_queries_is_independent_of_num_devices(self):
+        self.patch(Node, "update_host_maps")
         owner = factory.make_User()
         handler = DeviceHandler(owner, {})
         nodegroup = factory.make_NodeGroup()
@@ -211,6 +213,7 @@
             "Number of queries is not independent to the number of nodes.")
 
     def test_list_returns_devices_only_viewable_by_user(self):
+        self.patch(Node, "update_host_maps")
         user = factory.make_User()
         # Create another user.
         factory.make_User()
@@ -327,7 +330,7 @@
         hostname = factory.make_name("hostname")
         ip_address = factory.make_ipv4_address()
         self.patch(dhcp_module, "update_host_maps").return_value = []
-        mock_dns_update_zones = self.patch(device_module, "dns_update_zones")
+        mock_dns_update_zones = self.patch(dns_config.dns_update_zones)
         handler.create({
             "hostname": hostname,
             "primary_mac": mac,
@@ -371,6 +374,7 @@
             Equals(0), "Created StaticIPAddress was not deleted.")
 
     def test_create_creates_device_with_static_ip_assignment_implicit(self):
+        self.patch(Node, "update_host_maps")
         user = factory.make_User()
         handler = DeviceHandler(user, {})
         mac = factory.make_mac_address()
@@ -400,6 +404,7 @@
             Equals(1), "StaticIPAddress was not created.")
 
     def test_create_creates_device_with_static_ip_assignment_explicit(self):
+        self.patch(Node, "update_host_maps")
         user = factory.make_User()
         handler = DeviceHandler(user, {})
         mac = factory.make_mac_address()
@@ -431,14 +436,15 @@
             Equals(1), "StaticIPAddress was not created.")
 
     def test_create_with_static_ip_calls_dns_update_zones(self):
+        self.patch(device_module.update_host_maps).return_value = []
+        # self.patch(Node.update_host_maps).return_value = []
         user = factory.make_User()
         handler = DeviceHandler(user, {})
         mac = factory.make_mac_address()
         hostname = factory.make_name("hostname")
         nodegroup = factory.make_NodeGroup()
         nodegroup_interface = factory.make_NodeGroupInterface(nodegroup)
-        self.patch(dhcp_module, "update_host_maps").return_value = []
-        mock_dns_update_zones = self.patch(device_module, "dns_update_zones")
+        mock_dns_update_zones = self.patch(dns_config.dns_update_zones)
         handler.create({
             "hostname": hostname,
             "primary_mac": mac,
@@ -453,6 +459,8 @@
             MockCalledOnceWith([NodeGroup.objects.ensure_master()]))
 
     def test_create_raises_failure_static_ip_update_hostmaps_fails(self):
+        self.patch(Node, "update_host_maps")
+        mock_update_host_maps = self.patch(dhcp_module, "update_host_maps")
         user = factory.make_User()
         handler = DeviceHandler(user, {})
         mac = factory.make_mac_address()
@@ -460,7 +468,6 @@
         nodegroup = factory.make_NodeGroup()
         nodegroup_interface = factory.make_NodeGroupInterface(nodegroup)
         ip_address = nodegroup_interface.static_ip_range_low
-        mock_update_host_maps = self.patch(dhcp_module, "update_host_maps")
         mock_update_host_maps.return_value = [
             Failure(factory.make_exception()),
             ]
@@ -485,6 +492,7 @@
             Equals(0), "Created StaticIPAddress was not deleted.")
 
     def test_create_creates_device_with_static_and_external_ip(self):
+        self.patch(Node, "update_host_maps")
         user = factory.make_User()
         handler = DeviceHandler(user, {})
         hostname = factory.make_name("hostname")
@@ -539,18 +547,19 @@
             Equals(1), "External StaticIPAddress was not created.")
 
     def test_create_deletes_device_and_ips_when_only_one_errors(self):
-        user = factory.make_User()
-        handler = DeviceHandler(user, {})
-        hostname = factory.make_name("hostname")
-        nodegroup = factory.make_NodeGroup()
-        nodegroup_interface = factory.make_NodeGroupInterface(nodegroup)
-        mac_static = factory.make_mac_address()
-        static_ip_address = nodegroup_interface.static_ip_range_low
-        mac_external = factory.make_mac_address()
-        external_ip_address = factory.make_ipv4_address()
+        self.patch(Node, "update_host_maps")
         self.patch(dhcp_module, "update_host_maps").side_effect = [
             [], [Failure(factory.make_exception())],
         ]
+        user = factory.make_User()
+        handler = DeviceHandler(user, {})
+        hostname = factory.make_name("hostname")
+        nodegroup = factory.make_NodeGroup()
+        nodegroup_interface = factory.make_NodeGroupInterface(nodegroup)
+        mac_static = factory.make_mac_address()
+        static_ip_address = nodegroup_interface.static_ip_range_low
+        mac_external = factory.make_mac_address()
+        external_ip_address = factory.make_ipv4_address()
         self.assertRaises(HandlerError, handler.create, {
             "hostname": hostname,
             "primary_mac": mac_static,
 
=== modified file 'src/maastesting/testcase.py'
--- src/maastesting/testcase.py	2015-05-07 18:14:38 +0000
+++ src/maastesting/testcase.py	2015-06-15 08:11:13 +0000
@@ -19,6 +19,7 @@
 
 from contextlib import contextmanager
 import doctest
+from importlib import import_module
 import types
 import unittest
 
@@ -177,7 +178,7 @@
         with active_test(result, self):
             super(MAASTestCase, self).__call__(result)
 
-    def patch(self, obj, attribute, value=mock.sentinel.unset):
+    def patch(self, obj, attribute=None, value=mock.sentinel.unset):
         """Patch `obj.attribute` with `value`.
 
         If `value` is unspecified, a new `MagicMock` will be created and
@@ -188,6 +189,14 @@
 
         :return: The patched-in object.
         """
+
+        # If 'attribute' is None, assume 'obj' is a 'fully-qualified' object,
+        # and assume that its __module__ is what we want to patch. For more
+        # complex use cases, the two-paramerter 'patch' will still need to
+        # be used.
+        if attribute is None:
+            attribute = obj.__name__
+            obj = import_module(obj.__module__)
         if value is mock.sentinel.unset:
             value = mock.MagicMock()
         super(MAASTestCase, self).patch(obj, attribute, value)