Merge lp:~ubuntu-branches/ubuntu/trusty/maas/trusty-proposed-201409031457 into lp:ubuntu/trusty-proposed/maas

[Ubuntu Package Importer]

The package importer has detected a possible inconsistency between the package history in the archive and the history in bzr. As the archive is authoritative the importer has made lp:ubuntu/trusty-proposed/maas reflect what is in the archive and the old bzr branch has been pushed to lp:~ubuntu-branches/ubuntu/trusty/maas/trusty-proposed-201409031457. This merge proposal was created so that an Ubuntu developer can review the situations and perform a merge/upload if necessary. There are three typical cases where this can happen.
  1. Where someone pushes a change to bzr and someone else uploads the package without that change. This is the reason that this check is done by the importer. If this appears to be the case then a merge/upload should be done if the changes that were in bzr are still desirable.
  2. The importer incorrectly detected the above situation when someone made a change in bzr and then uploaded it.
  3. The importer incorrectly detected the above situation when someone just uploaded a package and didn't touch bzr.

If this case doesn't appear to be the first situation then set the status of the merge proposal to "Rejected" and help avoid the problem in future by filing a bug at https://bugs.launchpad.net/udd linking to this merge proposal.

(this is an automatically generated message)

Unmerged revisions

66. By Chuck Short on 2014-09-03

Change supported releases for install to Precise, Saucy, Trusty, Utopic
(Add Utopic; Remove Quantal/Raring) -- will still only be able to install
releases with streams available to maas (LP: #1337437)

65. By Chuck Short on 2014-08-29

* New upstream bug fix release:
  - Package fails to install when the default route is through an
    aliased/tagged interface (LP: #1350235)
  - ERROR Nonce already used (LP: #1190986)
  - Add MAAS arm64/xgene support (LP: #1338851)
  - Add utopic support (LP: #1337437)
  - API documentation for nodegroup op=details missing parameter
    (LP: #1331982)
  - Reduce number of celery tasks emitted when updating a cluster controller
    (LP: #1324944)
  - Fix VirshSSH template which was referencing invalid attributes
    (LP: #1324966)
  - Fix a start up problems where a database lock was being taken outside of
    a transaction (LP: #1325640, LP: #1325759)
  - Reformat badly formatted Architecture error message (LP: #1301465)
  - Final changes to support ppc64el (now known as PowerNV) (LP: #1315154)
  - UI tweak to make navigation elements visible for documentation
 * debian/control:
  - maas-provisioningserver not maas-cluster-controller depends on
    python-pexpect (LP: #1352273)
 * debian/maas-cluster-controller.postinst
  - Allow maas-pserv to bind to all IPv6 addresses too. (LP: #1342302)
 * debian/control:
  - python-maas-provisioningserver depends on python-paramiko (LP: #1334401)
 * debian/extras/99-maas-sudoers:
  - Add rule 'maas-dhcp-server stop' job.

=== removed directory '.pc/01-fix-database-settings.patch'
=== removed directory '.pc/01-fix-database-settings.patch/contrib'
=== removed file '.pc/01-fix-database-settings.patch/contrib/maas_local_settings.py'
--- .pc/01-fix-database-settings.patch/contrib/maas_local_settings.py	2014-01-31 09:38:51 +0000
+++ .pc/01-fix-database-settings.patch/contrib/maas_local_settings.py	1970-01-01 00:00:00 +0000
@@ -1,89 +0,0 @@
-# Debug/Production mode.
-DEBUG = False
-
-# Default URL specifying protocol, host, and (if necessary) port where
-# systems in this MAAS can find the MAAS server.  Configuration can, and
-# probably should, override this.
-DEFAULT_MAAS_URL = "http://maas.internal.example.com/"
-
-# Absolute path to the directory static files should be collected to.
-STATIC_ROOT = '/var/lib/maas/static/'
-
-# Prefix to use for MAAS's urls.
-# If FORCE_SCRIPT_NAME is None (the default), all the urls will start with
-# '/'.
-FORCE_SCRIPT_NAME = '/MAAS'
-
-# Where to store the user uploaded files.
-MEDIA_ROOT = '/var/lib/maas/media/'
-
-# Use the (libjs-yui) package's files to serve YUI3.
-YUI_LOCATION = '/usr/share/javascript/yui3/'
-
-# Use the package's files to serve RaphaelJS.
-RAPHAELJS_LOCATION = '/usr/share/javascript/raphael/'
-
-# RabbitMQ settings.
-RABBITMQ_HOST = 'localhost'
-RABBITMQ_USERID = 'maas_longpoll'
-RABBITMQ_PASSWORD = ''
-RABBITMQ_VIRTUAL_HOST = '/maas_longpoll'
-
-# See http://docs.djangoproject.com/en/dev/topics/logging for
-# more details on how to customize the logging configuration.
-LOGGING_LEVEL = 'INFO'
-LOGGING = {
-    'version': 1,
-    'disable_existing_loggers': False,
-    'formatters': {
-        'simple': {
-            'format': '%(levelname)s %(asctime)s %(name)s %(message)s'
-        },
-    },
-    'handlers': {
-        'log': {
-            'class': 'logging.handlers.RotatingFileHandler',
-            'filename': '/var/log/maas/maas.log',
-            'formatter': 'simple',
-        },
-    },
-    'loggers': {
-        'maasserver': {
-            'level': LOGGING_LEVEL,
-            'handlers': ['log'],
-            'propagate': True,
-        },
-        'metadataserver': {
-            'level': LOGGING_LEVEL,
-            'handlers': ['log'],
-            'propagate': True,
-        },
-        'django.request': {
-            'level': LOGGING_LEVEL,
-            'handlers': ['log'],
-            'propagate': True,
-        },
-        'django.db.backends': {
-            'level': LOGGING_LEVEL,
-            'handlers': ['log'],
-            'propagate': True,
-        },
-        'twisted': {
-            'level': LOGGING_LEVEL,
-            'handlers': ['log'],
-            'propagate': True,
-        },
-    },
-}
-
-# Database access configuration.
-DATABASES = {
-    'default': {
-        # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' etc.
-        'ENGINE': 'django.db.backends.postgresql_psycopg2',
-        'NAME': '',
-        'USER': '',
-        'PASSWORD': '',
-        'HOST': 'localhost',
-    }
-}
 
=== removed directory '.pc/02-pserv-config.patch'
=== removed directory '.pc/02-pserv-config.patch/etc'
=== removed directory '.pc/02-pserv-config.patch/etc/maas'
=== removed file '.pc/02-pserv-config.patch/etc/maas/pserv.yaml'
--- .pc/02-pserv-config.patch/etc/maas/pserv.yaml	2014-03-28 10:43:53 +0000
+++ .pc/02-pserv-config.patch/etc/maas/pserv.yaml	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-##
-## Provisioning Server (pserv) configuration.
-##
-
-## Where to log. This log can be rotated by sending SIGUSR1 to the
-## running server.
-#
-# logfile: "pserv.log"
-logfile: "/dev/null"
-
-## OOPS configuration (optional).
-#
-oops:
-  ## Directory in which to place OOPS reports.  Must not contain any files
-  # or directories other than what the oops machinery creates there.
-  #
-  # directory:
-  directory: "logs/oops"
-  # reporter:
-  reporter: "maas-pserv"
-
-## Message broker configuration (optional, not currently used).
-#
-broker:
-  # host: "localhost"
-  # port: 5673
-  # username: <current user>
-  # password: "test"
-  # vhost: "/"
-
-## TFTP configuration.
-#
-tftp:
-  # The "root" setting has been replaced by "resource_root".  The old setting
-  # is used one final time when upgrading a pre-14.04 cluster controller to a
-  # 14.04 version.  After that upgrade, it can be removed.
-  #
-  # resource_root: /var/lib/maas/boot-resources/current/
-
-  # port: 69
-  port: 5244
-  ## The URL to be contacted to generate PXE configurations.
-  # generator: http://localhost/MAAS/api/1.0/pxeconfig/
-  generator: http://localhost:5243/api/1.0/pxeconfig/
-
 
=== removed directory '.pc/03-txlongpoll-config.patch'
=== removed directory '.pc/03-txlongpoll-config.patch/etc'
=== removed file '.pc/03-txlongpoll-config.patch/etc/txlongpoll.yaml'
--- .pc/03-txlongpoll-config.patch/etc/txlongpoll.yaml	2012-07-03 17:42:37 +0000
+++ .pc/03-txlongpoll-config.patch/etc/txlongpoll.yaml	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-##
-## txlongpoll configuration.
-##
-
-## The front-end service.
-#
-frontend:
-  ## The port on which to serve.
-  port: 5242
-  ## If specified, queue names requested must have the given prefix.
-  # prefix:
-
-## OOPS configuration.
-#
-oops:
-  ## Directory in which to place OOPS reports.  Must not contain any files
-  # or directories other than what the oops machinery creates there.
-  #
-  # directory: ""
-  directory: "logs/oops"
-  ## The reporter used when generating OOPS reports.
-  # reporter: "LONGPOLL"
-  reporter: "maas-txlongpoll"
-
-## Message broker configuration.
-#
-broker:
-  # host: "localhost"
-  # port: 5672
-  # username: "guest"
-  # password: "guest"
-  # vhost: "/"
-
-## Where to log. This log can be rotated by sending SIGUSR1 to the
-## running server.
-#
-# logfile: "txlongpoll.log"
-logfile: "/dev/null"
 
=== removed file '.pc/applied-patches'
--- .pc/applied-patches	2014-03-28 10:43:53 +0000
+++ .pc/applied-patches	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-01-fix-database-settings.patch
-02-pserv-config.patch
-03-txlongpoll-config.patch
 
=== modified file 'contrib/maas_local_settings.py'
--- contrib/maas_local_settings.py	2014-01-31 09:38:51 +0000
+++ contrib/maas_local_settings.py	2014-09-03 15:03:36 +0000
@@ -7,7 +7,7 @@
 DEFAULT_MAAS_URL = "http://maas.internal.example.com/"
 
 # Absolute path to the directory static files should be collected to.
-STATIC_ROOT = '/usr/share/maas/web/static/'
+STATIC_ROOT = '/var/lib/maas/static/'
 
 # Prefix to use for MAAS's urls.
 # If FORCE_SCRIPT_NAME is None (the default), all the urls will start with
@@ -81,9 +81,9 @@
     'default': {
         # 'postgresql_psycopg2', 'postgresql', 'mysql', 'sqlite3' etc.
         'ENGINE': 'django.db.backends.postgresql_psycopg2',
-        'NAME': 'maasdb',
-        'USER': 'maas',
-        'PASSWORD': 'maas',
+        'NAME': '',
+        'USER': '',
+        'PASSWORD': '',
         'HOST': 'localhost',
     }
 }
 
=== modified file 'etc/maas/pserv.yaml'
--- etc/maas/pserv.yaml	2014-03-28 10:43:53 +0000
+++ etc/maas/pserv.yaml	2014-09-03 15:03:36 +0000
@@ -6,7 +6,7 @@
 ## running server.
 #
 # logfile: "pserv.log"
-logfile: "/var/log/maas/pserv.log"
+logfile: "/dev/null"
 
 ## OOPS configuration (optional).
 #
@@ -15,7 +15,7 @@
   # or directories other than what the oops machinery creates there.
   #
   # directory:
-  directory: "/var/log/maas/oops"
+  directory: "logs/oops"
   # reporter:
   reporter: "maas-pserv"
 
@@ -38,6 +38,8 @@
   # resource_root: /var/lib/maas/boot-resources/current/
 
   # port: 69
+  port: 5244
   ## The URL to be contacted to generate PXE configurations.
   # generator: http://localhost/MAAS/api/1.0/pxeconfig/
+  generator: http://localhost:5243/api/1.0/pxeconfig/
 
 
=== 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-09-03 15:03:36 +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
 
=== renamed file 'etc/maas/templates/power/mscm.template' => 'etc/maas/templates/power/mscm.template.moved'
=== added symlink 'etc/maas/templates/pxe/config.commissioning.arm64.template'
=== target is u'config.commissioning.armhf.template'
=== renamed symlink 'etc/maas/templates/pxe/config.commissioning.arm64.template' => 'etc/maas/templates/pxe/config.commissioning.arm64.template.moved'
=== added file 'etc/maas/templates/pxe/config.commissioning.ppc64el.template'
--- etc/maas/templates/pxe/config.commissioning.ppc64el.template	1970-01-01 00:00:00 +0000
+++ etc/maas/templates/pxe/config.commissioning.ppc64el.template	2014-09-03 15:03:36 +0000
@@ -0,0 +1,6 @@
+DEFAULT execute
+
+LABEL execute
+  KERNEL {{kernel_params | kernel_path }}
+  INITRD {{kernel_params | initrd_path }}
+  APPEND {{kernel_params | kernel_command}}
 
=== renamed file 'etc/maas/templates/pxe/config.commissioning.ppc64el.template' => 'etc/maas/templates/pxe/config.commissioning.ppc64el.template.moved'
=== added symlink 'etc/maas/templates/pxe/config.install.arm64.template'
=== target is u'config.install.armhf.template'
=== renamed symlink 'etc/maas/templates/pxe/config.install.arm64.template' => 'etc/maas/templates/pxe/config.install.arm64.template.moved'
=== added file 'etc/maas/templates/pxe/config.install.ppc64el.template'
--- etc/maas/templates/pxe/config.install.ppc64el.template	1970-01-01 00:00:00 +0000
+++ etc/maas/templates/pxe/config.install.ppc64el.template	2014-09-03 15:03:36 +0000
@@ -0,0 +1,6 @@
+DEFAULT execute
+
+LABEL execute
+  KERNEL {{kernel_params | kernel_path }}
+  INITRD {{kernel_params | initrd_path }}
+  APPEND {{kernel_params | kernel_command}}
 
=== renamed file 'etc/maas/templates/pxe/config.install.ppc64el.template' => 'etc/maas/templates/pxe/config.install.ppc64el.template.moved'
=== added symlink 'etc/maas/templates/pxe/config.xinstall.arm64.template'
=== target is u'config.xinstall.armhf.template'
=== renamed symlink 'etc/maas/templates/pxe/config.xinstall.arm64.template' => 'etc/maas/templates/pxe/config.xinstall.arm64.template.moved'
=== added symlink 'etc/maas/templates/pxe/config.xinstall.ppc64el.template'
=== target is u'config.install.ppc64el.template'
=== renamed symlink 'etc/maas/templates/pxe/config.xinstall.ppc64el.template' => 'etc/maas/templates/pxe/config.xinstall.ppc64el.template.moved'
=== modified file 'etc/txlongpoll.yaml'
--- etc/txlongpoll.yaml	2012-07-03 17:42:37 +0000
+++ etc/txlongpoll.yaml	2014-09-03 15:03:36 +0000
@@ -17,7 +17,7 @@
   # or directories other than what the oops machinery creates there.
   #
   # directory: ""
-  directory: "/var/log/maas/oops"
+  directory: "logs/oops"
   ## The reporter used when generating OOPS reports.
   # reporter: "LONGPOLL"
   reporter: "maas-txlongpoll"
@@ -25,14 +25,14 @@
 ## Message broker configuration.
 #
 broker:
-  host: "localhost"
-  port: 5672
-  username: "maas_longpoll"
-  password: "maaslongpoll"
-  vhost: "/maas_longpoll"
+  # host: "localhost"
+  # port: 5672
+  # username: "guest"
+  # password: "guest"
+  # vhost: "/"
 
 ## Where to log. This log can be rotated by sending SIGUSR1 to the
 ## running server.
 #
 # logfile: "txlongpoll.log"
-logfile: "/var/log/maas/txlongpoll.log"
+logfile: "/dev/null"
 
=== added file 'src/provisioningserver/boot/powernv.py'
--- src/provisioningserver/boot/powernv.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/boot/powernv.py	2014-09-03 15:03:36 +0000
@@ -0,0 +1,158 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""PowerNV Boot Method"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    'PowerNVBootMethod',
+    ]
+
+import re
+
+from provisioningserver.boot import (
+    BootMethod,
+    BytesReader,
+    get_parameters,
+    )
+from provisioningserver.boot.pxe import (
+    ARP_HTYPE,
+    re_mac_address,
+    )
+from provisioningserver.kernel_opts import compose_kernel_command_line
+from provisioningserver.utils import find_mac_via_arp
+from tftp.backend import FilesystemReader
+from twisted.python.context import get
+
+# The pxelinux.cfg path is prefixed with the architecture for the
+# PowerNV nodes. This prefix is set by the path-prefix dhcpd option.
+# We assume that the ARP HTYPE (hardware type) that PXELINUX sends is
+# always Ethernet.
+re_config_file = r'''
+    # Optional leading slash(es).
+    ^/*
+    ppc64el           # PowerNV pxe prefix, set by dhcpd
+    /
+    pxelinux[.]cfg    # PXELINUX expects this.
+    /
+    (?: # either a MAC
+        {htype:02x}    # ARP HTYPE.
+        -
+        (?P<mac>{re_mac_address.pattern})    # Capture MAC.
+    | # or "default"
+        default
+    )
+    $
+'''
+
+re_config_file = re_config_file.format(
+    htype=ARP_HTYPE.ETHERNET, re_mac_address=re_mac_address)
+re_config_file = re.compile(re_config_file, re.VERBOSE)
+
+
+def format_bootif(mac):
+    """Formats a mac address into the BOOTIF format, expected by
+    the linux kernel."""
+    mac = mac.replace(':', '-')
+    mac = mac.upper()
+    return '%02x-%s' % (ARP_HTYPE.ETHERNET, mac)
+
+
+class PowerNVBootMethod(BootMethod):
+
+    name = "powernv"
+    template_subdir = "pxe"
+    bootloader_path = "pxelinux.0"
+    arch_octet = "00:0E"
+    path_prefix = "ppc64el/"
+
+    def get_remote_mac(self):
+        """Gets the requestors MAC address from arp cache.
+
+        This is used, when the pxelinux.cfg is requested without the mac
+        address appended. This is needed to inject the BOOTIF into the
+        pxelinux.cfg that is returned to the node.
+        """
+        remote_host, remote_port = get("remote", (None, None))
+        return find_mac_via_arp(remote_host)
+
+    def get_params(self, backend, path):
+        """Gets the matching parameters from the requested path."""
+        match = re_config_file.match(path)
+        if match is not None:
+            return get_parameters(match)
+        if path.lstrip('/').startswith(self.path_prefix):
+            return {'path': path}
+        return None
+
+    def match_path(self, backend, path):
+        """Checks path for the configuration file that needs to be
+        generated.
+
+        :param backend: requesting backend
+        :param path: requested path
+        :returns: dict of match params from path, None if no match
+        """
+        params = self.get_params(backend, path)
+        if params is None:
+            return None
+        params['arch'] = "ppc64el"
+        if 'mac' not in params:
+            mac = self.get_remote_mac()
+            if mac is not None:
+                params['mac'] = mac
+        return params
+
+    def get_reader(self, backend, kernel_params, **extra):
+        """Render a configuration file as a unicode string.
+
+        :param backend: requesting backend
+        :param kernel_params: An instance of `KernelParameters`.
+        :param extra: Allow for other arguments. This is a safety valve;
+            parameters generated in another component (for example, see
+            `TFTPBackend.get_config_reader`) won't cause this to break.
+        """
+        # Due to the path prefix, all requested files from the client will
+        # contain that prefix. Removing the prefix from the path will return
+        # the correct path in the tftp root.
+        if 'path' in extra:
+            path = extra['path']
+            path = path.replace(self.path_prefix, '', 1)
+            target_path = backend.base.descendant(path.split('/'))
+            return FilesystemReader(target_path)
+
+        # Return empty config for PowerNV local. PowerNV fails to
+        # support the LOCALBOOT flag. Empty config will allow it
+        # to select the first device.
+        if kernel_params.purpose == 'local':
+            return BytesReader("".encode("utf-8"))
+
+        template = self.get_template(
+            kernel_params.purpose, kernel_params.arch,
+            kernel_params.subarch)
+        namespace = self.compose_template_namespace(kernel_params)
+
+        # Modify the kernel_command to inject the BOOTIF. PowerNV fails to
+        # support the IPAPPEND pxelinux flag.
+        def kernel_command(params):
+            cmd_line = compose_kernel_command_line(params)
+            if 'mac' in extra:
+                mac = extra['mac']
+                mac = format_bootif(mac)
+                return '%s BOOTIF=%s' % (cmd_line, mac)
+            return cmd_line
+
+        namespace['kernel_command'] = kernel_command
+        return BytesReader(template.substitute(namespace).encode("utf-8"))
+
+    def install_bootloader(self, destination):
+        """Does nothing. No extra boot files are required. All of the boot
+        files from PXEBootMethod will suffice."""
 
=== renamed file 'src/provisioningserver/boot/powernv.py' => 'src/provisioningserver/boot/powernv.py.moved'
=== added file 'src/provisioningserver/boot/tests/test_powernv.py'
--- src/provisioningserver/boot/tests/test_powernv.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/boot/tests/test_powernv.py	2014-09-03 15:03:36 +0000
@@ -0,0 +1,337 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for `provisioningserver.boot.powernv`."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+import os
+import re
+
+from maastesting.factory import factory
+from maastesting.testcase import MAASTestCase
+from provisioningserver.boot import BytesReader
+from provisioningserver.boot.powernv import (
+    ARP_HTYPE,
+    format_bootif,
+    PowerNVBootMethod,
+    re_config_file,
+    )
+from provisioningserver.boot.tests.test_pxe import parse_pxe_config
+from provisioningserver.boot.tftppath import compose_image_path
+from provisioningserver.testing.config import set_tftp_root
+from provisioningserver.tests.test_kernel_opts import make_kernel_parameters
+from provisioningserver.tftp import TFTPBackend
+from testtools.matchers import (
+    IsInstance,
+    MatchesAll,
+    MatchesRegex,
+    Not,
+    StartsWith,
+    )
+
+
+def compose_config_path(mac):
+    """Compose the TFTP path for a PowerNV PXE configuration file.
+
+    The path returned is relative to the TFTP root, as it would be
+    identified by clients on the network.
+
+    :param mac: A MAC address, in IEEE 802 hyphen-separated form,
+        corresponding to the machine for which this configuration is
+        relevant. This relates to PXELINUX's lookup protocol.
+    :return: Path for the corresponding PXE config file as exposed over
+        TFTP.
+    """
+    # Not using os.path.join: this is a TFTP path, not a native path. Yes, in
+    # practice for us they're the same. We always assume that the ARP HTYPE
+    # (hardware type) that PXELINUX sends is Ethernet.
+    return "ppc64el/pxelinux.cfg/{htype:02x}-{mac}".format(
+        htype=ARP_HTYPE.ETHERNET, mac=mac)
+
+
+def get_example_path_and_components():
+    """Return a plausible path and its components.
+
+    The path is intended to match `re_config_file`, and the components are
+    the expected groups from a match.
+    """
+    components = {"mac": factory.getRandomMACAddress("-")}
+    config_path = compose_config_path(components["mac"])
+    return config_path, components
+
+
+class TestPowerNVBootMethod(MAASTestCase):
+
+    def make_tftp_root(self):
+        """Set, and return, a temporary TFTP root directory."""
+        tftproot = self.make_dir()
+        self.useFixture(set_tftp_root(tftproot))
+        return tftproot
+
+    def test_compose_config_path_follows_maas_pxe_directory_layout(self):
+        name = factory.make_name('config')
+        self.assertEqual(
+            'ppc64el/pxelinux.cfg/%02x-%s' % (ARP_HTYPE.ETHERNET, name),
+            compose_config_path(name))
+
+    def test_compose_config_path_does_not_include_tftp_root(self):
+        tftproot = self.make_tftp_root()
+        name = factory.make_name('config')
+        self.assertThat(
+            compose_config_path(name),
+            Not(StartsWith(tftproot)))
+
+    def test_bootloader_path(self):
+        method = PowerNVBootMethod()
+        self.assertEqual('pxelinux.0', method.bootloader_path)
+
+    def test_bootloader_path_does_not_include_tftp_root(self):
+        tftproot = self.make_tftp_root()
+        method = PowerNVBootMethod()
+        self.assertThat(
+            method.bootloader_path,
+            Not(StartsWith(tftproot)))
+
+    def test_name(self):
+        method = PowerNVBootMethod()
+        self.assertEqual('powernv', method.name)
+
+    def test_template_subdir(self):
+        method = PowerNVBootMethod()
+        self.assertEqual('pxe', method.template_subdir)
+
+    def test_arch_octet(self):
+        method = PowerNVBootMethod()
+        self.assertEqual('00:0E', method.arch_octet)
+
+    def test_path_prefix(self):
+        method = PowerNVBootMethod()
+        self.assertEqual('ppc64el/', method.path_prefix)
+
+
+class TestPowerNVBootMethodMatchPath(MAASTestCase):
+    """Tests for
+    `provisioningserver.boot.powernv.PowerNVBootMethod.match_path`.
+    """
+
+    def test_match_path_pxe_config_with_mac(self):
+        method = PowerNVBootMethod()
+        config_path, expected = get_example_path_and_components()
+        params = method.match_path(None, config_path)
+        expected['arch'] = 'ppc64el'
+        self.assertEqual(expected, params)
+
+    def test_match_path_pxe_config_without_mac(self):
+        method = PowerNVBootMethod()
+        fake_mac = factory.getRandomMACAddress()
+        self.patch(method, 'get_remote_mac').return_value = fake_mac
+        config_path = 'ppc64el/pxelinux.cfg/default'
+        params = method.match_path(None, config_path)
+        expected = {
+            'arch': 'ppc64el',
+            'mac': fake_mac,
+            }
+        self.assertEqual(expected, params)
+
+    def test_match_path_pxe_prefix_request(self):
+        method = PowerNVBootMethod()
+        fake_mac = factory.getRandomMACAddress()
+        self.patch(method, 'get_remote_mac').return_value = fake_mac
+        file_path = 'ppc64el/file'
+        params = method.match_path(None, file_path)
+        expected = {
+            'arch': 'ppc64el',
+            'mac': fake_mac,
+            'path': file_path,
+            }
+        self.assertEqual(expected, params)
+
+
+class TestPowerNVBootMethodRenderConfig(MAASTestCase):
+    """Tests for
+    `provisioningserver.boot.powernv.PowerNVBootMethod.get_reader`
+    """
+
+    def test_get_reader_install(self):
+        # Given the right configuration options, the PXE configuration is
+        # correctly rendered.
+        method = PowerNVBootMethod()
+        params = make_kernel_parameters(self, purpose="install")
+        output = method.get_reader(backend=None, kernel_params=params)
+        # The output is a BytesReader.
+        self.assertThat(output, IsInstance(BytesReader))
+        output = output.read(10000)
+        # The template has rendered without error. PXELINUX configurations
+        # typically start with a DEFAULT line.
+        self.assertThat(output, StartsWith("DEFAULT "))
+        # The PXE parameters are all set according to the options.
+        image_dir = compose_image_path(
+            arch=params.arch, subarch=params.subarch,
+            release=params.release, label=params.label)
+        self.assertThat(
+            output, MatchesAll(
+                MatchesRegex(
+                    r'.*^\s+KERNEL %s/di-kernel$' % re.escape(image_dir),
+                    re.MULTILINE | re.DOTALL),
+                MatchesRegex(
+                    r'.*^\s+INITRD %s/di-initrd$' % re.escape(image_dir),
+                    re.MULTILINE | re.DOTALL),
+                MatchesRegex(
+                    r'.*^\s+APPEND .+?$',
+                    re.MULTILINE | re.DOTALL)))
+
+    def test_get_reader_with_extra_arguments_does_not_affect_output(self):
+        # get_reader() allows any keyword arguments as a safety valve.
+        method = PowerNVBootMethod()
+        options = {
+            "backend": None,
+            "kernel_params": make_kernel_parameters(self, purpose="install"),
+        }
+        # Capture the output before sprinking in some random options.
+        output_before = method.get_reader(**options).read(10000)
+        # Sprinkle some magic in.
+        options.update(
+            (factory.make_name("name"), factory.make_name("value"))
+            for _ in range(10))
+        # Capture the output after sprinking in some random options.
+        output_after = method.get_reader(**options).read(10000)
+        # The generated template is the same.
+        self.assertEqual(output_before, output_after)
+
+    def test_get_reader_with_local_purpose(self):
+        # If purpose is "local", output should be empty string.
+        method = PowerNVBootMethod()
+        options = {
+            "backend": None,
+            "kernel_params": make_kernel_parameters(purpose="local"),
+            }
+        output = method.get_reader(**options).read(10000)
+        self.assertIn("", output)
+
+    def test_get_reader_appends_bootif(self):
+        method = PowerNVBootMethod()
+        fake_mac = factory.getRandomMACAddress()
+        params = make_kernel_parameters(self, purpose="install")
+        output = method.get_reader(
+            backend=None, kernel_params=params, arch='ppc64el', mac=fake_mac)
+        output = output.read(10000)
+        config = parse_pxe_config(output)
+        expected = 'BOOTIF=%s' % format_bootif(fake_mac)
+        self.assertIn(expected, config['execute']['APPEND'])
+
+
+class TestPowerNVBootMethodPathPrefix(MAASTestCase):
+    """Tests for
+    `provisioningserver.boot.powernv.PowerNVBootMethod.get_reader`.
+    """
+
+    def test_get_reader_path_prefix(self):
+        data = factory.getRandomString().encode("ascii")
+        temp_file = self.make_file(name="example", contents=data)
+        temp_dir = os.path.dirname(temp_file)
+        backend = TFTPBackend(temp_dir, "http://nowhere.example.com/")
+        method = PowerNVBootMethod()
+        options = {
+            'backend': backend,
+            'kernel_params': make_kernel_parameters(),
+            'path': 'ppc64el/example',
+        }
+        reader = method.get_reader(**options)
+        self.addCleanup(reader.finish)
+        self.assertEqual(len(data), reader.size)
+        self.assertEqual(data, reader.read(len(data)))
+        self.assertEqual(b"", reader.read(1))
+
+    def test_get_reader_path_prefix_only_removes_first_occurrence(self):
+        data = factory.getRandomString().encode("ascii")
+        temp_dir = self.make_dir()
+        temp_subdir = os.path.join(temp_dir, 'ppc64el')
+        os.mkdir(temp_subdir)
+        factory.make_file(temp_subdir, "example", data)
+        backend = TFTPBackend(temp_dir, "http://nowhere.example.com/")
+        method = PowerNVBootMethod()
+        options = {
+            'backend': backend,
+            'kernel_params': make_kernel_parameters(),
+            'path': 'ppc64el/ppc64el/example',
+        }
+        reader = method.get_reader(**options)
+        self.addCleanup(reader.finish)
+        self.assertEqual(len(data), reader.size)
+        self.assertEqual(data, reader.read(len(data)))
+        self.assertEqual(b"", reader.read(1))
+
+
+class TestPowerNVBootMethodRegex(MAASTestCase):
+    """Tests for
+    `provisioningserver.boot.powernv.PowerNVBootMethod.re_config_file`.
+    """
+
+    def test_re_config_file_is_compatible_with_config_path_generator(self):
+        # The regular expression for extracting components of the file path is
+        # compatible with the PXE config path generator.
+        for iteration in range(10):
+            config_path, args = get_example_path_and_components()
+            match = re_config_file.match(config_path)
+            self.assertIsNotNone(match, config_path)
+            self.assertEqual(args, match.groupdict())
+
+    def test_re_config_file_with_leading_slash(self):
+        # The regular expression for extracting components of the file path
+        # doesn't care if there's a leading forward slash; the TFTP server is
+        # easy on this point, so it makes sense to be also.
+        config_path, args = get_example_path_and_components()
+        # Ensure there's a leading slash.
+        config_path = "/" + config_path.lstrip("/")
+        match = re_config_file.match(config_path)
+        self.assertIsNotNone(match, config_path)
+        self.assertEqual(args, match.groupdict())
+
+    def test_re_config_file_without_leading_slash(self):
+        # The regular expression for extracting components of the file path
+        # doesn't care if there's no leading forward slash; the TFTP server is
+        # easy on this point, so it makes sense to be also.
+        config_path, args = get_example_path_and_components()
+        # Ensure there's no leading slash.
+        config_path = config_path.lstrip("/")
+        match = re_config_file.match(config_path)
+        self.assertIsNotNone(match, config_path)
+        self.assertEqual(args, match.groupdict())
+
+    def test_re_config_file_matches_classic_pxelinux_cfg(self):
+        # The default config path is simply "pxelinux.cfg" (without
+        # leading slash).  The regex matches this.
+        mac = 'aa-bb-cc-dd-ee-ff'
+        match = re_config_file.match('ppc64el/pxelinux.cfg/01-%s' % mac)
+        self.assertIsNotNone(match)
+        self.assertEqual({'mac': mac}, match.groupdict())
+
+    def test_re_config_file_matches_pxelinux_cfg_with_leading_slash(self):
+        mac = 'aa-bb-cc-dd-ee-ff'
+        match = re_config_file.match('/ppc64el/pxelinux.cfg/01-%s' % mac)
+        self.assertIsNotNone(match)
+        self.assertEqual({'mac': mac}, match.groupdict())
+
+    def test_re_config_file_does_not_match_non_config_file(self):
+        self.assertIsNone(re_config_file.match('ppc64el/pxelinux.cfg/kernel'))
+
+    def test_re_config_file_does_not_match_file_in_root(self):
+        self.assertIsNone(re_config_file.match('01-aa-bb-cc-dd-ee-ff'))
+
+    def test_re_config_file_does_not_match_file_not_in_pxelinux_cfg(self):
+        self.assertIsNone(re_config_file.match('foo/01-aa-bb-cc-dd-ee-ff'))
+
+    def test_re_config_file_with_default(self):
+        match = re_config_file.match('ppc64el/pxelinux.cfg/default')
+        self.assertIsNotNone(match)
+        self.assertEqual({'mac': None}, match.groupdict())
 
=== renamed file 'src/provisioningserver/boot/tests/test_powernv.py' => 'src/provisioningserver/boot/tests/test_powernv.py.moved'
=== added directory 'src/provisioningserver/drivers'
=== renamed directory 'src/provisioningserver/drivers' => 'src/provisioningserver/drivers.moved'
=== 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-09-03 15:03:36 +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-09-03 15:03:36 +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))