Merge lp:~newell-jensen/maas/1.9-fix-1586499 into lp:maas/1.9

[Newell Jensen]

Hand picked backport trunk r5059: Update HP Moonshot iLO4 (IPMI) power driver to set PXE booting and also make it a queryable power type.

[Newell Jensen (newell-jensen)]

Self approved backport (minimal code changes due to merge conflicts).

review: Approve

=== modified file 'src/provisioningserver/drivers/power/moonshot.py'
--- src/provisioningserver/drivers/power/moonshot.py	2016-05-25 17:04:33 +0000
+++ src/provisioningserver/drivers/power/moonshot.py	2016-06-01 04:55:57 +0000
@@ -15,10 +15,12 @@
 __all__ = []
 
 
+import os
+import re
+
 from provisioningserver.drivers.power import (
     PowerActionError,
     PowerDriver,
-    PowerFatalError,
 )
 from provisioningserver.utils import shell
 from provisioningserver.utils.shell import (
@@ -39,28 +41,35 @@
         return []
 
     def _issue_ipmitool_command(
-            self, power_change, power_hwaddress=None, power_address=None,
-            power_user=None, power_pass=None, ipmitool=None, **extra):
+            self, power_change, ipmitool=None, power_address=None,
+            power_user=None, power_pass=None, power_hwaddress=None, **extra):
+        """Issue ipmitool command for HP Moonshot cartridge."""
+        env = os.environ.copy()
+        env['LC_ALL'] = 'C'
         command = (
-            ipmitool, '-I', 'lanplus', '-H', power_address, '-U', power_user,
-            '-P', power_pass, power_hwaddress, 'power', power_change
-        )
+            ipmitool, '-I', 'lanplus', '-H', power_address,
+            '-U', power_user, '-P', power_pass
+        ) + tuple(power_hwaddress.split())
+        if power_change == 'pxe':
+            command += ('chassis', 'bootdev', 'pxe')
+        else:
+            command += ('power', power_change)
         try:
-            output = call_and_check(command)
+            stdout = call_and_check(command, env=env)
+            stdout = stdout.decode('utf-8')
         except ExternalProcessError as e:
-            raise PowerFatalError(
-                "Failed to power %s %s: %s" % (
-                    power_change, power_hwaddress, e.output_as_unicode))
+            raise PowerActionError(
+                "Failed to execute %s for cartridge %s at %s: %s" % (
+                    command, power_hwaddress,
+                    power_address, e.output_as_unicode))
         else:
-            if 'on' in output:
-                return 'on'
-            elif 'off' in output:
-                return 'off'
-            else:
-                raise PowerActionError(
-                    "Got unknown power state from ipmipower: %s" % output)
+            # Return output if power query
+            if power_change == 'status':
+                match = re.search(r'\b(on|off)\b$', stdout)
+                return stdout if match is None else match.group(0)
 
     def power_on(self, system_id, context):
+        self._issue_ipmitool_command('pxe', **context)
         self._issue_ipmitool_command('on', **context)
 
     def power_off(self, system_id, context):

=== modified file 'src/provisioningserver/drivers/power/tests/test_moonshot.py'
--- src/provisioningserver/drivers/power/tests/test_moonshot.py	2016-05-25 17:04:33 +0000
+++ src/provisioningserver/drivers/power/tests/test_moonshot.py	2016-06-01 04:55:57 +0000
@@ -1,26 +1,23 @@
-# Copyright 2015 Canonical Ltd.  This software is licensed under the
+# Copyright 2015-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Tests for `provisioningserver.drivers.power.ipmi`."""
 
-from __future__ import (
-    absolute_import,
-    print_function,
-    unicode_literals,
-    )
-
-str = None
-
-__metaclass__ = type
 __all__ = []
 
+
+import os
+
 from maastesting.factory import factory
-from maastesting.matchers import MockCalledOnceWith
+from maastesting.matchers import (
+    MockCalledOnceWith,
+    MockCallsMatch,
+)
 from maastesting.testcase import MAASTestCase
+from mock import call
 from provisioningserver.drivers.power import (
     moonshot as moonshot_module,
     PowerActionError,
-    PowerFatalError,
 )
 from provisioningserver.drivers.power.moonshot import MoonshotIPMIPowerDriver
 from provisioningserver.utils.shell import (
@@ -30,23 +27,37 @@
 from testtools.matchers import Equals
 
 
-def make_parameters():
+def make_context():
     return {
-        'power_hwaddress': factory.make_name('power_hwaddress'),
+        'ipmitool': factory.make_name('ipmitool'),
         'power_address': factory.make_name('power_address'),
         'power_user': factory.make_name('power_user'),
         'power_pass': factory.make_name('power_pass'),
-        'ipmitool': factory.make_name('ipmitool'),
+        'power_hwaddress': factory.make_string(spaces=True),
     }
 
 
-def make_ipmitool_command(
-        power_change, power_hwaddress, power_address,
-        power_user, power_pass, ipmitool):
+def make_command(
+        ipmitool, power_address, power_user, power_pass,
+        power_hwaddress):
     return (
         ipmitool, '-I', 'lanplus', '-H', power_address, '-U', power_user,
-        '-P', power_pass, power_hwaddress, 'power', power_change
-    )
+        '-P', power_pass
+    ) + tuple(power_hwaddress.split())
+
+
+def make_pxe_command(context):
+    return make_command(
+        context['ipmitool'], context['power_address'], context['power_user'],
+        context['power_pass'], context['power_hwaddress']
+    ) + ('chassis', 'bootdev', 'pxe')
+
+
+def make_ipmitool_command(power_change, context):
+    return make_command(
+        context['ipmitool'], context['power_address'], context['power_user'],
+        context['power_pass'], context['power_hwaddress']
+    ) + ('power', power_change)
 
 
 class TestMoonshotIPMIPowerDriver(MAASTestCase):
@@ -65,63 +76,47 @@
         missing = driver.detect_missing_packages()
         self.assertItemsEqual([], missing)
 
-    def test__issue_ipmitool_command_issues_power_on(self):
-        context = make_parameters()
-        power_change = 'on'
-        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, **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):
-        context = make_parameters()
-        power_change = 'off'
-        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, **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):
-        context = make_parameters()
-        power_change = 'other'
-        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, **context)
-        self.expectThat(
-            call_and_check_mock, MockCalledOnceWith(ipmitool_command))
-
-    def test__issue_ipmitool_raises_power_fatal_error(self):
-        context = make_parameters()
+    def test__issue_ipmitool_command_sets_pxe_boot(self):
+        context = make_context()
+        env = os.environ.copy()
+        env['LC_ALL'] = 'C'
+        pxe_command = make_pxe_command(context)
+        moonshot_driver = MoonshotIPMIPowerDriver()
+        call_and_check_mock = self.patch(moonshot_module, 'call_and_check')
+
+        moonshot_driver._issue_ipmitool_command('pxe', **context)
+
+        self.assertThat(
+            call_and_check_mock, MockCalledOnceWith(pxe_command, env=env))
+
+    def test__issue_ipmitool_command_returns_stdout_if_no_match(self):
+        context = make_context()
+        env = os.environ.copy()
+        env['LC_ALL'] = 'C'
+        ipmitool_command = make_ipmitool_command('status', context)
+        moonshot_driver = MoonshotIPMIPowerDriver()
+        call_and_check_mock = self.patch(moonshot_module, 'call_and_check')
+        call_and_check_mock.return_value = b'other'
+
+        result = moonshot_driver._issue_ipmitool_command('status', **context)
+
+        self.expectThat(
+            call_and_check_mock, MockCalledOnceWith(ipmitool_command, env=env))
+        self.expectThat(result, Equals('other'))
+
+    def test__issue_ipmitool_raises_power_action_error(self):
+        context = make_context()
         moonshot_driver = MoonshotIPMIPowerDriver()
         call_and_check_mock = self.patch(moonshot_module, 'call_and_check')
         call_and_check_mock.side_effect = (
             ExternalProcessError(1, "ipmitool something"))
 
         self.assertRaises(
-            PowerFatalError, moonshot_driver._issue_ipmitool_command,
+            PowerActionError, moonshot_driver._issue_ipmitool_command,
             'status', **context)
 
     def test_power_on_calls__issue_ipmitool_command(self):
-        context = make_parameters()
+        context = make_context()
         moonshot_driver = MoonshotIPMIPowerDriver()
         _issue_ipmitool_command_mock = self.patch(
             moonshot_driver, '_issue_ipmitool_command')
@@ -129,10 +124,11 @@
         moonshot_driver.power_on(system_id, context)
 
         self.assertThat(
-            _issue_ipmitool_command_mock, MockCalledOnceWith('on', **context))
+            _issue_ipmitool_command_mock, MockCallsMatch(
+                call('pxe', **context), call('on', **context)))
 
     def test_power_off_calls__issue_ipmitool_command(self):
-        context = make_parameters()
+        context = make_context()
         moonshot_driver = MoonshotIPMIPowerDriver()
         _issue_ipmitool_command_mock = self.patch(
             moonshot_driver, '_issue_ipmitool_command')
@@ -143,7 +139,7 @@
             _issue_ipmitool_command_mock, MockCalledOnceWith('off', **context))
 
     def test_power_query_calls__issue_ipmitool_command(self):
-        context = make_parameters()
+        context = make_context()
         moonshot_driver = MoonshotIPMIPowerDriver()
         _issue_ipmitool_command_mock = self.patch(
             moonshot_driver, '_issue_ipmitool_command')

=== modified file 'src/provisioningserver/power/__init__.py'
--- src/provisioningserver/power/__init__.py	2015-12-04 20:57:06 +0000
+++ src/provisioningserver/power/__init__.py	2016-06-01 04:55:57 +0000
@@ -32,6 +32,7 @@
     'amt',
     'hmc',
     'ipmi',
+    'moonshot',
     'mscm',
     'msftocs',
     'sm15k',