Merge "Remove 'node' parameter from the Power interface"

ironic/conductor/manager.py

@@ -211,7 +211,7 @@ class ConductorManager(periodic_task.PeriodicTasks):
             if 'instance_uuid' in delta:
                 task.driver.power.validate(task, node_obj)
                 node_obj['power_state'] = \
-                        task.driver.power.get_power_state(task, node_obj)
+                        task.driver.power.get_power_state(task)
 
                 if node_obj['power_state'] != states.POWER_OFF:
                     raise exception.NodeInWrongPowerState(
@@ -249,7 +249,7 @@ class ConductorManager(periodic_task.PeriodicTasks):
         with task_manager.acquire(context, node_id, shared=False) as task:
             task.driver.power.validate(task, task.node)
             task.spawn_after(self._spawn_worker, utils.node_power_action,
-                             task, task.node, new_state)
+                             task, new_state)
 
     @messaging.expected_exceptions(exception.NoFreeConductorWorker,
                                    exception.NodeLocked,
@@ -512,7 +512,7 @@ class ConductorManager(periodic_task.PeriodicTasks):
                 return
 
         try:
-            power_state = task.driver.power.get_power_state(task, node)
+            power_state = task.driver.power.get_power_state(task)
         except Exception as e:
             # TODO(rloo): change to IronicException, after
             #             https://bugs.launchpad.net/ironic/+bug/1267693
@@ -565,8 +565,7 @@ class ConductorManager(periodic_task.PeriodicTasks):
         try:
             # node_power_action will update the node record
             # so don't do that again here.
-            utils.node_power_action(task, task.node,
+            utils.node_power_action(task, node.power_state)
-                                    node.power_state)
         except Exception as e:
             # TODO(rloo): change to IronicException after
             # https://bugs.launchpad.net/ironic/+bug/1267693

ironic/conductor/utils.py

@@ -43,13 +43,12 @@ def node_set_boot_device(task, device, persistent=False):
 
 
 @task_manager.require_exclusive_lock
-def node_power_action(task, node, state):
+def node_power_action(task, state):
     """Change power state or reset for a node.
 
     Perform the requested power action if the transition is required.
 
-    :param task: a TaskManager instance.
+    :param task: a TaskManager instance containing the node to act on.
-    :param node: the Node object to act upon.
     :param state: Any power state from ironic.common.states. If the
         state is 'REBOOT' then a reboot will be attempted, otherwise
         the node power state is directly set to 'state'.
@@ -59,12 +58,13 @@ def node_power_action(task, node, state):
              wrong occurred during the power action.
 
     """
+    node = task.node
     context = task.context
     new_state = states.POWER_ON if state == states.REBOOT else state
 
     if state != states.REBOOT:
         try:
-            curr_state = task.driver.power.get_power_state(task, node)
+            curr_state = task.driver.power.get_power_state(task)
         except Exception as e:
             with excutils.save_and_reraise_exception():
                 node['last_error'] = \
@@ -100,9 +100,9 @@ def node_power_action(task, node, state):
     # take power action
     try:
         if state != states.REBOOT:
-            task.driver.power.set_power_state(task, node, new_state)
+            task.driver.power.set_power_state(task, new_state)
         else:
-            task.driver.power.reboot(task, node)
+            task.driver.power.reboot(task)
     except Exception as e:
         with excutils.save_and_reraise_exception():
             node['last_error'] = \

ironic/drivers/base.py

@@ -192,6 +192,9 @@ class DeployInterface(object):
 class PowerInterface(object):
     """Interface for power-related actions."""
 
+    # TODO(lucasagomes): The 'node' parameter needs to be passed to validate()
+    # because of the ConductorManager.validate_driver_interfaces().
+    # Remove it after all cleaning all the interfaces
     @abc.abstractmethod
     def validate(self, task, node):
         """Validate the driver-specific Node power info.
@@ -200,30 +203,32 @@ class PowerInterface(object):
         supplied node contains the required information for this driver to
         manage the power state of the node.
 
-        :param task: a task from TaskManager.
+        :param task: a TaskManager instance containing the node to act on.
         :param node: a single Node to validate.
         :raises: InvalidParameterValue
         """
 
     @abc.abstractmethod
-    def get_power_state(self, task, node):
+    def get_power_state(self, task):
-        """Return the power state of the node.
+        """Return the power state of the task's node.
 
-        TODO
+        :param task: a TaskManager instance containing the node to act on.
+        :returns: a power state. One of :mod:`ironic.common.states`.
         """
 
     @abc.abstractmethod
-    def set_power_state(self, task, node, power_state):
+    def set_power_state(self, task, power_state):
-        """Set the power state of the node.
+        """Set the power state of the task's node.
 
-        TODO
+        :param task: a TaskManager instance containing the node to act on.
+        :param power_state: Any power state from :mod:`ironic.common.states`.
         """
 
     @abc.abstractmethod
-    def reboot(self, task, node):
+    def reboot(self, task):
-        """Perform a hard reboot of the node.
+        """Perform a hard reboot of the task's node.
 
-        TODO
+        :param task: a TaskManager instance containing the node to act on.
         """
 
 

ironic/drivers/modules/fake.py

@@ -45,16 +45,16 @@ class FakePower(base.PowerInterface):
     def validate(self, task, node):
         pass
 
-    def get_power_state(self, task, node):
+    def get_power_state(self, task):
-        return node.power_state
+        return task.node.power_state
 
-    def set_power_state(self, task, node, power_state):
+    def set_power_state(self, task, power_state):
         if power_state not in [states.POWER_ON, states.POWER_OFF]:
             raise exception.InvalidParameterValue(_("set_power_state called "
                     "with an invalid power state: %s.") % power_state)
-        node.power_state = power_state
+        task.node.power_state = power_state
 
-    def reboot(self, task, node):
+    def reboot(self, task):
         pass
 
 

ironic/drivers/modules/ipminative.py

@@ -205,29 +205,27 @@ class NativeIPMIPower(base.PowerInterface):
         :raises: InvalidParameterValue when required ipmi credentials
                  are missing.
         """
-        _parse_driver_info(node)
+        _parse_driver_info(task.node)
 
-    def get_power_state(self, task, node):
+    def get_power_state(self, task):
-        """Get the current power state.
+        """Get the current power state of the task's node.
 
-        :param task: a TaskManager instance.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: the node info.
         :returns:  power state POWER_ON, POWER_OFF or ERROR defined in
                  :class:`ironic.common.states`.
         :raises: InvalidParameterValue when required ipmi credentials
                  are missing.
         :raises: IPMIFailure when the native ipmi call fails.
         """
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
         return _power_status(driver_info)
 
     @task_manager.require_exclusive_lock
-    def set_power_state(self, task, node, pstate):
+    def set_power_state(self, task, pstate):
         """Turn the power on or off.
 
-        :param task: a TaskManager instance.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: the node info.
+        :param pstate: a power state that will be set on the task's node.
-        :param pstate: a power state that will be set on the given node.
         :raises: IPMIFailure when the native ipmi call fails.
         :raises: InvalidParameterValue when an invalid power state
                  is specified or required ipmi credentials are missing.
@@ -235,7 +233,7 @@ class NativeIPMIPower(base.PowerInterface):
                  from ipmi.
         """
 
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
 
         if pstate == states.POWER_ON:
             _power_on(driver_info)
@@ -247,11 +245,10 @@ class NativeIPMIPower(base.PowerInterface):
                 ) % pstate)
 
     @task_manager.require_exclusive_lock
-    def reboot(self, task, node):
+    def reboot(self, task):
-        """Cycles the power to a node.
+        """Cycles the power to the task's node.
 
-        :param task: a TaskManager instance.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: the node info.
         :raises: IPMIFailure when the native ipmi call fails.
         :raises: InvalidParameterValue when required ipmi credentials
                  are missing.
@@ -259,7 +256,7 @@ class NativeIPMIPower(base.PowerInterface):
                  from ipmi.
         """
 
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
         _reboot(driver_info)
 
 

ironic/drivers/modules/ipmitool.py

@@ -295,26 +295,24 @@ class IPMIPower(base.PowerInterface):
                     "%(error)s") % {'node': node.uuid, 'error': e}
             raise exception.InvalidParameterValue(msg)
 
-    def get_power_state(self, task, node):
+    def get_power_state(self, task):
-        """Get the current power state.
+        """Get the current power state of the task's node.
 
-        :param task: a TaskManager instance.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: The Node.
         :returns: one of ironic.common.states POWER_OFF, POWER_ON or ERROR.
         :raises: InvalidParameterValue if required ipmi parameters are missing.
         :raises: IPMIFailure on an error from ipmitool (from _power_status
             call).
 
         """
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
         return _power_status(driver_info)
 
     @task_manager.require_exclusive_lock
-    def set_power_state(self, task, node, pstate):
+    def set_power_state(self, task, pstate):
         """Turn the power on or off.
 
-        :param task: a TaskManager instance.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: The Node.
         :param pstate: The desired power state, one of ironic.common.states
             POWER_ON, POWER_OFF.
         :raises: InvalidParameterValue if required ipmi parameters are missing
@@ -322,7 +320,7 @@ class IPMIPower(base.PowerInterface):
         :raises: PowerStateFailure if the power couldn't be set to pstate.
 
         """
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
 
         if pstate == states.POWER_ON:
             state = _power_on(driver_info)
@@ -336,17 +334,16 @@ class IPMIPower(base.PowerInterface):
             raise exception.PowerStateFailure(pstate=pstate)
 
     @task_manager.require_exclusive_lock
-    def reboot(self, task, node):
+    def reboot(self, task):
-        """Cycles the power to a node.
+        """Cycles the power to the task's node.
 
-        :param task: a TaskManager instance.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: The Node.
         :raises: InvalidParameterValue if required ipmi parameters are missing.
         :raises: PowerStateFailure if the final state of the node is not
             POWER_ON.
 
         """
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
         _power_off(driver_info)
         state = _power_on(driver_info)
 

ironic/drivers/modules/pxe.py

@@ -553,7 +553,7 @@ class PXEDeploy(base.DeployInterface):
         _create_token_file(task)
         _update_neutron(task)
         manager_utils.node_set_boot_device(task, 'pxe', persistent=True)
-        manager_utils.node_power_action(task, task.node, states.REBOOT)
+        manager_utils.node_power_action(task, states.REBOOT)
 
         return states.DEPLOYWAIT
 
@@ -567,7 +567,7 @@ class PXEDeploy(base.DeployInterface):
         :param task: a TaskManager instance containing the node to act on.
         :returns: deploy state DELETED.
         """
-        manager_utils.node_power_action(task, task.node, states.POWER_OFF)
+        manager_utils.node_power_action(task, states.POWER_OFF)
         _remove_internal_attrs(task)
 
         return states.DELETED
@@ -680,7 +680,7 @@ class VendorPassthru(base.VendorInterface):
             node.target_provision_state = states.NOSTATE
             node.save(task.context)
             try:
-                manager_utils.node_power_action(task, node, states.POWER_OFF)
+                manager_utils.node_power_action(task, states.POWER_OFF)
             except Exception:
                 msg = (_('Node %s failed to power off while handling deploy '
                          'failure. This may be a serious condition. Node '

ironic/drivers/modules/seamicro.py

@@ -321,35 +321,33 @@ class Power(base.PowerInterface):
 
         Check that node 'driver_info' contains the required fields.
 
-        :param task: A instance of `ironic.manager.task_manager.TaskManager`.
+        :param task: a TaskManager instance containing the node to act on.
         :param node: Single node object.
         :raises: InvalidParameterValue if required seamicro parameters are
             missing.
         """
-        _parse_driver_info(node)
+        _parse_driver_info(task.node)
 
-    def get_power_state(self, task, node):
+    def get_power_state(self, task):
-        """Get the current power state.
+        """Get the current power state of the task's node.
 
         Poll the host for the current power state of the node.
 
-        :param task: A instance of `ironic.manager.task_manager.TaskManager`.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: A single node.
         :raises: InvalidParameterValue if required seamicro parameters are
             missing.
         :raises: ServiceUnavailable on an error from SeaMicro Client.
         :returns: power state. One of :class:`ironic.common.states`.
         """
-        return _get_power_status(node)
+        return _get_power_status(task.node)
 
     @task_manager.require_exclusive_lock
-    def set_power_state(self, task, node, pstate):
+    def set_power_state(self, task, pstate):
         """Turn the power on or off.
 
         Set the power state of a node.
 
-        :param task: A instance of `ironic.manager.task_manager.TaskManager`.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: A single node.
         :param pstate: Either POWER_ON or POWER_OFF from :class:
             `ironic.common.states`.
         :raises: InvalidParameterValue if an invalid power state was specified.
@@ -357,9 +355,9 @@ class Power(base.PowerInterface):
         """
 
         if pstate == states.POWER_ON:
-            state = _power_on(node)
+            state = _power_on(task.node)
         elif pstate == states.POWER_OFF:
-            state = _power_off(node)
+            state = _power_off(task.node)
         else:
             raise exception.InvalidParameterValue(_(
                 "set_power_state called with invalid power state."))
@@ -368,17 +366,16 @@ class Power(base.PowerInterface):
             raise exception.PowerStateFailure(pstate=pstate)
 
     @task_manager.require_exclusive_lock
-    def reboot(self, task, node):
+    def reboot(self, task):
-        """Cycles the power to a node.
+        """Cycles the power to the task's node.
 
-        :param task: a TaskManager instance.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: An Ironic node object.
         :raises: InvalidParameterValue if required seamicro parameters are
             missing.
         :raises: PowerStateFailure if the final state of the node is not
             POWER_ON.
         """
-        state = _reboot(node)
+        state = _reboot(task.node)
 
         if state != states.POWER_ON:
             raise exception.PowerStateFailure(pstate=states.POWER_ON)

ironic/drivers/modules/ssh.py

@@ -369,19 +369,17 @@ class SSHPower(base.PowerInterface):
             raise exception.InvalidParameterValue(_("Node %s does not have "
                                 "any port associated with it.") % node.uuid)
         try:
-            _get_connection(node)
+            _get_connection(task.node)
         except exception.SSHConnectFailed as e:
             raise exception.InvalidParameterValue(_("SSH connection cannot"
                                                     " be established: %s") % e)
 
-    def get_power_state(self, task, node):
+    def get_power_state(self, task):
-        """Get the current power state.
+        """Get the current power state of the task's node.
 
-        Poll the host for the current power state of the node.
+        Poll the host for the current power state of the task's node.
-
-        :param task: An instance of `ironic.manager.task_manager.TaskManager`.
-        :param node: A single node.
 
+        :param task: a TaskManager instance containing the node to act on.
         :returns: power state. One of :class:`ironic.common.states`.
         :raises: InvalidParameterValue if any connection parameters are
             incorrect.
@@ -389,22 +387,20 @@ class SSHPower(base.PowerInterface):
         :raises: SSHCommandFailed on an error from ssh.
         :raises: SSHConnectFailed if ssh failed to connect to the node.
         """
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
         driver_info['macs'] = driver_utils.get_node_mac_addresses(task)
-        ssh_obj = _get_connection(node)
+        ssh_obj = _get_connection(task.node)
         return _get_power_status(ssh_obj, driver_info)
 
     @task_manager.require_exclusive_lock
-    def set_power_state(self, task, node, pstate):
+    def set_power_state(self, task, pstate):
         """Turn the power on or off.
 
-        Set the power state of a node.
+        Set the power state of the task's node.
 
-        :param task: An instance of `ironic.manager.task_manager.TaskManager`.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: A single node.
         :param pstate: Either POWER_ON or POWER_OFF from :class:
             `ironic.common.states`.
-
         :raises: InvalidParameterValue if any connection parameters are
             incorrect, or if the desired power state is invalid.
         :raises: NodeNotFound.
@@ -412,9 +408,9 @@ class SSHPower(base.PowerInterface):
         :raises: SSHCommandFailed on an error from ssh.
         :raises: SSHConnectFailed if ssh failed to connect to the node.
         """
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
         driver_info['macs'] = driver_utils.get_node_mac_addresses(task)
-        ssh_obj = _get_connection(node)
+        ssh_obj = _get_connection(task.node)
 
         if pstate == states.POWER_ON:
             state = _power_on(ssh_obj, driver_info)
@@ -428,14 +424,12 @@ class SSHPower(base.PowerInterface):
             raise exception.PowerStateFailure(pstate=pstate)
 
     @task_manager.require_exclusive_lock
-    def reboot(self, task, node):
+    def reboot(self, task):
-        """Cycles the power to a node.
+        """Cycles the power to the task's node.
 
         Power cycles a node.
 
-        :param task: An instance of `ironic.manager.task_manager.TaskManager`.
+        :param task: a TaskManager instance containing the node to act on.
-        :param node: A single node.
-
         :raises: InvalidParameterValue if any connection parameters are
             incorrect.
         :raises: NodeNotFound.
@@ -443,9 +437,9 @@ class SSHPower(base.PowerInterface):
         :raises: SSHCommandFailed on an error from ssh.
         :raises: SSHConnectFailed if ssh failed to connect to the node.
         """
-        driver_info = _parse_driver_info(node)
+        driver_info = _parse_driver_info(task.node)
         driver_info['macs'] = driver_utils.get_node_mac_addresses(task)
-        ssh_obj = _get_connection(node)
+        ssh_obj = _get_connection(task.node)
         current_pstate = _get_power_status(ssh_obj, driver_info)
         if current_pstate == states.POWER_ON:
             _power_off(ssh_obj, driver_info)

ironic/tests/conductor/test_conductor_utils.py

@@ -85,11 +85,10 @@ class NodePowerActionTestCase(base.DbTestCase):
                 as get_power_mock:
             get_power_mock.return_value = states.POWER_OFF
 
-            conductor_utils.node_power_action(task, task.node,
+            conductor_utils.node_power_action(task, states.POWER_ON)
-                                              states.POWER_ON)
 
             node.refresh()
-            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
+            get_power_mock.assert_called_once_with(mock.ANY)
             self.assertEqual(states.POWER_ON, node['power_state'])
             self.assertIsNone(node['target_power_state'])
             self.assertIsNone(node['last_error'])
@@ -106,11 +105,10 @@ class NodePowerActionTestCase(base.DbTestCase):
                 as get_power_mock:
             get_power_mock.return_value = states.POWER_ON
 
-            conductor_utils.node_power_action(task, task.node,
+            conductor_utils.node_power_action(task, states.POWER_OFF)
-                                              states.POWER_OFF)
 
             node.refresh()
-            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
+            get_power_mock.assert_called_once_with(mock.ANY)
             self.assertEqual(states.POWER_OFF, node['power_state'])
             self.assertIsNone(node['target_power_state'])
             self.assertIsNone(node['last_error'])
@@ -124,11 +122,10 @@ class NodePowerActionTestCase(base.DbTestCase):
         task = task_manager.TaskManager(self.context, node.uuid)
 
         with mock.patch.object(self.driver.power, 'reboot') as reboot_mock:
-            conductor_utils.node_power_action(task, task.node,
+            conductor_utils.node_power_action(task, states.REBOOT)
-                                              states.REBOOT)
 
             node.refresh()
-            reboot_mock.assert_called_once_with(mock.ANY, mock.ANY)
+            reboot_mock.assert_called_once_with(mock.ANY)
             self.assertEqual(states.POWER_ON, node['power_state'])
             self.assertIsNone(node['target_power_state'])
             self.assertIsNone(node['last_error'])
@@ -150,18 +147,16 @@ class NodePowerActionTestCase(base.DbTestCase):
             self.assertRaises(exception.InvalidParameterValue,
                               conductor_utils.node_power_action,
                               task,
-                              task.node,
                               "INVALID_POWER_STATE")
 
             node.refresh()
-            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
+            get_power_mock.assert_called_once_with(mock.ANY)
             self.assertEqual(states.POWER_ON, node['power_state'])
             self.assertIsNone(node['target_power_state'])
             self.assertIsNotNone(node['last_error'])
 
             # last_error is cleared when a new transaction happens
-            conductor_utils.node_power_action(task, task.node,
+            conductor_utils.node_power_action(task, states.POWER_OFF)
-                                              states.POWER_OFF)
             node.refresh()
             self.assertEqual(states.POWER_OFF, node['power_state'])
             self.assertIsNone(node['target_power_state'])
@@ -181,8 +176,7 @@ class NodePowerActionTestCase(base.DbTestCase):
                                           target_power_state=states.POWER_OFF)
         task = task_manager.TaskManager(self.context, node.uuid)
 
-        conductor_utils.node_power_action(task, task.node,
+        conductor_utils.node_power_action(task, states.POWER_OFF)
-                                          states.POWER_OFF)
 
         node.refresh()
         self.assertEqual(states.POWER_OFF, node['power_state'])
@@ -206,11 +200,10 @@ class NodePowerActionTestCase(base.DbTestCase):
 
             with mock.patch.object(self.driver.power, 'set_power_state') \
                     as set_power_mock:
-                conductor_utils.node_power_action(task, task.node,
+                conductor_utils.node_power_action(task, states.POWER_ON)
-                                                  states.POWER_ON)
 
                 node.refresh()
-                get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
+                get_power_mock.assert_called_once_with(mock.ANY)
                 self.assertFalse(set_power_mock.called,
                                  "set_power_state unexpectedly called")
                 self.assertEqual(states.POWER_ON, node['power_state'])
@@ -235,11 +228,10 @@ class NodePowerActionTestCase(base.DbTestCase):
             self.assertRaises(exception.InvalidParameterValue,
                               conductor_utils.node_power_action,
                               task,
-                              task.node,
                               states.POWER_ON)
 
             node.refresh()
-            get_power_state_mock.assert_called_once_with(mock.ANY, mock.ANY)
+            get_power_state_mock.assert_called_once_with(mock.ANY)
             self.assertEqual(states.POWER_ON, node['power_state'])
             self.assertIsNone(node['target_power_state'])
             self.assertIsNotNone(node['last_error'])
@@ -265,12 +257,11 @@ class NodePowerActionTestCase(base.DbTestCase):
                     exception.IronicException,
                     conductor_utils.node_power_action,
                     task,
-                    task.node,
                     states.POWER_ON)
 
                 node.refresh()
-                get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
+                get_power_mock.assert_called_once_with(mock.ANY)
-                set_power_mock.assert_called_once_with(mock.ANY, mock.ANY,
+                set_power_mock.assert_called_once_with(mock.ANY,
                                                        states.POWER_ON)
                 self.assertEqual(states.POWER_OFF, node['power_state'])
                 self.assertIsNone(node['target_power_state'])

ironic/tests/conductor/test_manager.py

@@ -164,7 +164,7 @@ class ManagerTestCase(tests_db_base.DbTestCase):
                                                  states.POWER_ON)
             self.service._worker_pool.waitall()
 
-            get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
+            get_power_mock.assert_called_once_with(mock.ANY)
             node.refresh()
             self.assertEqual(states.POWER_ON, node.power_state)
             self.assertIsNone(node.target_power_state)
@@ -223,7 +223,7 @@ class ManagerTestCase(tests_db_base.DbTestCase):
             self.assertEqual(exception.NoFreeConductorWorker, exc.exc_info[0])
 
             spawn_mock.assert_called_once_with(mock.ANY, mock.ANY,
-                                               mock.ANY, mock.ANY)
+                                               mock.ANY)
             node.refresh()
             self.assertEqual(initial_state, node.power_state)
             self.assertIsNone(node.target_power_state)
@@ -256,9 +256,8 @@ class ManagerTestCase(tests_db_base.DbTestCase):
                                                      new_state)
                 self.service._worker_pool.waitall()
 
-                get_power_mock.assert_called_once_with(mock.ANY, mock.ANY)
+                get_power_mock.assert_called_once_with(mock.ANY)
-                set_power_mock.assert_called_once_with(mock.ANY, mock.ANY,
+                set_power_mock.assert_called_once_with(mock.ANY, new_state)
-                                                       new_state)
                 node.refresh()
                 self.assertEqual(initial_state, node.power_state)
                 self.assertIsNone(node.target_power_state)
@@ -1248,8 +1247,7 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
         self._do_sync_power_state('fake-power', 'fake-power')
 
         self.assertFalse(self.power.validate.called)
-        self.power.get_power_state.assert_called_once_with(self.task,
+        self.power.get_power_state.assert_called_once_with(self.task)
-                                                           self.node)
         self.assertEqual('fake-power', self.node.power_state)
         self.assertFalse(self.node.save.called)
         self.assertFalse(node_power_action.called)
@@ -1258,8 +1256,7 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
         self._do_sync_power_state(None, states.POWER_ON)
 
         self.power.validate.assert_called_once_with(self.task, self.node)
-        self.power.get_power_state.assert_called_once_with(self.task,
+        self.power.get_power_state.assert_called_once_with(self.task)
-                                                           self.node)
         self.node.save.assert_called_once_with(self.context)
         self.assertFalse(node_power_action.called)
         self.assertEqual(states.POWER_ON, self.node.power_state)
@@ -1268,7 +1265,7 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
         self._do_sync_power_state(None, states.POWER_ON,
                                   fail_validate=True)
 
-        self.power.validate.assert_called_once_with(self.task, self.node)
+        self.power.validate.assert_called_once_with(self.task, self.task.node)
         self.assertFalse(self.power.get_power_state.called)
         self.assertFalse(self.node.save.called)
         self.assertFalse(node_power_action.called)
@@ -1279,8 +1276,7 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
                                   exception.IronicException('foo'))
 
         self.assertFalse(self.power.validate.called)
-        self.power.get_power_state.assert_called_once_with(self.task,
+        self.power.get_power_state.assert_called_once_with(self.task)
-                                                           self.node)
         self.assertFalse(self.node.save.called)
         self.assertFalse(node_power_action.called)
         self.assertEqual('fake', self.node.power_state)
@@ -1291,8 +1287,7 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
         self._do_sync_power_state(states.POWER_ON, states.POWER_OFF)
 
         self.assertFalse(self.power.validate.called)
-        self.power.get_power_state.assert_called_once_with(self.task,
+        self.power.get_power_state.assert_called_once_with(self.task)
-                                                           self.node)
         self.node.save.assert_called_once_with(self.context)
         self.assertFalse(node_power_action.called)
         self.assertEqual(states.POWER_OFF, self.node.power_state)
@@ -1304,11 +1299,9 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
         self._do_sync_power_state(states.POWER_ON, states.POWER_OFF)
 
         self.assertFalse(self.power.validate.called)
-        self.power.get_power_state.assert_called_once_with(self.task,
+        self.power.get_power_state.assert_called_once_with(self.task)
-                                                           self.node)
         self.assertFalse(self.node.save.called)
-        node_power_action.assert_called_once_with(self.task, self.node,
+        node_power_action.assert_called_once_with(self.task, states.POWER_ON)
-                                                  states.POWER_ON)
         self.assertEqual(states.POWER_ON, self.node.power_state)
 
     def test_state_changed_sync_failed(self, node_power_action):
@@ -1319,11 +1312,9 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
 
         # Just testing that this test doesn't raise.
         self.assertFalse(self.power.validate.called)
-        self.power.get_power_state.assert_called_once_with(self.task,
+        self.power.get_power_state.assert_called_once_with(self.task)
-                                                           self.node)
         self.assertFalse(self.node.save.called)
-        node_power_action.assert_called_once_with(self.task, self.node,
+        node_power_action.assert_called_once_with(self.task, states.POWER_ON)
-                                                  states.POWER_ON)
         self.assertEqual(states.POWER_ON, self.node.power_state)
         self.assertEqual(1,
                          self.service.power_state_sync_count[self.node.uuid])
@@ -1336,12 +1327,11 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
                                                     states.POWER_OFF])
 
         self.assertFalse(self.power.validate.called)
-        power_exp_calls = [mock.call(self.task, self.node)] * 2
+        power_exp_calls = [mock.call(self.task)] * 2
         self.assertEqual(power_exp_calls,
                          self.power.get_power_state.call_args_list)
         self.node.save.assert_called_once_with(self.context)
-        node_power_action.assert_called_once_with(self.task, self.node,
+        node_power_action.assert_called_once_with(self.task, states.POWER_ON)
-                                                  states.POWER_ON)
         self.assertEqual(states.POWER_OFF, self.node.power_state)
         self.assertEqual(1,
                          self.service.power_state_sync_count[self.node.uuid])
@@ -1355,12 +1345,11 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
                                                     states.POWER_OFF])
 
         self.assertFalse(self.power.validate.called)
-        power_exp_calls = [mock.call(self.task, self.node)] * 3
+        power_exp_calls = [mock.call(self.task)] * 3
         self.assertEqual(power_exp_calls,
                          self.power.get_power_state.call_args_list)
         self.node.save.assert_called_once_with(self.context)
-        npa_exp_calls = [mock.call(self.task, self.node,
+        npa_exp_calls = [mock.call(self.task, states.POWER_ON)] * 2
-                                   states.POWER_ON)] * 2
         self.assertEqual(npa_exp_calls, node_power_action.call_args_list)
         self.assertEqual(states.POWER_OFF, self.node.power_state)
         self.assertEqual(2,
@@ -1375,12 +1364,11 @@ class ManagerDoSyncPowerStateTestCase(tests_base.TestCase):
                                                     states.POWER_ON])
 
         self.assertFalse(self.power.validate.called)
-        power_exp_calls = [mock.call(self.task, self.node)] * 3
+        power_exp_calls = [mock.call(self.task)] * 3
         self.assertEqual(power_exp_calls,
                          self.power.get_power_state.call_args_list)
         self.assertFalse(self.node.save.called)
-        npa_exp_calls = [mock.call(self.task, self.node,
+        npa_exp_calls = [mock.call(self.task, states.POWER_ON)] * 2
-                                   states.POWER_ON)] * 2
         self.assertEqual(npa_exp_calls, node_power_action.call_args_list)
         self.assertEqual(states.POWER_ON, self.node.power_state)
         self.assertNotIn(self.node.uuid, self.service.power_state_sync_count)

ironic/tests/drivers/test_fake.py

@@ -55,13 +55,12 @@ class FakeDriverTestCase(base.TestCase):
 
     def test_power_interface(self):
         self.driver.power.validate(self.task, self.node)
-        self.driver.power.get_power_state(self.task, self.node)
+        self.driver.power.get_power_state(self.task)
         self.assertRaises(exception.InvalidParameterValue,
                           self.driver.power.set_power_state,
-                          self.task, self.node, states.NOSTATE)
+                          self.task, states.NOSTATE)
-        self.driver.power.set_power_state(self.task, self.node,
+        self.driver.power.set_power_state(self.task, states.POWER_ON)
-                                          states.POWER_ON)
+        self.driver.power.reboot(self.task)
-        self.driver.power.reboot(self.task, self.node)
 
     def test_deploy_interface(self):
         self.driver.deploy.validate(None, self.node)

ironic/tests/drivers/test_ipminative.py

@@ -154,13 +154,14 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
 
         get_power_mock.side_effect = lambda: return_values.pop()
 
-        pstate = self.driver.power.get_power_state(None, self.node)
+        with task_manager.acquire(self.context, self.node.uuid) as task:
+            pstate = self.driver.power.get_power_state(task)
             self.assertEqual(states.POWER_OFF, pstate)
 
-        pstate = self.driver.power.get_power_state(None, self.node)
+            pstate = self.driver.power.get_power_state(task)
             self.assertEqual(states.POWER_ON, pstate)
 
-        pstate = self.driver.power.get_power_state(None, self.node)
+            pstate = self.driver.power.get_power_state(task)
             self.assertEqual(states.ERROR, pstate)
             self.assertEqual(3, get_power_mock.call_count,
                              "pyghmi.ipmi.command.Command.get_power was not"
@@ -173,7 +174,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
         with task_manager.acquire(self.context,
                                   [self.node.uuid]) as task:
             self.driver.power.set_power_state(
-                task, self.node, states.POWER_ON)
+                task, states.POWER_ON)
         power_on_mock.assert_called_once_with(self.info)
 
     @mock.patch.object(ipminative, '_power_off')
@@ -183,7 +184,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
         with task_manager.acquire(self.context,
                                   [self.node.uuid]) as task:
             self.driver.power.set_power_state(
-                task, self.node, states.POWER_OFF)
+                task, states.POWER_OFF)
         power_off_mock.assert_called_once_with(self.info)
 
     @mock.patch('pyghmi.ipmi.command.Command')
@@ -197,7 +198,6 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
             self.assertRaises(exception.PowerStateFailure,
                               self.driver.power.set_power_state,
                               task,
-                              self.node,
                               states.POWER_ON)
         ipmicmd.set_power.assert_called_once_with('on', 500)
 
@@ -224,7 +224,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
 
         with task_manager.acquire(self.context,
                                   [self.node.uuid]) as task:
-            self.driver.power.reboot(task, self.node)
+            self.driver.power.reboot(task)
         reboot_mock.assert_called_once_with(self.info)
 
     @mock.patch('pyghmi.ipmi.command.Command')
@@ -237,8 +237,7 @@ class IPMINativeDriverTestCase(db_base.DbTestCase):
                                   [self.node.uuid]) as task:
             self.assertRaises(exception.PowerStateFailure,
                               self.driver.power.reboot,
-                              task,
+                              task)
-                              self.node)
         ipmicmd.set_power.assert_called_once_with('boot', 500)
 
     def test_vendor_passthru_validate__set_boot_device_good(self):

ironic/tests/drivers/test_ipmitool.py

@@ -278,13 +278,14 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
                     mock.call(self.info, "power status")]
         mock_exec.side_effect = returns
 
-        pstate = self.driver.power.get_power_state(None, self.node)
+        with task_manager.acquire(self.context, self.node.uuid) as task:
+            pstate = self.driver.power.get_power_state(task)
             self.assertEqual(states.POWER_OFF, pstate)
 
-        pstate = self.driver.power.get_power_state(None, self.node)
+            pstate = self.driver.power.get_power_state(task)
             self.assertEqual(states.POWER_ON, pstate)
 
-        pstate = self.driver.power.get_power_state(None, self.node)
+            pstate = self.driver.power.get_power_state(task)
             self.assertEqual(states.ERROR, pstate)
 
         self.assertEqual(mock_exec.call_args_list, expected)
@@ -292,10 +293,10 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
     @mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
     def test_get_power_state_exception(self, mock_exec):
         mock_exec.side_effect = processutils.ProcessExecutionError("error")
+        with task_manager.acquire(self.context, self.node.uuid) as task:
             self.assertRaises(exception.IPMIFailure,
                               self.driver.power.get_power_state,
-                          None,
+                              task)
-                          self.node)
         mock_exec.assert_called_once_with(self.info, "power status")
 
     @mock.patch.object(ipmi, '_power_on', autospec=True)
@@ -307,7 +308,6 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
         with task_manager.acquire(self.context,
                                   [self.node['uuid']]) as task:
             self.driver.power.set_power_state(task,
-                                              self.node,
                                               states.POWER_ON)
 
         mock_on.assert_called_once_with(self.info)
@@ -323,7 +323,6 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
         with task_manager.acquire(self.context,
                                   [self.node['uuid']]) as task:
             self.driver.power.set_power_state(task,
-                                              self.node,
                                               states.POWER_OFF)
 
         mock_off.assert_called_once_with(self.info)
@@ -340,7 +339,6 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
             self.assertRaises(exception.PowerStateFailure,
                               self.driver.power.set_power_state,
                               task,
-                              self.node,
                               states.POWER_ON)
 
         mock_on.assert_called_once_with(self.info)
@@ -351,7 +349,6 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
             self.assertRaises(exception.InvalidParameterValue,
                     self.driver.power.set_power_state,
                     task,
-                    self.node,
                     "fake state")
 
     @mock.patch.object(ipmi, '_exec_ipmitool', autospec=True)
@@ -384,7 +381,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
 
         with task_manager.acquire(self.context,
                                   [self.node['uuid']]) as task:
-            self.driver.power.reboot(task, self.node)
+            self.driver.power.reboot(task)
 
         self.assertEqual(manager.mock_calls, expected)
 
@@ -403,8 +400,7 @@ class IPMIToolDriverTestCase(db_base.DbTestCase):
                                  [self.node['uuid']]) as task:
             self.assertRaises(exception.PowerStateFailure,
                               self.driver.power.reboot,
-                              task,
+                              task)
-                              self.node)
 
         self.assertEqual(manager.mock_calls, expected)
 

ironic/tests/drivers/test_pxe.py

@@ -698,8 +698,7 @@ class PXEDriverTestCase(db_base.DbTestCase):
             mock_update_neutron.assert_called_once_with(task)
             mock_node_set_boot.assert_called_once_with(task, 'pxe',
                                                        persistent=True)
-            mock_node_power_action.assert_called_once_with(task, task.node,
+            mock_node_power_action.assert_called_once_with(task, states.REBOOT)
-                                                           states.REBOOT)
 
             # ensure token file created
             t_path = pxe._get_token_file_path(self.node.uuid)
@@ -732,8 +731,7 @@ class PXEDriverTestCase(db_base.DbTestCase):
                                   self.node.uuid) as task:
             state = task.driver.deploy.tear_down(task)
             self.assertEqual(states.DELETED, state)
-            node_power_mock.assert_called_once_with(task, task.node,
+            node_power_mock.assert_called_once_with(task, states.POWER_OFF)
-                                                    states.POWER_OFF)
 
     @mock.patch.object(manager_utils, 'node_power_action')
     def test_tear_down_removes_internal_attrs(self, mock_npa):
@@ -746,7 +744,7 @@ class PXEDriverTestCase(db_base.DbTestCase):
         self.node.save()
         with task_manager.acquire(self.context, self.node.uuid) as task:
             task.driver.deploy.tear_down(task)
-            mock_npa.assert_called_once_with(task, task.node, states.POWER_OFF)
+            mock_npa.assert_called_once_with(task, states.POWER_OFF)
 
         self.node.refresh()
         self.assertNotIn('pxe_deploy_key', self.node.driver_info)

ironic/tests/drivers/test_seamicro.py

@@ -305,9 +305,9 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
 
         with task_manager.acquire(self.context, [info['uuid']],
                                   shared=False) as task:
-            task.resources[0].driver.power.reboot(task, self.node)
+            task.resources[0].driver.power.reboot(task)
 
-        mock_reboot.assert_called_once_with(self.node)
+            mock_reboot.assert_called_once_with(task.node)
 
     def test_set_power_state_bad_state(self):
         info = seamicro ._parse_driver_info(self.node)
@@ -318,7 +318,7 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
                                   shared=False) as task:
             self.assertRaises(exception.IronicException,
                               task.resources[0].driver.power.set_power_state,
-                              task, self.node, "BAD_PSTATE")
+                              task, "BAD_PSTATE")
         self.get_server_patcher.stop()
 
     @mock.patch.object(seamicro, '_power_on')
@@ -330,10 +330,9 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
         with task_manager.acquire(self.context, [info['uuid']],
                                   shared=False) as task:
             task.resources[0].driver.power.set_power_state(task,
-                                                           self.node,
                                                            states.POWER_ON)
 
-        mock_power_on.assert_called_once_with(self.node)
+            mock_power_on.assert_called_once_with(task.node)
 
     @mock.patch.object(seamicro, '_power_on')
     def test_set_power_state_on_fail(self, mock_power_on):
@@ -346,9 +345,9 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
             self.assertRaises(exception.PowerStateFailure,
                               task.resources[0]
                               .driver.power.set_power_state,
-                              task, self.node, states.POWER_ON)
+                              task, states.POWER_ON)
 
-        mock_power_on.assert_called_once_with(self.node)
+            mock_power_on.assert_called_once_with(task.node)
 
     @mock.patch.object(seamicro, '_power_off')
     def test_set_power_state_off_good(self, mock_power_off):
@@ -359,9 +358,9 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
         with task_manager.acquire(self.context, [info['uuid']],
                                   shared=False) as task:
             task.resources[0].driver.power.\
-                set_power_state(task, self.node, states.POWER_OFF)
+                set_power_state(task, states.POWER_OFF)
 
-        mock_power_off.assert_called_once_with(self.node)
+            mock_power_off.assert_called_once_with(task.node)
 
     @mock.patch.object(seamicro, '_power_off')
     def test_set_power_state_off_fail(self, mock_power_off):
@@ -374,9 +373,9 @@ class SeaMicroPowerDriverTestCase(db_base.DbTestCase):
             self.assertRaises(exception.PowerStateFailure,
                               task.resources[0]
                               .driver.power.set_power_state,
-                              task, self.node, states.POWER_OFF)
+                              task, states.POWER_OFF)
 
-        mock_power_off.assert_called_once_with(self.node)
+            mock_power_off.assert_called_once_with(task.node)
 
     def test_vendor_passthru_validate_good(self):
         with task_manager.acquire(self.context, [self.node['uuid']],

ironic/tests/drivers/test_ssh.py

@@ -614,12 +614,13 @@ class SSHDriverTestCase(db_base.DbTestCase):
             parse_drv_info_mock.return_value = info
             with task_manager.acquire(self.context, [info['uuid']],
                                       shared=False) as task:
-                task.resources[0].driver.power.reboot(task, self.node)
+                task.resources[0].driver.power.reboot(task)
 
-            parse_drv_info_mock.assert_called_once_with(self.node)
+                parse_drv_info_mock.assert_called_once_with(task.node)
                 get_mac_addr_mock.assert_called_once_with(mock.ANY)
-        get_conn_mock.assert_called_once_with(self.node)
+                get_conn_mock.assert_called_once_with(task.node)
-        get_power_stat_mock.assert_called_once_with(self.sshclient, info)
+                get_power_stat_mock.assert_called_once_with(self.sshclient,
+                                                            info)
                 power_off_mock.assert_called_once_with(self.sshclient, info)
                 power_on_mock.assert_called_once_with(self.sshclient, info)
 
@@ -645,12 +646,12 @@ class SSHDriverTestCase(db_base.DbTestCase):
                                       shared=False) as task:
                 self.assertRaises(exception.PowerStateFailure,
                                   task.resources[0].driver.power.reboot,
-                                  task,
+                                  task)
-                                  self.node)
+                parse_drv_info_mock.assert_called_once_with(task.node)
-            parse_drv_info_mock.assert_called_once_with(self.node)
                 get_mac_addr_mock.assert_called_once_with(mock.ANY)
-        get_conn_mock.assert_called_once_with(self.node)
+                get_conn_mock.assert_called_once_with(task.node)
-        get_power_stat_mock.assert_called_once_with(self.sshclient, info)
+                get_power_stat_mock.assert_called_once_with(self.sshclient,
+                                                            info)
                 power_off_mock.assert_called_once_with(self.sshclient, info)
                 power_on_mock.assert_called_once_with(self.sshclient, info)
 
@@ -671,12 +672,11 @@ class SSHDriverTestCase(db_base.DbTestCase):
                     exception.InvalidParameterValue,
                     task.resources[0].driver.power.set_power_state,
                     task,
-                    self.node,
                     "BAD_PSTATE")
 
-            parse_drv_info_mock.assert_called_once_with(self.node)
+                parse_drv_info_mock.assert_called_once_with(task.node)
                 get_mac_addr_mock.assert_called_once_with(mock.ANY)
-        get_conn_mock.assert_called_once_with(self.node)
+                get_conn_mock.assert_called_once_with(task.node)
 
     @mock.patch.object(driver_utils, 'get_node_mac_addresses')
     @mock.patch.object(ssh, '_get_connection')
@@ -693,12 +693,12 @@ class SSHDriverTestCase(db_base.DbTestCase):
             parse_drv_info_mock.return_value = info
             with task_manager.acquire(self.context, [info['uuid']],
                                       shared=False) as task:
-                task.resources[0].driver.power.set_power_state(task, self.node,
+                task.resources[0].driver.power.set_power_state(task,
                                                                states.POWER_ON)
 
-            parse_drv_info_mock.assert_called_once_with(self.node)
+                parse_drv_info_mock.assert_called_once_with(task.node)
                 get_mac_addr_mock.assert_called_once_with(mock.ANY)
-        get_conn_mock.assert_called_once_with(self.node)
+                get_conn_mock.assert_called_once_with(task.node)
                 power_on_mock.assert_called_once_with(self.sshclient, info)
 
     @mock.patch.object(driver_utils, 'get_node_mac_addresses')
@@ -720,12 +720,11 @@ class SSHDriverTestCase(db_base.DbTestCase):
                     exception.PowerStateFailure,
                     task.resources[0].driver.power.set_power_state,
                     task,
-                    self.node,
                     states.POWER_ON)
 
-            parse_drv_info_mock.assert_called_once_with(self.node)
+                parse_drv_info_mock.assert_called_once_with(task.node)
                 get_mac_addr_mock.assert_called_once_with(mock.ANY)
-        get_conn_mock.assert_called_once_with(self.node)
+                get_conn_mock.assert_called_once_with(task.node)
                 power_on_mock.assert_called_once_with(self.sshclient, info)
 
     @mock.patch.object(driver_utils, 'get_node_mac_addresses')
@@ -744,11 +743,11 @@ class SSHDriverTestCase(db_base.DbTestCase):
             with task_manager.acquire(self.context, [info['uuid']],
                                       shared=False) as task:
                 task.resources[0].driver.power.set_power_state(
-                    task, self.node, states.POWER_OFF)
+                                                        task, states.POWER_OFF)
 
-            parse_drv_info_mock.assert_called_once_with(self.node)
+                parse_drv_info_mock.assert_called_once_with(task.node)
                 get_mac_addr_mock.assert_called_once_with(mock.ANY)
-        get_conn_mock.assert_called_once_with(self.node)
+                get_conn_mock.assert_called_once_with(task.node)
                 power_off_mock.assert_called_once_with(self.sshclient, info)
 
     @mock.patch.object(driver_utils, 'get_node_mac_addresses')
@@ -770,10 +769,9 @@ class SSHDriverTestCase(db_base.DbTestCase):
                     exception.PowerStateFailure,
                     task.resources[0].driver.power.set_power_state,
                     task,
-                    self.node,
                     states.POWER_OFF)
 
-            parse_drv_info_mock.assert_called_once_with(self.node)
+                parse_drv_info_mock.assert_called_once_with(task.node)
                 get_mac_addr_mock.assert_called_once_with(mock.ANY)
-        get_conn_mock.assert_called_once_with(self.node)
+                get_conn_mock.assert_called_once_with(task.node)
                 power_off_mock.assert_called_once_with(self.sshclient, info)