def _getVMs(self):
        master = self.getMasterUUID()
        cmd = "xe vm-list dom-id=0 resident-on=%s params=uuid --minimal" % \
                master
        stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD + 1)
        masterVM = stdout.strip()
        if not tutil.validateUUID(masterVM):
            raise SMException("Got invalid UUID: %s" % masterVM)

        slaveVM = None
        host = self.getThisHost()
        if host == master:
            cmd = "xe host-list params=uuid --minimal"
            stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD + 1)
            hosts = stdout.strip().split(",")
            for h in hosts:
                if h != master:
                    host = h
                    break

        if host == master:
            return (masterVM, None)

        cmd = "xe vm-list dom-id=0 resident-on=%s params=uuid --minimal" % host
        stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD + 1)
        slaveVM = stdout.strip()
        if not tutil.validateUUID(slaveVM):
            raise SMException("Got invalid UUID: %s" % slaveVM)
        return (masterVM, slaveVM)

 def _unplugVBD(self, vbd):
     self.logger.log("Unplugging VBD %s" % vbd, 2)
     cmd = "xe vbd-unplug uuid=%s" % vbd
     try:
         tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
     except tutil.CommandException, inst:
         if str(inst).find("device is not currently attached") == -1:
             raise

 def mount(self, dev, mountDir):
     if not tutil.pathExists(mountDir):
         try:
             os.makedirs(mountDir)
         except OSError:
             raise SMException("makedirs failed (for %s)" % mountDir)
     if not tutil.pathExists(mountDir):
         raise SMException("mount dir '%s' not created" % mountDir)
     cmd = "mount %s %s" % (dev, mountDir)
     tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)

    def _createVBD(self, vdi, vm, ro = False, vbdLetter = None,
            unpluggable = True):
        """Creates a VBD for the specified VDI on the specified VM. If a device
        is not supplied (vbdLetter), the first available one is used. Returns
        the UUID of the VBD."""

        mode = "rw"
        if ro:
            mode="ro"

        if None == vbdLetter:
            devices = self._vm_get_allowed_vbd_devices(vm)
            assert len(devices) > 0 # FIXME raise exception instead
            vbdLetter = devices[0]
        
        cmd = "xe vbd-create vm-uuid=%s vdi-uuid=%s type=disk mode=%s "\
                "device=%s unpluggable=%s" % (vm, vdi, mode, vbdLetter,
                        unpluggable)
        stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
        # XXX xe vbd-create returns 0 if the device name is invalid
        if not stdout:
            raise SMException("No output from vbd-create")
        vbdUuid = stdout.strip()
        if not tutil.validateUUID(vbdUuid):
            raise SMException("Got invalid UUID: %s" % vbdUuid)
        return vbdUuid

    def _getInfoVDI(self, uuid):
        """Retrieves the parameters of the spcified VDI in the form of a
        dictionary."""

        cmd = "xe vdi-list uuid=%s params=all" % uuid
        stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD + 1)
        return self._toDict(stdout)

 def _getPoolUUID(self):
     cmd = "xe pool-list params=uuid --minimal"
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
     poolUuid = stdout.strip()
     if not tutil.validateUUID(poolUuid):
         raise SMException("Got invalid UUID: %s" % poolUuid)
     return poolUuid

 def _getInfoSR(self, uuid):
     cmd = "xe sr-list uuid=%s params=all" % uuid
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD + 1)
     info = self._toDict(stdout)
     if not info["sm-config"]:
         info["sm-config"] = dict()
     return info

 def _onMaster(self, plugin, fn, args):
     argsStr = ""
     for key, val in args.iteritems():
         argsStr += " args:%s=%s" % (key, val)
     cmd = "xe host-call-plugin host-uuid=%s plugin=%s fn=%s %s" % \
             (self.getMasterUUID(), plugin, fn, argsStr)
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
     return stdout.strip()

 def _vdi_get_vbd(self, vdi_uuid):
     """Retrieves the UUID of the specified VDI, else None."""
     out = tutil.execCmd('xe vbd-list vdi-uuid=' + vdi_uuid + ' --minimal',
             0, self.logger, LOG_LEVEL_CMD).strip()
     if '' != out:
         return out
     else:
         return None

 def _getVDIs(self, sr):
     cmd = "xe vdi-list sr-uuid=%s params=uuid --minimal" % sr
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_SUB)
     stdout = stdout.strip()
     if not stdout:
         return []
     vdiList = stdout.split(",")
     return vdiList

 def _findSR(self, type):
     cmd = "xe sr-list type=%s --minimal" % type
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
     stdout = stdout.strip()
     if not stdout:
         return []
     srList = stdout.split(",")
     return srList

 def _getDefaultSR(self):
     cmd = "xe pool-param-get param-name=default-SR uuid=%s --minimal" % \
             self._getPoolUUID()
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
     uuid = stdout.strip()
     if tutil.validateUUID(uuid):
         return uuid
     return None

 def _getDom0UUID(self):
     cmd = "xe vm-list dom-id=0 params=uuid --minimal"
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
     if not stdout:
         raise SMException("No output from vm-list")
     dom0uuid = stdout.strip()
     if not tutil.validateUUID(dom0uuid):
         raise SMException("Got invalid UUID: %s" % dom0uuid)
     return dom0uuid

    def _getInfoSR(self, uuid):
        """Retrieves the parameters of the specified SR in the form of a
        dictionary."""

        cmd = "xe sr-list uuid=%s params=all" % uuid
        stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD + 1)
        info = self._toDict(stdout)
        if not info["sm-config"]:
            info["sm-config"] = dict()
        return info

    def _findSR(self, type):
        "Retrieves all SRs of the specified type in the form of a list."

        cmd = "xe sr-list type=%s --minimal" % type
        stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
        stdout = stdout.strip()
        if not stdout:
            return []
        srList = stdout.split(",")
        return srList

 def _getVHDParentNoCheck(self, sr, path):
     cmd = "vhd-util read -p -n %s" % path
     text = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_SUB)
     for line in text.split('\n'):
         if line.find("decoded name :") != -1:
             val = line.split(':')[1].strip()
             vdi = val.replace("--", "-")[-40:]
             if vdi[1:].startswith("LV-"):
                 vdi = vdi[1:]
             return os.path.join(self.getPathSR(sr), vdi)
     return None

    def _getVDIs(self, sr):
        """Retrieves the UUIDs of all the VDIs on the specified SR, in the form
        of a list."""

        cmd = "xe vdi-list sr-uuid=%s params=uuid --minimal" % sr
        stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_SUB)
        stdout = stdout.strip()
        if not stdout:
            return []
        vdiList = stdout.split(",")
        return vdiList

 def _createSR(self, type, size):
     cmd = "xe sr-create name-label='%s' physical-size=%d \
             content-type=user device-config:device=%s type=%s" % \
             (self.SR_LABEL, size, self.targetDevice, type)
     stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
     if not stdout:
         raise SMException("No output from sr-create")
     srUuid = stdout.strip()
     if not tutil.validateUUID(srUuid):
         raise SMException("Got invalid UUID: %s" % srUuid)
     return srUuid

    def _vdi_get_parent(self, vdi_uuid):
        """Retrieves the parent UUID of the VDI."""
        # XXX It is expected to be a VHD VDI.

        out = tutil.execCmd('xe vdi-param-get uuid=' + vdi_uuid \
                + ' param-name=sm-config', 0, self.logger,
                LOG_LEVEL_CMD)

        assert re.match('vhd-parent: ' + tutil.uuidre + '; vdi_type: vhd\n',
                out)

        return re.search(tutil.uuidre, out).group(0)

 def _cloneVDI(self, vdi):
     cmd = "xe vdi-clone uuid=%s" % vdi
     for i in range(CMD_NUM_RETRIES):
         try:
             stdout = tutil.execCmd(cmd, 0, self.logger, LOG_LEVEL_CMD)
             break
         except tutil.CommandException, inst:
             if str(inst).find("VDI_IN_USE") != -1:
                 self.logger.log("Command failed, retrying", LOG_LEVEL_CMD)
                 time.sleep(CMD_RETRY_PERIOD)
             else:
                 raise