Merge lp:~newell-jensen/maas/arm64-backport-1.5 into lp:maas/1.5

[Newell Jensen]

arm64 enablement backported to MaaS 1.5

[Newell Jensen (newell-jensen)]

Self review, backport.

review: Approve

=== added file 'etc/maas/templates/power/mscm.template'
--- etc/maas/templates/power/mscm.template	1970-01-01 00:00:00 +0000
+++ etc/maas/templates/power/mscm.template	2014-07-24 05:13:03 +0000
@@ -0,0 +1,15 @@
+# -*- mode: shell-script -*-
+#
+# Control a system via Moonshot HP iLO Chassis Manager (MSCM).
+
+{{py: from provisioningserver.utils import escape_py_literal}}
+python - << END
+from provisioningserver.drivers.hardware.mscm import power_control_mscm
+power_control_mscm(
+    {{escape_py_literal(power_address) | safe}},
+    {{escape_py_literal(power_user) | safe}},
+    {{escape_py_literal(power_pass) | safe}},
+    {{escape_py_literal(node_id) | safe}},
+    {{escape_py_literal(power_change) | safe}},
+)
+END
 
=== added symlink 'etc/maas/templates/pxe/config.commissioning.arm64.template'
=== target is u'config.commissioning.armhf.template'
=== added symlink 'etc/maas/templates/pxe/config.install.arm64.template'
=== target is u'config.install.armhf.template'
=== added symlink 'etc/maas/templates/pxe/config.xinstall.arm64.template'
=== target is u'config.xinstall.armhf.template'
=== modified file 'src/maasserver/api.py'
--- src/maasserver/api.py	2014-06-19 11:25:08 +0000
+++ src/maasserver/api.py	2014-07-24 05:13:03 +0000
@@ -1763,6 +1763,30 @@
 
         return HttpResponse(status=httplib.OK)
 
+    @admin_method
+    @operation(idempotent=False)
+    def probe_and_enlist_mscm(self, request, uuid):
+        """Add the nodes from a Moonshot HP iLO Chassis Manager (MSCM).
+
+        :param host: IP Address for the MSCM.
+        :type host: unicode
+        :param username: The username for the MSCM.
+        :type username: unicode
+        :param password: The password for the MSCM.
+        :type password: unicode
+
+        """
+        nodegroup = get_object_or_404(NodeGroup, uuid=uuid)
+
+        host = get_mandatory_param(request.data, 'host')
+        username = get_mandatory_param(request.data, 'username')
+        password = get_mandatory_param(request.data, 'password')
+
+        nodegroup.enlist_nodes_from_mscm(host, username, password)
+
+        return HttpResponse(status=httplib.OK)
+
+
 DISPLAYED_NODEGROUPINTERFACE_FIELDS = (
     'ip', 'management', 'interface', 'subnet_mask',
     'broadcast_ip', 'ip_range_low', 'ip_range_high')
 
=== modified file 'src/maasserver/models/nodegroup.py'
--- src/maasserver/models/nodegroup.py	2014-05-21 17:30:26 +0000
+++ src/maasserver/models/nodegroup.py	2014-07-24 05:13:03 +0000
@@ -42,6 +42,7 @@
     add_new_dhcp_host_map,
     add_seamicro15k,
     add_virsh,
+    enlist_nodes_from_mscm,
     enlist_nodes_from_ucsm,
     import_boot_images,
     report_boot_images,
@@ -307,6 +308,16 @@
         args = (url, username, password)
         enlist_nodes_from_ucsm.apply_async(queue=self.uuid, args=args)
 
+    def enlist_nodes_from_mscm(self, host, username, password):
+        """ Add the servers from a Moonshot HP iLO Chassis Manager.
+
+        :param host: IP address for the MSCM.
+        :param username: username for MSCM.
+        :param password: password for MSCM.
+        """
+        args = (host, username, password)
+        enlist_nodes_from_mscm.apply_async(queue=self.uuid, args=args)
+
     def add_dhcp_host_maps(self, new_leases):
         if len(new_leases) > 0 and len(self.get_managed_interfaces()) > 0:
             # XXX JeroenVermeulen 2012-08-21, bug=1039362: the DHCP
 
=== modified file 'src/maasserver/tests/test_api_nodegroup.py'
--- src/maasserver/tests/test_api_nodegroup.py	2014-05-06 21:18:17 +0000
+++ src/maasserver/tests/test_api_nodegroup.py	2014-07-24 05:13:03 +0000
@@ -460,6 +460,32 @@
         matcher = MockCalledOnceWith(queue=nodegroup.uuid, args=args)
         self.assertThat(mock.apply_async, matcher)
 
+    def test_probe_and_enlist_mscm_adds_mscm(self):
+        nodegroup = factory.make_node_group()
+        host = 'http://host'
+        username = factory.make_name('user')
+        password = factory.make_name('password')
+        self.become_admin()
+
+        mock = self.patch(nodegroup_module, 'enlist_nodes_from_mscm')
+
+        response = self.client.post(
+            reverse('nodegroup_handler', args=[nodegroup.uuid]),
+            {
+                'op': 'probe_and_enlist_mscm',
+                'host': host,
+                'username': username,
+                'password': password,
+            })
+
+        self.assertEqual(
+            httplib.OK, response.status_code,
+            explain_unexpected_response(httplib.OK, response))
+
+        args = (host, username, password)
+        matcher = MockCalledOnceWith(queue=nodegroup.uuid, args=args)
+        self.assertThat(mock.apply_async, matcher)
+
 
 class TestNodeGroupAPIAuth(MAASServerTestCase):
     """Authorization tests for nodegroup API."""
 
=== modified file 'src/maastesting/factory.py'
--- src/maastesting/factory.py	2014-03-13 02:46:10 +0000
+++ src/maastesting/factory.py	2014-07-24 05:13:03 +0000
@@ -35,6 +35,7 @@
 from uuid import uuid1
 
 from maastesting.fixtures import TempDirectory
+import mock
 from netaddr import (
     IPAddress,
     IPNetwork,
@@ -264,6 +265,14 @@
 
         return tarball
 
+    def make_streams(self, stdin=None, stdout=None, stderr=None):
+        """Make a fake return value for a SSHClient.exec_command."""
+        # stdout.read() is called so stdout can't be None.
+        if stdout is None:
+            stdout = mock.Mock()
+
+        return (stdin, stdout, stderr)
+
 
 # Create factory singleton.
 factory = Factory()
 
=== modified file 'src/provisioningserver/driver/__init__.py'
--- src/provisioningserver/driver/__init__.py	2014-06-02 20:14:18 +0000
+++ src/provisioningserver/driver/__init__.py	2014-07-24 05:13:03 +0000
@@ -134,6 +134,12 @@
     Architecture(name="i386/generic", description="i386"),
     Architecture(name="amd64/generic", description="amd64"),
     Architecture(
+        name="arm64/generic", description="arm64/generic",
+        pxealiases=["arm"]),
+    Architecture(
+        name="arm64/xgene-uboot", description="arm64/xgene-uboot",
+        pxealiases=["arm"]),
+    Architecture(
         name="armhf/highbank", description="armhf/highbank",
         pxealiases=["arm"], kernel_options=["console=ttyAMA0"]),
     Architecture(
 
=== added directory 'src/provisioningserver/drivers'
=== added file 'src/provisioningserver/drivers/__init__.py'
=== added directory 'src/provisioningserver/drivers/hardware'
=== added file 'src/provisioningserver/drivers/hardware/__init__.py'
=== added file 'src/provisioningserver/drivers/hardware/mscm.py'
--- src/provisioningserver/drivers/hardware/mscm.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/drivers/hardware/mscm.py	2014-07-24 05:13:03 +0000
@@ -0,0 +1,187 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Support for managing nodes via the Moonshot HP iLO Chassis Manager CLI.
+
+This module provides support for interacting with HP Moonshot iLO Chassis
+Management (MSCM) CLI via SSH, and for using that support to allow MAAS to
+manage systems via iLO.
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+str = None
+
+__metaclass__ = type
+__all__ = [
+    'power_control_mscm',
+    'probe_and_enlist_mscm',
+]
+
+import re
+
+from paramiko import (
+    AutoAddPolicy,
+    SSHClient,
+    )
+import provisioningserver.custom_hardware.utils as utils
+
+
+cartridge_mapping = {
+    'ProLiant Moonshot Cartridge': 'amd64/generic',
+    'ProLiant m300 Server Cartridge': 'amd64/generic',
+    'ProLiant m350 Server Cartridge': 'amd64/generic',
+    'ProLiant m400 Server Cartridge': 'arm64/xgene-uboot',
+    'ProLiant m500 Server Cartridge': 'amd64/generic',
+    'ProLiant m710 Server Cartridge': 'amd64/generic',
+    'ProLiant m800 Server Cartridge': 'armhf/keystone',
+    'Default': 'arm64/generic',
+}
+
+
+class MSCM_CLI_API(object):
+    """An API for interacting with the Moonshot iLO CM CLI."""
+
+    def __init__(self, host, username, password):
+        """MSCM_CLI_API Constructor."""
+        self.host = host
+        self.username = username
+        self.password = password
+        self._ssh = SSHClient()
+        self._ssh.set_missing_host_key_policy(AutoAddPolicy())
+
+    def _run_cli_command(self, command):
+        """Run a single command and return unparsed text from stdout."""
+        self._ssh.connect(
+            self.host, username=self.username, password=self.password)
+        try:
+            _, stdout, _ = self._ssh.exec_command(command)
+            output = stdout.read()
+        finally:
+            self._ssh.close()
+
+        return output
+
+    def discover_nodes(self):
+        """Discover all available nodes.
+
+        Example of stdout from running "show node list":
+
+        'show node list\r\r\nSlot ID    Proc Manufacturer
+        Architecture         Memory Power Health\r\n----
+        ----- ---------------------- --------------------
+        ------ ----- ------\r\n 01  c1n1  Intel Corporation
+        x86 Architecture     32 GB  On    OK \r\n 02  c2n1
+        N/A                    No Asset Information \r\n\r\n'
+
+        The regex 'c\d+n\d' is finding the node_id's c1-45n1-8
+        """
+        node_list = self._run_cli_command("show node list")
+        return re.findall(r'c\d+n\d', node_list)
+
+    def get_node_macaddr(self, node_id):
+        """Get node MAC address(es).
+
+        Example of stdout from running "show node macaddr <node_id>":
+
+        'show node macaddr c1n1\r\r\nSlot ID    NIC 1 (Switch A)
+        NIC 2 (Switch B)  NIC 3 (Switch A)  NIC 4 (Switch B)\r\n
+        ---- ----- ----------------- ----------------- -----------------
+        -----------------\r\n  1  c1n1  a0:1d:48:b5:04:34 a0:1d:48:b5:04:35
+        a0:1d:48:b5:04:36 a0:1d:48:b5:04:37\r\n\r\n\r\n'
+
+        The regex '[\:]'.join(['[0-9A-F]{1,2}'] * 6) is finding
+        the MAC Addresses for the given node_id.
+        """
+        macs = self._run_cli_command("show node macaddr %s" % node_id)
+        return re.findall(r':'.join(['[0-9a-f]{2}'] * 6), macs)
+
+    def get_node_arch(self, node_id):
+        """Get node architecture.
+
+        Example of stdout from running "show node info <node_id>":
+
+        'show node info c1n1\r\r\n\r\nCartridge #1 \r\n  Type: Compute\r\n
+        Manufacturer: HP\r\n  Product Name: ProLiant m500 Server Cartridge\r\n'
+
+        Parsing this retrieves 'ProLiant m500 Server Cartridge'
+        """
+        node_detail = self._run_cli_command("show node info %s" % node_id)
+        cartridge = node_detail.split('Product Name: ')[1].splitlines()[0]
+        if cartridge in cartridge_mapping:
+            return cartridge_mapping[cartridge]
+        else:
+            return cartridge_mapping['Default']
+
+    def get_node_power_status(self, node_id):
+        """Get power state of node (on/off).
+
+        Example of stdout from running "show node power <node_id>":
+
+        'show node power c1n1\r\r\n\r\nCartridge #1\r\n  Node #1\r\n
+        Power State: On\r\n'
+
+        Parsing this retrieves 'On'
+        """
+        power_state = self._run_cli_command("show node power %s" % node_id)
+        return power_state.split('Power State: ')[1].splitlines()[0]
+
+    def power_node_on(self, node_id):
+        """Power node on."""
+        return self._run_cli_command("set node power on %s" % node_id)
+
+    def power_node_off(self, node_id):
+        """Power node off."""
+        return self._run_cli_command("set node power off force %s" % node_id)
+
+    def configure_node_boot_m2(self, node_id):
+        """Configure HDD boot for node."""
+        return self._run_cli_command("set node boot M.2 %s" % node_id)
+
+    def configure_node_bootonce_pxe(self, node_id):
+        """Configure PXE boot for node once."""
+        return self._run_cli_command("set node bootonce pxe %s" % node_id)
+
+
+def power_control_mscm(host, username, password, node_id, power_change):
+    """Handle calls from the power template for nodes with a power type
+    of 'mscm'.
+    """
+    mscm = MSCM_CLI_API(host, username, password)
+    power_status = mscm.get_node_power_status(node_id)
+
+    if power_change == 'off':
+        mscm.power_node_off(node_id)
+        return
+
+    if power_change != 'on':
+        raise AssertionError('Unexpected maas power mode.')
+
+    if power_status == 'On':
+        mscm.power_node_off(node_id)
+
+    mscm.configure_node_bootonce_pxe(node_id)
+    mscm.power_node_on(node_id)
+
+
+def probe_and_enlist_mscm(host, username, password):
+    """ Extracts all of nodes from mscm, sets all of them to boot via HDD by,
+    default, sets them to bootonce via PXE, and then enlists them into MAAS.
+    """
+    mscm = MSCM_CLI_API(host, username, password)
+    nodes = mscm.discover_nodes()
+    for node_id in nodes:
+        # Set default boot to HDD
+        mscm.configure_node_boot_m2(node_id)
+        params = {
+            'power_address': host,
+            'power_user': username,
+            'power_pass': password,
+            'node_id': node_id,
+        }
+        arch = mscm.get_node_arch(node_id)
+        macs = mscm.get_node_macaddr(node_id)
+        utils.create_node(macs, arch, 'mscm', params)
 
=== added directory 'src/provisioningserver/drivers/hardware/tests'
=== added file 'src/provisioningserver/drivers/hardware/tests/test_mscm.py'
--- src/provisioningserver/drivers/hardware/tests/test_mscm.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/drivers/hardware/tests/test_mscm.py	2014-07-24 05:13:03 +0000
@@ -0,0 +1,259 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for ``provisioningserver.drivers.hardware.mscm``."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+from random import randint
+import re
+from StringIO import StringIO
+
+from maastesting.factory import factory
+from maastesting.matchers import MockCalledOnceWith
+from maastesting.testcase import MAASTestCase
+from mock import Mock
+from provisioningserver.drivers.hardware.mscm import (
+    cartridge_mapping,
+    MSCM_CLI_API,
+    power_control_mscm,
+    probe_and_enlist_mscm,
+    )
+import provisioningserver.custom_hardware.utils as utils
+
+
+def make_mscm_api():
+    """Make a MSCM_CLI_API object with randomized parameters."""
+    host = factory.make_hostname('mscm')
+    username = factory.make_name('user')
+    password = factory.make_name('password')
+    return MSCM_CLI_API(host, username, password)
+
+
+def make_node_id():
+    """Make a node_id."""
+    return 'c%sn%s' % (randint(1, 45), randint(1, 8))
+
+
+def make_show_node_list(length=10):
+    """Make a fake return value for discover_nodes."""
+    return re.findall(r'c\d+n\d', ''.join(make_node_id()
+                                          for _ in xrange(length)))
+
+
+def make_show_node_macaddr(length=10):
+    """Make a fake return value for get_node_macaddr."""
+    return ''.join((factory.getRandomMACAddress() + ' ')
+                   for _ in xrange(length))
+
+
+class TestRunCliCommand(MAASTestCase):
+    """Tests for ``MSCM_CLI_API.run_cli_command``."""
+
+    def test_returns_output(self):
+        api = make_mscm_api()
+        ssh_mock = self.patch(api, '_ssh')
+        expected = factory.make_name('output')
+        stdout = StringIO(expected)
+        streams = factory.make_streams(stdout=stdout)
+        ssh_mock.exec_command = Mock(return_value=streams)
+        output = api._run_cli_command(factory.make_name('command'))
+        self.assertEqual(expected, output)
+
+    def test_connects_and_closes_ssh_client(self):
+        api = make_mscm_api()
+        ssh_mock = self.patch(api, '_ssh')
+        ssh_mock.exec_command = Mock(return_value=factory.make_streams())
+        api._run_cli_command(factory.make_name('command'))
+        self.assertThat(
+            ssh_mock.connect,
+            MockCalledOnceWith(
+                api.host, username=api.username, password=api.password))
+        self.assertThat(ssh_mock.close, MockCalledOnceWith())
+
+    def test_closes_when_exception_raised(self):
+        api = make_mscm_api()
+        ssh_mock = self.patch(api, '_ssh')
+
+        def fail():
+            raise Exception('fail')
+
+        ssh_mock.exec_command = Mock(side_effect=fail)
+        command = factory.make_name('command')
+        self.assertRaises(Exception, api._run_cli_command, command)
+        self.assertThat(ssh_mock.close, MockCalledOnceWith())
+
+
+class TestDiscoverNodes(MAASTestCase):
+    """Tests for ``MSCM_CLI_API.discover_nodes``."""
+
+    def test_discover_nodes(self):
+        api = make_mscm_api()
+        ssh_mock = self.patch(api, '_ssh')
+        expected = make_show_node_list()
+        stdout = StringIO(expected)
+        streams = factory.make_streams(stdout=stdout)
+        ssh_mock.exec_command = Mock(return_value=streams)
+        output = api.discover_nodes()
+        self.assertEqual(expected, output)
+
+
+class TestNodeMACAddress(MAASTestCase):
+    """Tests for ``MSCM_CLI_API.get_node_macaddr``."""
+
+    def test_get_node_macaddr(self):
+        api = make_mscm_api()
+        expected = make_show_node_macaddr()
+        cli_mock = self.patch(api, '_run_cli_command')
+        cli_mock.return_value = expected
+        node_id = make_node_id()
+        output = api.get_node_macaddr(node_id)
+        self.assertEqual(re.findall(r':'.join(['[0-9a-f]{2}'] * 6),
+                                    expected), output)
+
+
+class TestNodeArch(MAASTestCase):
+    """Tests for ``MSCM_CLI_API.get_node_arch``."""
+
+    def test_get_node_arch(self):
+        api = make_mscm_api()
+        expected = '\r\n    Product Name: ProLiant Moonshot Cartridge\r\n'
+        cli_mock = self.patch(api, '_run_cli_command')
+        cli_mock.return_value = expected
+        node_id = make_node_id()
+        output = api.get_node_arch(node_id)
+        key = expected.split('Product Name: ')[1].splitlines()[0]
+        self.assertEqual(cartridge_mapping[key], output)
+
+
+class TestGetNodePowerStatus(MAASTestCase):
+    """Tests for ``MSCM_CLI_API.get_node_power_status``."""
+
+    def test_get_node_power_status(self):
+        api = make_mscm_api()
+        expected = '\r\n  Node #1\r\n    Power State: On\r\n'
+        cli_mock = self.patch(api, '_run_cli_command')
+        cli_mock.return_value = expected
+        node_id = make_node_id()
+        output = api.get_node_power_status(node_id)
+        self.assertEqual(expected.split('Power State: ')[1].splitlines()[0],
+                         output)
+
+
+class TestPowerAndConfigureNode(MAASTestCase):
+    """Tests for ``MSCM_CLI_API.configure_node_bootonce_pxe,
+    MSCM_CLI_API.power_node_on, and MSCM_CLI_API.power_node_off``.
+    """
+
+    scenarios = [
+        ('power_node_on()',
+            dict(method='power_node_on')),
+        ('power_node_off()',
+            dict(method='power_node_off')),
+        ('configure_node_bootonce_pxe()',
+            dict(method='configure_node_bootonce_pxe')),
+    ]
+
+    def test_returns_expected_outout(self):
+        api = make_mscm_api()
+        ssh_mock = self.patch(api, '_ssh')
+        expected = factory.make_name('output')
+        stdout = StringIO(expected)
+        streams = factory.make_streams(stdout=stdout)
+        ssh_mock.exec_command = Mock(return_value=streams)
+        output = getattr(api, self.method)(make_node_id())
+        self.assertEqual(expected, output)
+
+
+class TestPowerControlMSCM(MAASTestCase):
+    """Tests for ``power_control_ucsm``."""
+
+    def test_power_control_mscm_on_on(self):
+        # power_change and power_status are both 'on'
+        host = factory.make_hostname('mscm')
+        username = factory.make_name('user')
+        password = factory.make_name('password')
+        node_id = make_node_id()
+        bootonce_mock = self.patch(MSCM_CLI_API, 'configure_node_bootonce_pxe')
+        power_status_mock = self.patch(MSCM_CLI_API, 'get_node_power_status')
+        power_status_mock.return_value = 'On'
+        power_node_on_mock = self.patch(MSCM_CLI_API, 'power_node_on')
+        power_node_off_mock = self.patch(MSCM_CLI_API, 'power_node_off')
+
+        power_control_mscm(host, username, password, node_id,
+                           power_change='on')
+        self.assertThat(bootonce_mock, MockCalledOnceWith(node_id))
+        self.assertThat(power_node_off_mock, MockCalledOnceWith(node_id))
+        self.assertThat(power_node_on_mock, MockCalledOnceWith(node_id))
+
+    def test_power_control_mscm_on_off(self):
+        # power_change is 'on' and power_status is 'off'
+        host = factory.make_hostname('mscm')
+        username = factory.make_name('user')
+        password = factory.make_name('password')
+        node_id = make_node_id()
+        bootonce_mock = self.patch(MSCM_CLI_API, 'configure_node_bootonce_pxe')
+        power_status_mock = self.patch(MSCM_CLI_API, 'get_node_power_status')
+        power_status_mock.return_value = 'Off'
+        power_node_on_mock = self.patch(MSCM_CLI_API, 'power_node_on')
+
+        power_control_mscm(host, username, password, node_id,
+                           power_change='on')
+        self.assertThat(bootonce_mock, MockCalledOnceWith(node_id))
+        self.assertThat(power_node_on_mock, MockCalledOnceWith(node_id))
+
+    def test_power_control_mscm_off_on(self):
+        # power_change is 'off' and power_status is 'on'
+        host = factory.make_hostname('mscm')
+        username = factory.make_name('user')
+        password = factory.make_name('password')
+        node_id = make_node_id()
+        power_status_mock = self.patch(MSCM_CLI_API, 'get_node_power_status')
+        power_status_mock.return_value = 'On'
+        power_node_off_mock = self.patch(MSCM_CLI_API, 'power_node_off')
+
+        power_control_mscm(host, username, password, node_id,
+                           power_change='off')
+        self.assertThat(power_node_off_mock, MockCalledOnceWith(node_id))
+
+
+class TestProbeAndEnlistMSCM(MAASTestCase):
+    """Tests for ``probe_and_enlist_mscm``."""
+
+    def test_probe_and_enlist(self):
+        host = factory.make_hostname('mscm')
+        username = factory.make_name('user')
+        password = factory.make_name('password')
+        node_id = make_node_id()
+        macs = make_show_node_macaddr(4)
+        arch = 'arm64/xgene-uboot'
+        discover_nodes_mock = self.patch(MSCM_CLI_API, 'discover_nodes')
+        discover_nodes_mock.return_value = [node_id]
+        boot_m2_mock = self.patch(MSCM_CLI_API, 'configure_node_boot_m2')
+        node_arch_mock = self.patch(MSCM_CLI_API, 'get_node_arch')
+        node_arch_mock.return_value = arch
+        node_macs_mock = self.patch(MSCM_CLI_API, 'get_node_macaddr')
+        node_macs_mock.return_value = macs
+        create_node_mock = self.patch(utils, 'create_node')
+        probe_and_enlist_mscm(host, username, password)
+        self.assertThat(discover_nodes_mock, MockCalledOnceWith())
+        self.assertThat(boot_m2_mock, MockCalledOnceWith(node_id))
+        self.assertThat(node_arch_mock, MockCalledOnceWith(node_id))
+        self.assertThat(node_macs_mock, MockCalledOnceWith(node_id))
+        params = {
+            'power_address': host,
+            'power_user': username,
+            'power_pass': password,
+            'node_id': node_id,
+        }
+        self.assertThat(create_node_mock,
+                        MockCalledOnceWith(macs, arch, 'mscm', params))
 
=== modified file 'src/provisioningserver/power/tests/test_poweraction.py'
--- src/provisioningserver/power/tests/test_poweraction.py	2014-05-21 17:30:26 +0000
+++ src/provisioningserver/power/tests/test_poweraction.py	2014-07-24 05:13:03 +0000
@@ -220,3 +220,14 @@
             power_user='bar', power_pass='baz',
             uuid=factory.getRandomUUID(), power_change='on')
         self.assertIn('power_control_ucsm', script)
+
+    def test_mscm_renders_template(self):
+        # I'd like to assert that escape_py_literal is being used here,
+        # but it's not obvious how to mock things in the template
+        # rendering namespace so I passed on that.
+        action = PowerAction('mscm')
+        script = action.render_template(
+            action.get_template(), power_address='foo',
+            power_user='bar', power_pass='baz',
+            node_id='c1n1', power_change='on')
+        self.assertIn('power_control_mscm', script)
 
=== modified file 'src/provisioningserver/power_schema.py'
--- src/provisioningserver/power_schema.py	2014-05-21 17:30:26 +0000
+++ src/provisioningserver/power_schema.py	2014-07-24 05:13:03 +0000
@@ -255,4 +255,17 @@
             make_json_field('power_pass', "API password"),
         ],
     },
+    {
+        'name': 'mscm',
+        'description': "Moonshot HP iLO Chassis Manager",
+        'fields': [
+            make_json_field('power_address', "IP for MSCM CLI API"),
+            make_json_field('power_user', "MSCM CLI API user"),
+            make_json_field('power_pass', "MSCM CLI API password"),
+            make_json_field(
+                'node_id',
+                "Node ID - Must adhere to cXnY format "
+                "(X=cartridge number, Y=node number)."),
+        ],
+    },
 ]
 
=== modified file 'src/provisioningserver/tasks.py'
--- src/provisioningserver/tasks.py	2014-06-02 07:48:17 +0000
+++ src/provisioningserver/tasks.py	2014-07-24 05:13:03 +0000
@@ -58,6 +58,7 @@
     set_up_options_conf,
     setup_rndc,
     )
+from provisioningserver.drivers.hardware.mscm import probe_and_enlist_mscm
 from provisioningserver.omshell import Omshell
 from provisioningserver.power.poweraction import (
     PowerAction,
@@ -493,5 +494,12 @@
 @task
 @log_exception_text
 def enlist_nodes_from_ucsm(url, username, password):
-    """ See `maasserver.api.NodeGroupsHandler.enlist_nodes_from_ucsm`. """
+    """ See `maasserver.api.NodeGroupHandler.enlist_nodes_from_ucsm`. """
     probe_and_enlist_ucsm(url, username, password)
+
+
+@task
+@log_exception_text
+def enlist_nodes_from_mscm(host, username, password):
+    """ See `maasserver.api.NodeGroupHandler.enlist_nodes_from_mscm`. """
+    probe_and_enlist_mscm(host, username, password)
 
=== modified file 'src/provisioningserver/tests/test_tasks.py'
--- src/provisioningserver/tests/test_tasks.py	2014-06-02 07:48:17 +0000
+++ src/provisioningserver/tests/test_tasks.py	2014-07-24 05:13:03 +0000
@@ -73,6 +73,7 @@
 from provisioningserver.tags import MissingCredentials
 from provisioningserver.tasks import (
     add_new_dhcp_host_map,
+    enlist_nodes_from_mscm,
     enlist_nodes_from_ucsm,
     import_boot_images,
     Omshell,
@@ -661,3 +662,14 @@
         mock = self.patch(tasks, 'probe_and_enlist_ucsm')
         enlist_nodes_from_ucsm(url, username, password)
         self.assertThat(mock, MockCalledOnceWith(url, username, password))
+
+
+class TestAddMSCM(PservTestCase):
+
+    def test_enlist_nodes_from_mscm(self):
+        host = 'host'
+        username = 'username'
+        password = 'password'
+        mock = self.patch(tasks, 'probe_and_enlist_mscm')
+        enlist_nodes_from_mscm(host, username, password)
+        self.assertThat(mock, MockCalledOnceWith(host, username, password))