Merge lp:~newell-jensen/maas/change-power-driver-parameters into lp:~maas-committers/maas/trunk

[Newell Jensen]

Change parameters of power driver base class's methods to use context instead of **context to fix possible variable collisions.

[Blake Rouse (blake-rouse)]

Looks good. Mechanical change.

review: Approve

[Blake Rouse (blake-rouse)]

Don't forget this needs to be backported to 1.9.

=== modified file 'src/provisioningserver/drivers/power/__init__.py'
--- src/provisioningserver/drivers/power/__init__.py	2015-11-06 16:52:07 +0000
+++ src/provisioningserver/drivers/power/__init__.py	2015-11-17 02:16:14 +0000
@@ -143,32 +143,32 @@
         """List of settings for the driver.
 
         Each setting in this list will be different per user. They are passed
-        to the `on`, `off`, and `query` using the kwargs. It is up
+        to the `on`, `off`, and `query` using the context. It is up
         to the driver to read these options before performing the operation.
         """
 
     @abstractmethod
-    def on(self, system_id, **kwargs):
+    def on(self, system_id, context):
         """Perform the power on action for `system_id`.
 
         :param system_id: `Node.system_id`
-        :param kwargs: Power settings for the node.
+        :param context: Power settings for the node.
         """
 
     @abstractmethod
-    def off(self, system_id, **kwargs):
+    def off(self, system_id, context):
         """Perform the power off action for `system_id`.
 
         :param system_id: `Node.system_id`
-        :param kwargs: Power settings for the node.
+        :param context: Power settings for the node.
         """
 
     @abstractmethod
-    def query(self, system_id, **kwargs):
+    def query(self, system_id, context):
         """Perform the query action for `system_id`.
 
         :param system_id: `Node.system_id`
-        :param kwargs: Power settings for the node.
+        :param context: Power settings for the node.
         :return: status of power on BMC. `on` or `off`.
         :raises PowerError: states unable to get status from BMC. It is
             up to this method to report the actual issue to the Region. The
@@ -213,32 +213,32 @@
         """
 
     @abstractmethod
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Implement this method for the actual implementation
         of the power on command.
         """
 
     @abstractmethod
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Implement this method for the actual implementation
         of the power off command.
         """
 
     @abstractmethod
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Implement this method for the actual implementation
         of the power query command."""
 
-    def on(self, system_id, **kwargs):
+    def on(self, system_id, context):
         """Performs the power on action for `system_id`.
 
         Do not override `on` method unless you want to provide custom logic on
         how retries and error detection is handled. Override `power_on` for
         just the power on action, and `on` will handle the retrying.
         """
-        return self.perform_power(self.power_on, "on", system_id, **kwargs)
+        return self.perform_power(self.power_on, "on", system_id, context)
 
-    def off(self, system_id, **kwargs):
+    def off(self, system_id, context):
         """Performs the power off action for `system_id`.
 
         Do not override `off` method unless you want to provide custom logic on
@@ -246,16 +246,16 @@
         just the power off action, and `off` will handle the retrying and error
         reporting.
         """
-        return self.perform_power(self.power_off, "off", system_id, **kwargs)
+        return self.perform_power(self.power_off, "off", system_id, context)
 
     @inlineCallbacks
-    def query(self, system_id, **kwargs):
+    def query(self, system_id, context):
         """Performs the power query action for `system_id`."""
         exc_info = None, None, None
         for waiting_time in self.wait_time:
             try:
                 state = yield deferToThread(
-                    self.power_query, system_id, **kwargs)
+                    self.power_query, system_id, context)
             except PowerFatalError:
                 raise  # Don't retry.
             except PowerError:
@@ -268,7 +268,7 @@
             raise exc_info[0], exc_info[1], exc_info[2]
 
     @inlineCallbacks
-    def perform_power(self, power_func, state_desired, system_id, **kwargs):
+    def perform_power(self, power_func, state_desired, system_id, context):
         """Provides the logic to perform the power actions.
 
         :param power_func: Function used to change the power state of the
@@ -285,7 +285,7 @@
             # Try to change state.
             try:
                 yield deferToThread(
-                    power_func, system_id, **kwargs)
+                    power_func, system_id, context)
             except PowerFatalError:
                 raise  # Don't retry.
             except PowerError:
@@ -298,7 +298,7 @@
                 # Try to get power state.
                 try:
                     state = yield deferToThread(
-                        self.power_query, system_id, **kwargs)
+                        self.power_query, system_id, context)
                 except PowerFatalError:
                     raise  # Don't retry.
                 except PowerError:

=== modified file 'src/provisioningserver/drivers/power/amt.py'
--- src/provisioningserver/drivers/power/amt.py	2015-11-13 17:51:32 +0000
+++ src/provisioningserver/drivers/power/amt.py	2015-11-17 02:16:14 +0000
@@ -330,15 +330,15 @@
         else:
             raise PowerFatalError('No host provided')
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on AMT node."""
         ip_address = self._get_ip_address(
-            kwargs.get('power_address'), kwargs.get('ip_address'))
-        power_pass = kwargs.get('power_pass')
+            context.get('power_address'), context.get('ip_address'))
+        power_pass = context.get('power_pass')
         amt_command = self._get_amt_command(ip_address, power_pass)
         if amt_command == 'amttool':
             amttool_boot_mode = self._get_amttool_boot_mode(
-                kwargs.get('boot_mode'))
+                context.get('boot_mode'))
             if self.amttool_query_state(ip_address, power_pass) == 'on':
                 self.amttool_restart(ip_address, power_pass, amttool_boot_mode)
             else:
@@ -350,11 +350,11 @@
             else:
                 self.wsman_power_on(ip_address, power_pass)
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off AMT node."""
         ip_address = self._get_ip_address(
-            kwargs.get('power_address'), kwargs.get('ip_address'))
-        power_pass = kwargs.get('power_pass')
+            context.get('power_address'), context.get('ip_address'))
+        power_pass = context.get('power_pass')
         amt_command = self._get_amt_command(ip_address, power_pass)
         if amt_command == 'amttool':
             if self.amttool_query_state(ip_address, power_pass) != 'off':
@@ -363,11 +363,11 @@
             if self.wsman_query_state(ip_address, power_pass) != 'off':
                 self.wsman_power_off(ip_address, power_pass)
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query AMT node."""
         ip_address = self._get_ip_address(
-            kwargs.get('power_address'), kwargs.get('ip_address'))
-        power_pass = kwargs.get('power_pass')
+            context.get('power_address'), context.get('ip_address'))
+        power_pass = context.get('power_pass')
         amt_command = self._get_amt_command(ip_address, power_pass)
         if amt_command == 'amttool':
             return self.amttool_query_state(ip_address, power_pass)

=== modified file 'src/provisioningserver/drivers/power/apc.py'
--- src/provisioningserver/drivers/power/apc.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/apc.py	2015-11-17 02:16:14 +0000
@@ -23,10 +23,10 @@
 from provisioningserver.utils import shell
 
 
-def extract_apc_parameters(params):
-    ip = params.get('power_address')
-    outlet = params.get('node_outlet')
-    power_on_delay = params.get('power_on_delay')
+def extract_apc_parameters(context):
+    ip = context.get('power_address')
+    outlet = context.get('node_outlet')
+    power_on_delay = context.get('power_on_delay')
     return ip, outlet, power_on_delay
 
 
@@ -42,21 +42,21 @@
             return [package]
         return []
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on Apc outlet."""
         power_change = 'on'
-        ip, outlet, power_on_delay = extract_apc_parameters(kwargs)
+        ip, outlet, power_on_delay = extract_apc_parameters(context)
         power_control_apc(
             ip, outlet, power_change, power_on_delay)
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off APC outlet."""
         power_change = 'off'
-        ip, outlet, power_on_delay = extract_apc_parameters(kwargs)
+        ip, outlet, power_on_delay = extract_apc_parameters(context)
         power_control_apc(
             ip, outlet, power_change, power_on_delay)
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query APC outlet."""
-        ip, outlet, _ = extract_apc_parameters(kwargs)
+        ip, outlet, _ = extract_apc_parameters(context)
         return power_state_apc(ip, outlet)

=== modified file 'src/provisioningserver/drivers/power/dli.py'
--- src/provisioningserver/drivers/power/dli.py	2015-11-04 15:53:35 +0000
+++ src/provisioningserver/drivers/power/dli.py	2015-11-17 02:16:14 +0000
@@ -91,14 +91,14 @@
                 "Failed to power query outlet %s: %s" % (
                     outlet_id, e.output_as_unicode))
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on DLI outlet."""
-        self._set_outlet_state('ON', **kwargs)
+        self._set_outlet_state('ON', **context)
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off DLI outlet."""
-        self._set_outlet_state('OFF', **kwargs)
+        self._set_outlet_state('OFF', **context)
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query DLI outlet."""
-        return self._query_outlet_state(**kwargs)
+        return self._query_outlet_state(**context)

=== modified file 'src/provisioningserver/drivers/power/ether_wake.py'
--- src/provisioningserver/drivers/power/ether_wake.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/ether_wake.py	2015-11-17 02:16:14 +0000
@@ -24,11 +24,11 @@
         # you need one or the other, not both
         return ['wakeonlan or etherwake']
 
-    def power_on(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def power_off(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def power_query(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
+        raise NotImplementedError
+
+    def power_off(self, system_id, context):
+        raise NotImplementedError
+
+    def power_query(self, system_id, context):
         raise NotImplementedError

=== modified file 'src/provisioningserver/drivers/power/fence_cdu.py'
--- src/provisioningserver/drivers/power/fence_cdu.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/fence_cdu.py	2015-11-17 02:16:14 +0000
@@ -22,11 +22,11 @@
             return ['fence-agents']
         return []
 
-    def power_on(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def power_off(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def power_query(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
+        raise NotImplementedError
+
+    def power_off(self, system_id, context):
+        raise NotImplementedError
+
+    def power_query(self, system_id, context):
         raise NotImplementedError

=== modified file 'src/provisioningserver/drivers/power/hmc.py'
--- src/provisioningserver/drivers/power/hmc.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/hmc.py	2015-11-17 02:16:14 +0000
@@ -23,12 +23,12 @@
 from provisioningserver.utils import shell
 
 
-def extract_hmc_parameters(params):
-    ip = params.get('power_address')
-    username = params.get('power_user')
-    password = params.get('power_pass')
-    server_name = params.get('server_name')
-    lpar = params.get('lpar')
+def extract_hmc_parameters(context):
+    ip = context.get('power_address')
+    username = context.get('power_user')
+    password = context.get('power_pass')
+    server_name = context.get('server_name')
+    lpar = context.get('lpar')
     return ip, username, password, server_name, lpar
 
 
@@ -44,19 +44,19 @@
             return [package]
         return []
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         ip, username, password, server_name, lpar = (
-            extract_hmc_parameters(kwargs))
+            extract_hmc_parameters(context))
         power_control_hmc(
             ip, username, password, server_name, lpar, power_change='on')
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         ip, username, password, server_name, lpar = (
-            extract_hmc_parameters(kwargs))
+            extract_hmc_parameters(context))
         power_control_hmc(
             ip, username, password, server_name, lpar, power_change='off')
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         ip, username, password, server_name, lpar = (
-            extract_hmc_parameters(kwargs))
+            extract_hmc_parameters(context))
         return power_state_hmc(ip, username, password, server_name, lpar)

=== modified file 'src/provisioningserver/drivers/power/ipmi.py'
--- src/provisioningserver/drivers/power/ipmi.py	2015-10-14 18:10:57 +0000
+++ src/provisioningserver/drivers/power/ipmi.py	2015-11-17 02:16:14 +0000
@@ -152,11 +152,11 @@
         return self._issue_ipmi_power_command(
             ipmipower_command, power_change, power_address, env)
 
-    def power_on(self, system_id, **kwargs):
-        self._issue_ipmi_command('on', **kwargs)
-
-    def power_off(self, system_id, **kwargs):
-        self._issue_ipmi_command('off', **kwargs)
-
-    def power_query(self, system_id, **kwargs):
-        return self._issue_ipmi_command('query', **kwargs)
+    def power_on(self, system_id, context):
+        self._issue_ipmi_command('on', **context)
+
+    def power_off(self, system_id, context):
+        self._issue_ipmi_command('off', **context)
+
+    def power_query(self, system_id, context):
+        return self._issue_ipmi_command('query', **context)

=== modified file 'src/provisioningserver/drivers/power/moonshot.py'
--- src/provisioningserver/drivers/power/moonshot.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/moonshot.py	2015-11-17 02:16:14 +0000
@@ -60,11 +60,11 @@
                 raise PowerActionError(
                     "Got unknown power state from ipmipower: %s" % output)
 
-    def power_on(self, system_id, **kwargs):
-        self._issue_ipmitool_command('on', **kwargs)
-
-    def power_off(self, system_id, **kwargs):
-        self._issue_ipmitool_command('off', **kwargs)
-
-    def power_query(self, system_id, **kwargs):
-        return self._issue_ipmitool_command('status', **kwargs)
+    def power_on(self, system_id, context):
+        self._issue_ipmitool_command('on', **context)
+
+    def power_off(self, system_id, context):
+        self._issue_ipmitool_command('off', **context)
+
+    def power_query(self, system_id, context):
+        return self._issue_ipmitool_command('status', **context)

=== modified file 'src/provisioningserver/drivers/power/mscm.py'
--- src/provisioningserver/drivers/power/mscm.py	2015-09-30 07:16:42 +0000
+++ src/provisioningserver/drivers/power/mscm.py	2015-11-17 02:16:14 +0000
@@ -21,11 +21,11 @@
 from provisioningserver.drivers.power import PowerDriver
 
 
-def extract_mscm_parameters(params):
-    host = params.get('power_address')
-    username = params.get('power_user')
-    password = params.get('power_pass')
-    node_id = params.get('node_id')
+def extract_mscm_parameters(context):
+    host = context.get('power_address')
+    username = context.get('power_user')
+    password = context.get('power_pass')
+    node_id = context.get('node_id')
     return host, username, password, node_id
 
 
@@ -39,19 +39,19 @@
         # uses pure-python paramiko ssh client - nothing to look for!
         return []
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on MSCM node."""
-        host, username, password, node_id = extract_mscm_parameters(kwargs)
+        host, username, password, node_id = extract_mscm_parameters(context)
         power_control_mscm(
             host, username, password, node_id, power_change='on')
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off MSCM node."""
-        host, username, password, node_id = extract_mscm_parameters(kwargs)
+        host, username, password, node_id = extract_mscm_parameters(context)
         power_control_mscm(
             host, username, password, node_id, power_change='off')
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query MSCM node."""
-        host, username, password, node_id = extract_mscm_parameters(kwargs)
+        host, username, password, node_id = extract_mscm_parameters(context)
         return power_state_mscm(host, username, password, node_id)

=== modified file 'src/provisioningserver/drivers/power/msftocs.py'
--- src/provisioningserver/drivers/power/msftocs.py	2015-09-30 07:16:42 +0000
+++ src/provisioningserver/drivers/power/msftocs.py	2015-11-17 02:16:14 +0000
@@ -21,12 +21,12 @@
 from provisioningserver.drivers.power import PowerDriver
 
 
-def extract_msftocs_parameters(params):
-    ip = params.get('power_address')
-    port = params.get('power_port')
-    username = params.get('power_user')
-    password = params.get('power_pass')
-    blade_id = params.get('blade_id')
+def extract_msftocs_parameters(context):
+    ip = context.get('power_address')
+    port = context.get('power_port')
+    username = context.get('power_user')
+    password = context.get('power_pass')
+    blade_id = context.get('blade_id')
     return ip, port, username, password, blade_id
 
 
@@ -40,24 +40,24 @@
         # uses urllib2 http client - nothing to look for!
         return []
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on MicrosoftOCS node."""
         power_change = 'on'
         ip, port, username, password, blade_id = (
-            extract_msftocs_parameters(kwargs))
+            extract_msftocs_parameters(context))
         power_control_msftocs(
             ip, port, username, password, power_change)
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off MicrosoftOCS node."""
         power_change = 'off'
         ip, port, username, password, blade_id = (
-            extract_msftocs_parameters(kwargs))
+            extract_msftocs_parameters(context))
         power_control_msftocs(
             ip, port, username, password, power_change)
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query MicrosoftOCS node."""
         ip, port, username, password, blade_id = (
-            extract_msftocs_parameters(kwargs))
+            extract_msftocs_parameters(context))
         return power_state_msftocs(ip, port, username, password, blade_id)

=== modified file 'src/provisioningserver/drivers/power/seamicro.py'
--- src/provisioningserver/drivers/power/seamicro.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/seamicro.py	2015-11-17 02:16:14 +0000
@@ -30,12 +30,12 @@
 )
 
 
-def extract_seamicro_parameters(params):
-    ip = params.get('power_address')
-    username = params.get('power_user')
-    password = params.get('power_pass')
-    server_id = params.get('system_id')
-    power_control = params.get('power_control')
+def extract_seamicro_parameters(context):
+    ip = context.get('power_address')
+    username = context.get('power_user')
+    password = context.get('power_pass')
+    server_id = context.get('system_id')
+    power_control = context.get('power_control')
     return ip, username, password, server_id, power_control
 
 
@@ -65,10 +65,10 @@
                 "Failed to power %s %s at %s: %s" % (
                     power_change, server_id, ip, e.output_as_unicode))
 
-    def _power(self, power_change, **kwargs):
+    def _power(self, power_change, context):
         """Power SeaMicro node."""
         ip, username, password, server_id, power_control = (
-            extract_seamicro_parameters(kwargs))
+            extract_seamicro_parameters(context))
         if power_control == 'ipmi':
             self._power_control_seamicro15k_ipmi(
                 ip, username, password, server_id, power_change=power_change)
@@ -79,20 +79,20 @@
             power_control_seamicro15k_v2(
                 ip, username, password, server_id, power_change=power_change)
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on SeaMicro node."""
-        self._power('on', **kwargs)
+        self._power('on', context)
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off SeaMicro node."""
-        self._power('off', **kwargs)
+        self._power('off', context)
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query SeaMicro node."""
         # Query the state.
         # Only supported by REST v2.
         ip, username, password, _, power_control = (
-            extract_seamicro_parameters(kwargs))
+            extract_seamicro_parameters(context))
         if power_control == 'restapi2':
             return power_query_seamicro15k_v2(
                 ip, username, password, system_id)

=== modified file 'src/provisioningserver/drivers/power/tests/test_amt.py'
--- src/provisioningserver/drivers/power/tests/test_amt.py	2015-11-13 17:51:32 +0000
+++ src/provisioningserver/drivers/power/tests/test_amt.py	2015-11-17 02:16:14 +0000
@@ -66,6 +66,16 @@
 """)
 
 
+def make_parameters():
+    return {
+        'system_id': factory.make_name('system_id'),
+        'power_address': factory.make_name('power_address'),
+        'ip_address': factory.make_ipv4_address(),
+        'power_pass': factory.make_name('power_pass'),
+        'boot_mode': factory.make_name('boot_mode'),
+    }
+
+
 class TestAMTPowerDriver(MAASTestCase):
 
     def patch_popen(self, return_value=(None, None), returncode=0):
@@ -589,13 +599,7 @@
 
     def test_power_on_powers_on_with_amttool_when_already_on(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-            'boot_mode': factory.make_name('boot_mode'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'amttool'
@@ -605,28 +609,22 @@
         amttool_restart_mock = self.patch(
             amt_power_driver, 'amttool_restart')
 
-        amt_power_driver.power_on(**kwargs)
+        amt_power_driver.power_on(context['system_id'], context)
 
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             amttool_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             amttool_restart_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass'],
-                kwargs['boot_mode']))
+                context['ip_address'], context['power_pass'],
+                context['boot_mode']))
 
     def test_power_on_powers_on_with_amttool_when_already_off(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-            'boot_mode': factory.make_name('boot_mode'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'amttool'
@@ -636,27 +634,22 @@
         amttool_power_on_mock = self.patch(
             amt_power_driver, 'amttool_power_on')
 
-        amt_power_driver.power_on(**kwargs)
+        amt_power_driver.power_on(context['system_id'], context)
 
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             amttool_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             amttool_power_on_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass'],
-                kwargs['boot_mode']))
+                context['ip_address'], context['power_pass'],
+                context['boot_mode']))
 
     def test_power_on_powers_on_with_wsman_when_already_on(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'wsman'
@@ -666,26 +659,21 @@
         wsman_restart_mock = self.patch(
             amt_power_driver, 'wsman_restart')
 
-        amt_power_driver.power_on(**kwargs)
+        amt_power_driver.power_on(context['system_id'], context)
 
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             wsman_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             wsman_restart_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
 
     def test_power_on_powers_on_with_wsman_when_already_off(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'wsman'
@@ -695,26 +683,21 @@
         wsman_power_on_mock = self.patch(
             amt_power_driver, 'wsman_power_on')
 
-        amt_power_driver.power_on(**kwargs)
+        amt_power_driver.power_on(context['system_id'], context)
 
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             wsman_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             wsman_power_on_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
 
     def test_power_off_powers_off_with_amttool(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'amttool'
@@ -724,26 +707,20 @@
         amttool_power_off_mock = self.patch(
             amt_power_driver, 'amttool_power_off')
 
-        amt_power_driver.power_off(**kwargs)
-
+        amt_power_driver.power_off(context['system_id'], context)
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             amttool_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             amttool_power_off_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
 
     def test_power_off_powers_off_with_wsman(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'wsman'
@@ -753,26 +730,20 @@
         wsman_power_off_mock = self.patch(
             amt_power_driver, 'wsman_power_off')
 
-        amt_power_driver.power_off(**kwargs)
-
+        amt_power_driver.power_off(context['system_id'], context)
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             wsman_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             wsman_power_off_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
 
     def test_power_query_queries_with_amttool(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'amttool'
@@ -780,24 +751,19 @@
             amt_power_driver, 'amttool_query_state')
         amttool_query_state_mock.return_value = 'off'
 
-        state = amt_power_driver.power_query(**kwargs)
+        state = amt_power_driver.power_query(context['system_id'], context)
 
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             amttool_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(state, Equals('off'))
 
     def test_power_query_queries_with_wsman(self):
         amt_power_driver = AMTPowerDriver()
-        kwargs = {
-            'system_id': factory.make_name('system_id'),
-            'power_address': factory.make_name('power_address'),
-            'ip_address': factory.make_ipv4_address(),
-            'power_pass': factory.make_name('power_pass'),
-        }
+        context = make_parameters()
         _get_amt_command_mock = self.patch(
             amt_power_driver, '_get_amt_command')
         _get_amt_command_mock.return_value = 'wsman'
@@ -805,12 +771,12 @@
             amt_power_driver, 'wsman_query_state')
         wsman_query_state_mock.return_value = 'on'
 
-        state = amt_power_driver.power_query(**kwargs)
+        state = amt_power_driver.power_query(context['system_id'], context)
 
         self.expectThat(
             _get_amt_command_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(
             wsman_query_state_mock, MockCalledOnceWith(
-                kwargs['ip_address'], kwargs['power_pass']))
+                context['ip_address'], context['power_pass']))
         self.expectThat(state, Equals('on'))

=== modified file 'src/provisioningserver/drivers/power/tests/test_apc.py'
--- src/provisioningserver/drivers/power/tests/test_apc.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_apc.py	2015-11-17 02:16:14 +0000
@@ -49,28 +49,28 @@
         ip = factory.make_ipv4_address()
         outlet = '%d' % randint(1, 16)
         power_on_delay = '%d' % randint(1, 5)
-        params = {
+        context = {
             'system_id': system_id,
             'power_address': ip,
             'node_outlet': outlet,
             'power_on_delay': power_on_delay,
         }
-        return system_id, ip, outlet, power_on_delay, params
+        return system_id, ip, outlet, power_on_delay, context
 
     def test_extract_apc_parameters_extracts_parameters(self):
-        system_id, ip, outlet, power_on_delay, params = self.make_parameters()
+        system_id, ip, outlet, power_on_delay, context = self.make_parameters()
 
         self.assertItemsEqual(
             (ip, outlet, power_on_delay),
-            extract_apc_parameters(params))
+            extract_apc_parameters(context))
 
     def test_power_on_calls_power_control_apc(self):
         power_change = 'on'
-        system_id, ip, outlet, power_on_delay, params = self.make_parameters()
+        system_id, ip, outlet, power_on_delay, context = self.make_parameters()
         apc_power_driver = APCPowerDriver()
         power_control_apc = self.patch(
             apc_module, 'power_control_apc')
-        apc_power_driver.power_on(**params)
+        apc_power_driver.power_on(system_id, context)
 
         self.assertThat(
             power_control_apc, MockCalledOnceWith(
@@ -78,23 +78,23 @@
 
     def test_power_off_calls_power_control_apc(self):
         power_change = 'off'
-        system_id, ip, outlet, power_on_delay, params = self.make_parameters()
+        system_id, ip, outlet, power_on_delay, context = self.make_parameters()
         apc_power_driver = APCPowerDriver()
         power_control_apc = self.patch(
             apc_module, 'power_control_apc')
-        apc_power_driver.power_off(**params)
+        apc_power_driver.power_off(system_id, context)
 
         self.assertThat(
             power_control_apc, MockCalledOnceWith(
                 ip, outlet, power_change, power_on_delay))
 
     def test_power_query_calls_power_state_apc(self):
-        system_id, ip, outlet, power_on_delay, params = self.make_parameters()
+        system_id, ip, outlet, power_on_delay, context = self.make_parameters()
         apc_power_driver = APCPowerDriver()
         power_state_apc = self.patch(
             apc_module, 'power_state_apc')
         power_state_apc.return_value = 'off'
-        expected_result = apc_power_driver.power_query(**params)
+        expected_result = apc_power_driver.power_query(system_id, context)
 
         self.expectThat(
             power_state_apc, MockCalledOnceWith(ip, outlet))

=== modified file 'src/provisioningserver/drivers/power/tests/test_base.py'
--- src/provisioningserver/drivers/power/tests/test_base.py	2015-09-30 00:05:45 +0000
+++ src/provisioningserver/drivers/power/tests/test_base.py	2015-11-17 02:16:14 +0000
@@ -65,13 +65,13 @@
         self.settings = settings
         super(FakePowerDriverBase, self).__init__()
 
-    def on(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def off(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def query(self, system_id, **kwargs):
+    def on(self, system_id, context):
+        raise NotImplementedError
+
+    def off(self, system_id, context):
+        raise NotImplementedError
+
+    def query(self, system_id, context):
         raise NotImplementedError
 
 
@@ -131,19 +131,19 @@
         fake_driver = make_power_driver_base()
         self.assertRaises(
             NotImplementedError,
-            fake_driver.on, sentinel.system_id)
+            fake_driver.on, sentinel.system_id, sentinel.context)
 
     def test_off_raises_not_implemented(self):
         fake_driver = make_power_driver_base()
         self.assertRaises(
             NotImplementedError,
-            fake_driver.off, sentinel.system_id)
+            fake_driver.off, sentinel.system_id, sentinel.context)
 
     def test_query_raises_not_implemented(self):
         fake_driver = make_power_driver_base()
         self.assertRaises(
             NotImplementedError,
-            fake_driver.query, sentinel.system_id)
+            fake_driver.query, sentinel.system_id, sentinel.context)
 
 
 class TestPowerDriverBase(MAASTestCase):
@@ -256,13 +256,13 @@
     def detect_missing_packages(self):
         raise NotImplementedError
 
-    def power_on(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def power_off(self, system_id, **kwargs):
-        raise NotImplementedError
-
-    def power_query(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
+        raise NotImplementedError
+
+    def power_off(self, system_id, context):
+        raise NotImplementedError
+
+    def power_query(self, system_id, context):
         raise NotImplementedError
 
 
@@ -297,16 +297,18 @@
     @inlineCallbacks
     def test_success(self):
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         driver = make_power_driver(wait_time=[0])
         self.patch(driver, self.action_func)
         self.patch(driver, 'power_query').return_value = self.action
         method = getattr(driver, self.action)
-        result = yield method(system_id)
+        result = yield method(system_id, context)
         self.assertEqual(result, None)
 
     @inlineCallbacks
     def test_handles_fatal_error_on_first_call(self):
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         driver = make_power_driver(wait_time=[0, 0])
         mock_on = self.patch(driver, self.action_func)
         mock_on.side_effect = [PowerFatalError(), None]
@@ -314,7 +316,7 @@
         mock_query.return_value = self.action
         method = getattr(driver, self.action)
         with ExpectedException(PowerFatalError):
-            yield method(system_id)
+            yield method(system_id, context)
         self.expectThat(
             mock_query,
             Equals(MockNotCalled()))
@@ -322,21 +324,23 @@
     @inlineCallbacks
     def test_handles_non_fatal_error_on_first_call(self):
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         driver = make_power_driver(wait_time=[0, 0])
         mock_on = self.patch(driver, self.action_func)
         mock_on.side_effect = [PowerError(), None]
         mock_query = self.patch(driver, 'power_query')
         mock_query.return_value = self.action
         method = getattr(driver, self.action)
-        result = yield method(system_id)
+        result = yield method(system_id, context)
         self.expectThat(
             mock_query,
-            Equals(MockCalledOnceWith(system_id)))
+            Equals(MockCalledOnceWith(system_id, context)))
         self.expectThat(result, Equals(None))
 
     @inlineCallbacks
     def test_handles_non_fatal_error_and_holds_error(self):
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         driver = make_power_driver(wait_time=[0])
         error_msg = factory.make_name('error')
         self.patch(driver, self.action_func)
@@ -344,31 +348,33 @@
         mock_query.side_effect = PowerError(error_msg)
         method = getattr(driver, self.action)
         with ExpectedException(PowerError):
-            yield method(system_id)
+            yield method(system_id, context)
         self.expectThat(
             mock_query,
-            Equals(MockCalledOnceWith(system_id)))
+            Equals(MockCalledOnceWith(system_id, context)))
 
     @inlineCallbacks
     def test_handles_non_fatal_error(self):
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         driver = make_power_driver(wait_time=[0])
         mock_on = self.patch(driver, self.action_func)
         mock_on.side_effect = PowerError()
         method = getattr(driver, self.action)
         with ExpectedException(PowerError):
-            yield method(system_id)
+            yield method(system_id, context)
 
     @inlineCallbacks
     def test_handles_fails_to_complete_power_action_in_time(self):
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         driver = make_power_driver(wait_time=[0])
         self.patch(driver, self.action_func)
         mock_query = self.patch(driver, 'power_query')
         mock_query.return_value = self.bad_state
         method = getattr(driver, self.action)
         with ExpectedException(PowerError):
-            yield method(system_id)
+            yield method(system_id, context)
 
 
 class TestPowerDriverQuery(MAASTestCase):
@@ -382,10 +388,11 @@
     @inlineCallbacks
     def test_returns_state(self):
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         driver = make_power_driver()
         state = factory.make_name('state')
         self.patch(driver, 'power_query').return_value = state
-        output = yield driver.query(system_id)
+        output = yield driver.query(system_id, context)
         self.assertEqual(state, output)
 
     @inlineCallbacks
@@ -393,7 +400,7 @@
         driver = make_power_driver()
         self.patch(driver, 'power_query').side_effect = [
             PowerError("one"), PowerError("two"), sentinel.state]
-        output = yield driver.query(sentinel.system_id)
+        output = yield driver.query(sentinel.system_id, sentinel.context)
         self.assertEqual(sentinel.state, output)
 
     @inlineCallbacks
@@ -405,7 +412,7 @@
             for _ in wait_time)
         self.patch(driver, 'power_query').side_effect = exception_types
         with ExpectedException(exception_types[-1]):
-            yield driver.query(sentinel.system_id)
+            yield driver.query(sentinel.system_id, sentinel.context)
 
     @inlineCallbacks
     def test_pauses_between_retries(self):
@@ -413,6 +420,6 @@
         driver = make_power_driver(wait_time=wait_time)
         self.patch(driver, 'power_query').side_effect = PowerError
         with ExpectedException(PowerError):
-            yield driver.query(sentinel.system_id)
+            yield driver.query(sentinel.system_id, sentinel.context)
         self.assertThat(power.pause, MockCallsMatch(
             *(call(wait, reactor) for wait in wait_time)))

=== modified file 'src/provisioningserver/drivers/power/tests/test_dli.py'
--- src/provisioningserver/drivers/power/tests/test_dli.py	2015-11-04 15:53:35 +0000
+++ src/provisioningserver/drivers/power/tests/test_dli.py	2015-11-17 02:16:14 +0000
@@ -142,20 +142,26 @@
     def test_power_on(self):
         driver = dli_module.DLIPowerDriver()
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         _set_outlet_state_mock = self.patch(driver, '_set_outlet_state')
-        driver.power_on(system_id)
-        self.assertThat(_set_outlet_state_mock, MockCalledOnceWith('ON'))
+        driver.power_on(system_id, context)
+        self.assertThat(
+            _set_outlet_state_mock, MockCalledOnceWith('ON', **context))
 
     def test_power_off(self):
         driver = dli_module.DLIPowerDriver()
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         _set_outlet_state_mock = self.patch(driver, '_set_outlet_state')
-        driver.power_off(system_id)
-        self.assertThat(_set_outlet_state_mock, MockCalledOnceWith('OFF'))
+        driver.power_off(system_id, context)
+        self.assertThat(
+            _set_outlet_state_mock, MockCalledOnceWith('OFF', **context))
 
     def test_power_query(self):
         driver = dli_module.DLIPowerDriver()
         system_id = factory.make_name('system_id')
+        context = {'context': factory.make_name('context')}
         _query_outlet_state_mock = self.patch(driver, '_query_outlet_state')
-        driver.power_query(system_id)
-        self.assertThat(_query_outlet_state_mock, MockCalledOnceWith())
+        driver.power_query(system_id, context)
+        self.assertThat(
+            _query_outlet_state_mock, MockCalledOnceWith(**context))

=== modified file 'src/provisioningserver/drivers/power/tests/test_ether_wake.py'
--- src/provisioningserver/drivers/power/tests/test_ether_wake.py	2015-10-01 23:30:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_ether_wake.py	2015-11-17 02:16:14 +0000
@@ -38,14 +38,14 @@
     def test_power_on(self):
         driver = ether_wake_module.EtherWakePowerDriver()
         self.assertRaises(
-            NotImplementedError, driver.power_on, "fake_id")
+            NotImplementedError, driver.power_on, "fake_id", {})
 
     def test_power_off(self):
         driver = ether_wake_module.EtherWakePowerDriver()
         self.assertRaises(
-            NotImplementedError, driver.power_off, "fake_id")
+            NotImplementedError, driver.power_off, "fake_id", {})
 
     def test_power_query(self):
         driver = ether_wake_module.EtherWakePowerDriver()
         self.assertRaises(
-            NotImplementedError, driver.power_query, "fake_id")
+            NotImplementedError, driver.power_query, "fake_id", {})

=== modified file 'src/provisioningserver/drivers/power/tests/test_fence_cdu.py'
--- src/provisioningserver/drivers/power/tests/test_fence_cdu.py	2015-10-01 23:30:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_fence_cdu.py	2015-11-17 02:16:14 +0000
@@ -38,14 +38,14 @@
     def test_power_on(self):
         driver = fence_cdu_module.FenceCDUPowerDriver()
         self.assertRaises(
-            NotImplementedError, driver.power_on, "fake_id")
+            NotImplementedError, driver.power_on, "fake_id", {})
 
     def test_power_off(self):
         driver = fence_cdu_module.FenceCDUPowerDriver()
         self.assertRaises(
-            NotImplementedError, driver.power_off, "fake_id")
+            NotImplementedError, driver.power_off, "fake_id", {})
 
     def test_power_query(self):
         driver = fence_cdu_module.FenceCDUPowerDriver()
         self.assertRaises(
-            NotImplementedError, driver.power_query, "fake_id")
+            NotImplementedError, driver.power_query, "fake_id", {})

=== modified file 'src/provisioningserver/drivers/power/tests/test_hmc.py'
--- src/provisioningserver/drivers/power/tests/test_hmc.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_hmc.py	2015-11-17 02:16:14 +0000
@@ -49,7 +49,7 @@
         password = factory.make_name('power_pass')
         server_name = factory.make_name('server_name')
         lpar = factory.make_name('lpar')
-        params = {
+        context = {
             'system_id': system_id,
             'power_address': ip,
             'power_user': username,
@@ -57,47 +57,47 @@
             'server_name': server_name,
             'lpar': lpar,
         }
-        return system_id, ip, username, password, server_name, lpar, params
+        return system_id, ip, username, password, server_name, lpar, context
 
     def test_extract_hmc_parameters_extracts_parameters(self):
-        system_id, ip, username, password, server_name, lpar, params = (
+        system_id, ip, username, password, server_name, lpar, context = (
             self.make_parameters())
         self.assertItemsEqual(
             (ip, username, password, server_name, lpar),
-            extract_hmc_parameters(params))
+            extract_hmc_parameters(context))
 
     def test_power_on_calls_power_control_hmc(self):
-        system_id, ip, username, password, server_name, lpar, params = (
+        system_id, ip, username, password, server_name, lpar, context = (
             self.make_parameters())
         hmc_power_driver = HMCPowerDriver()
         power_control_hmc = self.patch(
             hmc_module, 'power_control_hmc')
-        hmc_power_driver.power_on(**params)
+        hmc_power_driver.power_on(system_id, context)
 
         self.assertThat(
             power_control_hmc, MockCalledOnceWith(
                 ip, username, password, server_name, lpar, power_change='on'))
 
     def test_power_off_calls_power_control_hmc(self):
-        system_id, ip, username, password, server_name, lpar, params = (
+        system_id, ip, username, password, server_name, lpar, context = (
             self.make_parameters())
         hmc_power_driver = HMCPowerDriver()
         power_control_hmc = self.patch(
             hmc_module, 'power_control_hmc')
-        hmc_power_driver.power_off(**params)
+        hmc_power_driver.power_off(system_id, context)
 
         self.assertThat(
             power_control_hmc, MockCalledOnceWith(
                 ip, username, password, server_name, lpar, power_change='off'))
 
     def test_power_query_calls_power_state_hmc(self):
-        system_id, ip, username, password, server_name, lpar, params = (
+        system_id, ip, username, password, server_name, lpar, context = (
             self.make_parameters())
         hmc_power_driver = HMCPowerDriver()
         power_state_hmc = self.patch(
             hmc_module, 'power_state_hmc')
         power_state_hmc.return_value = 'off'
-        expected_result = hmc_power_driver.power_query(**params)
+        expected_result = hmc_power_driver.power_query(system_id, context)
 
         self.expectThat(
             power_state_hmc, MockCalledOnceWith(

=== modified file 'src/provisioningserver/drivers/power/tests/test_ipmi.py'
--- src/provisioningserver/drivers/power/tests/test_ipmi.py	2015-10-14 18:10:57 +0000
+++ src/provisioningserver/drivers/power/tests/test_ipmi.py	2015-11-17 02:16:14 +0000
@@ -55,7 +55,7 @@
     power_off_mode = factory.make_name('power_off_mode')
     ipmipower = factory.make_name('ipmipower')
     ipmi_chassis_config = factory.make_name('ipmi_chassis_config')
-    params = {
+    context = {
         'power_address': power_address,
         'power_user': power_user,
         'power_pass': power_pass,
@@ -67,7 +67,7 @@
 
     return (
         power_address, power_user, power_pass, power_driver,
-        power_off_mode, ipmipower, ipmi_chassis_config, params
+        power_off_mode, ipmipower, ipmi_chassis_config, context
     )
 
 
@@ -109,7 +109,7 @@
 
     def test__finds_power_address_from_mac_address(self):
         (power_address, power_user, power_pass, power_driver, power_off_mode,
-         ipmipower, ipmi_chassis_config, params) = make_parameters()
+         ipmipower, ipmi_chassis_config, context) = make_parameters()
         driver = IPMIPowerDriver()
         ip_address = factory.make_ipv4_address()
         find_ip_via_arp = self.patch(ipmi_module, 'find_ip_via_arp')
@@ -117,12 +117,12 @@
         power_change = random.choice(("on", "off"))
         env = get_c_environment()
 
-        params['mac_address'] = factory.make_mac_address()
-        params['power_address'] = random.choice((None, "", "   "))
+        context['mac_address'] = factory.make_mac_address()
+        context['power_address'] = random.choice((None, "", "   "))
 
         self.patch_autospec(driver, "_issue_ipmi_chassis_config_command")
         self.patch_autospec(driver, "_issue_ipmi_power_command")
-        driver._issue_ipmi_command(power_change, **params)
+        driver._issue_ipmi_command(power_change, **context)
 
         # The IP address is passed to _issue_ipmi_chassis_config_command.
         self.assertThat(
@@ -160,7 +160,7 @@
 
     def test__issue_ipmi_command_issues_power_on(self):
         (power_address, power_user, power_pass, power_driver, power_off_mode,
-         ipmipower, ipmi_chassis_config, params) = make_parameters()
+         ipmipower, ipmi_chassis_config, context) = make_parameters()
         ipmi_chassis_config_command = make_ipmi_chassis_config_command(
             ipmi_chassis_config, power_address, power_pass, power_driver,
             power_user, ANY)
@@ -176,7 +176,7 @@
         call_and_check_mock = self.patch(ipmi_module, 'call_and_check')
         call_and_check_mock.return_value = 'on'
 
-        result = ipmi_power_driver._issue_ipmi_command('on', **params)
+        result = ipmi_power_driver._issue_ipmi_command('on', **context)
 
         self.expectThat(
             popen_mock, MockCalledOnceWith(
@@ -189,7 +189,7 @@
 
     def test__issue_ipmi_command_issues_power_off(self):
         (power_address, power_user, power_pass, power_driver, power_off_mode,
-         ipmipower, ipmi_chassis_config, params) = make_parameters()
+         ipmipower, ipmi_chassis_config, context) = make_parameters()
         ipmi_chassis_config_command = make_ipmi_chassis_config_command(
             ipmi_chassis_config, power_address, power_pass, power_driver,
             power_user, ANY)
@@ -205,7 +205,7 @@
         call_and_check_mock = self.patch(ipmi_module, 'call_and_check')
         call_and_check_mock.return_value = 'off'
 
-        result = ipmi_power_driver._issue_ipmi_command('off', **params)
+        result = ipmi_power_driver._issue_ipmi_command('off', **context)
 
         self.expectThat(
             popen_mock, MockCalledOnceWith(
@@ -218,8 +218,8 @@
 
     def test__issue_ipmi_command_issues_power_off_soft_mode(self):
         (power_address, power_user, power_pass, power_driver, power_off_mode,
-         ipmipower, ipmi_chassis_config, params) = make_parameters()
-        params['power_off_mode'] = 'soft'
+         ipmipower, ipmi_chassis_config, context) = make_parameters()
+        context['power_off_mode'] = 'soft'
         ipmi_chassis_config_command = make_ipmi_chassis_config_command(
             ipmi_chassis_config, power_address, power_pass, power_driver,
             power_user, ANY)
@@ -235,7 +235,7 @@
         call_and_check_mock = self.patch(ipmi_module, 'call_and_check')
         call_and_check_mock.return_value = 'off'
 
-        result = ipmi_power_driver._issue_ipmi_command('off', **params)
+        result = ipmi_power_driver._issue_ipmi_command('off', **context)
 
         self.expectThat(
             popen_mock, MockCalledOnceWith(
@@ -248,7 +248,7 @@
 
     def test__issue_ipmi_command_issues_power_query(self):
         (power_address, power_user, power_pass, power_driver, power_off_mode,
-         ipmipower, ipmi_chassis_config, params) = make_parameters()
+         ipmipower, ipmi_chassis_config, context) = make_parameters()
         ipmipower_command = make_ipmipower_command(
             ipmipower, power_address, power_pass, power_driver, power_user)
         ipmipower_command += ('--stat', )
@@ -261,7 +261,7 @@
         call_and_check_mock = self.patch(ipmi_module, 'call_and_check')
         call_and_check_mock.return_value = 'other'
 
-        result = ipmi_power_driver._issue_ipmi_command('query', **params)
+        result = ipmi_power_driver._issue_ipmi_command('query', **context)
 
         self.expectThat(popen_mock, MockNotCalled())
         self.expectThat(
@@ -270,7 +270,7 @@
         self.expectThat(result, Equals('other'))
 
     def test__issue_ipmi_command_issues_raises_power_auth_error(self):
-        _, _, _, _, _, _, _, params = make_parameters()
+        _, _, _, _, _, _, _, context = make_parameters()
         ipmi_power_driver = IPMIPowerDriver()
         popen_mock = self.patch(ipmi_module, 'Popen')
         process = popen_mock.return_value
@@ -279,10 +279,10 @@
 
         self.assertRaises(
             PowerAuthError, ipmi_power_driver._issue_ipmi_command,
-            'on', **params)
+            'on', **context)
 
     def test__issue_ipmi_command_issues_raises_power_fatal_error(self):
-        _, _, _, _, _, _, _, params = make_parameters()
+        _, _, _, _, _, _, _, context = make_parameters()
         ipmi_power_driver = IPMIPowerDriver()
         popen_mock = self.patch(ipmi_module, 'Popen')
         process = popen_mock.return_value
@@ -291,10 +291,10 @@
 
         self.assertRaises(
             PowerFatalError, ipmi_power_driver._issue_ipmi_command,
-            'on', **params)
+            'on', **context)
 
     def test__issue_ipmi_command_issues_catches_external_process_error(self):
-        _, _, _, _, _, _, _, params = make_parameters()
+        _, _, _, _, _, _, _, context = make_parameters()
         ipmi_power_driver = IPMIPowerDriver()
         popen_mock = self.patch(ipmi_module, 'Popen')
         process = popen_mock.return_value
@@ -306,37 +306,37 @@
 
         self.assertRaises(
             PowerFatalError, ipmi_power_driver._issue_ipmi_command,
-            'on', **params)
+            'on', **context)
 
     def test_power_on_calls__issue_ipmi_command(self):
-        _, _, _, _, _, _, _, params = make_parameters()
+        _, _, _, _, _, _, _, context = make_parameters()
         ipmi_power_driver = IPMIPowerDriver()
         _issue_ipmi_command_mock = self.patch(
             ipmi_power_driver, '_issue_ipmi_command')
         system_id = factory.make_name('system_id')
-        ipmi_power_driver.power_on(system_id, **params)
+        ipmi_power_driver.power_on(system_id, context)
 
         self.assertThat(
-            _issue_ipmi_command_mock, MockCalledOnceWith('on', **params))
+            _issue_ipmi_command_mock, MockCalledOnceWith('on', **context))
 
     def test_power_off_calls__issue_ipmi_command(self):
-        _, _, _, _, _, _, _, params = make_parameters()
+        _, _, _, _, _, _, _, context = make_parameters()
         ipmi_power_driver = IPMIPowerDriver()
         _issue_ipmi_command_mock = self.patch(
             ipmi_power_driver, '_issue_ipmi_command')
         system_id = factory.make_name('system_id')
-        ipmi_power_driver.power_off(system_id, **params)
+        ipmi_power_driver.power_off(system_id, context)
 
         self.assertThat(
-            _issue_ipmi_command_mock, MockCalledOnceWith('off', **params))
+            _issue_ipmi_command_mock, MockCalledOnceWith('off', **context))
 
     def test_power_query_calls__issue_ipmi_command(self):
-        _, _, _, _, _, _, _, params = make_parameters()
+        _, _, _, _, _, _, _, context = make_parameters()
         ipmi_power_driver = IPMIPowerDriver()
         _issue_ipmi_command_mock = self.patch(
             ipmi_power_driver, '_issue_ipmi_command')
         system_id = factory.make_name('system_id')
-        ipmi_power_driver.power_query(system_id, **params)
+        ipmi_power_driver.power_query(system_id, context)
 
         self.assertThat(
-            _issue_ipmi_command_mock, MockCalledOnceWith('query', **params))
+            _issue_ipmi_command_mock, MockCalledOnceWith('query', **context))

=== modified file 'src/provisioningserver/drivers/power/tests/test_moonshot.py'
--- src/provisioningserver/drivers/power/tests/test_moonshot.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_moonshot.py	2015-11-17 02:16:14 +0000
@@ -66,51 +66,51 @@
         self.assertItemsEqual([], missing)
 
     def test__issue_ipmitool_command_issues_power_on(self):
-        params = make_parameters()
+        context = make_parameters()
         power_change = 'on'
-        ipmitool_command = make_ipmitool_command(power_change, **params)
+        ipmitool_command = make_ipmitool_command(power_change, **context)
         moonshot_driver = MoonshotIPMIPowerDriver()
         call_and_check_mock = self.patch(moonshot_module, 'call_and_check')
         call_and_check_mock.return_value = power_change
 
         result = moonshot_driver._issue_ipmitool_command(
-            power_change, **params)
+            power_change, **context)
 
         self.expectThat(
             call_and_check_mock, MockCalledOnceWith(ipmitool_command))
         self.expectThat(result, Equals(power_change))
 
     def test__issue_ipmitool_command_issues_power_off(self):
-        params = make_parameters()
+        context = make_parameters()
         power_change = 'off'
-        ipmitool_command = make_ipmitool_command(power_change, **params)
+        ipmitool_command = make_ipmitool_command(power_change, **context)
         moonshot_driver = MoonshotIPMIPowerDriver()
         call_and_check_mock = self.patch(moonshot_module, 'call_and_check')
         call_and_check_mock.return_value = power_change
 
         result = moonshot_driver._issue_ipmitool_command(
-            power_change, **params)
+            power_change, **context)
 
         self.expectThat(
             call_and_check_mock, MockCalledOnceWith(ipmitool_command))
         self.expectThat(result, Equals(power_change))
 
     def test__issue_ipmitool_command_raises_power_action_error(self):
-        params = make_parameters()
+        context = make_parameters()
         power_change = 'other'
-        ipmitool_command = make_ipmitool_command(power_change, **params)
+        ipmitool_command = make_ipmitool_command(power_change, **context)
         moonshot_driver = MoonshotIPMIPowerDriver()
         call_and_check_mock = self.patch(moonshot_module, 'call_and_check')
         call_and_check_mock.return_value = power_change
 
         self.assertRaises(
             PowerActionError, moonshot_driver._issue_ipmitool_command,
-            power_change, **params)
+            power_change, **context)
         self.expectThat(
             call_and_check_mock, MockCalledOnceWith(ipmitool_command))
 
     def test__issue_ipmitool_raises_power_fatal_error(self):
-        params = make_parameters()
+        context = make_parameters()
         moonshot_driver = MoonshotIPMIPowerDriver()
         call_and_check_mock = self.patch(moonshot_module, 'call_and_check')
         call_and_check_mock.side_effect = (
@@ -118,38 +118,38 @@
 
         self.assertRaises(
             PowerFatalError, moonshot_driver._issue_ipmitool_command,
-            'status', **params)
+            'status', **context)
 
     def test_power_on_calls__issue_ipmitool_command(self):
-        params = make_parameters()
+        context = make_parameters()
         moonshot_driver = MoonshotIPMIPowerDriver()
         _issue_ipmitool_command_mock = self.patch(
             moonshot_driver, '_issue_ipmitool_command')
         system_id = factory.make_name('system_id')
-        moonshot_driver.power_on(system_id, **params)
+        moonshot_driver.power_on(system_id, context)
 
         self.assertThat(
-            _issue_ipmitool_command_mock, MockCalledOnceWith('on', **params))
+            _issue_ipmitool_command_mock, MockCalledOnceWith('on', **context))
 
     def test_power_off_calls__issue_ipmitool_command(self):
-        params = make_parameters()
+        context = make_parameters()
         moonshot_driver = MoonshotIPMIPowerDriver()
         _issue_ipmitool_command_mock = self.patch(
             moonshot_driver, '_issue_ipmitool_command')
         system_id = factory.make_name('system_id')
-        moonshot_driver.power_off(system_id, **params)
+        moonshot_driver.power_off(system_id, context)
 
         self.assertThat(
-            _issue_ipmitool_command_mock, MockCalledOnceWith('off', **params))
+            _issue_ipmitool_command_mock, MockCalledOnceWith('off', **context))
 
     def test_power_query_calls__issue_ipmitool_command(self):
-        params = make_parameters()
+        context = make_parameters()
         moonshot_driver = MoonshotIPMIPowerDriver()
         _issue_ipmitool_command_mock = self.patch(
             moonshot_driver, '_issue_ipmitool_command')
         system_id = factory.make_name('system_id')
-        moonshot_driver.power_query(system_id, **params)
+        moonshot_driver.power_query(system_id, context)
 
         self.assertThat(
             _issue_ipmitool_command_mock, MockCalledOnceWith(
-                'status', **params))
+                'status', **context))

=== modified file 'src/provisioningserver/drivers/power/tests/test_mscm.py'
--- src/provisioningserver/drivers/power/tests/test_mscm.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_mscm.py	2015-11-17 02:16:14 +0000
@@ -40,55 +40,55 @@
         username = factory.make_name('power_user')
         password = factory.make_name('power_pass')
         node_id = make_node_id()
-        params = {
+        context = {
             'system_id': system_id,
             'power_address': host,
             'power_user': username,
             'power_pass': password,
             'node_id': node_id,
         }
-        return system_id, host, username, password, node_id, params
+        return system_id, host, username, password, node_id, context
 
     def test_extract_mscm_parameters_extracts_parameters(self):
-        system_id, host, username, password, node_id, params = (
+        system_id, host, username, password, node_id, context = (
             self.make_parameters())
 
         self.assertItemsEqual(
             (host, username, password, node_id),
-            extract_mscm_parameters(params))
+            extract_mscm_parameters(context))
 
     def test_power_on_calls_power_control_mscm(self):
-        system_id, host, username, password, node_id, params = (
+        system_id, host, username, password, node_id, context = (
             self.make_parameters())
         mscm_power_driver = MSCMPowerDriver()
         power_control_mscm = self.patch(
             mscm_module, 'power_control_mscm')
-        mscm_power_driver.power_on(**params)
+        mscm_power_driver.power_on(system_id, context)
 
         self.assertThat(
             power_control_mscm, MockCalledOnceWith(
                 host, username, password, node_id, power_change='on'))
 
     def test_power_off_calls_power_control_mscm(self):
-        system_id, host, username, password, node_id, params = (
+        system_id, host, username, password, node_id, context = (
             self.make_parameters())
         mscm_power_driver = MSCMPowerDriver()
         power_control_mscm = self.patch(
             mscm_module, 'power_control_mscm')
-        mscm_power_driver.power_off(**params)
+        mscm_power_driver.power_off(system_id, context)
 
         self.assertThat(
             power_control_mscm, MockCalledOnceWith(
                 host, username, password, node_id, power_change='off'))
 
     def test_power_query_calls_power_state_mscm(self):
-        system_id, host, username, password, node_id, params = (
+        system_id, host, username, password, node_id, context = (
             self.make_parameters())
         mscm_power_driver = MSCMPowerDriver()
         power_state_mscm = self.patch(
             mscm_module, 'power_state_mscm')
         power_state_mscm.return_value = 'off'
-        expected_result = mscm_power_driver.power_query(**params)
+        expected_result = mscm_power_driver.power_query(system_id, context)
 
         self.expectThat(
             power_state_mscm, MockCalledOnceWith(

=== modified file 'src/provisioningserver/drivers/power/tests/test_msftocs.py'
--- src/provisioningserver/drivers/power/tests/test_msftocs.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_msftocs.py	2015-11-17 02:16:14 +0000
@@ -40,7 +40,7 @@
         username = factory.make_name('power_user')
         password = factory.make_name('power_pass')
         blade_id = factory.make_name('blade_id')
-        params = {
+        context = {
             'system_id': system_id,
             'power_address': ip,
             'power_port': port,
@@ -48,24 +48,24 @@
             'power_pass': password,
             'blade_id': blade_id,
         }
-        return system_id, ip, port, username, password, blade_id, params
+        return system_id, ip, port, username, password, blade_id, context
 
     def test_extract_msftocs_parameters_extracts_parameters(self):
-        system_id, ip, port, username, password, blade_id, params = (
+        system_id, ip, port, username, password, blade_id, context = (
             self.make_parameters())
 
         self.assertItemsEqual(
             (ip, port, username, password, blade_id),
-            extract_msftocs_parameters(params))
+            extract_msftocs_parameters(context))
 
     def test_power_on_calls_power_control_msftocs(self):
         power_change = 'on'
-        system_id, ip, port, username, password, blade_id, params = (
+        system_id, ip, port, username, password, blade_id, context = (
             self.make_parameters())
         msftocs_power_driver = MicrosoftOCSPowerDriver()
         power_control_msftocs = self.patch(
             msftocs_module, 'power_control_msftocs')
-        msftocs_power_driver.power_on(**params)
+        msftocs_power_driver.power_on(system_id, context)
 
         self.assertThat(
             power_control_msftocs, MockCalledOnceWith(
@@ -73,25 +73,25 @@
 
     def test_power_off_calls_power_control_msftocs(self):
         power_change = 'off'
-        system_id, ip, port, username, password, blade_id, params = (
+        system_id, ip, port, username, password, blade_id, context = (
             self.make_parameters())
         msftocs_power_driver = MicrosoftOCSPowerDriver()
         power_control_msftocs = self.patch(
             msftocs_module, 'power_control_msftocs')
-        msftocs_power_driver.power_off(**params)
+        msftocs_power_driver.power_off(system_id, context)
 
         self.assertThat(
             power_control_msftocs, MockCalledOnceWith(
                 ip, port, username, password, power_change))
 
     def test_power_query_calls_power_state_msftocs(self):
-        system_id, ip, port, username, password, blade_id, params = (
+        system_id, ip, port, username, password, blade_id, context = (
             self.make_parameters())
         msftocs_power_driver = MicrosoftOCSPowerDriver()
         power_state_msftocs = self.patch(
             msftocs_module, 'power_state_msftocs')
         power_state_msftocs.return_value = 'off'
-        expected_result = msftocs_power_driver.power_query(**params)
+        expected_result = msftocs_power_driver.power_query(system_id, context)
 
         self.expectThat(
             power_state_msftocs, MockCalledOnceWith(

=== modified file 'src/provisioningserver/drivers/power/tests/test_seamicro.py'
--- src/provisioningserver/drivers/power/tests/test_seamicro.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_seamicro.py	2015-11-17 02:16:14 +0000
@@ -50,30 +50,30 @@
         missing = driver.detect_missing_packages()
         self.assertItemsEqual([], missing)
 
-    def make_parameters(self):
+    def make_context(self):
         ip = factory.make_name('power_address')
         username = factory.make_name('power_user')
         password = factory.make_name('power_pass')
         server_id = factory.make_name('system_id')
-        params = {
+        context = {
             'power_address': ip,
             'power_user': username,
             'power_pass': password,
             'system_id': server_id,
         }
-        return ip, username, password, server_id, params
+        return ip, username, password, server_id, context
 
     def test_extract_seamicro_parameters_extracts_parameters(self):
-        ip, username, password, server_id, params = self.make_parameters()
+        ip, username, password, server_id, context = self.make_context()
         power_control = choice(['ipmi', 'restapi', 'restapi2'])
-        params['power_control'] = power_control
+        context['power_control'] = power_control
 
         self.assertItemsEqual(
             (ip, username, password, server_id, power_control),
-            extract_seamicro_parameters(params))
+            extract_seamicro_parameters(context))
 
     def test__power_control_seamicro15k_ipmi_calls_call_and_check(self):
-        ip, username, password, server_id, _ = self.make_parameters()
+        ip, username, password, server_id, _ = self.make_context()
         power_change = choice(['on', 'off'])
         seamicro_power_driver = SeaMicroPowerDriver()
         call_and_check_mock = self.patch(seamicro_module, 'call_and_check')
@@ -89,7 +89,7 @@
             ]))
 
     def test__power_control_seamicro15k_ipmi_raises_PowerFatalError(self):
-        ip, username, password, server_id, _ = self.make_parameters()
+        ip, username, password, server_id, _ = self.make_context()
         power_change = choice(['on', 'off'])
         seamicro_power_driver = SeaMicroPowerDriver()
         call_and_check_mock = self.patch(seamicro_module, 'call_and_check')
@@ -102,74 +102,73 @@
             ip, username, password, server_id, power_change)
 
     def test__power_calls__power_control_seamicro15k_ipmi(self):
-        ip, username, password, server_id, params = self.make_parameters()
-        params['power_control'] = 'ipmi'
+        ip, username, password, server_id, context = self.make_context()
+        context['power_control'] = 'ipmi'
         power_change = choice(['on', 'off'])
         seamicro_power_driver = SeaMicroPowerDriver()
         _power_control_seamicro15k_ipmi_mock = self.patch(
             seamicro_power_driver, '_power_control_seamicro15k_ipmi')
-        seamicro_power_driver._power(power_change, **params)
+        seamicro_power_driver._power(power_change, context)
 
         self.assertThat(
             _power_control_seamicro15k_ipmi_mock, MockCalledOnceWith(
                 ip, username, password, server_id, power_change=power_change))
 
     def test__power_calls_power_control_seamicro15k_v09(self):
-        ip, username, password, server_id, params = self.make_parameters()
-        params['power_control'] = 'restapi'
+        ip, username, password, server_id, context = self.make_context()
+        context['power_control'] = 'restapi'
         power_change = choice(['on', 'off'])
         seamicro_power_driver = SeaMicroPowerDriver()
         power_control_seamicro15k_v09_mock = self.patch(
             seamicro_module, 'power_control_seamicro15k_v09')
-        seamicro_power_driver._power(power_change, **params)
+        seamicro_power_driver._power(power_change, context)
 
         self.assertThat(
             power_control_seamicro15k_v09_mock, MockCalledOnceWith(
                 ip, username, password, server_id, power_change=power_change))
 
     def test__power_calls_power_control_seamicro15k_v2(self):
-        ip, username, password, server_id, params = self.make_parameters()
-        params['power_control'] = 'restapi2'
+        ip, username, password, server_id, context = self.make_context()
+        context['power_control'] = 'restapi2'
         power_change = choice(['on', 'off'])
         seamicro_power_driver = SeaMicroPowerDriver()
         power_control_seamicro15k_v2_mock = self.patch(
             seamicro_module, 'power_control_seamicro15k_v2')
-        seamicro_power_driver._power(power_change, **params)
+        seamicro_power_driver._power(power_change, context)
 
         self.assertThat(
             power_control_seamicro15k_v2_mock, MockCalledOnceWith(
                 ip, username, password, server_id, power_change=power_change))
 
     def test_power_on_calls_power(self):
-        _, _, _, _, params = self.make_parameters()
-        params['power_control'] = factory.make_name('power_control')
+        _, _, _, _, context = self.make_context()
+        context['power_control'] = factory.make_name('power_control')
         seamicro_power_driver = SeaMicroPowerDriver()
         power_mock = self.patch(seamicro_power_driver, '_power')
-        seamicro_power_driver.power_on(**params)
-        del params['system_id']
+        seamicro_power_driver.power_on(context['system_id'], context)
 
         self.assertThat(
-            power_mock, MockCalledOnceWith('on', **params))
+            power_mock, MockCalledOnceWith('on', context))
 
     def test_power_off_calls_power(self):
-        _, _, _, _, params = self.make_parameters()
-        params['power_control'] = factory.make_name('power_control')
+        _, _, _, _, context = self.make_context()
+        context['power_control'] = factory.make_name('power_control')
         seamicro_power_driver = SeaMicroPowerDriver()
         power_mock = self.patch(seamicro_power_driver, '_power')
-        seamicro_power_driver.power_off(**params)
-        del params['system_id']
+        seamicro_power_driver.power_off(context['system_id'], context)
 
         self.assertThat(
-            power_mock, MockCalledOnceWith('off', **params))
+            power_mock, MockCalledOnceWith('off', context))
 
     def test_power_query_calls_power_query_seamicro15k_v2(self):
-        ip, username, password, server_id, params = self.make_parameters()
-        params['power_control'] = 'restapi2'
+        ip, username, password, server_id, context = self.make_context()
+        context['power_control'] = 'restapi2'
         seamicro_power_driver = SeaMicroPowerDriver()
         power_query_seamicro15k_v2_mock = self.patch(
             seamicro_module, 'power_query_seamicro15k_v2')
         power_query_seamicro15k_v2_mock.return_value = 'on'
-        power_state = seamicro_power_driver.power_query(**params)
+        power_state = seamicro_power_driver.power_query(
+            context['system_id'], context)
 
         self.expectThat(
             power_query_seamicro15k_v2_mock, MockCalledOnceWith(
@@ -177,9 +176,10 @@
         self.expectThat(power_state, Equals('on'))
 
     def test_power_query_returns_unknown_if_not_restapi2(self):
-        ip, username, password, server_id, params = self.make_parameters()
-        params['power_control'] = factory.make_name('power_control')
+        ip, username, password, server_id, context = self.make_context()
+        context['power_control'] = factory.make_name('power_control')
         seamicro_power_driver = SeaMicroPowerDriver()
-        power_state = seamicro_power_driver.power_query(**params)
+        power_state = seamicro_power_driver.power_query(
+            context['system_id'], context)
 
         self.assertThat(power_state, Equals('unknown'))

=== modified file 'src/provisioningserver/drivers/power/tests/test_ucsm.py'
--- src/provisioningserver/drivers/power/tests/test_ucsm.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_ucsm.py	2015-11-17 02:16:14 +0000
@@ -39,55 +39,55 @@
         username = factory.make_name('power_user')
         password = factory.make_name('power_pass')
         uuid = factory.make_UUID()
-        params = {
+        context = {
             'system_id': system_id,
             'power_address': url,
             'power_user': username,
             'power_pass': password,
             'uuid': uuid,
         }
-        return system_id, url, username, password, uuid, params
+        return system_id, url, username, password, uuid, context
 
     def test_extract_ucsm_parameters_extracts_parameters(self):
-        system_id, url, username, password, uuid, params = (
+        system_id, url, username, password, uuid, context = (
             self.make_parameters())
 
         self.assertItemsEqual(
             (url, username, password, uuid),
-            extract_ucsm_parameters(params))
+            extract_ucsm_parameters(context))
 
     def test_power_on_calls_power_control_ucsm(self):
-        system_id, url, username, password, uuid, params = (
+        system_id, url, username, password, uuid, context = (
             self.make_parameters())
         ucsm_power_driver = UCSMPowerDriver()
         power_control_ucsm = self.patch(
             ucsm_module, 'power_control_ucsm')
-        ucsm_power_driver.power_on(**params)
+        ucsm_power_driver.power_on(system_id, context)
 
         self.assertThat(
             power_control_ucsm, MockCalledOnceWith(
                 url, username, password, uuid, maas_power_mode='on'))
 
     def test_power_off_calls_power_control_ucsm(self):
-        system_id, url, username, password, uuid, params = (
+        system_id, url, username, password, uuid, context = (
             self.make_parameters())
         ucsm_power_driver = UCSMPowerDriver()
         power_control_ucsm = self.patch(
             ucsm_module, 'power_control_ucsm')
-        ucsm_power_driver.power_off(**params)
+        ucsm_power_driver.power_off(system_id, context)
 
         self.assertThat(
             power_control_ucsm, MockCalledOnceWith(
                 url, username, password, uuid, maas_power_mode='off'))
 
     def test_power_query_calls_power_state_ucsm(self):
-        system_id, url, username, password, uuid, params = (
+        system_id, url, username, password, uuid, context = (
             self.make_parameters())
         ucsm_power_driver = UCSMPowerDriver()
         power_state_ucsm = self.patch(
             ucsm_module, 'power_state_ucsm')
         power_state_ucsm.return_value = 'off'
-        expected_result = ucsm_power_driver.power_query(**params)
+        expected_result = ucsm_power_driver.power_query(system_id, context)
 
         self.expectThat(
             power_state_ucsm, MockCalledOnceWith(

=== modified file 'src/provisioningserver/drivers/power/tests/test_virsh.py'
--- src/provisioningserver/drivers/power/tests/test_virsh.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_virsh.py	2015-11-17 02:16:14 +0000
@@ -47,30 +47,30 @@
         poweraddr = factory.make_name('power_address')
         machine = factory.make_name('power_id')
         password = factory.make_name('power_pass')
-        params = {
+        context = {
             'system_id': system_id,
             'power_address': poweraddr,
             'power_id': machine,
             'power_pass': password,
         }
-        return system_id, poweraddr, machine, password, params
+        return system_id, poweraddr, machine, password, context
 
     def test_extract_virsh_parameters_extracts_parameters(self):
-        system_id, poweraddr, machine, password, params = (
+        system_id, poweraddr, machine, password, context = (
             self.make_parameters())
 
         self.assertItemsEqual(
             (poweraddr, machine, password),
-            extract_virsh_parameters(params))
+            extract_virsh_parameters(context))
 
     def test_power_on_calls_power_control_virsh(self):
         power_change = 'on'
-        system_id, poweraddr, machine, password, params = (
+        system_id, poweraddr, machine, password, context = (
             self.make_parameters())
         virsh_power_driver = VirshPowerDriver()
         power_control_virsh = self.patch(
             virsh_module, 'power_control_virsh')
-        virsh_power_driver.power_on(**params)
+        virsh_power_driver.power_on(system_id, context)
 
         self.assertThat(
             power_control_virsh, MockCalledOnceWith(
@@ -78,25 +78,25 @@
 
     def test_power_off_calls_power_control_virsh(self):
         power_change = 'off'
-        system_id, poweraddr, machine, password, params = (
+        system_id, poweraddr, machine, password, context = (
             self.make_parameters())
         virsh_power_driver = VirshPowerDriver()
         power_control_virsh = self.patch(
             virsh_module, 'power_control_virsh')
-        virsh_power_driver.power_off(**params)
+        virsh_power_driver.power_off(system_id, context)
 
         self.assertThat(
             power_control_virsh, MockCalledOnceWith(
                 poweraddr, machine, power_change, password))
 
     def test_power_query_calls_power_state_virsh(self):
-        system_id, poweraddr, machine, password, params = (
+        system_id, poweraddr, machine, password, context = (
             self.make_parameters())
         virsh_power_driver = VirshPowerDriver()
         power_state_virsh = self.patch(
             virsh_module, 'power_state_virsh')
         power_state_virsh.return_value = 'off'
-        expected_result = virsh_power_driver.power_query(**params)
+        expected_result = virsh_power_driver.power_query(system_id, context)
 
         self.expectThat(
             power_state_virsh, MockCalledOnceWith(

=== modified file 'src/provisioningserver/drivers/power/tests/test_vmware.py'
--- src/provisioningserver/drivers/power/tests/test_vmware.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/tests/test_vmware.py	2015-11-17 02:16:14 +0000
@@ -1,5 +1,5 @@
 # Copyright 2015 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
+# Gnu Affero General Public License version 3 (see the file LICENSE).
 
 """Tests for `provisioningserver.drivers.power.vmware`."""
 
@@ -50,7 +50,7 @@
         vm_name = factory.make_name('power_vm_name')
         uuid = factory.make_name('power_uuid')
         port = protocol = None
-        params = {
+        context = {
             'system_id': system_id,
             'power_address': host,
             'power_user': username,
@@ -61,24 +61,24 @@
             'power_protocol': protocol,
         }
         return (system_id, host, username, password,
-                vm_name, uuid, port, protocol, params)
+                vm_name, uuid, port, protocol, context)
 
     def test_extract_vmware_parameters_extracts_parameters(self):
         (system_id, host, username, password,
-         vm_name, uuid, port, protocol, params) = self.make_parameters()
+         vm_name, uuid, port, protocol, context) = self.make_parameters()
 
         self.assertItemsEqual(
             (host, username, password, vm_name, uuid, port, protocol),
-            extract_vmware_parameters(params))
+            extract_vmware_parameters(context))
 
     def test_power_on_calls_power_control_vmware(self):
         power_change = 'on'
         (system_id, host, username, password,
-         vm_name, uuid, port, protocol, params) = self.make_parameters()
+         vm_name, uuid, port, protocol, context) = self.make_parameters()
         vmware_power_driver = VMwarePowerDriver()
         power_control_vmware = self.patch(
             vmware_module, 'power_control_vmware')
-        vmware_power_driver.power_on(**params)
+        vmware_power_driver.power_on(system_id, context)
 
         self.assertThat(
             power_control_vmware, MockCalledOnceWith(
@@ -88,11 +88,11 @@
     def test_power_off_calls_power_control_vmware(self):
         power_change = 'off'
         (system_id, host, username, password,
-         vm_name, uuid, port, protocol, params) = self.make_parameters()
+         vm_name, uuid, port, protocol, context) = self.make_parameters()
         vmware_power_driver = VMwarePowerDriver()
         power_control_vmware = self.patch(
             vmware_module, 'power_control_vmware')
-        vmware_power_driver.power_off(**params)
+        vmware_power_driver.power_off(system_id, context)
 
         self.assertThat(
             power_control_vmware, MockCalledOnceWith(
@@ -101,12 +101,12 @@
 
     def test_power_query_calls_power_query_vmware(self):
         (system_id, host, username, password,
-         vm_name, uuid, port, protocol, params) = self.make_parameters()
+         vm_name, uuid, port, protocol, context) = self.make_parameters()
         vmware_power_driver = VMwarePowerDriver()
         power_query_vmware = self.patch(
             vmware_module, 'power_query_vmware')
         power_query_vmware.return_value = 'off'
-        expected_result = vmware_power_driver.power_query(**params)
+        expected_result = vmware_power_driver.power_query(system_id, context)
 
         self.expectThat(
             power_query_vmware, MockCalledOnceWith(

=== modified file 'src/provisioningserver/drivers/power/ucsm.py'
--- src/provisioningserver/drivers/power/ucsm.py	2015-09-30 07:16:42 +0000
+++ src/provisioningserver/drivers/power/ucsm.py	2015-11-17 02:16:14 +0000
@@ -21,11 +21,11 @@
 from provisioningserver.drivers.power import PowerDriver
 
 
-def extract_ucsm_parameters(params):
-    url = params.get('power_address')
-    username = params.get('power_user')
-    password = params.get('power_pass')
-    uuid = params.get('uuid')
+def extract_ucsm_parameters(context):
+    url = context.get('power_address')
+    username = context.get('power_user')
+    password = context.get('power_pass')
+    uuid = context.get('uuid')
     return url, username, password, uuid
 
 
@@ -39,19 +39,19 @@
         # uses urllib2 http client - nothing to look for!
         return []
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on UCSM node."""
-        url, username, password, uuid = extract_ucsm_parameters(kwargs)
+        url, username, password, uuid = extract_ucsm_parameters(context)
         power_control_ucsm(
             url, username, password, uuid, maas_power_mode='on')
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off UCSM node."""
-        url, username, password, uuid = extract_ucsm_parameters(kwargs)
+        url, username, password, uuid = extract_ucsm_parameters(context)
         power_control_ucsm(
             url, username, password, uuid, maas_power_mode='off')
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query UCSM node."""
-        url, username, password, uuid = extract_ucsm_parameters(kwargs)
+        url, username, password, uuid = extract_ucsm_parameters(context)
         return power_state_ucsm(url, username, password, uuid)

=== modified file 'src/provisioningserver/drivers/power/virsh.py'
--- src/provisioningserver/drivers/power/virsh.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/virsh.py	2015-11-17 02:16:14 +0000
@@ -26,10 +26,10 @@
                      ["virt-login-shell", "libvirt-bin"]]
 
 
-def extract_virsh_parameters(params):
-    poweraddr = params.get('power_address')
-    machine = params.get('power_id')
-    password = params.get('power_pass')
+def extract_virsh_parameters(context):
+    poweraddr = context.get('power_address')
+    machine = context.get('power_id')
+    password = context.get('power_pass')
     return poweraddr, machine, password
 
 
@@ -46,21 +46,21 @@
                 missing_packages.add(package)
         return list(missing_packages)
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on Virsh node."""
         power_change = 'on'
-        poweraddr, machine, password = extract_virsh_parameters(kwargs)
+        poweraddr, machine, password = extract_virsh_parameters(context)
         power_control_virsh(
             poweraddr, machine, power_change, password)
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off Virsh node."""
         power_change = 'off'
-        poweraddr, machine, password = extract_virsh_parameters(kwargs)
+        poweraddr, machine, password = extract_virsh_parameters(context)
         power_control_virsh(
             poweraddr, machine, power_change, password)
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query Virsh node."""
-        poweraddr, machine, password = extract_virsh_parameters(kwargs)
+        poweraddr, machine, password = extract_virsh_parameters(context)
         return power_state_virsh(poweraddr, machine, password)

=== modified file 'src/provisioningserver/drivers/power/vmware.py'
--- src/provisioningserver/drivers/power/vmware.py	2015-10-01 22:48:50 +0000
+++ src/provisioningserver/drivers/power/vmware.py	2015-11-17 02:16:14 +0000
@@ -22,14 +22,14 @@
 from provisioningserver.drivers.power import PowerDriver
 
 
-def extract_vmware_parameters(params):
-    host = params.get('power_address')
-    username = params.get('power_user')
-    password = params.get('power_pass')
-    vm_name = params.get('power_vm_name')
-    uuid = params.get('power_uuid')
-    port = params.get('power_port')
-    protocol = params.get('power_protocol')
+def extract_vmware_parameters(context):
+    host = context.get('power_address')
+    username = context.get('power_user')
+    password = context.get('power_pass')
+    vm_name = context.get('power_vm_name')
+    uuid = context.get('power_uuid')
+    port = context.get('power_port')
+    protocol = context.get('power_protocol')
     return host, username, password, vm_name, uuid, port, protocol
 
 
@@ -44,27 +44,27 @@
             return ["python-pyvmomi"]
         return []
 
-    def power_on(self, system_id, **kwargs):
+    def power_on(self, system_id, context):
         """Power on VMware node."""
         power_change = 'on'
         host, username, password, vm_name, uuid, port, protocol = (
-            extract_vmware_parameters(kwargs))
+            extract_vmware_parameters(context))
         power_control_vmware(
             host, username, password, vm_name,
             uuid, power_change, port, protocol)
 
-    def power_off(self, system_id, **kwargs):
+    def power_off(self, system_id, context):
         """Power off VMware node."""
         power_change = 'off'
         host, username, password, vm_name, uuid, port, protocol = (
-            extract_vmware_parameters(kwargs))
+            extract_vmware_parameters(context))
         power_control_vmware(
             host, username, password, vm_name,
             uuid, power_change, port, protocol)
 
-    def power_query(self, system_id, **kwargs):
+    def power_query(self, system_id, context):
         """Power query VMware node."""
         host, username, password, vm_name, uuid, port, protocol = (
-            extract_vmware_parameters(kwargs))
+            extract_vmware_parameters(context))
         return power_query_vmware(
             host, username, password, vm_name, uuid, port, protocol)

=== modified file 'src/provisioningserver/power/change.py'
--- src/provisioningserver/power/change.py	2015-10-20 17:59:57 +0000
+++ src/provisioningserver/power/change.py	2015-11-17 02:16:14 +0000
@@ -116,9 +116,9 @@
     power_driver = PowerDriverRegistry.get_item(power_type)
 
     if power_change == 'on':
-        d = power_driver.on(**context)
+        d = power_driver.on(system_id, context)
     elif power_change == 'off':
-        d = power_driver.off(**context)
+        d = power_driver.off(system_id, context)
 
     def power_change_failed(failure):
         message = "Node could not be powered %s: %s" % (

=== modified file 'src/provisioningserver/power/query.py'
--- src/provisioningserver/power/query.py	2015-10-20 17:59:57 +0000
+++ src/provisioningserver/power/query.py	2015-11-17 02:16:14 +0000
@@ -82,7 +82,7 @@
     """
     # Get power driver for given power type
     power_driver = PowerDriverRegistry[power_type]
-    return power_driver.query(**context)
+    return power_driver.query(system_id, context)
 
 
 @asynchronous