def mount(self, device, mountpoint): """ mount a filesystem device: ComDevice.Device mountpoint: ComMountPoint.MountPoint """ __exclusive = self.getAttribute("exlock", "") __mkdir = self.getAttributeBoolean("mkdir", True) __mp = mountpoint.getAttribute("name") if not os.path.exists(__mp) and __mkdir: log.debug("Path %s does not exists. I'll create it." % __mp) ComSystem.execMethod(os.makedirs, __mp) if __exclusive and __exclusive != "" and os.path.exists(__exclusive): raise ComException("lockfile " + __exclusive + " exists!") __cmd = self.mkmountcmd(device, mountpoint) __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) log.debug("mount:" + __cmd + ": " + __ret) if __rc != 0: raise ComException(__cmd + __ret) if __exclusive: __fd = open(__exclusive, 'w') __fd.write(device.getDevicePath() + " is mounted ")
def rescan(self, __hosts, __bus, __target, __lun): """ Rescan SCSI invokes a rescan via /sys/class/scsi_host/hostH/scan interface IDEAS INPUTS * host - name of scsi host ( - for all ) * bus - number of scsi bus (- for all ) * target - number of target ( - for all ) * lun - number of lun ( - for all ) """ __syspath = "/sys/class/scsi_host" if not os.path.isdir( __syspath ): raise ComException(__syspath + " not found") if __hosts == "-": __hosts=self.getAllSCSIHosts() if not ( ComUtils.isInt(__bus) or __bus == "-"): raise ComException( __bus + " is not valid to scan SCSI Bus"); if not ( ComUtils.isInt(__target) or __target == "-"): raise ComException( __bus + " is not valid to scan SCSI Target") if not (ComUtils.isInt(__lun) or __lun == "-"): raise ComException( __bus + " is not valid to scan SCSI Lun") print "Hosts: ", __hosts for __host in __hosts: ComSystem.execLocal( "echo \""+__bus+"\" \""+ __target+"\" \""+ __lun+ "\" > "+__syspath+"/"+__host+"/scan")
def scanOptions(self, device, mountpoint=None): """ Scans a mountded gfs and puts the meta information into the DOM raises ComException """ if mountpoint: __mountpoint = mountpoint.getAttribute("name") else: __mountpoint, fstype = device.scanMountPoint() if not __mountpoint: raise ComException("device " + device.getDevicePath() + " is not mounted.") __cmd = CMD_GFS_TOOL + " getsb " + __mountpoint __rc, __ret = ComSystem.execLocalGetResult(__cmd) if __rc != 0: raise ComException(__cmd + __ret) if __ret[0] == ComSystem.SKIPPED: # Just to keep up working when SIMULATING self.setAttribute("bsize", "4096") self.setAttribute("lockproto", "lock_dlm") self.setAttribute("clustername", "testcluster") self.setAttribute("journals", "4") else: __bsize = ComUtils.grepInLines(__ret, " sb_bsize = ([0-9]*)")[0] log.debug("scan Options bsize: " + __bsize) self.setAttribute("bsize", __bsize) __lockproto = ComUtils.grepInLines(__ret, " sb_lockproto = (.*)")[0] log.debug("scan Options lockproto: " + __lockproto) self.setAttribute("lockproto", __lockproto) __locktable = ComUtils.grepInLines(__ret, " sb_locktable = .*?:(.*)") if len(__locktable) == 1: log.debug("scan Options locktable: " + __locktable[0]) self.setAttribute("locktable", __locktable[0]) __clustername = ComUtils.grepInLines(__ret, " sb_locktable = (.*?):.*") if len(__clustername) == 1: log.debug("scan Options clustername: " + __clustername[0]) self.setAttribute("clustername", __clustername[0]) __cmd = CMD_GFS_TOOL + " df " + __mountpoint __rc, __ret = ComSystem.execLocalGetResult(__cmd) if __rc != 0: raise ComException(__cmd + __ret) __journals = ComUtils.grepInLines(__ret, " Journals = ([0-9]+)")[0] log.debug("scan Options Journals: " + __journals) self.setAttribute("journals", __journals)
def formatDevice(self, device): __devicePath = device.getDevicePath() __cmd = self.getMkfsCmd() + " " + __devicePath __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) log.debug("formatDevice: " + __cmd + ": " + __ret) if __rc != 0: raise ComException(__cmd + __ret)
def copyPartitionTable(source_device, destination_device): __cmd = CMD_SFDISK + " -d " + source_device.getDeviceName() + " | " + CMD_SFDISK \ + " " + destination_device.getDeviceName() __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) log.debug("copyPartitionTable " + __ret) if __rc != 0: raise ComException(__cmd)
def formatDevice(self, device): __cmd = self.getMkfsCmd() + self.getOptionsString( ) + device.getDevicePath() __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) #self.getLog().debug("formatDevice: \n" , __cmd + __ret) if __rc != 0: raise ComException(__cmd + __ret)
def scanBootloaderGrub(self): #scans bootdisk for a possible grub installation #returns (hd0,x) when succeeded import tempfile __tmp = tempfile.NamedTemporaryFile() # This is not working with all devices (e.g. cciss, mpath) # So I removed the part. #__exp=re.compile("[0-9]*") #__dev=__exp.sub("",self.getDeviceName()) __dev = self.getDeviceName() __cmd = """/sbin/grub --batch 2>/dev/null <<EOF | egrep "(hd[0-9]+,[0-9]+)" 1>""" + __tmp.name + """ device (hd0) """ + __dev + """ find /grub/stage2 quit EOF """ # TODO this will not work if ComSystem.execLocal(__cmd, """(hd0,1) """): raise ComException("cannot find grub on " + __dev) __part = __tmp.readline() self.log.debug("Found grub loader on " + __part) return __part
def __init__(self, *params, **kwds): """ Valid constructors are __init__(element, doc) __init__(source, dest) __init__(source=source, dest=dest) """ if (len(params)==2 and isinstance(params[0], CopyObject) and isinstance(params[1], CopyObject)) or \ (kwds and kwds.has_key("source") and kwds.has_key("dest")): source = None dest = None if len(params) == 2: source = params[0] dest = params[1] else: source = kwds["source"] dest = kwds["dest"] doc = xml.dom.getDOMImplementation().createDocument( None, self.TAGNAME, None) element = doc.documentElement element.setAttribute("type", "filesystem") element.appendChild(source.getElement()) element.appendChild(dest.getElement()) Copyset.__init__(self, element, doc) self.source = source self.dest = dest elif len(params) == 2: element = params[0] doc = params[1] Copyset.__init__(self, element, doc) try: __source = element.getElementsByTagName('source')[0] self.source = CopyObject(__source, doc) except Exception, e: ComLog.getLogger(__logStrLevel__).warning(e) ComLog.debugTraceLog(ComLog.getLogger(__logStrLevel__)) raise ComException( "Source for filesystem copyset with name \"%s\" is not defined" % (self.getAttribute("name", "unknown"))) try: __dest = element.getElementsByTagName('destination')[0] self.dest = CopyObject(__dest, doc) except Exception, e: ComLog.getLogger(__logStrLevel__).warning(e) raise ComException( "Destination for filesystem copyset with name \"%s\" is not defined" % (self.getAttribute("name", "unknown")))
def labelDevice(self, device, label): __devicePath = device.getDevicePath() __cmd = self.labelCmd + " " + __devicePath + " " + label __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) log.debug("labelDevice: " + __cmd + ": " + __ret) if __rc: raise ComException(__cmd + __ret) self.setAttribute("label", label)
def removeFlag(self, name): try: from comoonics import XmlTools node = XmlTools.evaluateXPath('flag/@name=' + name, self.element)[0] self.element.removeChild(node) except Exception: raise ComException("no flag with name %s found" % name)
def getDataArchive(self): ''' returns data archive object''' import comoonics.XmlTools try: __archive = comoonics.XmlTools.evaluateXPath( 'data/archive', self.element)[0] return Archive(__archive, self.document) except Exception: raise ComException("no data archiv description found")
def __init__(self, element, doc): Copyset.__init__(self, element, doc) try: _dest = element.getElementsByTagName("destination")[0] __dest = element.getElementsByTagName("disk")[0] self.destination = BootDisk(__dest, doc) except Exception: raise ComException("destination for copyset not defined")
def getLabelFromDevice(self, device): # BUG: Cannot function!!!! __devicePath = device.getDevicePath() __cmd = self.labelCmd + " " + __devicePath __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) log.debug("getLabel: " + __cmd + ": " + __ret) if __rc: raise ComException(__cmd + __ret) return __ret
def __init__(self, element, doc): ModificationsetJournaled.__init__(self, element, doc) try: __disk=element.getElementsByTagName('disk')[0] self.disk=HostDisk(__disk, doc) except Exception: raise ComException("disk for modificationset not defined") self.addToUndoMap(self.disk.__class__.__name__, "savePartitionTable", "restorePartitionTable") self.addToUndoMap(self.disk.__class__.__name__, "noPartitionTable", "deletePartitionTable")
def findLabel(self, label): """ try to find Device with label returns Device """ import ComDevice __cmd = "/sbin/findfs LABEL=" + label __rc, __path = ComSystem.execLocalGetResult(__cmd) if not __rc: raise ComException("device with label " + label + "not found") return ComDevice.Device(__path[0])
def doPost(self): super(ISOFSModificationset, self).doPost() self.replayJournal() self.commitJournal() ISOFSModificationset.logger.debug("doPost() CWD: " + os.getcwd()) __cmd = self._get_mkisofs_command() __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) ISOFSModificationset.logger.debug("mkisofs: " + __cmd + ": " + __ret) if __rc != 0: raise ComException(__cmd + __ret)
def umountDir(self, mountpoint): """ umount a filesystem with the use of the mountpoint mountpoint: ComMountPoint.MountPoint """ __cmd = self.cmd_umount + " " + mountpoint.getAttribute("name") __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) log.debug("umount: " + __cmd + ": " + __ret) if __rc != 0: raise ComException(__cmd + __ret) self.unlinkLockfile()
def umountDev(self, device): """ umount a filesystem with the use of the device name device: ComDevice.Device """ __cmd = self.cmd_umount + " " + device.getDevicePath() __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) log.debug("umount:" + __cmd + ": " + __ret) if __rc != 0: raise ComException(__cmd + __ret) self.unlinkLockfile()
def createPartitionsParted(self): import parted import ComParted if not self.exists(): raise ComException("Device %s not found" % self.getDeviceName()) phelper=ComParted.PartedHelper() #IDEA compare the partition configurations for update #1. delete all aprtitions dev=parted.PedDevice.get(self.getDeviceName()) try: disk=parted.PedDisk.new(dev) disk.delete_all() except parted.error: #FIXME use generic disk types disk=dev.disk_new_fresh(parted.disk_type_get("msdos")) # create new partitions for com_part in self.getAllPartitions(): type=com_part.getPartedType() if self.sameSize(): size=com_part.getPartedSize(dev) else: size=com_part.getPartedSizeOptimum(dev) flags=com_part.getPartedFlags() self.log.debug("creating partition: size: %i" % size ) phelper.add_partition(disk, type, size, flags) disk.commit() self.commit() #dev.sync() #dev.close() # run partx if the device is a multipath device self.log.debug("ComHostDisk: checking for multipath devices") if self.isDMMultipath(): self.log.debug("Device %s is a dm_multipath device, adding partitions" %self.getDeviceName()) __cmd=CMD_KPARTX + " -d " + self.getDeviceName() try: __ret = ComSystem.execLocalOutput(__cmd, True, "") self.log.debug(__ret) __cmd=CMD_KPARTX + " -a " + self.getDeviceName() __ret = ComSystem.execLocalOutput(__cmd, True, "") self.log.debug(__ret) #FIXME: crappy fix to give os some time to create devicefiles. time.sleep(10) except ComSystem.ExecLocalException, ele: ComLog.debugTraceLog(self.log) self.log.debug("Could not execute %s. Error %s" %(ele.cmd, ele))
def __init__(self, element, doc): """ default constructor: __init__(element, doc) """ super(PathModificationset, self).__init__(element, doc) try: __path = element.getElementsByTagName('path')[0] except Exception: raise ComException("Path for modificationset \"%s\" not defined" % self.getAttribute("name", "unknown")) self.path = Path(__path, doc) self.createModificationsList( self.path.getElement().getElementsByTagName("modification"), doc) self.addToUndoMap(self.path.__class__.__name__, "pushd", "popd")
def __init__(self, element, doc): """ default constructor: __init__(element, doc) """ super(ISOFSModificationset, self).__init__(element, doc) try: __path = element.getElementsByTagName('path') except Exception: raise ComException("Path for modificationset \"%s\" not defined" % self.getAttribute("name", "unknown")) self.pathlist = __path self.createModificationsList( self.getElement().getElementsByTagName("modification"), doc) self.isoname = self.getAttribute("name")
def initFromDisk(self): """ reads partition information from the disk and fills up DOM with new information """ HostDisk.log.debug("initFromDisk()") #FIXME: create LabelResolver if self.refByLabel(): pass if not self.exists(): raise ComException("Device %s not found or no valid device!" % self.getDeviceName()) try: self.initFromDiskParted() except ImportError: self.initFromDiskPartedCmd()
def __init__(self, element, doc): CopyObjectJournaled.__init__(self, element, doc) try: __disk = element.getElementsByTagName('disk')[0] self.disk = HostDisk(__disk, doc) except Exception: raise ComException("disk for copyset not defined") self.addToUndoMap(self.disk.__class__.__name__, "savePartitionTable", "restorePartitionTable") self.addToUndoMap(self.disk.__class__.__name__, "noPartitionTable", "deletePartitionTable") # We need to have the tempfile globlally available because of it deleteing itself when not # referenced anymore. import tempfile self.__tmp = tempfile.NamedTemporaryFile()
def getPartedSize(self, dev): """ returns always size in sectors """ size = self.getAttribute("size") # calculate new size # FIXME Round up to next cylinder # Test Megabyte e.g. size="200M" res = re.search("([0-9]+)M", size) if res: sectors = int(res.group(1)) * 1024 * 1024 / dev.sector_size ComLog.getLogger(self.__logStrLevel__). \ debug("found size in Megabytes : %s -> %s sectors" % (res.group(1), sectors)) return sectors # Test Gigabyte e.g. size="200G" res = re.search("([0-9]+)G", size) if res: sectors = int(res.group(1)) * 1024 * 1024 * 1024 / dev.sector_size ComLog.getLogger(self.__logStrLevel__). \ debug("found size in Gigabytes : %s -> %s sectors" %(res.group(1), sectors)) return sectors # Test Percentage res = re.search("([0-9]+)%", size) if res: sectors = int( float( float(res.group(1)) / 100 * dev.heads * dev.cylinders * dev.sectors)) ComLog.getLogger(self.__logStrLevel__). \ debug("found size in %% : %s -> %s sectors" %( res.group(1), sectors)) return sectors # Test REMAIN res = re.search("REMAIN", size) if res: ComLog.getLogger( self.__logStrLevel__).debug("found size in Tag :REMAIN") return 0 # Test sectors res = re.search("[0-9]+", size) if res: ComLog.getLogger(self.__logStrLevel__).debug( "found size in Tag :%s " % size) return int(size) raise ComException("size %s not supported" % size)
def getMountList(self): if not os.path.isfile("/proc/mounts"): raise ComException("/proc/mounts not found.") if sys.version[:3] < "2.5": [i, o] = os.popen2("cat /proc/mounts") else: import subprocess p = subprocess.Popen(["cat /proc/mounts"], shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True) p.wait() i = p.returncode o = p.stdout return o.readlines()
def installBootloaderGrub(self): # To DO # Add some checks if grub install was successfull. __part = self.scanBootloaderGrub() # This is not working with all devices (e.g. cciss, mpath) # So I removed the part. #__exp=re.compile("[0-9]*") #__dev=__exp.sub("",self.getDeviceName()) __dev = self.getDeviceName() __cmd = """grub --batch 2>/dev/null <<EOF | grep "succeeded" > /dev/null device (hd0) """ + __dev + """ root """ + __part + """ setup (hd0) quit EOF """ if ComSystem.execLocal(__cmd): raise ComException("cannot install grub on " + __dev)
def __init__(self, *params, **kwds): """ Supported constructors __init__(element, doc) __init__(path, source=True|False) __init__(path=path, source=True, dest=True) """ PathCopyObject.logger.debug("__init__()") if (len(params) == 2 and not isinstance(params[0], xml.dom.Node)) or ( kwds and kwds.has_key("path") and (kwds.has_key("source") or kwds.has_key("dest"))): _path = None _source = (len(params) == 2 and params[1] == True) or ( kwds and kwds.has_key("source") and kwds["source"] == True) if len(params) >= 1: _path = params[0] else: _path = kwds["path"] _tagname = "destination" if _source: _tagname = "source" doc = xml.dom.getDOMImplementation().createDocument( None, _tagname, None) element = doc.documentElement element.setAttribute("type", "path") if isinstance(_path, basestring): _path = Path(_path) element.appendChild(_path.getElement()) self.path = _path CopyObjectJournaled.__init__(self, element, doc) else: element = params[0] doc = params[1] CopyObjectJournaled.__init__(self, element, doc) try: __path = element.getElementsByTagName('path')[0] self.path = Path(__path, doc) except Exception: raise ComException("Path for copyobject \"%s\" not defined" % self.getAttribute("name", "unknown")) PathCopyObject.logger.debug("__init__(%s)" % self.path) self.addToUndoMap(self.path.__class__.__name__, "pushd", "popd")
def doRealModifications(self): import xml.dom import StringIO if self.hasAttribute("command"): __cmd=self.getAttribute("command") else: buf=StringIO.StringIO() element=self.getElement() child=element.firstChild while child != None: if child.nodeType==xml.dom.Node.TEXT_NODE: buf.write(child.data) child=child.nextSibling __cmd=buf.getvalue() __rc, __ret, __err = ComSystem.execLocalGetResult(__cmd, True) if __rc: raise ComException(__cmd + ": out:" + " ".join(__ret) + \ " err: " + " ".join(__err)) else: ComLog.getLogger("ExecutionModification").debug(__cmd + ": return:" + " ".join(__ret) + \ " err: " + " ".join(__err))
# return False # 3. copy archive to fs elif isinstance(self.source, ArchiveCopyObject): if isinstance(self.dest, FilesystemCopyObject) or isinstance( self.dest, PathCopyObject): if self.dest.filesystem.copyable: return True # try: archive = self.source.getDataArchive() mountpoint = self.dest.getMountpoint().getAttribute("name") archive.extractArchive(mountpoint) return True # except Exception, e: # ComLog.getLogger(__logStrLevel__).error(e) # return False raise ComException("data copy %s to %s is not supported" \ %( self.source.__class__.__name__, self.dest.__class__.__name__)) # $Log: ComFilesystemCopyset.py,v $ # Revision 1.19 2011-02-21 16:23:53 marc # - implemented functionality that a filesystem would be queried if it allows copying or not (e.g. swap does not) # # Revision 1.18 2011/02/17 13:14:04 marc # added support for labeled filesystems # # Revision 1.17 2010/03/08 12:30:48 marc # version for comoonics4.6-rc1 # # Revision 1.16 2010/02/09 21:48:24 mark # added .storage path in includes #
def getAllSCSIHosts(self): try: return os.listdir("/sys/class/scsi_host") except Exception: #return ["host0", "host1"] raise ComException("/sys/class/scsi_host not available")