Python util.pread函数代码示例

    def _probe_hba(self):
        try:
            # use sysfs tree to gather FC data

            dom = xml.dom.minidom.Document()
            hbalist = dom.createElement("HBAInfoList")
            dom.appendChild(hbalist)

            hostlist = util.listdir("/sys/class/fc_host")
            for host in hostlist: 

                hbainfo = dom.createElement("HBAInfo")
                hbalist.appendChild(hbainfo)

                cmd = ["cat", "/sys/class/fc_host/%s/symbolic_name" % host]
                sname = util.pread(cmd)[:-1]
                entry = dom.createElement("model")
                hbainfo.appendChild(entry)
                textnode = dom.createTextNode(sname)
                entry.appendChild(textnode)

                cmd = ["cat", "/sys/class/fc_host/%s/node_name" % host]
                nname = util.pread(cmd)[:-1]
                nname = util.make_WWN(nname)
                entry = dom.createElement("nodeWWN")
                hbainfo.appendChild(entry)
                # adjust nodename to look like expected string
                textnode = dom.createTextNode(nname)
                entry.appendChild(textnode)

                port = dom.createElement("Port")
                hbainfo.appendChild(port)

                cmd = ["cat", "/sys/class/fc_host/%s/port_name" % host]
                pname = util.pread(cmd)[:-1]
                pname = util.make_WWN(pname)
                entry = dom.createElement("portWWN")
                port.appendChild(entry)
                # adjust nodename to look like expected string
                textnode = dom.createTextNode(pname)
                entry.appendChild(textnode)

                cmd = ["cat", "/sys/class/fc_host/%s/port_state" % host]
                state = util.pread(cmd)[:-1]
                entry = dom.createElement("state")
                port.appendChild(entry)
                # adjust nodename to look like expected string
                textnode = dom.createTextNode(state)
                entry.appendChild(textnode)

                entry = dom.createElement("deviceName")
                port.appendChild(entry)
                # adjust nodename to look like expected string
                textnode = dom.createTextNode("/sys/class/scsi_host/%s" % host)
                entry.appendChild(textnode)

            return dom.toxml()
        except:
            raise xs_errors.XenError('CSLGXMLParse', \
                                     opterr='HBA probe failed')

def setSize(path, size, confirm):
    sizeMB = size / (1024 * 1024)
    cmd = [CMD_LVRESIZE, "-L", str(sizeMB), path]
    if confirm:
        util.pread3(cmd, "y\n")
    else:
        util.pread(cmd)

 def detach(self, sr_uuid):
     if not util.ioretry(lambda: self._checkmount()):
         return
     try:
         util.pread(["umount", self.path])
         os.rmdir(self.path)
     except util.CommandException, inst:
         raise xs_errors.XenError('NFSUnMount', \
               opterr='error is %d' % inst.code)

 def detach(self, sr_uuid):
     if self._checkmount():
         try:
             util.SMlog("Aborting GC/coalesce")
             cleanup.abort(self.uuid)
             os.chdir(SR.MOUNT_BASE)
             util.pread(["umount", self.path])
             os.rmdir(self.path)
         except Exception, e:
             raise xs_errors.XenError('SRInUse', opterr=str(e))

def _lvmBugCleanup(path):
    # the device should not exist at this point. If it does, this was an LVM 
    # bug, and we manually clean up after LVM here
    mapperDevice = path[5:].replace("-", "--").replace("/", "-")
    mapperPath = "/dev/mapper/" + mapperDevice
            
    nodeExists = False
    cmd = [CMD_DMSETUP, "status", mapperDevice]
    try:
        util.pread(cmd, expect_rc=1)
    except util.CommandException, e:
        if e.code == 0:
            nodeExists = True

 def attach(self, sr_uuid):
     if not self._checkmount():
         try:
             util.ioretry(lambda: util.makedirs(self.path))
         except util.CommandException, inst:
             if inst.code != errno.EEXIST:
                 raise xs_errors.XenError("FileSRCreate", \
                                          opterr='fail to create mount point. Errno is %s' % inst.code)
         try:
             util.pread(["mount", "--bind", self.remotepath, self.path])
         except util.CommandException, inst:
             raise xs_errors.XenError('FileSRCreate', \
                                      opterr='fail to mount FileSR. Errno is %s' % inst.code)

def check_server_service(server):
    """Ensure NFS service is up and available on the remote server.

    Returns False if fails to detect service after 
    NFS_SERVICE_RETRY * NFS_SERVICE_WAIT
    """

    retries = 0
    errlist = [errno.EPERM, errno.EPIPE, errno.EIO]

    while True:
        try:
            services = util.pread([RPCINFO_BIN, "-s", "%s" % server])
            services = services.split("\n")
            for i in range(len(services)):
                if services[i].find("nfs") > 0:
                    return True
        except util.CommandException, inst:
            if not int(inst.code) in errlist:
                raise

        util.SMlog("NFS service not ready on server %s" % server)
        retries += 1
        if retries >= NFS_SERVICE_RETRY:
            break

        time.sleep(NFS_SERVICE_WAIT)

def removeDevMapperEntry(path, strict=True):
    try:
        # remove devmapper entry using dmsetup
        cmd = [CMD_DMSETUP, "remove", path]
        util.pread2(cmd)
        return True
    except Exception, e:
        if not strict:
            cmd = [CMD_DMSETUP, "status", path]
            try:
                util.pread(cmd, expect_rc=1)
                return True
            except:
                pass  # Continuining will fail and log the right way
        util.SMlog("removeDevMapperEntry: dmsetup remove failed for file %s " \
                   "with error %s." % (path, str(e)))
        return False

 def create(self, sr_uuid, size):
     if util.pathexists(self.blockdevice):
         util.zeroOut(self.blockdevice, 0, 1024 * 1024)
     cmd = ["mkfs", "-t", "ocfs2", "-b", "4K", "-C", "1M", "-N", "16", "-F", self.blockdevice]
     try:
         ret = util.pread(cmd)
     except util.CommandException, inst:
         raise xs_errors.XenError("OCFSFilesystem", opterr="mkfs failed error %d" % os.strerror(inst.code))

 def create(self, sr_uuid, size):
     if util.pathexists(self.blockdevice):
         util.zeroOut(self.blockdevice, 0, 1024*1024)
     cmd = ['mkfs', '-t', 'ocfs2', '-b', '4K', '-C', '1M', '-N', '16', '-F', self.blockdevice ]
     try:
         ret = util.pread(cmd)
     except util.CommandException, inst:
         raise xs_errors.XenError('OCFSFilesystem', \
               opterr='mkfs failed error %d' % os.strerror(inst.code))

    def _query_info(self, path):
        diskinfo = {}
        cmd = [SR.TAPDISK_UTIL, "query", SR.DEFAULT_TAP, "-vpf", path]
        txt = util.pread(cmd).split('\n')
        diskinfo['size'] = txt[0]
	for val in filter(util.exactmatch_uuid, [txt[1].split('/')[-1].replace(".%s" % SR.DEFAULT_TAP,"")]):
            diskinfo['parent'] = val
        diskinfo['hidden'] = txt[2].split()[1]
        return diskinfo

 def _probe_hba(self):
     try:
         cmd = [HBA_CLI, "xml"]
         fc_xml = util.pread(cmd)
         #strip junk until xml
         return fc_xml[fc_xml.index("<HBAInfoList>"):len(fc_xml)]
     except:
         raise xs_errors.XenError('CSLGXMLParse', \
                                  opterr='HBA probe failed')

 def _query_info(self, path):
     diskinfo = {}
     cmd = [SR.TAPDISK_UTIL, "query", SR.DEFAULT_TAP, "-vpf", path]
     txt = util.pread(cmd).split('\n')
     diskinfo['size'] = txt[0]
     if txt[1].find("has no parent") == -1:
         diskinfo['parent'] = txt[1].split('/')[-1].replace(".%s" % SR.DEFAULT_TAP,"")
     diskinfo['hidden'] = txt[2].split()[1]
     return diskinfo

    def create(self, sr_uuid, size):
        if self._checkmount():
            raise xs_errors.XenError('SRExists')

        # Check none of the devices already in use by other PBDs
        if util.test_hostPBD_devs(self.session, sr_uuid, self.root):
            raise xs_errors.XenError('SRInUse')

        # Check serial number entry in SR records
        for dev in self.root.split(','):
            if util.test_scsiserial(self.session, dev):
                raise xs_errors.XenError('SRInUse')

        if not lvutil._checkVG(self.vgname):
            lvutil.createVG(self.root, self.vgname)

        if lvutil._checkLV(self.remotepath):
            raise xs_errors.XenError('SRExists')

        try:
            numdevs = len(self.root.split(','))
            cmd = ["lvcreate", "-n", sr_uuid]
            if numdevs > 1:
                lowest = -1
                for dev in self.root.split(','):
                    stats = lvutil._getPVstats(dev)
                    if lowest < 0  or stats['freespace'] < lowest:
                        lowest = stats['freespace']
                size_mb = (lowest / (1024 * 1024)) * numdevs

                # Add stripe parameter to command
                cmd += ["-i", str(numdevs), "-I", "2048"]
            else:
                stats = lvutil._getVGstats(self.vgname)
                size_mb = stats['freespace'] / (1024 * 1024)
            assert(size_mb > 0)
            cmd += ["-L", str(size_mb), self.vgname]
            text = util.pread(cmd)

            cmd = ["lvchange", "-ay", self.remotepath]
            text = util.pread(cmd)
        except util.CommandException, inst:
            raise xs_errors.XenError('LVMCreate', \
                  opterr='lv operation, error %d' % inst.code)

 def _query_info(self, path):
     diskinfo = {}
     cmd = [SR.TAPDISK_UTIL, "query", vhdutil.VDI_TYPE_VHD, "-vpf", path]
     txt = util.pread(cmd).split('\n')
     diskinfo['size'] = txt[0]
     lst = [txt[1].split('/')[-1].replace(vhdutil.FILE_EXTN_VHD, "")]
     for val in filter(util.exactmatch_uuid, lst):
         diskinfo['parent'] = val
     diskinfo['hidden'] = txt[2].split()[1]
     return diskinfo