Merge lp:~blake-rouse/maas/virsh-probe-and-enlist-1.5 into lp:maas/1.5

[Blake Rouse]

Use probe-and-enlist-hardware to enlist all virtual machine inside a libvirt machine, allow password qemu+ssh connections.

Backport: https://code.launchpad.net/~blake-rouse/maas/virsh-probe-and-enlist/+merge/216632

[Blake Rouse (blake-rouse)]

review: Approve

=== modified file 'etc/maas/templates/power/virsh.template'
--- etc/maas/templates/power/virsh.template	2013-11-08 02:28:38 +0000
+++ etc/maas/templates/power/virsh.template	2014-05-21 17:37:04 +0000
@@ -3,50 +3,16 @@
 # Control virtual system's "power" through virsh.
 #
 
-# Parameters.
-power_change={{power_change}}
-power_address={{power_address}}
-power_id={{power_id}}
-virsh={{virsh}}
-
-
-# Choose command for virsh to make the requested power change happen.
-formulate_power_command() {
-  if [ ${power_change} = 'on' ]
-  then
-      echo 'start'
-  else
-      echo 'destroy'
-  fi
-}
-
-
-# Express system's current state as expressed by virsh as "on" or "off".
-formulate_power_state() {
-    case $1 in
-    'running') echo 'on' ;;
-    'shut off') echo 'off' ;;
-    *)
-        echo "Got unknown power state from virsh: '$1'" >&2
-        exit 1
-    esac
-}
-
-
-# Issue command to virsh, for the given system.
 issue_virsh_command() {
-    ${virsh} --connect ${power_address} $1 ${power_id}
-}
-
-
-# Get the given system's power state: 'on' or 'off'.
-get_power_state() {
-    virsh_state=$(issue_virsh_command domstate)
-    formulate_power_state ${virsh_state}
-}
-
-
-if [ "$(get_power_state)" != "${power_change}" ]
-then
-    issue_virsh_command $(formulate_power_command)
-fi
+python - << END
+from provisioningserver.custom_hardware.virsh import power_control_virsh
+power_control_virsh(
+    {{repr(power_address).decode("ascii") | safe}},
+    {{repr(power_id).decode("ascii") | safe}},
+    {{repr(power_change).decode("ascii") | safe}},
+    {{repr(power_pass).decode("ascii") | safe}},
+)
+END
+}
+
+issue_virsh_command

=== modified file 'required-packages/base'
--- required-packages/base	2014-03-25 13:13:36 +0000
+++ required-packages/base	2014-05-21 17:37:04 +0000
@@ -35,6 +35,7 @@
 python-oops-datedir-repo
 python-oops-twisted
 python-oops-wsgi
+python-pexpect
 python-psycopg2
 python-pyinotify
 python-seamicroclient

=== modified file 'src/maasserver/api.py'
--- src/maasserver/api.py	2014-05-07 02:53:23 +0000
+++ src/maasserver/api.py	2014-05-21 17:37:04 +0000
@@ -1684,8 +1684,8 @@
     def probe_and_enlist_hardware(self, request, uuid):
         """Add special hardware types.
 
-        :param model: The type of special hardware, currently only
-            'seamicro15k' is supported.
+        :param model: The type of special hardware, 'seamicro15k' and
+            'virsh' is supported.
         :type model: unicode
 
         The following are only required if you are probing a seamicro15k:
@@ -1702,6 +1702,17 @@
         :param power_control: The power_control to use, either ipmi (default)
             or restapi.
         :type power_control: unicode
+
+        The following are only required if you are probing a virsh:
+
+        :param power_address: The connection string to virsh.
+        :type power_address: unicode
+
+        The following are optional if you are probing a virsh:
+
+        :param power_pass: The password to use, when qemu+ssh is given as a
+            connection string and ssh key authentication is not being used.
+        :type power_pass: unicode
         """
         nodegroup = get_object_or_404(NodeGroup, uuid=uuid)
 
@@ -1716,6 +1727,12 @@
 
             nodegroup.add_seamicro15k(
                 mac, username, password, power_control=power_control)
+        elif model == 'powerkvm' or model == 'virsh':
+            poweraddr = get_mandatory_param(request.data, 'power_address')
+            password = get_optional_param(
+                request.data, 'power_pass', default=None)
+
+            nodegroup.add_virsh(poweraddr, password=password)
         else:
             return HttpResponse(status=httplib.BAD_REQUEST)
 

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2014-05-07 02:53:23 +0000
+++ src/maasserver/models/node.py	2014-05-21 17:37:04 +0000
@@ -758,7 +758,6 @@
             power_params = {}
 
         power_params.setdefault('system_id', self.system_id)
-        power_params.setdefault('virsh', '/usr/bin/virsh')
         power_params.setdefault('fence_cdu', '/usr/sbin/fence_cdu')
         power_params.setdefault('ipmipower', '/usr/sbin/ipmipower')
         power_params.setdefault('ipmitool', '/usr/bin/ipmitool')
@@ -769,6 +768,7 @@
         power_params.setdefault('username', '')
         power_params.setdefault('power_id', self.system_id)
         power_params.setdefault('power_driver', '')
+        power_params.setdefault('power_pass', '')
 
         # The "mac" parameter defaults to the node's primary MAC
         # address, but only if not already set.

=== modified file 'src/maasserver/models/nodegroup.py'
--- src/maasserver/models/nodegroup.py	2014-05-06 21:18:17 +0000
+++ src/maasserver/models/nodegroup.py	2014-05-21 17:37:04 +0000
@@ -41,6 +41,7 @@
 from provisioningserver.tasks import (
     add_new_dhcp_host_map,
     add_seamicro15k,
+    add_virsh,
     enlist_nodes_from_ucsm,
     import_boot_images,
     report_boot_images,
@@ -287,6 +288,15 @@
         args = (mac, username, password, power_control)
         add_seamicro15k.apply_async(queue=self.uuid, args=args)
 
+    def add_virsh(self, poweraddr, password=None):
+        """ Add all of the virtual machines inside a virsh controller.
+
+        :param poweraddr: virsh connection string
+        :param password: ssh password
+        """
+        args = (poweraddr, password)
+        add_virsh.apply_async(queue=self.uuid, args=args)
+
     def enlist_nodes_from_ucsm(self, url, username, password):
         """ Add the servers from a Cicso UCS Manager.
 

=== added file 'src/provisioningserver/custom_hardware/tests/test_virsh.py'
--- src/provisioningserver/custom_hardware/tests/test_virsh.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/custom_hardware/tests/test_virsh.py	2014-05-21 17:37:04 +0000
@@ -0,0 +1,240 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for `provisioningserver.custom_hardware.virsh`.
+"""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+import random
+from textwrap import dedent
+
+from maastesting.factory import factory
+from maastesting.matchers import (
+    MockCalledOnceWith,
+    MockCallsMatch,
+    )
+from maastesting.testcase import MAASTestCase
+from mock import call
+from provisioningserver.custom_hardware import (
+    utils,
+    virsh,
+    )
+
+
+SAMPLE_IFLIST = dedent("""
+    Interface  Type       Source     Model       MAC
+    -------------------------------------------------------
+    -          bridge     br0        e1000       %s
+    -          bridge     br1        e1000       %s
+    """)
+
+SAMPLE_DUMPXML = dedent("""
+    <domain type='kvm'>
+      <name>test</name>
+      <memory unit='KiB'>4096576</memory>
+      <currentMemory unit='KiB'>4096576</currentMemory>
+      <vcpu placement='static'>1</vcpu>
+      <os>
+        <type arch='%s'>hvm</type>
+        <boot dev='network'/>
+      </os>
+    </domain>
+    """)
+
+
+class TestVirshSSH(MAASTestCase):
+    """Tests for `VirshSSH`."""
+
+    def configure_virshssh(self, output):
+        self.patch(virsh.VirshSSH, 'run').return_value = output
+        return virsh.VirshSSH()
+
+    def test_virssh_mac_addresses_returns_list(self):
+        macs = [factory.getRandomMACAddress() for _ in range(2)]
+        output = SAMPLE_IFLIST % (macs[0], macs[1])
+        conn = self.configure_virshssh(output)
+        expected = conn.get_mac_addresses('')
+        for i in range(2):
+            self.assertEqual(macs[i], expected[i])
+
+    def test_virssh_get_arch_returns_valid(self):
+        arch = factory.make_name('arch')
+        output = SAMPLE_DUMPXML % arch
+        conn = self.configure_virshssh(output)
+        expected = conn.get_arch('')
+        self.assertEqual(arch, expected)
+
+    def test_virssh_get_arch_returns_valid_fixed(self):
+        arch = random.choice(virsh.ARCH_FIX.keys())
+        fixed_arch = virsh.ARCH_FIX[arch]
+        output = SAMPLE_DUMPXML % arch
+        conn = self.configure_virshssh(output)
+        expected = conn.get_arch('')
+        self.assertEqual(fixed_arch, expected)
+
+
+class TestVirsh(MAASTestCase):
+    """Tests for `probe_virsh_and_enlist`."""
+
+    def test_probe_and_enlist(self):
+        # Patch VirshSSH list so that some machines are returned
+        # with some fake architectures.
+        machines = [factory.make_name('machine') for _ in range(3)]
+        self.patch(virsh.VirshSSH, 'list').return_value = machines
+        fake_arch = factory.make_name('arch')
+        mock_arch = self.patch(virsh.VirshSSH, 'get_arch')
+        mock_arch.return_value = fake_arch
+
+        # Patch get_state so that one of the machines is on, so we
+        # can check that it will be forced off.
+        fake_states = [
+            virsh.VirshVMState.ON,
+            virsh.VirshVMState.OFF,
+            virsh.VirshVMState.OFF
+            ]
+        mock_state = self.patch(virsh.VirshSSH, 'get_state')
+        mock_state.side_effect = fake_states
+
+        # Setup the power parameters that we should expect to be
+        # the output of the probe_and_enlist
+        fake_password = factory.getRandomString()
+        poweraddr = factory.make_name('poweraddr')
+        called_params = []
+        fake_macs = []
+        for machine in machines:
+            macs = [factory.getRandomMACAddress() for _ in range(3)]
+            fake_macs.append(macs)
+            called_params.append({
+                'power_address': poweraddr,
+                'power_id': machine,
+                'power_pass': fake_password,
+                })
+
+        # Patch the get_mac_addresses so we get a known list of
+        # mac addresses for each machine.
+        mock_macs = self.patch(virsh.VirshSSH, 'get_mac_addresses')
+        mock_macs.side_effect = fake_macs
+
+        # Patch the poweroff and create as we really don't want these
+        # actions to occur, but want to also check that they are called.
+        mock_poweroff = self.patch(virsh.VirshSSH, 'poweroff')
+        mock_create = self.patch(utils, 'create_node')
+
+        # Patch login and logout so that we don't really contact
+        # a server at the fake poweraddr
+        mock_login = self.patch(virsh.VirshSSH, 'login')
+        mock_login.return_value = True
+        mock_logout = self.patch(virsh.VirshSSH, 'logout')
+
+        # Perform the probe and enlist
+        virsh.probe_virsh_and_enlist(poweraddr, password=fake_password)
+
+        # Check that login was called with the provided poweraddr and
+        # password.
+        self.assertThat(
+            mock_login, MockCalledOnceWith(poweraddr, fake_password))
+
+        # The first machine should have poweroff called on it, as it
+        # was initial in the on state.
+        self.assertThat(
+            mock_poweroff, MockCalledOnceWith(machines[0]))
+
+        # Check that the create command had the correct parameters for
+        # each machine.
+        self.assertThat(
+            mock_create, MockCallsMatch(
+                call(fake_macs[0], fake_arch, 'virsh', called_params[0]),
+                call(fake_macs[1], fake_arch, 'virsh', called_params[1]),
+                call(fake_macs[2], fake_arch, 'virsh', called_params[2])))
+        mock_logout.assert_called()
+
+    def test_probe_and_enlist_login_failure(self):
+        mock_login = self.patch(virsh.VirshSSH, 'login')
+        mock_login.return_value = False
+        self.assertRaises(
+            virsh.VirshError, virsh.probe_virsh_and_enlist,
+            factory.make_name('poweraddr'), password=factory.getRandomString())
+
+
+class TestVirshPowerControl(MAASTestCase):
+    """Tests for `power_control_virsh`."""
+
+    def test_power_control_login_failure(self):
+        mock_login = self.patch(virsh.VirshSSH, 'login')
+        mock_login.return_value = False
+        self.assertRaises(
+            virsh.VirshError, virsh.power_control_virsh,
+            factory.make_name('poweraddr'), factory.make_name('machine'),
+            'on', password=factory.getRandomString())
+
+    def test_power_control_on(self):
+        mock_login = self.patch(virsh.VirshSSH, 'login')
+        mock_login.return_value = True
+        mock_state = self.patch(virsh.VirshSSH, 'get_state')
+        mock_state.return_value = virsh.VirshVMState.OFF
+        mock_poweron = self.patch(virsh.VirshSSH, 'poweron')
+
+        poweraddr = factory.make_name('poweraddr')
+        machine = factory.make_name('machine')
+        virsh.power_control_virsh(poweraddr, machine, 'on')
+
+        self.assertThat(
+            mock_login, MockCalledOnceWith(poweraddr, None))
+        self.assertThat(
+            mock_state, MockCalledOnceWith(machine))
+        self.assertThat(
+            mock_poweron, MockCalledOnceWith(machine))
+
+    def test_power_control_off(self):
+        mock_login = self.patch(virsh.VirshSSH, 'login')
+        mock_login.return_value = True
+        mock_state = self.patch(virsh.VirshSSH, 'get_state')
+        mock_state.return_value = virsh.VirshVMState.ON
+        mock_poweroff = self.patch(virsh.VirshSSH, 'poweroff')
+
+        poweraddr = factory.make_name('poweraddr')
+        machine = factory.make_name('machine')
+        virsh.power_control_virsh(poweraddr, machine, 'off')
+
+        self.assertThat(
+            mock_login, MockCalledOnceWith(poweraddr, None))
+        self.assertThat(
+            mock_state, MockCalledOnceWith(machine))
+        self.assertThat(
+            mock_poweroff, MockCalledOnceWith(machine))
+
+    def test_power_control_bad_domain(self):
+        mock_login = self.patch(virsh.VirshSSH, 'login')
+        mock_login.return_value = True
+        mock_state = self.patch(virsh.VirshSSH, 'get_state')
+        mock_state.return_value = None
+
+        poweraddr = factory.make_name('poweraddr')
+        machine = factory.make_name('machine')
+        self.assertRaises(
+            virsh.VirshError, virsh.power_control_virsh,
+            poweraddr, machine, 'on')
+
+    def test_power_control_power_failure(self):
+        mock_login = self.patch(virsh.VirshSSH, 'login')
+        mock_login.return_value = True
+        mock_state = self.patch(virsh.VirshSSH, 'get_state')
+        mock_state.return_value = virsh.VirshVMState.ON
+        mock_poweroff = self.patch(virsh.VirshSSH, 'poweroff')
+        mock_poweroff.return_value = False
+
+        poweraddr = factory.make_name('poweraddr')
+        machine = factory.make_name('machine')
+        self.assertRaises(
+            virsh.VirshError, virsh.power_control_virsh,
+            poweraddr, machine, 'off')

=== modified file 'src/provisioningserver/custom_hardware/utils.py'
--- src/provisioningserver/custom_hardware/utils.py	2014-03-27 04:15:45 +0000
+++ src/provisioningserver/custom_hardware/utils.py	2014-05-21 17:37:04 +0000
@@ -42,3 +42,7 @@
         'autodetect_nodegroup': 'true'
     }
     return client.post('/api/1.0/nodes/', 'new', **data)
+
+
+def escape_string(data):
+    return repr(data).decode("ascii")

=== added file 'src/provisioningserver/custom_hardware/virsh.py'
--- src/provisioningserver/custom_hardware/virsh.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/custom_hardware/virsh.py	2014-05-21 17:37:04 +0000
@@ -0,0 +1,219 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    'probe_virsh_and_enlist',
+    ]
+
+from lxml import etree
+import pexpect
+import provisioningserver.custom_hardware.utils as utils
+
+
+XPATH_ARCH = "/domain/os/type/@arch"
+
+# Virsh stores the architecture with a different
+# label then MAAS. This maps virsh architecture to
+# MAAS architecture.
+ARCH_FIX = {
+    'x86_64': 'amd64',
+    'ppc64': 'ppc64el',
+    }
+
+
+class VirshVMState:
+    OFF = "shut off"
+    ON = "running"
+
+
+class VirshError(Exception):
+    """Failure communicating to virsh. """
+
+
+class VirshSSH(pexpect.spawn):
+
+    PROMPT = r"virsh \#"
+    PROMPT_SSHKEY = "(?i)are you sure you want to continue connecting"
+    PROMPT_PASSWORD = "(?i)(?:password)|(?:passphrase for key)"
+    PROMPT_DENIED = "(?i)permission denied"
+    PROMPT_CLOSED = "(?i)connection closed by remote host"
+
+    PROMPTS = [
+        PROMPT_SSHKEY,
+        PROMPT_PASSWORD,
+        PROMPT,
+        PROMPT_DENIED,
+        pexpect.TIMEOUT,
+        PROMPT_CLOSED
+    ]
+
+    I_PROMPT = PROMPTS.index(PROMPT)
+    I_PROMPT_SSHKEY = PROMPTS.index(PROMPT_SSHKEY)
+    I_PROMPT_PASSWORD = PROMPTS.index(PROMPT_PASSWORD)
+
+    def __init__(self, timeout=30, maxread=2000):
+        super(VirshSSH, self).__init__(
+            None, timeout=timeout, maxread=maxread)
+        self.name = '<virssh>'
+
+    def login(self, poweraddr, password=None):
+        """Starts connection to virsh."""
+        cmd = 'virsh --connect %s' % poweraddr
+        super(VirshSSH, self)._spawn(cmd)
+
+        i = self.expect(self.PROMPTS, timeout=10)
+        if i == self.I_PROMPT_SSHKEY:
+            # New certificate, lets always accept but if
+            # it changes it will fail to login.
+            self.sendline("yes")
+            i = self.expect(self.EXPECT_PROMPTS)
+        elif i == self.I_PROMPT_PASSWORD:
+            # Requesting password, give it if available.
+            if password is None:
+                self.close()
+                return False
+            self.sendline(password)
+            i = self.expect(self.EXPECT_PROMPTS)
+
+        if i != self.I_PROMPT:
+            # Something bad happened, either disconnect,
+            # timeout, wrong password.
+            self.close()
+            return False
+        return True
+
+    def logout(self):
+        """Quits the virsh session."""
+        self.sendline("quit")
+        self.close()
+
+    def prompt(self, timeout=None):
+        """Waits for virsh prompt."""
+        if timeout is None:
+            timeout = self.timeout
+        i = self.expect([self.VIRSH_PROMPT, pexpect.TIMEOUT], timeout=timeout)
+        if i == 1:
+            return False
+        return True
+
+    def run(self, args):
+        cmd = ' '.join(args)
+        self.sendline(cmd)
+        self.prompt()
+        result = self.before.splitlines()
+        return '\n'.join(result[1:])
+
+    def list(self):
+        """Lists all virtual machines by name."""
+        machines = self.run(['list', '--all', '--name'])
+        return machines.strip().splitlines()
+
+    def get_state(self, machine):
+        """Gets the virtual machine state."""
+        state = self.run(['domstate', machine])
+        state = state.strip()
+        if 'error' in state:
+            return None
+        return state
+
+    def get_mac_addresses(self, machine):
+        """Gets list of mac addressess assigned to the virtual machine."""
+        output = self.run(['domiflist', machine]).strip()
+        if 'error' in output:
+            return None
+        output = output.splitlines()[2:]
+        return [line.split()[4] for line in output]
+
+    def get_arch(self, machine):
+        """Gets the virtual machine architecture."""
+        output = self.run(['dumpxml', machine]).strip()
+        if 'error' in output:
+            return None
+
+        doc = etree.XML(output)
+        evaluator = etree.XPathEvaluator(doc)
+        arch = evaluator(XPATH_ARCH)[0]
+
+        # Fix architectures that need to be referenced by a different
+        # name, that MAAS understands.
+        return ARCH_FIX.get(arch, arch)
+
+    def poweron(self, machine):
+        """Poweron a virtual machine."""
+        output = self.run(['start', machine]).strip()
+        if 'error' in output:
+            return False
+        return True
+
+    def poweroff(self, machine):
+        """Poweroff a virtual machine."""
+        output = self.run(['destroy', machine]).strip()
+        if 'error' in output:
+            return False
+        return True
+
+
+def probe_virsh_and_enlist(poweraddr, password=None):
+    """Extracts all of the virtual machines from virsh and enlists them
+    into MAAS.
+
+    :param poweraddr: virsh connection string
+    """
+    conn = VirshSSH()
+    if not conn.login(poweraddr, password):
+        raise VirshError('Failed to login to virsh console.')
+
+    for machine in conn.list():
+        arch = conn.get_arch(machine)
+        state = conn.get_state(machine)
+        macs = conn.get_mac_addresses(machine)
+
+        # Force the machine off, as MAAS will control the machine
+        # and it needs to be in a known state of off.
+        if state == VirshVMState.ON:
+            conn.poweroff(machine)
+
+        params = {
+            'power_address': poweraddr,
+            'power_id': machine,
+        }
+        if password is not None:
+            params['power_pass'] = password
+        utils.create_node(macs, arch, 'virsh', params)
+
+    conn.logout()
+
+
+def power_control_virsh(poweraddr, machine, power_change, password=None):
+    """Powers controls a virtual machine using virsh."""
+
+    # Force password to None if blank, as the power control
+    # script will send a blank password if one is not set.
+    if password == '':
+        password = None
+
+    conn = VirshSSH()
+    if not conn.login(poweraddr, password):
+        raise VirshError('Failed to login to virsh console.')
+
+    state = conn.get_state(machine)
+    if state is None:
+        raise VirshError('Failed to get domain: %s' % machine)
+
+    if state == VirshVMState.OFF:
+        if power_change == 'on':
+            if conn.poweron(machine) is False:
+                raise VirshError('Failed to power on domain: %s' % machine)
+    elif state == VirshVMState.ON:
+        if power_change == 'off':
+            if conn.poweroff(machine) is False:
+                raise VirshError('Failed to power off domain: %s' % machine)

=== modified file 'src/provisioningserver/power/tests/test_poweraction.py'
--- src/provisioningserver/power/tests/test_poweraction.py	2014-05-06 21:18:17 +0000
+++ src/provisioningserver/power/tests/test_poweraction.py	2014-05-21 17:37:04 +0000
@@ -158,20 +158,6 @@
             PowerActionFail,
             pa.execute, power_change='off', mac=factory.getRandomMACAddress())
 
-    def test_virsh_checks_vm_state(self):
-        # We can't test the virsh template in detail (and it may be
-        # customized), but by making it use "echo" instead of a real
-        # virsh we can make it get a bogus answer from its status check.
-        # The bogus answer is actually the rest of the virsh command
-        # line.  It will complain about this and fail.
-        action = PowerAction('virsh')
-        script = action.render_template(
-            action.get_template(), power_change='on',
-            power_address='qemu://example.com/',
-            power_id='mysystem', virsh='echo')
-        output = action.run_shell(script)
-        self.assertIn("Got unknown power state from virsh", output)
-
     def test_fence_cdu_checks_state(self):
         # We can't test the fence_cdu template in detail (and it may be
         # customized), but by making it use "echo" instead of a real

=== modified file 'src/provisioningserver/power_schema.py'
--- src/provisioningserver/power_schema.py	2014-05-06 21:18:17 +0000
+++ src/provisioningserver/power_schema.py	2014-05-21 17:37:04 +0000
@@ -168,6 +168,9 @@
         'fields': [
             make_json_field('power_address', "Power address"),
             make_json_field('power_id', "Power ID"),
+            make_json_field(
+                'power_pass', "Power password (optional)",
+                required=False),
         ],
     },
     {

=== modified file 'src/provisioningserver/tasks.py'
--- src/provisioningserver/tasks.py	2014-05-06 21:18:17 +0000
+++ src/provisioningserver/tasks.py	2014-05-21 17:37:04 +0000
@@ -46,6 +46,7 @@
     probe_seamicro15k_and_enlist,
     )
 from provisioningserver.custom_hardware.ucsm import probe_and_enlist_ucsm
+from provisioningserver.custom_hardware.virsh import probe_virsh_and_enlist
 from provisioningserver.dhcp import (
     config,
     detect,
@@ -464,7 +465,7 @@
 @task
 @log_exception_text
 def add_seamicro15k(mac, username, password, power_control=None):
-    """ See `maasserver.api.NodeGroupsHandler.add_seamicro15k`. """
+    """ See `maasserver.api.NodeGroup.add_seamicro15k`. """
     ip = find_ip_via_arp(mac)
     if ip is not None:
         probe_seamicro15k_and_enlist(
@@ -476,6 +477,13 @@
 
 @task
 @log_exception_text
+def add_virsh(poweraddr, password=None):
+    """ See `maasserver.api.NodeGroup.add_virsh`. """
+    probe_virsh_and_enlist(poweraddr, password=password)
+
+
+@task
+@log_exception_text
 def enlist_nodes_from_ucsm(url, username, password):
     """ See `maasserver.api.NodeGroupsHandler.enlist_nodes_from_ucsm`. """
     probe_and_enlist_ucsm(url, username, password)