Merge lp:~gmb/maas/1.7-backport-bug-1330765 into lp:maas/1.7

[Graham Binns]

Backport of all the fixes for bug 1330765 to 1.7. Also backport the fix for bug 1382108.

[Gavin Panella (allenap)]

Rubberstamp.

review: Approve

[Christian Reis (kiko)]

This looks like too much for 1.7.

review: Disapprove

[Graham Binns (gmb)]

On 22 October 2014 11:59, Christian Reis <email address hidden> wrote:
> This looks like too much for 1.7.

Patch size doesn't equate to risk. There's a huge chunk of removals
and mechanical changes here. Moreover, this fixes some fairly
significant bugs. Is it really worth the risk of *not* landing it?

[Christian Reis (kiko)]

Yes, because it is too big.

[Christian Reis (kiko)]

Waitin' for a simpler fix for bug 1382108 as we discussed today..

review: Disapprove

=== modified file 'src/maasserver/api/nodes.py'
--- src/maasserver/api/nodes.py	2014-10-20 22:01:33 +0000
+++ src/maasserver/api/nodes.py	2014-10-22 10:46:23 +0000
@@ -259,12 +259,11 @@
         node = Node.objects.get_node_or_404(
             system_id=system_id, user=request.user,
             perm=NODE_PERMISSION.EDIT)
-        nodes_stopped = Node.objects.stop_nodes(
-            [node.system_id], request.user, stop_mode=stop_mode)
-        if len(nodes_stopped) == 0:
+        power_action_sent = node.stop(request.user, stop_mode=stop_mode)
+        if power_action_sent:
+            return node
+        else:
             return None
-        else:
-            return node
 
     @operation(idempotent=False)
     def start(self, request, system_id):
@@ -285,12 +284,14 @@
         user_data = request.POST.get('user_data', None)
         series = request.POST.get('distro_series', None)
         license_key = request.POST.get('license_key', None)
+
+        node = Node.objects.get_node_or_404(
+            system_id=system_id, user=request.user,
+            perm=NODE_PERMISSION.EDIT)
+
         if user_data is not None:
             user_data = b64decode(user_data)
         if series is not None or license_key is not None:
-            node = Node.objects.get_node_or_404(
-                system_id=system_id, user=request.user,
-                perm=NODE_PERMISSION.EDIT)
             Form = get_node_edit_form(request.user)
             form = Form(instance=node)
             if series is not None:
@@ -301,19 +302,16 @@
                 form.save()
             else:
                 raise ValidationError(form.errors)
+
         try:
-            nodes = Node.objects.start_nodes(
-                [system_id], request.user, user_data=user_data)
+            node.start(request.user, user_data=user_data)
         except StaticIPAddressExhaustion:
             # The API response should contain error text with the
             # system_id in it, as that is the primary API key to a node.
             raise StaticIPAddressExhaustion(
                 "%s: Unable to allocate static IP due to address"
                 " exhaustion." % system_id)
-        if len(nodes) == 0:
-            raise PermissionDenied(
-                "You are not allowed to start up this node.")
-        return nodes[0]
+        return node
 
     @operation(idempotent=False)
     def release(self, request, system_id):

=== modified file 'src/maasserver/api/tests/test_node.py'
--- src/maasserver/api/tests/test_node.py	2014-09-29 10:26:31 +0000
+++ src/maasserver/api/tests/test_node.py	2014-10-22 10:46:23 +0000
@@ -215,28 +215,27 @@
 
     def test_POST_stop_checks_permission(self):
         node = factory.make_Node()
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
+        node_stop = self.patch(node, 'stop')
         response = self.client.post(self.get_node_uri(node), {'op': 'stop'})
         self.assertEqual(httplib.FORBIDDEN, response.status_code)
-        self.assertThat(stop_nodes, MockNotCalled())
+        self.assertThat(node_stop, MockNotCalled())
 
     def test_POST_stop_returns_nothing_if_node_was_not_stopped(self):
         # The node may not be stopped by stop_nodes because, for example, its
         # power type does not support it. In this case the node is not
         # returned to the caller.
         node = factory.make_Node(owner=self.logged_in_user)
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = []
+        node_stop = self.patch(node_module.Node, 'stop')
+        node_stop.return_value = False
         response = self.client.post(self.get_node_uri(node), {'op': 'stop'})
         self.assertEqual(httplib.OK, response.status_code)
         self.assertIsNone(json.loads(response.content))
-        self.assertThat(stop_nodes, MockCalledOnceWith(
-            [node.system_id], ANY, stop_mode=ANY))
+        self.assertThat(node_stop, MockCalledOnceWith(
+            ANY, stop_mode=ANY))
 
     def test_POST_stop_returns_node(self):
         node = factory.make_Node(owner=self.logged_in_user)
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        self.patch(node_module.Node, 'stop').return_value = True
         response = self.client.post(self.get_node_uri(node), {'op': 'stop'})
         self.assertEqual(httplib.OK, response.status_code)
         self.assertEqual(
@@ -246,23 +245,20 @@
         node = factory.make_Node(
             owner=self.logged_in_user, mac=True,
             power_type='ether_wake')
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        self.patch(node, 'stop')
         self.client.post(self.get_node_uri(node), {'op': 'stop'})
         response = self.client.post(self.get_node_uri(node), {'op': 'stop'})
         self.assertEqual(httplib.OK, response.status_code)
 
     def test_POST_stop_stops_nodes(self):
         node = factory.make_Node(owner=self.logged_in_user)
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        node_stop = self.patch(node_module.Node, 'stop')
         stop_mode = factory.make_name('stop_mode')
         self.client.post(
             self.get_node_uri(node), {'op': 'stop', 'stop_mode': stop_mode})
         self.assertThat(
-            stop_nodes,
-            MockCalledOnceWith(
-                [node.system_id], self.logged_in_user, stop_mode=stop_mode))
+            node_stop,
+            MockCalledOnceWith(self.logged_in_user, stop_mode=stop_mode))
 
     def test_POST_start_checks_permission(self):
         node = factory.make_Node()
@@ -1278,8 +1274,7 @@
     def test_abort_operation_changes_state(self):
         node = factory.make_Node(
             status=NODE_STATUS.DISK_ERASING, owner=self.logged_in_user)
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        self.patch_autospec(node_module.Node, "stop")
         response = self.client.post(
             self.get_node_uri(node), {'op': 'abort_operation'})
         self.assertEqual(httplib.OK, response.status_code)

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2014-10-15 20:00:42 +0000
+++ src/maasserver/models/node.py	2014-10-22 10:46:23 +0000
@@ -325,140 +325,6 @@
         available_nodes = self.get_nodes(for_user, NODE_PERMISSION.VIEW)
         return available_nodes.filter(status=NODE_STATUS.READY)
 
-    def stop_nodes(self, ids, by_user, stop_mode='hard'):
-        """Request on given user's behalf that the given nodes be shut down.
-
-        Shutdown is only requested for nodes that the user has ownership
-        privileges for; any other nodes in the request are ignored.
-
-        :param ids: The `system_id` values for nodes to be shut down.
-        :type ids: Sequence
-        :param by_user: Requesting user.
-        :type by_user: User_
-        :param stop_mode: Power off mode - usually 'soft' or 'hard'.
-        :type stop_mode: unicode
-        :return: Those Nodes for which shutdown was actually requested.
-        :rtype: list
-        """
-        # Obtain node model objects for each node specified.
-        nodes = self.get_nodes(by_user, NODE_PERMISSION.EDIT, ids=ids)
-
-        # Helper function to whittle the list of nodes down to those that we
-        # can actually stop, and keep hold of their power control info.
-        def gen_power_info(nodes):
-            for node in nodes:
-                power_info = node.get_effective_power_info()
-                if power_info.can_be_stopped:
-                    # Smuggle in a hint about how to power-off the node.
-                    power_info.power_parameters['power_off_mode'] = stop_mode
-                    yield node, power_info
-
-        # Create info that we can pass into the reactor (no model objects).
-        nodes_stop_info = list(
-            (node.system_id, node.hostname, node.nodegroup.uuid, power_info)
-            for node, power_info in gen_power_info(nodes))
-        powered_systems = [
-            system_id for system_id, _, _, _ in nodes_stop_info]
-
-        # Request that these nodes be powered off and wait for the
-        # commands to return or fail.
-        deferreds = power_off_nodes(nodes_stop_info).viewvalues()
-        wait_for_power_commands(deferreds)
-
-        # Return a list of those nodes that we've sent power commands for.
-        return list(
-            node for node in nodes if node.system_id in powered_systems)
-
-    def start_nodes(self, ids, by_user, user_data=None):
-        """Request on given user's behalf that the given nodes be started up.
-
-        Power-on is only requested for nodes that the user has ownership
-        privileges for; any other nodes in the request are ignored.
-
-        Nodes are also ignored if they don't have a valid power type
-        configured.
-
-        :param ids: The `system_id` values for nodes to be started.
-        :type ids: Sequence
-        :param by_user: Requesting user.
-        :type by_user: User_
-        :param user_data: Optional blob of user-data to be made available to
-            the nodes through the metadata service.  If not given, any
-            previous user data is used.
-        :type user_data: unicode
-        :return: Those Nodes for which power-on was actually requested.
-        :rtype: list
-
-        :raises MultipleFailures: When there are failures originating from a
-            remote process. There could be one or more failures -- it's not
-            strictly *multiple* -- but they do all originate from comms with
-            remote processes.
-        :raises: `StaticIPAddressExhaustion` if there are not enough IP
-            addresses left in the static range..
-        """
-        # Avoid circular imports.
-        from metadataserver.models import NodeUserData
-
-        # Obtain node model objects for each node specified.
-        nodes = self.get_nodes(by_user, NODE_PERMISSION.EDIT, ids=ids)
-
-        # Record the same user data for all nodes we've been *requested* to
-        # start, regardless of whether or not we actually can; the user may
-        # choose to manually start them.
-        NodeUserData.objects.bulk_set_user_data(nodes, user_data)
-
-        # Claim static IP addresses for all nodes we've been *requested* to
-        # start, such that they're recorded in the database. This results in a
-        # mapping of nodegroups to (ips, macs).
-        static_mappings = defaultdict(dict)
-        for node in nodes:
-            if node.status == NODE_STATUS.ALLOCATED:
-                claims = node.claim_static_ip_addresses()
-                static_mappings[node.nodegroup].update(claims)
-                node.start_deployment()
-
-        # XXX 2014-06-17 bigjools bug=1330765
-        # If the above fails it needs to release the static IPs back to the
-        # pool. An enclosing transaction or savepoint from the caller may take
-        # care of this, given that a serious problem above will result in an
-        # exception. If we're being belt-n-braces though it ought to clear up
-        # before returning too. As part of the robustness work coming up, it
-        # also needs to inform the user.
-
-        # Update host maps and wait for them so that we can report failures
-        # directly to the caller.
-        update_host_maps_failures = list(update_host_maps(static_mappings))
-        if len(update_host_maps_failures) != 0:
-            raise MultipleFailures(*update_host_maps_failures)
-
-        # Update the DNS zone with the new static IP info as necessary.
-        from maasserver.dns.config import change_dns_zones
-        change_dns_zones({node.nodegroup for node in nodes})
-
-        # Helper function to whittle the list of nodes down to those that we
-        # can actually start, and keep hold of their power control info.
-        def gen_power_info(nodes):
-            for node in nodes:
-                power_info = node.get_effective_power_info()
-                if power_info.can_be_started:
-                    yield node, power_info
-
-        # Create info that we can pass into the reactor (no model objects).
-        nodes_start_info = list(
-            (node.system_id, node.hostname, node.nodegroup.uuid, power_info)
-            for node, power_info in gen_power_info(nodes))
-        powered_systems = [
-            system_id for system_id, _, _, _ in nodes_start_info]
-
-        # Request that these nodes be powered off and wait for the
-        # commands to return or fail.
-        deferreds = power_on_nodes(nodes_start_info).viewvalues()
-        wait_for_power_commands(deferreds)
-
-        # Return a list of those nodes that we've sent power commands for.
-        return list(
-            node for node in nodes if node.system_id in powered_systems)
-
 
 def patch_pgarray_types():
     """Monkey-patch incompatibility with recent versions of `djorm_pgarray`.
@@ -969,11 +835,7 @@
         self.save()
         transaction.commit()
         try:
-            # We don't check for which nodes we've started here, because
-            # it's possible we can't start the node - its power type may not
-            # allow us to do that.
-            Node.objects.start_nodes(
-                [self.system_id], user, user_data=commissioning_user_data)
+            self.start(user, user_data=commissioning_user_data)
         except Exception as ex:
             maaslog.error(
                 "%s: Unable to start node: %s",
@@ -997,10 +859,7 @@
         maaslog.info(
             "%s: Aborting commissioning", self.hostname)
         try:
-            # We don't check for which nodes we've stopped here, because
-            # it's possible we can't stop the node - its power type may
-            # not allow us to do that.
-            Node.objects.stop_nodes([self.system_id], user)
+            self.stop(user)
         except Exception as ex:
             maaslog.error(
                 "%s: Unable to shut node down: %s",
@@ -1287,8 +1146,7 @@
         self.save()
         transaction.commit()
         try:
-            Node.objects.start_nodes(
-                [self.system_id], user, user_data=disk_erase_user_data)
+            self.start(user, user_data=disk_erase_user_data)
         except Exception as ex:
             maaslog.error(
                 "%s: Unable to start node: %s",
@@ -1318,7 +1176,7 @@
         maaslog.info(
             "%s: Aborting disk erasing", self.hostname)
         try:
-            Node.objects.stop_nodes([self.system_id], user)
+            self.stop(user)
         except Exception as ex:
             maaslog.error(
                 "%s: Unable to shut node down: %s",
@@ -1348,7 +1206,7 @@
         """
         maaslog.info("%s: Releasing node", self.hostname)
         try:
-            Node.objects.stop_nodes([self.system_id], self.owner)
+            self.stop(self.owner)
         except Exception as ex:
             maaslog.error(
                 "%s: Unable to shut node down: %s", self.hostname,
@@ -1550,3 +1408,130 @@
             return self.pxe_mac
 
         return self.macaddress_set.first()
+
+    def is_pxe_mac_on_managed_interface(self):
+        pxe_mac = self.get_pxe_mac()
+        if pxe_mac is not None:
+            cluster_interface = pxe_mac.cluster_interface
+            if cluster_interface is not None:
+                return cluster_interface.is_managed
+        return False
+
+    def start(self, by_user, user_data=None):
+        """Request on given user's behalf that the node be started up.
+
+        :param by_user: Requesting user.
+        :type by_user: User_
+        :param user_data: Optional blob of user-data to be made available to
+            the node through the metadata service.  If not given, any
+            previous user data is used.
+        :type user_data: unicode
+
+        :raises MultipleFailures: When there are failures originating from a
+            remote process. There could be one or more failures -- it's not
+            strictly *multiple* -- but they do all originate from comms with
+            remote processes.
+        :raises: `StaticIPAddressExhaustion` if there are not enough IP
+            addresses left in the static range for this node toget all
+            the addresses it needs.
+        """
+        # Avoid circular imports.
+        from metadataserver.models import NodeUserData
+        from maasserver.dns.config import change_dns_zones
+
+        if not by_user.has_perm(NODE_PERMISSION.EDIT, self):
+            # You can't stop a node you don't own unless you're an
+            # admin, so we return early.  This is consistent with the
+            # behaviour of NodeManager.stop_nodes(); it may be better to
+            # raise an error here.
+            return
+
+        # Record the user data for the node. Note that we do this
+        # whether or not we can actually send power commands to the
+        # node; the user may choose to start it manually.
+        NodeUserData.objects.set_user_data(self, user_data)
+
+        # Claim static IP addresses for the node if it's ALLOCATED.
+        if self.status == NODE_STATUS.ALLOCATED:
+            static_mappings = defaultdict(dict)
+            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():
+                static_mappings[self.nodegroup].update(claims)
+                update_host_maps_failures = list(
+                    update_host_maps(static_mappings))
+                if len(update_host_maps_failures) != 0:
+                    # We've hit errors, so release any IPs we've claimed
+                    # and then raise the errors for the call site to
+                    # handle.
+                    StaticIPAddress.objects.deallocate_by_node(self)
+                    raise MultipleFailures(*update_host_maps_failures)
+
+        if self.status == NODE_STATUS.ALLOCATED:
+            self.start_deployment()
+
+        # Update the DNS zone with the new static IP info as necessary.
+        change_dns_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.
+            # Everything we've done up to this point is still valid;
+            # this is not an error state.
+            return
+
+        # We need to convert the node into something that we can
+        # pass into the reactor.
+        start_info = (
+            self.system_id, self.hostname, self.nodegroup.uuid, power_info,)
+
+        try:
+            # Send the power on command to the node and wait for it to
+            # return.
+            deferreds = power_on_nodes([start_info]).viewvalues()
+            wait_for_power_commands(deferreds)
+        except:
+            # If we encounter any failure here, we deallocate the static
+            # IPs we claimed earlier. We don't try to handle the error;
+            # that's the job of the call site.
+            StaticIPAddress.objects.deallocate_by_node(self)
+            raise
+
+    def stop(self, by_user, stop_mode='hard'):
+        """Request that the node be powered down.
+
+        :param by_user: Requesting user.
+        :type by_user: User_
+        :param stop_mode: Power off mode - usually 'soft' or 'hard'.
+        :type stop_mode: unicode
+        :raises MultipleFailures: When there are failures originating
+            from the RPC power action.
+        :return: True if the power action was sent to the node; False if
+            it wasn't sent. If the user doesn't have permission to stop
+            the node, return None.
+        """
+        if not by_user.has_perm(NODE_PERMISSION.EDIT, self):
+            # You can't stop a node you don't own unless you're an
+            # admin, so we return early.  This is consistent with the
+            # behaviour of NodeManager.stop_nodes(); it may be better to
+            # raise an error here.
+            return
+
+        power_info = self.get_effective_power_info()
+        if not power_info.can_be_stopped:
+            # We can't stop this node, so just return; trying to stop a
+            # node we don't know how to stop isn't an error state, but
+            # it's a no-op.
+            return False
+
+        # Smuggle in a hint about how to power-off the self.
+        power_info.power_parameters['power_off_mode'] = stop_mode
+        stop_info = (
+            self.system_id, self.hostname, self.nodegroup.uuid, power_info)
+
+        # Request that the node be powered off and wait for the command
+        # to return or fail.
+        deferreds = power_off_nodes([stop_info]).viewvalues()
+        wait_for_power_commands(deferreds)
+        return True

=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2014-10-15 22:29:41 +0000
+++ src/maasserver/models/tests/test_node.py	2014-10-22 10:46:23 +0000
@@ -18,7 +18,6 @@
     datetime,
     timedelta,
     )
-from itertools import izip
 import random
 
 import crochet
@@ -84,7 +83,6 @@
 from maastesting.matchers import (
     MockAnyCall,
     MockCalledOnceWith,
-    MockCallsMatch,
     MockNotCalled,
     )
 from metadataserver.enum import RESULT_TYPE
@@ -99,7 +97,6 @@
     )
 from mock import (
     ANY,
-    call,
     Mock,
     sentinel,
     )
@@ -112,14 +109,10 @@
     NoConnectionsAvailable,
     )
 from provisioningserver.rpc.power import QUERY_POWER_TYPES
-from provisioningserver.rpc.testing import (
-    always_succeed_with,
-    TwistedLoggerFixture,
-    )
+from provisioningserver.rpc.testing import always_succeed_with
 from provisioningserver.utils.enum import map_enum
 from testtools.matchers import (
     Equals,
-    HasLength,
     Is,
     IsInstance,
     MatchesStructure,
@@ -740,13 +733,13 @@
         owner = factory.make_User()
         node = factory.make_Node(
             status=NODE_STATUS.ALLOCATED, owner=owner, agent_name=agent_name)
-        start_nodes = self.patch(Node.objects, "start_nodes")
+        node_start = self.patch(node, 'start')
         node.start_disk_erasing(owner)
-        self.assertEqual(
-            (owner, NODE_STATUS.DISK_ERASING, agent_name),
-            (node.owner, node.status, node.agent_name))
-        self.assertThat(start_nodes, MockCalledOnceWith(
-            [node.system_id], owner, user_data=ANY))
+        self.expectThat(node.owner, Equals(owner))
+        self.expectThat(node.status, Equals(NODE_STATUS.DISK_ERASING))
+        self.expectThat(node.agent_name, Equals(agent_name))
+        self.assertThat(
+            node_start, MockCalledOnceWith(owner, user_data=ANY))
 
     def test_abort_disk_erasing_changes_state_and_stops_node(self):
         agent_name = factory.make_name('agent-name')
@@ -754,14 +747,12 @@
         node = factory.make_Node(
             status=NODE_STATUS.DISK_ERASING, owner=owner,
             agent_name=agent_name)
-        stop_nodes = self.patch(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        node_stop = self.patch(node, 'stop')
         node.abort_disk_erasing(owner)
         self.assertEqual(
             (owner, NODE_STATUS.FAILED_DISK_ERASING, agent_name),
             (node.owner, node.status, node.agent_name))
-        self.assertThat(stop_nodes, MockCalledOnceWith(
-            [node.system_id], owner))
+        self.assertThat(node_stop, MockCalledOnceWith(owner))
 
     def test_start_disk_erasing_reverts_to_sane_state_on_error(self):
         # If start_disk_erasing encounters an error when calling
@@ -769,53 +760,35 @@
         # Failures encountered in one call to start_disk_erasing() won't
         # affect subsequent calls.
         admin = factory.make_admin()
-        nodes = [
-            factory.make_Node(
-                status=NODE_STATUS.ALLOCATED, power_type="virsh")
-            for _ in range(3)
-            ]
+        node = factory.make_Node(status=NODE_STATUS.ALLOCATED)
         generate_user_data = self.patch(disk_erasing, 'generate_user_data')
-        start_nodes = self.patch(Node.objects, 'start_nodes')
-        start_nodes.side_effect = [
-            None,
-            MultipleFailures(
-                Failure(NoConnectionsAvailable())),
-            None,
-            ]
+        node_start = self.patch(node, 'start')
+        node_start.side_effect = MultipleFailures(
+            Failure(NoConnectionsAvailable())),
 
         with transaction.atomic():
-            for node in nodes:
-                try:
-                    node.start_disk_erasing(admin)
-                except RPC_EXCEPTIONS:
-                    # Suppress all the expected errors coming out of
-                    # start_disk_erasing() because they're tested
-                    # eleswhere.
-                    pass
+            try:
+                node.start_disk_erasing(admin)
+            except RPC_EXCEPTIONS:
+                # Suppress all the expected errors coming out of
+                # start_disk_erasing() because they're tested
+                # eleswhere.
+                pass
 
-        expected_calls = (
-            call(
-                [node.system_id], admin,
-                user_data=generate_user_data.return_value)
-            for node in nodes)
         self.assertThat(
-            start_nodes, MockCallsMatch(*expected_calls))
-        self.assertEqual(
-            [
-                NODE_STATUS.DISK_ERASING,
-                NODE_STATUS.FAILED_DISK_ERASING,
-                NODE_STATUS.DISK_ERASING,
-            ],
-            [node.status for node in nodes])
+            node_start, MockCalledOnceWith(
+                admin, user_data=generate_user_data.return_value))
+        self.assertEqual(NODE_STATUS.FAILED_DISK_ERASING, node.status)
 
     def test_start_disk_erasing_logs_and_raises_errors_in_starting(self):
         admin = factory.make_admin()
         node = factory.make_Node(status=NODE_STATUS.ALLOCATED)
         maaslog = self.patch(node_module, 'maaslog')
-        exception = NoConnectionsAvailable(factory.make_name())
-        self.patch(Node.objects, 'start_nodes').side_effect = exception
+        exception_type = factory.make_exception_type()
+        exception = exception_type(factory.make_name())
+        self.patch(node, 'start').side_effect = exception
         self.assertRaises(
-            NoConnectionsAvailable, node.start_disk_erasing, admin)
+            exception_type, node.start_disk_erasing, admin)
         self.assertEqual(NODE_STATUS.FAILED_DISK_ERASING, node.status)
         self.assertThat(
             maaslog.error, MockCalledOnceWith(
@@ -846,51 +819,33 @@
         # Failures encountered in one call to start_disk_erasing() won't
         # affect subsequent calls.
         admin = factory.make_admin()
-        nodes = [
-            factory.make_Node(
-                status=NODE_STATUS.DISK_ERASING, power_type="virsh")
-            for _ in range(3)
-            ]
-        stop_nodes = self.patch(Node.objects, 'stop_nodes')
-        stop_nodes.return_value = [
-            [node] for node in nodes
-            ]
-        stop_nodes.side_effect = [
-            None,
-            MultipleFailures(
-                Failure(NoConnectionsAvailable())),
-            None,
-            ]
+        node = factory.make_Node(
+            status=NODE_STATUS.DISK_ERASING, power_type="virsh")
+        node_stop = self.patch(node, 'stop')
+        node_stop.side_effect = MultipleFailures(
+            Failure(NoConnectionsAvailable()))
 
         with transaction.atomic():
-            for node in nodes:
-                try:
-                    node.abort_disk_erasing(admin)
-                except RPC_EXCEPTIONS:
-                    # Suppress all the expected errors coming out of
-                    # abort_disk_erasing() because they're tested
-                    # eleswhere.
-                    pass
+            try:
+                node.abort_disk_erasing(admin)
+            except RPC_EXCEPTIONS:
+                # Suppress all the expected errors coming out of
+                # abort_disk_erasing() because they're tested
+                # eleswhere.
+                pass
 
-        self.assertThat(
-            stop_nodes, MockCallsMatch(
-                *(call([node.system_id], admin) for node in nodes)))
-        self.assertEqual(
-            [
-                NODE_STATUS.FAILED_DISK_ERASING,
-                NODE_STATUS.DISK_ERASING,
-                NODE_STATUS.FAILED_DISK_ERASING,
-            ],
-            [node.status for node in nodes])
+        self.assertThat(node_stop, MockCalledOnceWith(admin))
+        self.assertEqual(NODE_STATUS.DISK_ERASING, node.status)
 
     def test_abort_disk_erasing_logs_and_raises_errors_in_stopping(self):
         admin = factory.make_admin()
         node = factory.make_Node(status=NODE_STATUS.DISK_ERASING)
         maaslog = self.patch(node_module, 'maaslog')
-        exception = NoConnectionsAvailable(factory.make_name())
-        self.patch(Node.objects, 'stop_nodes').side_effect = exception
+        exception_class = factory.make_exception_type()
+        exception = exception_class(factory.make_name())
+        self.patch(node, 'stop').side_effect = exception
         self.assertRaises(
-            NoConnectionsAvailable, node.abort_disk_erasing, admin)
+            exception_class, node.abort_disk_erasing, admin)
         self.assertEqual(NODE_STATUS.DISK_ERASING, node.status)
         self.assertThat(
             maaslog.error, MockCalledOnceWith(
@@ -1188,13 +1143,13 @@
         self.assertEqual("", node.distro_series)
 
     def test_release_powers_off_node(self):
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
         user = factory.make_User()
         node = factory.make_Node(
             status=NODE_STATUS.ALLOCATED, owner=user, power_type='virsh')
+        node_stop = self.patch(node, 'stop')
         node.release()
         self.assertThat(
-            stop_nodes, MockCalledOnceWith([node.system_id], user))
+            node_stop, MockCalledOnceWith(user))
 
     def test_release_deallocates_static_ips(self):
         deallocate = self.patch(StaticIPAddressManager, 'deallocate_by_node')
@@ -1206,6 +1161,7 @@
         self.assertThat(deallocate, MockCalledOnceWith(node))
 
     def test_release_updates_dns(self):
+        self.patch(node_module, 'wait_for_power_commands')
         change_dns_zones = self.patch(dns_config, 'change_dns_zones')
         nodegroup = factory.make_NodeGroup(
             management=NODEGROUPINTERFACE_MANAGEMENT.DHCP_AND_DNS,
@@ -1219,9 +1175,10 @@
     def test_release_logs_and_raises_errors_in_stopping(self):
         node = factory.make_Node(status=NODE_STATUS.DEPLOYED)
         maaslog = self.patch(node_module, 'maaslog')
-        exception = NoConnectionsAvailable(factory.make_name())
-        self.patch(Node.objects, 'stop_nodes').side_effect = exception
-        self.assertRaises(NoConnectionsAvailable, node.release)
+        exception_class = factory.make_exception_type()
+        exception = exception_class(factory.make_name())
+        self.patch(node, 'stop').side_effect = exception
+        self.assertRaises(exception_class, node.release)
         self.assertEqual(NODE_STATUS.DEPLOYED, node.status)
         self.assertThat(
             maaslog.error, MockCalledOnceWith(
@@ -1231,45 +1188,27 @@
     def test_release_reverts_to_sane_state_on_error(self):
         # If release() encounters an error when stopping the node, it
         # will leave the node in its previous state (i.e. DEPLOYED).
-        nodes = [
-            factory.make_Node(
-                status=NODE_STATUS.DEPLOYED, power_type="virsh")
-            for _ in range(3)
-            ]
-        stop_nodes = self.patch(Node.objects, 'stop_nodes')
-        stop_nodes.return_value = [
-            [node] for node in nodes
-            ]
-        stop_nodes.side_effect = [
-            None,
-            MultipleFailures(
-                Failure(NoConnectionsAvailable())),
-            None,
-            ]
+        node = factory.make_Node(
+            status=NODE_STATUS.DEPLOYED, power_type="virsh",
+            owner=factory.make_User())
+        node_stop = self.patch(node, 'stop')
+        node_stop.side_effect = MultipleFailures(
+            Failure(NoConnectionsAvailable()))
 
         with transaction.atomic():
-            for node in nodes:
-                try:
-                    node.release()
-                except RPC_EXCEPTIONS:
-                    # Suppress all expected errors; we test for them
-                    # elsewhere.
-                    pass
+            try:
+                node.release()
+            except RPC_EXCEPTIONS:
+                # Suppress all expected errors; we test for them
+                # elsewhere.
+                pass
 
-        self.assertThat(
-            stop_nodes, MockCallsMatch(
-                *(call([node.system_id], None) for node in nodes)))
-        self.assertEqual(
-            [
-                NODE_STATUS.RELEASING,
-                NODE_STATUS.DEPLOYED,
-                NODE_STATUS.RELEASING,
-            ],
-            [node.status for node in nodes])
+        self.assertThat(node_stop, MockCalledOnceWith(node.owner))
+        self.assertEqual(NODE_STATUS.DEPLOYED, node.status)
 
     def test_release_commits_after_status_change(self):
         node = factory.make_Node(status=NODE_STATUS.DEPLOYED)
-        self.patch(Node.objects, 'stop_nodes')
+        self.patch(node, 'stop')
         commit = self.patch(transaction, 'commit')
         node.release()
         self.assertThat(commit, MockCalledOnceWith())
@@ -1337,8 +1276,7 @@
     def test_start_commissioning_changes_status_and_starts_node(self):
         node = factory.make_Node(
             status=NODE_STATUS.NEW, power_type='ether_wake')
-        start_nodes = self.patch(Node.objects, "start_nodes")
-        start_nodes.return_value = [node]
+        node_start = self.patch(node, 'start')
         factory.make_MACAddress(node=node)
         admin = factory.make_admin()
         node.start_commissioning(admin)
@@ -1347,21 +1285,20 @@
             'status': NODE_STATUS.COMMISSIONING,
         }
         self.assertAttributes(node, expected_attrs)
-        self.assertThat(start_nodes, MockCalledOnceWith(
-            [node.system_id], admin, user_data=ANY))
+        self.assertThat(node_start, MockCalledOnceWith(
+            admin, user_data=ANY))
 
     def test_start_commissioning_sets_user_data(self):
-        start_nodes = self.patch(Node.objects, "start_nodes")
-
         node = factory.make_Node(status=NODE_STATUS.NEW)
+        node_start = self.patch(node, 'start')
         user_data = factory.make_string().encode('ascii')
         generate_user_data = self.patch(
             commissioning, 'generate_user_data')
         generate_user_data.return_value = user_data
         admin = factory.make_admin()
         node.start_commissioning(admin)
-        self.assertThat(start_nodes, MockCalledOnceWith(
-            [node.system_id], admin, user_data=user_data))
+        self.assertThat(node_start, MockCalledOnceWith(
+            admin, user_data=user_data))
 
     def test_start_commissioning_clears_node_commissioning_results(self):
         node = factory.make_Node(status=NODE_STATUS.NEW)
@@ -1391,49 +1328,32 @@
         # start the node, it will revert the node to its previous
         # status.
         admin = factory.make_admin()
-        nodes = [
-            factory.make_Node(status=NODE_STATUS.NEW, power_type="ether_wake")
-            for _ in range(3)
-            ]
+        node = factory.make_Node(status=NODE_STATUS.NEW)
         generate_user_data = self.patch(commissioning, 'generate_user_data')
-        start_nodes = self.patch(Node.objects, 'start_nodes')
-        start_nodes.side_effect = [
-            None,
-            MultipleFailures(
-                Failure(NoConnectionsAvailable())),
-            None,
-            ]
+        node_start = self.patch(node, 'start')
+        node_start.side_effect = MultipleFailures(
+            Failure(NoConnectionsAvailable()))
 
         with transaction.atomic():
-            for node in nodes:
-                try:
-                    node.start_commissioning(admin)
-                except RPC_EXCEPTIONS:
-                    # Suppress all expected errors; we test for them
-                    # elsewhere.
-                    pass
+            try:
+                node.start_commissioning(admin)
+            except RPC_EXCEPTIONS:
+                # Suppress all expected errors; we test for them
+                # elsewhere.
+                pass
 
-        expected_calls = (
-            call(
-                [node.system_id], admin,
-                user_data=generate_user_data.return_value)
-            for node in nodes)
         self.assertThat(
-            start_nodes, MockCallsMatch(*expected_calls))
-        self.assertEqual(
-            [
-                NODE_STATUS.COMMISSIONING,
-                NODE_STATUS.NEW,
-                NODE_STATUS.COMMISSIONING
-            ],
-            [node.status for node in nodes])
+            node_start,
+            MockCalledOnceWith(
+                admin, user_data=generate_user_data.return_value))
+        self.assertEqual(NODE_STATUS.NEW, node.status)
 
     def test_start_commissioning_logs_and_raises_errors_in_starting(self):
         admin = factory.make_admin()
         node = factory.make_Node(status=NODE_STATUS.NEW)
         maaslog = self.patch(node_module, 'maaslog')
         exception = NoConnectionsAvailable(factory.make_name())
-        self.patch(Node.objects, 'start_nodes').side_effect = exception
+        self.patch(node, 'start').side_effect = exception
         self.assertRaises(
             NoConnectionsAvailable, node.start_commissioning, admin)
         self.assertEqual(NODE_STATUS.NEW, node.status)
@@ -1447,50 +1367,32 @@
         # node, it will revert the node to the state it was in before
         # abort_commissioning() was called.
         admin = factory.make_admin()
-        nodes = [
-            factory.make_Node(
-                status=NODE_STATUS.COMMISSIONING, power_type="virsh")
-            for _ in range(3)
-            ]
-        stop_nodes = self.patch(Node.objects, 'stop_nodes')
-        stop_nodes.return_value = [
-            [node] for node in nodes
-            ]
-        stop_nodes.side_effect = [
-            None,
-            MultipleFailures(
-                Failure(NoConnectionsAvailable())),
-            None,
-            ]
+        node = factory.make_Node(
+            status=NODE_STATUS.COMMISSIONING, power_type="virsh")
+        node_stop = self.patch(node, 'stop')
+        node_stop.side_effect = MultipleFailures(
+            Failure(NoConnectionsAvailable()))
 
         with transaction.atomic():
-            for node in nodes:
-                try:
-                    node.abort_commissioning(admin)
-                except RPC_EXCEPTIONS:
-                    # Suppress all expected errors; we test for them
-                    # elsewhere.
-                    pass
+            try:
+                node.abort_commissioning(admin)
+            except RPC_EXCEPTIONS:
+                # Suppress all expected errors; we test for them
+                # elsewhere.
+                pass
 
-        self.assertThat(
-            stop_nodes, MockCallsMatch(
-                *(call([node.system_id], admin) for node in nodes)))
-        self.assertEqual(
-            [
-                NODE_STATUS.NEW,
-                NODE_STATUS.COMMISSIONING,
-                NODE_STATUS.NEW,
-            ],
-            [node.status for node in nodes])
+        self.assertThat(node_stop, MockCalledOnceWith(admin))
+        self.assertEqual(NODE_STATUS.COMMISSIONING, node.status)
 
     def test_abort_commissioning_logs_and_raises_errors_in_stopping(self):
         admin = factory.make_admin()
         node = factory.make_Node(status=NODE_STATUS.COMMISSIONING)
         maaslog = self.patch(node_module, 'maaslog')
-        exception = NoConnectionsAvailable(factory.make_name())
-        self.patch(Node.objects, 'stop_nodes').side_effect = exception
+        exception_class = factory.make_exception_type()
+        exception = exception_class(factory.make_name())
+        self.patch(node, 'stop').side_effect = exception
         self.assertRaises(
-            NoConnectionsAvailable, node.abort_commissioning, admin)
+            exception_class, node.abort_commissioning, admin)
         self.assertEqual(NODE_STATUS.COMMISSIONING, node.status)
         self.assertThat(
             maaslog.error, MockCalledOnceWith(
@@ -1502,16 +1404,14 @@
             status=NODE_STATUS.COMMISSIONING, power_type='virsh')
         admin = factory.make_admin()
 
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        node_stop = self.patch(node, 'stop')
 
         node.abort_commissioning(admin)
         expected_attrs = {
             'status': NODE_STATUS.NEW,
         }
         self.assertAttributes(node, expected_attrs)
-        self.assertThat(
-            stop_nodes, MockCalledOnceWith([node.system_id], admin))
+        self.assertThat(node_stop, MockCalledOnceWith(admin))
 
     def test_abort_commisssioning_errors_if_node_is_not_commissioning(self):
         unaccepted_statuses = set(map_enum(NODE_STATUS).values())
@@ -1834,6 +1734,28 @@
         self.assertEqual(node.macaddress_set.first(), node.get_pxe_mac())
 
 
+class TestNode_pxe_mac_on_managed_interface(MAASServerTestCase):
+
+    def test__returns_true_if_managed(self):
+        node = factory.make_node_with_mac_attached_to_nodegroupinterface()
+        self.assertTrue(node.is_pxe_mac_on_managed_interface())
+
+    def test__returns_false_if_no_pxe_mac(self):
+        node = factory.make_Node()
+        self.assertFalse(node.is_pxe_mac_on_managed_interface())
+
+    def test__returns_false_if_no_attached_cluster_interface(self):
+        node = factory.make_Node()
+        node.pxe_mac = factory.make_MACAddress(node=node)
+        node.save()
+        self.assertFalse(node.is_pxe_mac_on_managed_interface())
+
+    def test__returns_false_if_cluster_interface_unmanaged(self):
+        node = factory.make_node_with_mac_attached_to_nodegroupinterface(
+            management=NODEGROUPINTERFACE_MANAGEMENT.UNMANAGED)
+        self.assertFalse(node.is_pxe_mac_on_managed_interface())
+
+
 class NodeRoutersTest(MAASServerTestCase):
 
     def test_routers_stores_mac_address(self):
@@ -2101,375 +2023,6 @@
         self.assertThat(erase_mock, MockNotCalled())
 
 
-class NodeManagerTest_StartNodes(MAASServerTestCase):
-
-    def setUp(self):
-        super(NodeManagerTest_StartNodes, self).setUp()
-        self.useFixture(RegionEventLoopFixture("rpc"))
-        self.useFixture(RunningEventLoopFixture())
-        self.rpc_fixture = self.useFixture(MockLiveRegionToClusterRPCFixture())
-
-    def prepare_rpc_to_cluster(self, nodegroup):
-        protocol = self.rpc_fixture.makeCluster(
-            nodegroup, cluster_module.CreateHostMaps, cluster_module.PowerOn,
-            cluster_module.StartMonitors)
-        protocol.CreateHostMaps.side_effect = always_succeed_with({})
-        protocol.StartMonitors.side_effect = always_succeed_with({})
-        protocol.PowerOn.side_effect = always_succeed_with({})
-        return protocol
-
-    def make_acquired_nodes_with_macs(self, user, nodegroup=None, count=3):
-        nodes = []
-        for _ in xrange(count):
-            node = factory.make_node_with_mac_attached_to_nodegroupinterface(
-                nodegroup=nodegroup, status=NODE_STATUS.READY)
-            self.prepare_rpc_to_cluster(node.nodegroup)
-            node.acquire(user)
-            nodes.append(node)
-        return nodes
-
-    def test__sets_user_data(self):
-        user = factory.make_User()
-        nodegroup = factory.make_NodeGroup()
-        self.prepare_rpc_to_cluster(nodegroup)
-        nodes = self.make_acquired_nodes_with_macs(user, nodegroup)
-        user_data = factory.make_bytes()
-
-        with TwistedLoggerFixture() as twisted_log:
-            Node.objects.start_nodes(
-                list(node.system_id for node in nodes),
-                user, user_data=user_data)
-
-        # All three nodes have been given the same user data.
-        nuds = NodeUserData.objects.filter(
-            node_id__in=(node.id for node in nodes))
-        self.assertEqual({user_data}, {nud.data for nud in nuds})
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__resets_user_data(self):
-        user = factory.make_User()
-        nodegroup = factory.make_NodeGroup()
-        self.prepare_rpc_to_cluster(nodegroup)
-        nodes = self.make_acquired_nodes_with_macs(user, nodegroup)
-
-        with TwistedLoggerFixture() as twisted_log:
-            Node.objects.start_nodes(
-                list(node.system_id for node in nodes),
-                user, user_data=None)
-
-        # All three nodes have been given the same user data.
-        nuds = NodeUserData.objects.filter(
-            node_id__in=(node.id for node in nodes))
-        self.assertThat(list(nuds), HasLength(0))
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__claims_static_ip_addresses(self):
-        user = factory.make_User()
-        nodegroup = factory.make_NodeGroup()
-        self.prepare_rpc_to_cluster(nodegroup)
-        nodes = self.make_acquired_nodes_with_macs(user, nodegroup)
-
-        claim_static_ip_addresses = self.patch_autospec(
-            Node, "claim_static_ip_addresses", spec_set=False)
-        claim_static_ip_addresses.return_value = {}
-
-        with TwistedLoggerFixture() as twisted_log:
-            Node.objects.start_nodes(
-                list(node.system_id for node in nodes), user)
-
-        for node in nodes:
-            self.expectThat(claim_static_ip_addresses, MockAnyCall(node))
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__claims_static_ip_addresses_for_allocated_nodes_only(self):
-        user = factory.make_User()
-        nodegroup = factory.make_NodeGroup()
-        self.prepare_rpc_to_cluster(nodegroup)
-        nodes = self.make_acquired_nodes_with_macs(user, nodegroup, count=2)
-
-        # Change the status of the first node to something other than
-        # allocated.
-        broken_node, allocated_node = nodes
-        broken_node.status = NODE_STATUS.BROKEN
-        broken_node.save()
-
-        claim_static_ip_addresses = self.patch_autospec(
-            Node, "claim_static_ip_addresses", spec_set=False)
-        claim_static_ip_addresses.return_value = {}
-
-        with TwistedLoggerFixture() as twisted_log:
-            Node.objects.start_nodes(
-                list(node.system_id for node in nodes), user)
-
-        # Only one call is made to claim_static_ip_addresses(), for the
-        # still-allocated node.
-        self.assertThat(
-            claim_static_ip_addresses,
-            MockCalledOnceWith(allocated_node))
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__updates_host_maps(self):
-        user = factory.make_User()
-        nodes = self.make_acquired_nodes_with_macs(user)
-
-        update_host_maps = self.patch(node_module, "update_host_maps")
-        update_host_maps.return_value = []  # No failures.
-
-        with TwistedLoggerFixture() as twisted_log:
-            Node.objects.start_nodes(
-                list(node.system_id for node in nodes), user)
-
-        # Host maps are updated.
-        self.assertThat(
-            update_host_maps, MockCalledOnceWith({
-                node.nodegroup: {
-                    ip_address.ip: mac.mac_address
-                    for ip_address in mac.ip_addresses.all()
-                }
-                for node in nodes
-                for mac in node.mac_addresses_on_managed_interfaces()
-            }))
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__propagates_errors_when_updating_host_maps(self):
-        user = factory.make_User()
-        nodes = self.make_acquired_nodes_with_macs(user)
-
-        update_host_maps = self.patch(node_module, "update_host_maps")
-        update_host_maps.return_value = [
-            Failure(AssertionError("That is so not true")),
-            Failure(ZeroDivisionError("I cannot defy mathematics")),
-        ]
-
-        with TwistedLoggerFixture() as twisted_log:
-            error = self.assertRaises(
-                MultipleFailures, Node.objects.start_nodes,
-                list(node.system_id for node in nodes), user)
-
-        self.assertSequenceEqual(
-            update_host_maps.return_value, error.args)
-
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__updates_dns(self):
-        user = factory.make_User()
-        nodes = self.make_acquired_nodes_with_macs(user)
-
-        change_dns_zones = self.patch(dns_config, "change_dns_zones")
-
-        with TwistedLoggerFixture() as twisted_log:
-            Node.objects.start_nodes(
-                list(node.system_id for node in nodes), user)
-
-        self.assertThat(
-            change_dns_zones, MockCalledOnceWith(
-                {node.nodegroup for node in nodes}))
-
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__starts_nodes(self):
-        user = factory.make_User()
-        nodes = self.make_acquired_nodes_with_macs(user)
-        power_infos = list(
-            node.get_effective_power_info()
-            for node in nodes)
-
-        power_on_nodes = self.patch(node_module, "power_on_nodes")
-        power_on_nodes.return_value = {}
-
-        with TwistedLoggerFixture() as twisted_log:
-            Node.objects.start_nodes(
-                list(node.system_id for node in nodes), user)
-
-        self.assertThat(power_on_nodes, MockCalledOnceWith(ANY))
-
-        nodes_start_info_observed = power_on_nodes.call_args[0][0]
-        nodes_start_info_expected = [
-            (node.system_id, node.hostname, node.nodegroup.uuid, power_info)
-            for node, power_info in izip(nodes, power_infos)
-        ]
-
-        # If the following fails the diff is big, but it's useful.
-        self.maxDiff = None
-
-        self.assertItemsEqual(
-            nodes_start_info_expected,
-            nodes_start_info_observed)
-
-        # No complaints are made to the Twisted log.
-        self.assertFalse(twisted_log.containsError(), twisted_log.output)
-
-    def test__raises_failures_for_nodes_that_cannot_be_started(self):
-        power_on_nodes = self.patch(node_module, "power_on_nodes")
-        power_on_nodes.return_value = {
-            factory.make_name("system_id"): defer.fail(
-                ZeroDivisionError("Defiance is futile")),
-            factory.make_name("system_id"): defer.succeed({}),
-        }
-
-        failures = self.assertRaises(
-            MultipleFailures, Node.objects.start_nodes, [],
-            factory.make_User())
-        [failure] = failures.args
-        self.assertThat(failure.value, IsInstance(ZeroDivisionError))
-
-    def test__marks_allocated_node_as_deploying(self):
-        user = factory.make_User()
-        [node] = self.make_acquired_nodes_with_macs(user, count=1)
-        nodes_started = Node.objects.start_nodes([node.system_id], user)
-        self.assertItemsEqual([node], nodes_started)
-        self.assertEqual(
-            NODE_STATUS.DEPLOYING, reload_object(node).status)
-
-    def test__does_not_change_state_of_deployed_node(self):
-        user = factory.make_User()
-        node = factory.make_Node(
-            power_type='ether_wake', status=NODE_STATUS.DEPLOYED,
-            owner=user)
-        factory.make_MACAddress(node=node)
-        power_on_nodes = self.patch(node_module, "power_on_nodes")
-        power_on_nodes.return_value = {
-            node.system_id: defer.succeed({}),
-        }
-        nodes_started = Node.objects.start_nodes([node.system_id], user)
-        self.assertItemsEqual([node], nodes_started)
-        self.assertEqual(
-            NODE_STATUS.DEPLOYED, reload_object(node).status)
-
-    def test__only_returns_nodes_for_which_power_commands_have_been_sent(self):
-        user = factory.make_User()
-        node1, node2 = self.make_acquired_nodes_with_macs(user, count=2)
-        node1.power_type = 'ether_wake'  # Can be started.
-        node1.save()
-        node2.power_type = ''  # Undefined power type, cannot be started.
-        node2.save()
-        nodes_started = Node.objects.start_nodes(
-            [node1.system_id, node2.system_id], user)
-        self.assertItemsEqual([node1], nodes_started)
-
-    def test__does_not_try_to_start_nodes_not_allocated_to_user(self):
-        user1 = factory.make_User()
-        [node1] = self.make_acquired_nodes_with_macs(user1, count=1)
-        node1.power_type = 'ether_wake'  # can be started.
-        node1.save()
-        user2 = factory.make_User()
-        [node2] = self.make_acquired_nodes_with_macs(user2, count=1)
-        node2.power_type = 'ether_wake'  # can be started.
-        node2.save()
-
-        self.patch(node_module, 'power_on_nodes')
-        self.patch(node_module, 'wait_for_power_commands')
-        nodes_started = Node.objects.start_nodes(
-            [node1.system_id, node2.system_id], user1)
-
-        # Since no power commands were sent to the node, it isn't
-        # returned by start_nodes().
-        # test__only_returns_nodes_for_which_power_commands_have_been_sent()
-        # demonstrates this behaviour.
-        self.assertItemsEqual([node1], nodes_started)
-
-
-class NodeManagerTest_StopNodes(MAASServerTestCase):
-
-    def make_nodes_with_macs(self, user, nodegroup=None, count=3):
-        nodes = []
-        for _ in xrange(count):
-            node = factory.make_node_with_mac_attached_to_nodegroupinterface(
-                nodegroup=nodegroup, status=NODE_STATUS.READY,
-                power_type='virsh')
-            node.acquire(user)
-            nodes.append(node)
-        return nodes
-
-    def test_stop_nodes_stops_nodes(self):
-        wait_for_power_commands = self.patch_autospec(
-            node_module, 'wait_for_power_commands')
-        power_off_nodes = self.patch_autospec(node_module, "power_off_nodes")
-        power_off_nodes.side_effect = lambda nodes: {
-            system_id: Deferred() for system_id, _, _, _ in nodes}
-
-        user = factory.make_User()
-        nodes = self.make_nodes_with_macs(user)
-        power_infos = list(node.get_effective_power_info() for node in nodes)
-
-        stop_mode = factory.make_name('stop-mode')
-        nodes_stopped = Node.objects.stop_nodes(
-            list(node.system_id for node in nodes), user, stop_mode)
-
-        self.assertItemsEqual(nodes, nodes_stopped)
-        self.assertThat(power_off_nodes, MockCalledOnceWith(ANY))
-        self.assertThat(wait_for_power_commands, MockCalledOnceWith(ANY))
-
-        nodes_stop_info_observed = power_off_nodes.call_args[0][0]
-        nodes_stop_info_expected = [
-            (node.system_id, node.hostname, node.nodegroup.uuid, power_info)
-            for node, power_info in izip(nodes, power_infos)
-        ]
-
-        # The stop mode is added into the power info that's passed.
-        for _, _, _, power_info in nodes_stop_info_expected:
-            power_info.power_parameters['power_off_mode'] = stop_mode
-
-        # If the following fails the diff is big, but it's useful.
-        self.maxDiff = None
-
-        self.assertItemsEqual(
-            nodes_stop_info_expected,
-            nodes_stop_info_observed)
-
-    def test_stop_nodes_ignores_uneditable_nodes(self):
-        owner = factory.make_User()
-        nodes = self.make_nodes_with_macs(owner)
-
-        user = factory.make_User()
-        nodes_stopped = Node.objects.stop_nodes(
-            list(node.system_id for node in nodes), user)
-
-        self.assertItemsEqual([], nodes_stopped)
-
-    def test_stop_nodes_does_not_attempt_power_off_if_no_power_type(self):
-        # If the node has a power_type set to UNKNOWN_POWER_TYPE, stop_nodes()
-        # won't attempt to power it off.
-        user = factory.make_User()
-        [node] = self.make_nodes_with_macs(user, count=1)
-        node.power_type = ""
-        node.save()
-
-        nodes_stopped = Node.objects.stop_nodes([node.system_id], user)
-        self.assertItemsEqual([], nodes_stopped)
-
-    def test_stop_nodes_does_not_attempt_power_off_if_cannot_be_stopped(self):
-        # If the node has a power_type that MAAS knows stopping does not work,
-        # stop_nodes() won't attempt to power it off.
-        user = factory.make_User()
-        [node] = self.make_nodes_with_macs(user, count=1)
-        node.power_type = "ether_wake"
-        node.save()
-
-        nodes_stopped = Node.objects.stop_nodes([node.system_id], user)
-        self.assertItemsEqual([], nodes_stopped)
-
-    def test__raises_failures_for_nodes_that_cannot_be_stopped(self):
-        power_off_nodes = self.patch(node_module, "power_off_nodes")
-        power_off_nodes.return_value = {
-            factory.make_name("system_id"): defer.fail(
-                ZeroDivisionError("Ee by gum lad, that's a rum 'un.")),
-            factory.make_name("system_id"): defer.succeed({}),
-        }
-
-        failures = self.assertRaises(
-            MultipleFailures, Node.objects.stop_nodes, [], factory.make_User())
-        [failure] = failures.args
-        self.assertThat(failure.value, IsInstance(ZeroDivisionError))
-
-
 class TestNodeTransitionMonitors(MAASServerTestCase):
 
     def prepare_rpc(self):
@@ -2584,3 +2137,390 @@
             )
         node = factory.make_Node(status=status)
         self.assertEqual("Not in deployment", node.get_deployment_status())
+
+
+class TestNode_Start(MAASServerTestCase):
+    """Tests for Node.start()."""
+
+    def setUp(self):
+        super(TestNode_Start, self).setUp()
+        self.useFixture(RegionEventLoopFixture("rpc"))
+        self.useFixture(RunningEventLoopFixture())
+        self.rpc_fixture = self.useFixture(MockLiveRegionToClusterRPCFixture())
+
+    def prepare_rpc_to_cluster(self, nodegroup):
+        protocol = self.rpc_fixture.makeCluster(
+            nodegroup, cluster_module.CreateHostMaps, cluster_module.PowerOn,
+            cluster_module.StartMonitors)
+        protocol.CreateHostMaps.side_effect = always_succeed_with({})
+        protocol.StartMonitors.side_effect = always_succeed_with({})
+        protocol.PowerOn.side_effect = always_succeed_with({})
+        return protocol
+
+    def make_acquired_node_with_mac(self, user, nodegroup=None):
+        node = factory.make_node_with_mac_attached_to_nodegroupinterface(
+            nodegroup=nodegroup, status=NODE_STATUS.READY)
+        self.prepare_rpc_to_cluster(node.nodegroup)
+        node.acquire(user)
+        return node
+
+    def test__sets_user_data(self):
+        user = factory.make_User()
+        nodegroup = factory.make_NodeGroup()
+        self.prepare_rpc_to_cluster(nodegroup)
+        node = self.make_acquired_node_with_mac(user, nodegroup)
+        user_data = factory.make_bytes()
+
+        node.start(user, user_data=user_data)
+
+        nud = NodeUserData.objects.get(node=node)
+        self.assertEqual(user_data, nud.data)
+
+    def test__resets_user_data(self):
+        user = factory.make_User()
+        nodegroup = factory.make_NodeGroup()
+        self.prepare_rpc_to_cluster(nodegroup)
+        node = self.make_acquired_node_with_mac(user, nodegroup)
+        user_data = factory.make_bytes()
+        NodeUserData.objects.set_user_data(node, user_data)
+
+        node.start(user, user_data=None)
+
+        self.assertFalse(NodeUserData.objects.filter(node=node).exists())
+
+    def test__claims_static_ip_addresses(self):
+        user = factory.make_User()
+        nodegroup = factory.make_NodeGroup()
+        self.prepare_rpc_to_cluster(nodegroup)
+        node = self.make_acquired_node_with_mac(user, nodegroup)
+
+        claim_static_ip_addresses = self.patch_autospec(
+            node, "claim_static_ip_addresses", spec_set=False)
+        claim_static_ip_addresses.return_value = {}
+
+        node.start(user)
+
+        self.expectThat(node.claim_static_ip_addresses, MockAnyCall())
+
+    def test__only_claims_static_addresses_when_allocated(self):
+        user = factory.make_User()
+        nodegroup = factory.make_NodeGroup()
+        self.prepare_rpc_to_cluster(nodegroup)
+        node = self.make_acquired_node_with_mac(user, nodegroup)
+        node.status = NODE_STATUS.BROKEN
+        node.save()
+
+        claim_static_ip_addresses = self.patch_autospec(
+            node, "claim_static_ip_addresses", spec_set=False)
+        claim_static_ip_addresses.return_value = {}
+
+        node.start(user)
+
+        # No calls are made to claim_static_ip_addresses, since the node
+        # isn't ALLOCATED.
+        self.assertThat(claim_static_ip_addresses, MockNotCalled())
+
+    def test__does_not_generate_host_maps_if_not_on_managed_interface(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+        self.patch(
+            node, 'is_pxe_mac_on_managed_interface').return_value = False
+        update_host_maps = self.patch(node_module, "update_host_maps")
+        node.start(user)
+        self.assertThat(update_host_maps, MockNotCalled())
+
+    def test__updates_host_maps(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+
+        update_host_maps = self.patch(node_module, "update_host_maps")
+        update_host_maps.return_value = []  # No failures.
+
+        node.start(user)
+
+        # Host maps are updated.
+        self.assertThat(
+            update_host_maps, MockCalledOnceWith({
+                node.nodegroup: {
+                    ip_address.ip: mac.mac_address
+                    for ip_address in mac.ip_addresses.all()
+                }
+                for mac in node.mac_addresses_on_managed_interfaces()
+            }))
+
+    def test__propagates_errors_when_updating_host_maps(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+
+        update_host_maps = self.patch(node_module, "update_host_maps")
+        update_host_maps.return_value = [
+            Failure(AssertionError("Please, don't do that.")),
+            ]
+
+        error = self.assertRaises(
+            MultipleFailures, node.start, user)
+
+        self.assertSequenceEqual(
+            update_host_maps.return_value, error.args)
+
+    def test__updates_dns(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+
+        change_dns_zones = self.patch(dns_config, "change_dns_zones")
+
+        node.start(user)
+
+        self.assertThat(
+            change_dns_zones, MockCalledOnceWith(node.nodegroup))
+
+    def test__starts_nodes(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+        power_info = node.get_effective_power_info()
+
+        power_on_nodes = self.patch(node_module, "power_on_nodes")
+        power_on_nodes.return_value = {}
+
+        node.start(user)
+
+        self.assertThat(power_on_nodes, MockCalledOnceWith(ANY))
+
+        nodes_start_info_observed = power_on_nodes.call_args[0][0]
+        nodes_start_info_expected = [
+            (node.system_id, node.hostname, node.nodegroup.uuid, power_info)
+        ]
+
+        # If the following fails the diff is big, but it's useful.
+        self.maxDiff = None
+
+        self.assertItemsEqual(
+            nodes_start_info_expected,
+            nodes_start_info_observed)
+
+    def test__raises_failures_when_power_action_fails(self):
+        class PraiseBeToJTVException(Exception):
+            """A nonsense exception for this test.
+
+            (Though jtv is praiseworthy, and that's worth noting).
+            """
+
+        power_on_nodes = self.patch(node_module, "power_on_nodes")
+        power_on_nodes.return_value = {
+            factory.make_name("system_id"): defer.fail(
+                PraiseBeToJTVException("Defiance is futile")),
+        }
+
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+        failures = self.assertRaises(MultipleFailures, node.start, user)
+        [failure] = failures.args
+        self.assertThat(failure.value, IsInstance(PraiseBeToJTVException))
+
+    def test__marks_allocated_node_as_deploying(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+        node.start(user)
+        self.assertEqual(
+            NODE_STATUS.DEPLOYING, reload_object(node).status)
+
+    def test__does_not_change_state_of_deployed_node(self):
+        user = factory.make_User()
+        # Create a node that we can execute power actions on, so that we
+        # exercise the whole of start().
+        node = factory.make_Node(
+            power_type='ether_wake', status=NODE_STATUS.DEPLOYED,
+            owner=user)
+        factory.make_MACAddress(node=node)
+        power_on_nodes = self.patch(node_module, "power_on_nodes")
+        power_on_nodes.return_value = {
+            node.system_id: defer.succeed({}),
+        }
+        node.start(user)
+        self.assertEqual(
+            NODE_STATUS.DEPLOYED, reload_object(node).status)
+
+    def test__does_not_try_to_start_nodes_that_cant_be_started_by_MAAS(self):
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+        power_info = PowerInfo(
+            can_be_started=False,
+            can_be_stopped=True,
+            can_be_queried=True,
+            power_type=node.get_effective_power_type(),
+            power_parameters=node.get_effective_power_parameters(),
+            )
+        self.patch(node, 'get_effective_power_info').return_value = power_info
+        power_on_nodes = self.patch(node_module, "power_on_nodes")
+        node.start(user)
+        self.assertThat(power_on_nodes, MockNotCalled())
+
+    def test__does_not_start_nodes_the_user_cannot_edit(self):
+        power_on_nodes = self.patch_autospec(node_module, "power_on_nodes")
+        owner = factory.make_User()
+        node = self.make_acquired_node_with_mac(owner)
+
+        user = factory.make_User()
+        node.start(user)
+        self.assertThat(power_on_nodes, MockNotCalled())
+
+    def test__allows_admin_to_start_any_node(self):
+        wait_for_power_commands = self.patch_autospec(
+            node_module, 'wait_for_power_commands')
+        power_on_nodes = self.patch_autospec(node_module, "power_on_nodes")
+        owner = factory.make_User()
+        node = self.make_acquired_node_with_mac(owner)
+
+        admin = factory.make_admin()
+        node.start(admin)
+
+        self.expectThat(power_on_nodes, MockCalledOnceWith(ANY))
+        self.expectThat(wait_for_power_commands, MockCalledOnceWith(ANY))
+
+    def test__releases_static_ips_when_power_action_fails(self):
+        power_on_nodes = self.patch(node_module, "power_on_nodes")
+        power_on_nodes.return_value = {
+            factory.make_name("system_id"): defer.fail(
+                factory.make_exception("He's fallen in the water!"))
+        }
+        deallocate_ips = self.patch(
+            node_module.StaticIPAddress.objects, 'deallocate_by_node')
+
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+
+        self.assertRaises(MultipleFailures, node.start, user)
+        self.assertThat(deallocate_ips, MockCalledOnceWith(node))
+
+    def test__releases_static_ips_when_update_host_maps_fails(self):
+        update_host_maps = self.patch(node_module, "update_host_maps")
+        update_host_maps.return_value = [
+            Failure(factory.make_exception("You steaming nit, you!"))
+            ]
+        deallocate_ips = self.patch(
+            node_module.StaticIPAddress.objects, 'deallocate_by_node')
+
+        user = factory.make_User()
+        node = self.make_acquired_node_with_mac(user)
+
+        self.assertRaises(MultipleFailures, node.start, user)
+        self.assertThat(deallocate_ips, MockCalledOnceWith(node))
+
+
+class TestNode_Stop(MAASServerTestCase):
+    """Tests for Node.stop()."""
+
+    def make_node_with_mac(self, user, nodegroup=None, power_type="virsh"):
+        node = factory.make_node_with_mac_attached_to_nodegroupinterface(
+            nodegroup=nodegroup, status=NODE_STATUS.READY,
+            power_type=power_type)
+        node.acquire(user)
+        return node
+
+    def test__stops_nodes(self):
+        wait_for_power_commands = self.patch_autospec(
+            node_module, 'wait_for_power_commands')
+        power_off_nodes = self.patch_autospec(node_module, "power_off_nodes")
+        power_off_nodes.side_effect = lambda nodes: {
+            system_id: Deferred() for system_id, _, _, _ in nodes}
+
+        user = factory.make_User()
+        node = self.make_node_with_mac(user)
+        power_info = node.get_effective_power_info()
+
+        stop_mode = factory.make_name('stop-mode')
+        node.stop(user, stop_mode)
+
+        self.assertThat(power_off_nodes, MockCalledOnceWith(ANY))
+        self.assertThat(wait_for_power_commands, MockCalledOnceWith(ANY))
+
+        nodes_stop_info_observed = power_off_nodes.call_args[0][0]
+        nodes_stop_info_expected = [
+            (node.system_id, node.hostname, node.nodegroup.uuid, power_info)
+            ]
+
+        # The stop mode is added into the power info that's passed.
+        for _, _, _, power_info in nodes_stop_info_expected:
+            power_info.power_parameters['power_off_mode'] = stop_mode
+
+        # If the following fails the diff is big, but it's useful.
+        self.maxDiff = None
+
+        self.assertItemsEqual(
+            nodes_stop_info_expected,
+            nodes_stop_info_observed)
+
+    def test__does_not_stop_nodes_the_user_cannot_edit(self):
+        power_off_nodes = self.patch_autospec(node_module, "power_off_nodes")
+        owner = factory.make_User()
+        node = self.make_node_with_mac(owner)
+
+        user = factory.make_User()
+        node.stop(user)
+        self.assertThat(power_off_nodes, MockNotCalled())
+
+    def test__allows_admin_to_stop_any_node(self):
+        wait_for_power_commands = self.patch_autospec(
+            node_module, 'wait_for_power_commands')
+        power_off_nodes = self.patch_autospec(node_module, "power_off_nodes")
+        owner = factory.make_User()
+        node = self.make_node_with_mac(owner)
+
+        admin = factory.make_admin()
+        node.stop(admin)
+
+        self.assertThat(power_off_nodes, MockCalledOnceWith(ANY))
+        self.assertThat(wait_for_power_commands, MockCalledOnceWith(ANY))
+
+    def test__does_not_attempt_power_off_if_no_power_type(self):
+        # If the node has a power_type set to UNKNOWN_POWER_TYPE, stop()
+        # won't attempt to power it off.
+        user = factory.make_User()
+        node = self.make_node_with_mac(user)
+        node.power_type = ""
+        node.save()
+
+        power_off_nodes = self.patch_autospec(node_module, "power_off_nodes")
+        node.stop(user)
+        self.assertThat(power_off_nodes, MockNotCalled())
+
+    def test__does_not_attempt_power_off_if_cannot_be_stopped(self):
+        # If the node has a power_type that doesn't allow MAAS to power
+        # the node off, stop() won't attempt to send the power command.
+        user = factory.make_User()
+        node = self.make_node_with_mac(user, power_type="ether_wake")
+        node.save()
+
+        power_off_nodes = self.patch_autospec(node_module, "power_off_nodes")
+        node.stop(user)
+        self.assertThat(power_off_nodes, MockNotCalled())
+
+    def test__propagates_failures_when_power_action_fails(self):
+        fake_exception_type = factory.make_exception_type()
+
+        power_off_nodes = self.patch(node_module, "power_off_nodes")
+        power_off_nodes.return_value = {
+            factory.make_name("system_id"): defer.fail(
+                fake_exception_type("Soon be the weekend!"))
+        }
+
+        user = factory.make_User()
+        node = self.make_node_with_mac(user)
+
+        error = self.assertRaises(MultipleFailures, node.stop, user)
+        [failure] = error.args
+        self.assertThat(failure.value, IsInstance(fake_exception_type))
+
+    def test__returns_false_if_power_action_not_sent(self):
+        user = factory.make_User()
+        node = self.make_node_with_mac(user, power_type="")
+
+        self.patch_autospec(node_module, "power_off_nodes")
+        self.assertIs(False, node.stop(user))
+
+    def test__returns_true_if_power_action_sent(self):
+        user = factory.make_User()
+        node = self.make_node_with_mac(user, power_type="virsh")
+
+        self.patch_autospec(node_module, "power_off_nodes")
+        self.assertIs(True, node.stop(user))

=== modified file 'src/maasserver/node_action.py'
--- src/maasserver/node_action.py	2014-10-20 22:01:33 +0000
+++ src/maasserver/node_action.py	2014-10-22 10:46:23 +0000
@@ -47,10 +47,7 @@
     Redirect,
     StaticIPAddressExhaustion,
     )
-from maasserver.models import (
-    Node,
-    SSHKey,
-    )
+from maasserver.models import SSHKey
 from maasserver.node_status import is_failed_status
 from provisioningserver.rpc.exceptions import (
     MultipleFailures,
@@ -345,7 +342,7 @@
             self.node.acquire(self.user, token=None)
 
         try:
-            Node.objects.start_nodes([self.node.system_id], self.user)
+            self.node.start(self.user)
         except StaticIPAddressExhaustion:
             raise NodeActionError(
                 "%s: Failed to start, static IP addresses are exhausted."
@@ -378,7 +375,7 @@
     def execute(self, allow_redirect=True):
         """See `NodeAction.execute`."""
         try:
-            Node.objects.stop_nodes([self.node.system_id], self.user)
+            self.node.stop(self.user)
         except RPC_EXCEPTIONS as exception:
             raise NodeActionError(exception)
         else:

=== modified file 'src/maasserver/tests/test_node_action.py'
--- src/maasserver/tests/test_node_action.py	2014-10-20 22:01:33 +0000
+++ src/maasserver/tests/test_node_action.py	2014-10-22 10:46:23 +0000
@@ -33,7 +33,6 @@
     Redirect,
     )
 from maasserver.models import StaticIPAddress
-from maasserver.models.node import Node
 from maasserver.node_action import (
     AbortCommissioning,
     AbortOperation,
@@ -230,17 +229,16 @@
     )
 
     def test_Commission_starts_commissioning(self):
-        start_nodes = self.patch(Node.objects, "start_nodes")
         node = factory.make_Node(
             mac=True, status=self.status,
             power_type='ether_wake')
+        node_start = self.patch(node, 'start')
         admin = factory.make_admin()
         action = Commission(node, admin)
         action.execute()
         self.assertEqual(NODE_STATUS.COMMISSIONING, node.status)
         self.assertThat(
-            start_nodes, MockCalledOnceWith(
-                [node.system_id], admin, user_data=ANY))
+            node_start, MockCalledOnceWith(admin, user_data=ANY))
 
 
 class TestAbortCommissioningNodeAction(MAASServerTestCase):
@@ -249,14 +247,12 @@
         node = factory.make_Node(
             mac=True, status=NODE_STATUS.COMMISSIONING,
             power_type='virsh')
-        stop_nodes = self.patch(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        node_stop = self.patch_autospec(node, 'stop')
         admin = factory.make_admin()
 
         AbortCommissioning(node, admin).execute()
         self.assertEqual(NODE_STATUS.NEW, node.status)
-        self.assertThat(
-            stop_nodes, MockCalledOnceWith([node.system_id], admin))
+        self.assertThat(node_stop, MockCalledOnceWith(admin))
 
 
 class TestAbortOperationNodeAction(MAASServerTestCase):
@@ -265,14 +261,12 @@
         owner = factory.make_User()
         node = factory.make_Node(
             status=NODE_STATUS.DISK_ERASING, owner=owner)
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        node_stop = self.patch_autospec(node, 'stop')
 
         AbortOperation(node, owner).execute()
 
         self.assertEqual(NODE_STATUS.FAILED_DISK_ERASING, node.status)
-        self.assertThat(
-            stop_nodes, MockCalledOnceWith([node.system_id], owner))
+        self.assertThat(node_stop, MockCalledOnceWith(owner))
 
 
 class TestAcquireNodeNodeAction(MAASServerTestCase):
@@ -314,14 +308,14 @@
         self.assertIn("SSH key", inhibition)
 
     def test_StartNode_starts_node(self):
-        start_nodes = self.patch(Node.objects, "start_nodes")
         user = factory.make_User()
         node = factory.make_Node(
             mac=True, status=NODE_STATUS.ALLOCATED,
             power_type='ether_wake', owner=user)
+        node_start = self.patch(node, 'start')
         StartNode(node, user).execute()
         self.assertThat(
-            start_nodes, MockCalledOnceWith([node.system_id], user))
+            node_start, MockCalledOnceWith(user))
 
     def test_StartNode_returns_error_when_no_more_static_IPs(self):
         user = factory.make_User()
@@ -351,9 +345,9 @@
         self.assertFalse(StartNode(node, user).is_permitted())
 
     def test_StartNode_allocates_node_if_node_not_already_allocated(self):
-        self.patch(Node.objects, "start_nodes")
         user = factory.make_User()
         node = factory.make_Node(status=NODE_STATUS.READY)
+        self.patch(node, 'start')
         action = StartNode(node, user)
         action.execute()
 
@@ -361,16 +355,16 @@
         self.assertEqual(NODE_STATUS.ALLOCATED, node.status)
 
     def test_StartNode_label_shows_allocate_if_unallocated(self):
-        self.patch(Node.objects, "start_nodes")
         user = factory.make_User()
         node = factory.make_Node(status=NODE_STATUS.READY)
+        self.patch(node, 'start')
         action = StartNode(node, user)
         self.assertEqual("Acquire and start node", action.display)
 
     def test_StartNode_label_hides_allocate_if_allocated(self):
-        self.patch(Node.objects, "start_nodes")
         user = factory.make_User()
         node = factory.make_Node(status=NODE_STATUS.READY)
+        self.patch(node, 'start')
         node.acquire(user)
         action = StartNode(node, user)
         self.assertEqual("Start node", action.display)
@@ -384,17 +378,17 @@
         self.assertEqual("Start node", action.display)
 
     def test_StartNode_does_not_reallocate_when_run_by_non_owner(self):
-        self.patch(Node.objects, "start_nodes")
         user = factory.make_User()
         admin = factory.make_admin()
         node = factory.make_Node(status=NODE_STATUS.READY)
+        self.patch(node, 'start')
         node.acquire(user)
         action = StartNode(node, admin)
 
         # This action.execute() will not fail because the non-owner is
         # an admin, so they can start the node. Even if they weren't an
-        # admin, the node still wouldn't start;
-        # NodeManager.start_nodes() would ignore it.
+        # admin, the node still wouldn't start; Node.start() would
+        # ignore it.
         action.execute()
         self.assertEqual(user, node.owner)
         self.assertEqual(NODE_STATUS.ALLOCATED, node.status)
@@ -412,13 +406,11 @@
             mac=True, status=NODE_STATUS.DEPLOYED,
             power_type='ipmi',
             owner=user, power_parameters=params)
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        node_stop = self.patch_autospec(node, 'stop')
 
         StopNode(node, user).execute()
 
-        self.assertThat(
-            stop_nodes, MockCalledOnceWith([node.system_id], user))
+        self.assertThat(node_stop, MockCalledOnceWith(user))
 
     def test_StopNode_actionnable_for_failed_states(self):
         status = random.choice(FAILED_STATUSES)
@@ -452,14 +444,13 @@
             mac=True, status=self.actionable_status,
             power_type='ipmi',
             owner=user, power_parameters=params)
-        stop_nodes = self.patch_autospec(Node.objects, "stop_nodes")
-        stop_nodes.return_value = [node]
+        node_stop = self.patch_autospec(node, 'stop')
 
         ReleaseNode(node, user).execute()
 
         self.expectThat(node.status, Equals(NODE_STATUS.RELEASING))
         self.assertThat(
-            stop_nodes, MockCalledOnceWith([node.system_id], user))
+            node_stop, MockCalledOnceWith(user))
 
 
 class TestUseCurtinNodeAction(MAASServerTestCase):
@@ -571,12 +562,10 @@
             exception = self.exception_class(factory.make_name("exception"))
         return exception
 
-    def patch_rpc_methods(self):
+    def patch_rpc_methods(self, node):
         exception = self.make_exception()
-        self.patch(Node.objects, "start_nodes").side_effect = (
-            exception)
-        self.patch(Node.objects, "stop_nodes").side_effect = (
-            exception)
+        self.patch(node, 'start').side_effect = exception
+        self.patch(node, 'stop').side_effect = exception
 
     def make_action(self, action_class, node_status):
         node = factory.make_Node(
@@ -586,56 +575,56 @@
 
     def test_Commission_handles_rpc_errors(self):
         action = self.make_action(Commission, NODE_STATUS.READY)
-        self.patch_rpc_methods()
+        self.patch_rpc_methods(action.node)
         exception = self.assertRaises(NodeActionError, action.execute)
         self.assertEqual(
             get_error_message_for_exception(
-                Node.objects.start_nodes.side_effect),
+                action.node.start.side_effect),
             unicode(exception))
 
     def test_AbortCommissioning_handles_rpc_errors(self):
         action = self.make_action(
             AbortCommissioning, NODE_STATUS.COMMISSIONING)
-        self.patch_rpc_methods()
+        self.patch_rpc_methods(action.node)
         exception = self.assertRaises(NodeActionError, action.execute)
         self.assertEqual(
             get_error_message_for_exception(
-                Node.objects.stop_nodes.side_effect),
+                action.node.stop.side_effect),
             unicode(exception))
 
     def test_AbortOperation_handles_rpc_errors(self):
         action = self.make_action(
             AbortOperation, NODE_STATUS.DISK_ERASING)
-        self.patch_rpc_methods()
+        self.patch_rpc_methods(action.node)
         exception = self.assertRaises(NodeActionError, action.execute)
         self.assertEqual(
             get_error_message_for_exception(
-                Node.objects.stop_nodes.side_effect),
+                action.node.stop.side_effect),
             unicode(exception))
 
     def test_StartNode_handles_rpc_errors(self):
         action = self.make_action(StartNode, NODE_STATUS.READY)
-        self.patch_rpc_methods()
+        self.patch_rpc_methods(action.node)
         exception = self.assertRaises(NodeActionError, action.execute)
         self.assertEqual(
             get_error_message_for_exception(
-                Node.objects.start_nodes.side_effect),
+                action.node.start.side_effect),
             unicode(exception))
 
     def test_StopNode_handles_rpc_errors(self):
         action = self.make_action(StopNode, NODE_STATUS.DEPLOYED)
-        self.patch_rpc_methods()
+        self.patch_rpc_methods(action.node)
         exception = self.assertRaises(NodeActionError, action.execute)
         self.assertEqual(
             get_error_message_for_exception(
-                Node.objects.stop_nodes.side_effect),
+                action.node.stop.side_effect),
             unicode(exception))
 
     def test_ReleaseNode_handles_rpc_errors(self):
         action = self.make_action(ReleaseNode, NODE_STATUS.ALLOCATED)
-        self.patch_rpc_methods()
+        self.patch_rpc_methods(action.node)
         exception = self.assertRaises(NodeActionError, action.execute)
         self.assertEqual(
             get_error_message_for_exception(
-                Node.objects.stop_nodes.side_effect),
+                action.node.stop.side_effect),
             unicode(exception))