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 _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 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 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 _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 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 _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] 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 _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 check_server_tcp(server): """Make sure that NFS over TCP/IP V3 is supported on the server. Returns True if everything is OK, False otherwise.""" try: util.ioretry(lambda: util.pread([RPCINFO_BIN,"-t", "%s" % server, "nfs","3"]), errlist=[errno.EPERM], maxretry=2, nofail=True) except util.CommandException, inst: raise NfsException("rpcinfo failed or timed out: return code %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
def check_server_service(server): """Ensure NFS service is up and available on the remote server. Raises exception if fails to detect service after NFS_SERVICE_RETRY * NFS_SERVICE_WAIT """ util.ioretry(lambda: util.pread([RPCINFO_BIN, "-t", "%s" % server, "nfs"]), errlist=[errno.EPERM, errno.EPIPE, errno.EIO], maxretry=NFS_SERVICE_RETRY, period=NFS_SERVICE_WAIT, nofail=True)
def activateNoRefcount(path, refresh): cmd = [CMD_LVCHANGE, "-ay", path] if refresh: cmd.append("--refresh") text = util.pread2(cmd) if not _checkActive(path): raise util.CommandException(-1, str(cmd), "LV not activated") if refresh: mapperDevice = path[5:].replace("-", "--").replace("/", "-") cmd = [CMD_DMSETUP, "table", mapperDevice] ret = util.pread(cmd) util.SMlog("DM table for %s: %s" % (path, ret.strip()))
def _getVHDParentNoCheck(path): cmd = [VHD_UTIL, "read", "-p", "-n", "%s" % path] text = util.pread(cmd) util.SMlog(text) 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 vdi return None
def _query_info(self, path, use_bkp_footer=False): diskinfo = {} qopts = '-vpf' if use_bkp_footer: qopts += 'b' cmd = [SR.TAPDISK_UTIL, "query", vhdutil.VDI_TYPE_VHD, qopts, 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
def _query_info(self, path, use_bkp_footer=False): diskinfo = {} qopts = "-vpf" if use_bkp_footer: qopts += "b" cmd = [SR.TAPDISK_UTIL, "query", vhdutil.VDI_TYPE_VHD, qopts, 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
def attach(self, sr_uuid): if not self._checkmount(): try: #Activate LV cmd = ['lvchange','-ay',self.remotepath] util.pread2(cmd) # make a mountpoint: if not os.path.isdir(self.path): os.makedirs(self.path) except util.CommandException, inst: raise xs_errors.XenError('LVMMount', \ opterr='Unable to activate LV. Errno is %d' % inst.code) try: util.pread(["fsck", "-a", self.remotepath]) except util.CommandException, inst: if inst.code == 1: util.SMlog("FSCK detected and corrected FS errors. Not fatal.") else: raise xs_errors.XenError('LVMMount', \ opterr='FSCK failed on %s. Errno is %d' % (self.remotepath,inst.code))
def detach(self, sr_uuid): if not self._checkmount(): return cleanup.abort(self.uuid) try: # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) # unmount the device util.pread(["umount", self.path]) # remove the mountpoint os.rmdir(self.path) self.path = None # deactivate SR try: cmd = ["lvchange", "-an", self.remotepath] util.pread2(cmd) except util.CommandException, inst: raise xs_errors.XenError('LVMUnMount', \ opterr='lvm -an failed errno is %d' % inst.code) self.attached = False
def detach(self, sr_uuid): """Detach the SR: Unmounts and removes the mountpoint""" if not self._checkmount(): return util.SMlog("Aborting GC/coalesce") cleanup.abort(self.uuid) # Change directory to avoid unmount conflicts os.chdir(SR.MOUNT_BASE) cmd = ["umount", self.path] try: ret = util.pread(cmd) except util.CommandException, inst: raise xs_errors.XenError("OCFSUnMount", opterr="Failed to umount FS. Errno is %d" % os.strerror(inst.code))
def activateNoRefcount(path, refresh): cmd = [CMD_LVCHANGE, "-ay", path] text = cmd_lvm(cmd) if not _checkActive(path): raise util.CommandException(-1, str(cmd), "LV not activated") if refresh: # Override slave mode lvm.conf for this command os.environ['LVM_SYSTEM_DIR'] = MASTER_LVM_CONF text = cmd_lvm([CMD_LVCHANGE, "--refresh", path]) mapperDevice = path[5:].replace("-", "--").replace("/", "-") cmd = [CMD_DMSETUP, "table", mapperDevice] ret = util.pread(cmd) util.SMlog("DM table for %s: %s" % (path, ret.strip())) # Restore slave mode lvm.conf os.environ['LVM_SYSTEM_DIR'] = DEF_LVM_CONF
def attach(self, sr_uuid): if not util.ioretry(lambda: self._checkmount()): try: # make sure NFS over TCP/IP V3 is supported on the server util.ioretry(lambda: util.pread(["/usr/sbin/rpcinfo","-t", \ "%s" % self.remoteserver, "nfs","3"]), \ errlist=[errno.EPERM], nofail=1) except util.CommandException, inst: raise xs_errors.XenError('NFSVersion', \ opterr='or NFS server timed out') try: # make a mountpoint: if not util.ioretry(lambda: util.isdir(self.path)): util.ioretry(lambda: util.makedirs(self.path)) timeout = int((SOFTMOUNT_TIMEOUT / 3.0) * 10.0) util.ioretry(lambda: util.pread(["mount.nfs", "%s:%s" \ % (self.remoteserver, self.remotepath), \ self.path, "-o", \ "udp,soft,timeo=%d,retrans=1,noac" % \ timeout]), errlist=[errno.EPIPE, errno.EIO], nofail=1) except util.CommandException, inst: raise xs_errors.XenError('NFSMount')
def _getPVstats(dev): try: cmd = [CMD_PVS, "--noheadings", "--nosuffix", "--units", "b", dev] text = util.pread(cmd).split() size = long(text[4]) freespace = long(text[5]) utilisation = size - freespace stats = {} stats['physical_size'] = size stats['physical_utilisation'] = utilisation stats['freespace'] = freespace return stats except util.CommandException, inst: raise xs_errors.XenError('VDILoad', \ opterr='pvstats failed error is %d' % inst.code)
def _getVGstats(vgname): try: cmd = [CMD_VGS, "--noheadings", "--units", "b", vgname] text = util.pread(cmd).split() size = long(text[5].replace("B","")) utilisation = size - long(text[6].replace("B","")) freespace = size - utilisation stats = {} stats['physical_size'] = size stats['physical_utilisation'] = utilisation stats['freespace'] = freespace return stats except util.CommandException, inst: raise xs_errors.XenError('VDILoad', \ opterr='rvgstats failed error is %d' % inst.code)
def mount(self, mountpoint, blockdevice): try: if not util.ioretry(lambda: util.isdir(mountpoint)): util.ioretry(lambda: util.makedirs(mountpoint)) except util.CommandException: raise xs_errors.XenError('SRUnavailable', \ opterr='no such directory %s' % mountpoint) cmd = ['mount', '-t', 'ocfs2', blockdevice, mountpoint, '-o', \ 'noatime,data=writeback,nointr,commit=60,coherency=buffered'] try: ret = util.pread(cmd) except util.CommandException, inst: raise xs_errors.XenError('OCFSMount', opterr='Failed to mount FS. Errno is %d' \ % os.strerror(inst.code))
def mount(self, mountpoint, blockdevice): try: if not util.ioretry(lambda: util.isdir(mountpoint)): util.ioretry(lambda: util.makedirs(mountpoint)) except util.CommandException: raise xs_errors.XenError("SRUnavailable", opterr="no such directory %s" % mountpoint) cmd = [ "mount", "-t", "ocfs2", blockdevice, mountpoint, "-o", "noatime,data=writeback,nointr,commit=60,coherency=buffered", ] try: ret = util.pread(cmd) except util.CommandException, inst: raise xs_errors.XenError("OCFSMount", opterr="Failed to mount FS. Errno is %d" % os.strerror(inst.code))
def soft_mount(mountpoint, remoteserver, remotepath, transport): """Mount the remote NFS export at 'mountpoint'""" try: if not util.ioretry(lambda: util.isdir(mountpoint)): util.ioretry(lambda: util.makedirs(mountpoint)) except util.CommandException, inst: raise NfsException("Failed to make directory: code is %d" % inst.code) options = "soft,timeo=%d,retrans=%d,%s" % (SOFTMOUNT_TIMEOUT, SOFTMOUNT_RETRANS, transport) options += ',noac' # CA-27534 try: util.ioretry(lambda: util.pread([ "mount.nfs", "%s:%s" % (remoteserver, remotepath), mountpoint, "-o", options ]), errlist=[errno.EPIPE, errno.EIO], maxretry=2, nofail=True) except util.CommandException, inst: raise NfsException("mount failed with return code %d" % inst.code) def unmount(mountpoint, rmmountpoint): """Unmount the mounted mountpoint""" try: util.pread(["umount", mountpoint]) except util.CommandException, inst: raise NfsException("umount failed with return code %d" % inst.code)
def unmount(self, mountpoint, rmmountpoint): """Unmount the remote SMB export at 'mountpoint'""" try: util.pread(["umount", mountpoint]) except util.CommandException, inst: raise SMBException("umount failed with return code %d" % inst.code)
def _create(self, size, path): cmd = [SR.TAPDISK_UTIL, "create", vhdutil.VDI_TYPE_VHD, size, path] text = util.pread(cmd)
def _singlesnap(self, src, dst): cmd = [SR.TAPDISK_UTIL, "snapshot", SR.DEFAULT_TAP, src, dst] text = util.pread(cmd)
def _query_p_uuid(self, path): cmd = [SR.TAPDISK_UTIL, "query", SR.DEFAULT_TAP, "-p", path] parent = util.pread(cmd) parent = parent[:-1] ls = parent.split('/') return ls[len(ls) - 1].replace(SR.DEFAULT_TAP, '')[:-1]
def unmount(mountpoint, rmmountpoint): """Unmount the mounted mountpoint""" try: util.pread(["umount", mountpoint]) except util.CommandException, inst: raise NfsException("umount failed with return code %d" % inst.code)
raise NfsException("Failed to make directory: code is %d" % inst.code) mountcommand = 'mount.nfs' if nfsversion == '4': mountcommand = 'mount.nfs4' if timeout < 1: timeout = SOFTMOUNT_TIMEOUT options = "soft,timeo=%d,retrans=%d,proto=%s,vers=%s" % ( timeout * 10, SOFTMOUNT_RETRANS, transport, nfsversion) options += ',acdirmin=0,acdirmax=0' try: util.ioretry(lambda: util.pread([ mountcommand, "%s:%s" % (remoteserver, remotepath), mountpoint, "-o", options ]), errlist=[errno.EPIPE, errno.EIO], maxretry=2, nofail=True) except util.CommandException, inst: raise NfsException("mount failed with return code %d" % inst.code) def unmount(mountpoint, rmmountpoint): """Unmount the mounted mountpoint""" try: util.pread(["umount", mountpoint]) except util.CommandException, inst: raise NfsException("umount failed with return code %d" % inst.code)
def _query_v(self, path): cmd = [SR.TAPDISK_UTIL, "query", vhdutil.VDI_TYPE_VHD, "-v", path] return long(util.pread(cmd)) * 1024 * 1024
def _query_p_uuid(self, path): cmd = [SR.TAPDISK_UTIL, "query", vhdutil.VDI_TYPE_VHD, "-p", path] parent = util.pread(cmd) parent = parent[:-1] ls = parent.split('/') return ls[len(ls) - 1].replace(vhdutil.FILE_EXTN_VHD, '')
def _mark_hidden(self, path): cmd = [SR.TAPDISK_UTIL, "set", SR.DEFAULT_TAP, path, "hidden", "1"] text = util.pread(cmd) self.hidden = 1
return util.SMlog("_lvmBugCleanup: seeing dm file %s" % mapperPath) # destroy the dm device if nodeExists: util.SMlog("_lvmBugCleanup: removing dm device %s" % mapperDevice) for i in range(LVM_FAIL_RETRIES): try: util.pread2(cmd_rm) break except util.CommandException, e: if i < LVM_FAIL_RETRIES - 1: util.SMlog("Failed on try %d, retrying" % i) try: util.pread(cmd_st, expect_rc=1) util.SMlog("_lvmBugCleanup: dm device {}" " removed".format(mapperDevice)) break except: cmd_rm = cmd_rf time.sleep(1) else: # make sure the symlink is still there for consistency if not os.path.lexists(path): os.symlink(mapperPath, path) util.SMlog("_lvmBugCleanup: restored symlink %s" % path) raise e if util.pathexists(mapperPath):
def _create(self, size, path): cmd = [SR.TAPDISK_UTIL, "create", SR.DEFAULT_TAP, size, path] text = util.pread(cmd)
except util.CommandException, inst: raise xs_errors.XenError('LVMMount', \ opterr='Unable to activate LV. Errno is %d' % inst.code) try: util.pread(["fsck", "-a", self.remotepath]) except util.CommandException, inst: if inst.code == 1: util.SMlog( "FSCK detected and corrected FS errors. Not fatal.") else: raise xs_errors.XenError('LVMMount', \ opterr='FSCK failed on %s. Errno is %d' % (self.remotepath,inst.code)) try: util.pread(["mount", self.remotepath, self.path]) except util.CommandException, inst: raise xs_errors.XenError('LVMMount', \ opterr='Failed to mount FS. Errno is %d' % inst.code) self.attached = True #Update SCSIid string scsiutil.add_serial_record(self.session, self.sr_ref, \ scsiutil.devlist_to_serialstring(self.root.split(','))) # Set the block scheduler for dev in self.root.split(','): self.block_setscheduler(dev) def detach(self, sr_uuid):
def _query_v(self, path): cmd = [SR.TAPDISK_UTIL, "query", SR.DEFAULT_TAP, "-v", path] return long(util.pread(cmd)) * 1024 * 1024
def _snap(self, child, parent): cmd = [ SR.TAPDISK_UTIL, "snapshot", vhdutil.VDI_TYPE_VHD, child, parent ] text = util.pread(cmd)
def unmount(self, mountpoint, rmmountpoint): try: util.pread(["umount", mountpoint]) except util.CommandException, inst: raise GlusterFSException("umount failed with return code %d" % inst.code)
util.SMlog("_lvmBugCleanup: seeing dm file %s" % mapperPath) # destroy the dm device if nodeExists: util.SMlog("_lvmBugCleanup: removing dm device %s" % mapperDevice) cmd = [CMD_DMSETUP, "remove", mapperDevice] for i in range(LVM_FAIL_RETRIES): try: util.pread2(cmd) break except util.CommandException, e: if i < LVM_FAIL_RETRIES - 1: util.SMlog("Failed on try %d, retrying" % i) cmd = [CMD_DMSETUP, "status", mapperDevice] try: util.pread(cmd, expect_rc=1) util.SMlog("_lvmBugCleanup: dm device {}" " removed".format(mapperDevice) ) break except: time.sleep(1) else: # make sure the symlink is still there for consistency if not os.path.lexists(path): os.symlink(mapperPath, path) util.SMlog("_lvmBugCleanup: restored symlink %s" % path) raise e if util.pathexists(mapperPath): os.unlink(mapperPath)
def _dualsnap(self, src, dst, newsrc): cmd = [SR.TAPDISK_UTIL, "snapshot", SR.DEFAULT_TAP, src, newsrc] text = util.pread(cmd) cmd = [SR.TAPDISK_UTIL, "snapshot", SR.DEFAULT_TAP, dst, newsrc] text = util.pread(cmd)
def setReadonly(path, readonly): val = "r" if not readonly: val += "w" cmd = [CMD_LVCHANGE, path, "-p", val] ret = util.pread(cmd)
class SMBSR(FileSR.FileSR): """SMB file-based storage repository""" def handles(type): return type == 'smb' handles = staticmethod(handles) def load(self, sr_uuid): self.ops_exclusive = FileSR.OPS_EXCLUSIVE self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid) self.sr_vditype = SR.DEFAULT_TAP self.driver_config = DRIVER_CONFIG if not self.dconf.has_key('server'): raise xs_errors.XenError('ConfigServerMissing') self.remoteserver = self.dconf['server'] if self.sr_ref and self.session is not None : self.sm_config = self.session.xenapi.SR.get_sm_config(self.sr_ref) else: self.sm_config = self.srcmd.params.get('sr_sm_config') or {} self.credentials = None self.mountpoint = os.path.join(SR.MOUNT_BASE, 'SMB', self.__extract_server(), sr_uuid) self.linkpath = os.path.join(self.mountpoint, sr_uuid or "") # Remotepath is the absolute path inside a share that is to be mounted # For a SMB SR, only the root can be mounted. self.remotepath = '' self.path = os.path.join(SR.MOUNT_BASE, sr_uuid) self._check_o_direct() def checkmount(self): return util.ioretry(lambda: ((util.pathexists(self.mountpoint) and \ util.ismount(self.mountpoint)) and \ util.pathexists(self.linkpath))) def mount(self, mountpoint=None): """Mount the remote SMB export at 'mountpoint'""" if mountpoint == None: mountpoint = self.mountpoint elif not util.is_string(mountpoint) or mountpoint == "": raise SMBException("mountpoint not a string object") try: if not util.ioretry(lambda: util.isdir(mountpoint)): util.ioretry(lambda: util.makedirs(mountpoint)) except util.CommandException, inst: raise SMBException("Failed to make directory: code is %d" % inst.code) self.credentials = os.path.join("/tmp", util.gen_uuid()) options = self.getMountOptions() if options: options = ",".join(str(x) for x in options if x) try: util.ioretry(lambda: util.pread(["mount.cifs", self.remoteserver, mountpoint, "-o", options]), errlist=[errno.EPIPE, errno.EIO], maxretry=2, nofail=True) except util.CommandException, inst: raise SMBException("mount failed with return code %d" % inst.code)
def unblockIP(ip): try: cmd = ['iptables', '-D', 'INPUT', '-s', ip, '-j', 'DROP'] util.pread(cmd) except Exception, e: XenCertPrint("There was an exception in unblocking ip: %s. Exception: %s" % (ip, str(e)))
os.makedirs(self.path) except util.CommandException, inst: raise xs_errors.XenError('LVMMount', \ opterr='Unable to activate LV. Errno is %d' % inst.code) try: util.pread(["fsck", "-a", self.remotepath]) except util.CommandException, inst: if inst.code == 1: util.SMlog("FSCK detected and corrected FS errors. Not fatal.") else: raise xs_errors.XenError('LVMMount', \ opterr='FSCK failed on %s. Errno is %d' % (self.remotepath,inst.code)) try: util.pread(["mount", self.remotepath, self.path]) FileSR.FileSR.attach(self, sr_uuid) self.attached = True except util.CommandException, inst: raise xs_errors.XenError('LVMMount', \ opterr='Failed to mount FS. Errno is %d' % inst.code) #Update SCSIid string scsiutil.add_serial_record(self.session, self.sr_ref, \ scsiutil.devlist_to_serialstring(self.root.split(','))) # Set the block scheduler for dev in self.root.split(','): self.block_setscheduler(dev) def detach(self, sr_uuid):
class GlusterFSSR(FileSR.FileSR): """Gluster file-based storage repository""" def handles(sr_type): # fudge, because the parent class (FileSR) checks for smb to alter its behavior return sr_type == 'glusterfs' or sr_type == 'smb' handles = staticmethod(handles) def load(self, sr_uuid): self.ops_exclusive = FileSR.OPS_EXCLUSIVE self.lock = Lock(vhdutil.LOCK_TYPE_SR, self.uuid) self.sr_vditype = SR.DEFAULT_TAP self.driver_config = DRIVER_CONFIG if 'server' not in self.dconf: raise xs_errors.XenError('ConfigServerMissing') self.remoteserver = self.dconf['server'] if self.sr_ref and self.session is not None: self.sm_config = self.session.xenapi.SR.get_sm_config(self.sr_ref) else: self.sm_config = self.srcmd.params.get('sr_sm_config') or {} self.mountpoint = os.path.join(SR.MOUNT_BASE, 'GlusterFS', self.remoteserver.split(':')[0], sr_uuid) self.linkpath = os.path.join(self.mountpoint, sr_uuid or "") self.path = os.path.join(SR.MOUNT_BASE, sr_uuid) self._check_o_direct() def checkmount(self): return util.ioretry( lambda: ((util.pathexists(self.mountpoint) and util.ismount( self.mountpoint)) and util.pathexists(self.linkpath))) def mount(self, mountpoint=None): """Mount the remote gluster export at 'mountpoint'""" if mountpoint is None: mountpoint = self.mountpoint elif not util.is_string(mountpoint) or mountpoint == "": raise GlusterFSException("mountpoint not a string object") try: if not util.ioretry(lambda: util.isdir(mountpoint)): util.ioretry(lambda: util.makedirs(mountpoint)) except util.CommandException, inst: raise GlusterFSException("Failed to make directory: code is %d" % inst.code) try: options = [] if 'backupservers' in self.dconf: options.append('backup-volfile-servers=' + self.dconf['backupservers']) if 'fetchattempts' in self.dconf: options.append('fetch-attempts=' + self.dconf['fetchattempts']) if options: options = ['-o', ','.join(options)] command = [ "mount", '-t', 'glusterfs', self.remoteserver, mountpoint ] + options util.ioretry(lambda: util.pread(command), errlist=[errno.EPIPE, errno.EIO], maxretry=2, nofail=True) except util.CommandException, inst: syslog(_syslog.LOG_ERR, 'GlusterFS mount failed ' + inst.__str__()) raise GlusterFSException("mount failed with return code %d" % inst.code)
def _create(self, size, path): cmd = [SR.TAPDISK_UTIL, "create", vhdutil.VDI_TYPE_VHD, size, path] text = util.pread(cmd) if self.key_hash: vhdutil.setKey(path, self.key_hash)
def rename(path, newName): cmd = [CMD_LVRENAME, path, newName] util.pread(cmd)