def __new__(cls, *args, **kwds): if len(args) > 0 and isinstance(args[0], Node): __type = args[0].getAttribute("type") #print "getCopyObject(%s)" %(element.tagName) if __type == "disk": from ComPartitionCopyObject import PartitionCopyObject cls = PartitionCopyObject elif __type == "filesystem": from ComFilesystemCopyObject import FilesystemCopyObject cls = FilesystemCopyObject elif __type == "lvm": from ComLVMCopyObject import LVMCopyObject cls = LVMCopyObject elif __type == "backup": from ComArchiveCopyObject import ArchiveCopyObject cls = ArchiveCopyObject elif _copyobject_registry.has_key(__type): cls = _copyobject_registry[__type] #from ComPathCopyObject import PathCopyObject #cls=PathCopyObject else: raise UnsupportedCopyObjectException( "Unsupported CopyObject type %s in element %s" % (__type, args[0].tagName)) ComLog.getLogger(CopyObject.__logStrLevel__).debug( "Returning new object %s" % (cls)) return object.__new__(cls, args, kwds) else: return object.__new__(cls, args, kwds)
def __new__(cls, *args, **kwds): if len (args) > 0 and isinstance(args[0], Node): __type=args[0].getAttribute("type") #print "getCopyObject(%s)" %(element.tagName) if __type == "disk": from ComPartitionCopyObject import PartitionCopyObject cls=PartitionCopyObject elif __type == "filesystem": from ComFilesystemCopyObject import FilesystemCopyObject cls=FilesystemCopyObject elif __type == "lvm": from ComLVMCopyObject import LVMCopyObject cls=LVMCopyObject elif __type == "backup": from ComArchiveCopyObject import ArchiveCopyObject cls=ArchiveCopyObject elif _copyobject_registry.has_key(__type): cls=_copyobject_registry[__type] #from ComPathCopyObject import PathCopyObject #cls=PathCopyObject else: raise UnsupportedCopyObjectException("Unsupported CopyObject type %s in element %s" % (__type, args[0].tagName)) ComLog.getLogger(CopyObject.__logStrLevel__).debug("Returning new object %s" %(cls)) return object.__new__(cls, args, kwds) else: return object.__new__(cls, args, kwds)
def updateMetaData(self, element): ComLog.getLogger(self.__logStrLevel__).debug("%u logical volumes cloning all from source" %(len(self.getVolumeGroup().getLogicalVolumes()))) #ComLog.getLogger(self.__logStrLevel__).debug("Element to copy %s" %(element)) if (len(self.getVolumeGroup().getLogicalVolumes()) == 0): #ComLog.getLogger(self.__logStrLevel__).debug("0 logical volumes cloning all from source") XmlTools.merge_trees_with_pk(element, self.getVolumeGroup().getElement(), self.document, "name", XmlTools.ElementFilter("logicalvolume")) self.vg=VolumeGroup(self.getVolumeGroup().getElement(), self.getDocument())
def getCommands(self, what): names = self.get_names() cmds = {} prevname = '' for name in names: if name[:len(what)] == what: if name == prevname: continue prevname = name under1=len(what)+name[len(what):].find("_")+1 # under2=-1 # if under1>0: # under2=under1+name[under1:].find("_")+1 ComLog.getLogger().debug("do_help(name %s, what %s, under1 %u/%s" %(name, what, under1, name[:under1])) if under1==len(what): cmds[name[len(what):]]=1 elif under1>0 and not hasattr(self, name[:under1-1]): cmds[name[len(what):]]=1 #elif not hasattr(self, "%s_%s" %(name[:name(+len # cmds[name[len(what):]]=1 # self.stdout.write("%s\n"%str(self.doc_leader)) self.stdout.write("%s" %(self.doc_header)) # ComLog.getLogger().debug("do_help(cmds: %s" %(cmds)) cmds_keys=cmds.keys() cmds_keys.sort() return cmds_keys
def doPre(self): """ Unpacks the given file to dest """ srcfile=self.getAttribute("name") destfile=self.getAttribute("dest") __mkdir=self.getAttributeBoolean("mkdir", default=True) if not ComSystem.execMethod(os.path.exists, destfile) and __mkdir: ComLog.getLogger(ArchiveRequirement.__logStrLevel__).debug("Path %s does not exists. I'll create it." % destfile) os.makedirs(destfile) if self.check() and not ComSystem.isSimulate(): if not os.access(srcfile, os.R_OK) or not os.access(destfile, os.F_OK) or not os.access(destfile, os.W_OK): raise ArchiveRequirementException("Either srcfile %s is not readable or dest %s is not writeable" % (srcfile, destfile)) __cmd="rm -rf %s/*" % destfile (rc, rv) = ComSystem.execLocalGetResult(__cmd) if rc >> 8 != 0: raise RuntimeError("running \"%s\" failed: %u, %s" % (__cmd, rc,rv)) self.olddir=os.curdir ComSystem.execMethod(os.chdir, destfile) __cmd="gzip -cd %s | cpio -i" % srcfile (rc, rv, stderr) = ComSystem.execLocalGetResult(__cmd, True) if rc >> 8 != 0: raise RuntimeError("running \"%s\" failed: %u, %s, %s" % (__cmd, rc,rv, stderr))
def create(self): """ Newly creates the logical volume """ LinuxVolumeManager.has_lvm() size="" if self.ondisk and self.getAttribute("overwrite", "false") == "true": self.remove() try: self.init_from_disk() except: pass if self.ondisk: raise LinuxVolumeManager.LVMAlreadyExistsException(self.__class__.__name__+"("+str(self.getAttribute("name"))+")") try: size=self.getAttribute("size") if int(self.getAttribute("size")) > int(self.parentvg.getAttribute("free")): ComLog.getLogger(self.__logStrLevel__).warn("Requested LV size %s is too big taking free %s" % (self.getAttribute("size"), self.parentvg.getAttribute("free"))) self.setAttribute("size", self.parentvg.getAttribute("free")) size=self.getAttribute("size") except NameError: if ComSystem.isSimulate(): size="1000" else: size=self.parentvg.getAttribute("free") LinuxVolumeManager.lvm('lvcreate', '-L %sM' %size, '-n %s' %str(self.getAttribute("name")), '%s' %str(self.parentvg.getAttribute("name"))) self.init_from_disk() if ComSystem.isSimulate(): self.ondisk=True
def do_help(self, arg): ComLog.getLogger().debug("do_help(%s)" %(arg)) arg=arg.strip() arg=arg.replace(" ", "_") if arg == '?' or arg == "help": cmds_keys=self.getCommands("do_") self.print_topics("", cmds_keys, 15, 6) #self.print_topics(self.undoc_header, cmds_undoc, 15,80) elif arg: # XXX check arg syntax try: func = getattr(self, 'help_' + arg) except AttributeError: cmds_keys=self.getCommands("do_%s_" %(arg)) if cmds_keys: ComLog.getLogger().debug("do_help(%s, %s)" %(arg, cmds_keys)) self.print_topics("", cmds_keys, 15, 6) else: try: doc=getattr(self, 'do_' + arg).__doc__ if doc: self.stdout.write("%s"%str(doc)) return except AttributeError: pass # self.stdout.write("%s\n"%str(self.nohelp % (arg))) return func() else: self.stdout.write(HP_EVA_SSSU_Sim.DEFAULT_HELP)
def doPost(self): """ Does something afterwards """ srcfile = self.getAttribute("name") destfile = self.getAttribute("dest") if self.check() and not ComSystem.isSimulate(): if not os.access(srcfile, os.R_OK) or not os.access( destfile, os.F_OK) or not os.access(destfile, os.W_OK): raise ArchiveRequirementException( "Either srcfile %s is not readable or dest %s is not writeable" % (srcfile, destfile)) ComSystem.execMethod(os.chdir, destfile) __cmd = "cp %s %s" % (srcfile, srcfile + self.getAttribute("bak_suffix", ".bak")) try: (rc, rv, stderr) = ComSystem.execLocalGetResult(__cmd, True) if rc >> 8 != 0: raise RuntimeError( "running \"%s\" failed: %u, %s, errors: %s" % (__cmd, rc, rv, stderr)) except RuntimeError, re: ComLog.getLogger(ArchiveRequirement.__logStrLevel__).warn( "Cannot backup sourcefile %s=%s, %s." % (srcfile, srcfile + ".bak", re))
def do_help(self, arg): ComLog.getLogger().debug("do_help(%s)" % (arg)) arg = arg.strip() arg = arg.replace(" ", "_") if arg == '?' or arg == "help": cmds_keys = self.getCommands("do_") self.print_topics("", cmds_keys, 15, 6) #self.print_topics(self.undoc_header, cmds_undoc, 15,80) elif arg: # XXX check arg syntax try: func = getattr(self, 'help_' + arg) except AttributeError: cmds_keys = self.getCommands("do_%s_" % (arg)) if cmds_keys: ComLog.getLogger().debug("do_help(%s, %s)" % (arg, cmds_keys)) self.print_topics("", cmds_keys, 15, 6) else: try: doc = getattr(self, 'do_' + arg).__doc__ if doc: self.stdout.write("%s" % str(doc)) return except AttributeError: pass # self.stdout.write("%s\n"%str(self.nohelp % (arg))) return func() else: self.stdout.write(HP_EVA_SSSU_Sim.DEFAULT_HELP)
def getCommands(self, what): names = self.get_names() cmds = {} prevname = '' for name in names: if name[:len(what)] == what: if name == prevname: continue prevname = name under1 = len(what) + name[len(what):].find("_") + 1 # under2=-1 # if under1>0: # under2=under1+name[under1:].find("_")+1 ComLog.getLogger().debug( "do_help(name %s, what %s, under1 %u/%s" % (name, what, under1, name[:under1])) if under1 == len(what): cmds[name[len(what):]] = 1 elif under1 > 0 and not hasattr(self, name[:under1 - 1]): cmds[name[len(what):]] = 1 #elif not hasattr(self, "%s_%s" %(name[:name(+len # cmds[name[len(what):]]=1 # self.stdout.write("%s\n"%str(self.doc_leader)) self.stdout.write("%s" % (self.doc_header)) # ComLog.getLogger().debug("do_help(cmds: %s" %(cmds)) cmds_keys = cmds.keys() cmds_keys.sort() return cmds_keys
def doPre(self): """ Unpacks the given file to dest """ srcfile = self.getAttribute("name") destfile = self.getAttribute("dest") __mkdir = self.getAttributeBoolean("mkdir", default=True) if not ComSystem.execMethod(os.path.exists, destfile) and __mkdir: ComLog.getLogger(ArchiveRequirement.__logStrLevel__).debug( "Path %s does not exists. I'll create it." % destfile) os.makedirs(destfile) if self.check() and not ComSystem.isSimulate(): if not os.access(srcfile, os.R_OK) or not os.access( destfile, os.F_OK) or not os.access(destfile, os.W_OK): raise ArchiveRequirementException( "Either srcfile %s is not readable or dest %s is not writeable" % (srcfile, destfile)) __cmd = "rm -rf %s/*" % destfile (rc, rv) = ComSystem.execLocalGetResult(__cmd) if rc >> 8 != 0: raise RuntimeError("running \"%s\" failed: %u, %s" % (__cmd, rc, rv)) self.olddir = os.curdir ComSystem.execMethod(os.chdir, destfile) __cmd = "gzip -cd %s | cpio -i" % srcfile (rc, rv, stderr) = ComSystem.execLocalGetResult(__cmd, True) if rc >> 8 != 0: raise RuntimeError("running \"%s\" failed: %u, %s, %s" % (__cmd, rc, rv, stderr))
def testlogger(self): import logging import inspect import os.path from comoonics import ComLog _mylogger=logging.getLogger("comoonics.ComLog") logging.basicConfig() _mylogger.setLevel(logging.DEBUG) #from comoonics.db.ComDBLogger import DBLogger #registerHandler("DBLogger", DBLogger) _filenames=("loggingconfig.ini") ComLog.getLogger().info("Testing ComLog:") loggers={"test1": logging.DEBUG, "test2": logging.INFO, "test3": logging.WARNING} for loggername in loggers.keys(): print "%s level: %s" %(loggername, logging.getLevelName(loggers[loggername])) ComLog.setLevel(loggers[loggername], loggername) self.__testLogger(loggername, ComLog.getLogger(loggername)) print("mylogger without level") self.__testLogger("mylogger", ComLog.getLogger("mylogger")) cp=None print("ComLog._classregistry: %s" %ComLog._classregistry) for _filename in _filenames: logging.shutdown() print("Testing configfile %s/%s cwd: %s" %(os.path.dirname(inspect.getfile(self.__class__)), _filename, os.path.curdir)) ComLog.fileConfig(os.path.join(os.path.dirname(inspect.getfile(self.__class__)), _filename), None, ) rootlogger=ComLog.getLogger() self.__testLogger("root", rootlogger) print("handlernames: %s" %rootlogger.manager.loggerDict.keys()) for _lname in [ "atix", "atix", "atix.atix1" ]: self.__testLogger(_lname, logging.getLogger(_lname)) self.__testLogger(_lname+".test", logging.getLogger(_lname+".test"))
def getCopyObject(element, doc): """ Factory function to create Copyset Objects""" if isinstance(element, Node): __type=element.getAttribute("type") #print "getCopyObject(%s)" %(element.tagName) if __type == "disk": from ComPartitionCopyObject import PartitionCopyObject cls=PartitionCopyObject elif __type == "filesystem": from ComFilesystemCopyObject import FilesystemCopyObject cls=FilesystemCopyObject elif __type == "lvm": from ComLVMCopyObject import LVMCopyObject cls=LVMCopyObject elif __type == "backup": from ComArchiveCopyObject import ArchiveCopyObject cls=ArchiveCopyObject elif _copyobject_registry.has_key(__type): cls=_copyobject_registry[__type] #from ComPathCopyObject import PathCopyObject #cls=PathCopyObject else: raise UnsupportedCopyObjectException("Unsupported CopyObject type %s in element %s" % (__type, element.tagName)) ComLog.getLogger(CopyObject.__logStrLevel__).debug("Returning new object %s" %(cls)) return cls(element, doc) else: raise UnsupportedCopyObjectException("Wrong parameters passed to factory method getCopyObject. Expected element, doc.")
def serialize(self, element): from comoonics.storage.ComArchive import Archive earchive=self.getElement().getElementsByTagName("archive")[0] archive=Archive(earchive, self.getDocument()) # print "Created archive: %s" %(archive) ComLog.getLogger(self.__logStrLevel__).debug("Saving element %s to archive" %(element)) archive.addNextDOMElement(element) ComLog.getLogger(self.__logStrLevel__).debug("Saved element %s to archive element" %(element.tagName))
def selection_changed(self, selection, dest, filter): (model, iter) = selection.get_selected() ComLog.getLogger(__logStrLevel__).debug("Selection changed %s, %s, %s %s" % (model, iter, dest, filter)) dest.clear() if iter: dest.createStoreModelFromNode(model.get_value(iter, DOMModel.COLUMN_NODE).get_data(DOMModel.NODE_KEY)) if filter: filter.refilter()
def delete_attribute(self, item, model, iter, name): self.status("Menu Delete attribute... " + name + " pressed menuitem %s, model %s, iter %s" % (item, model, iter)) value = model.get_value(iter, DOMModel.COLUMN_NODE) ref_node=value.get_data(DOMModel.NODE_KEY) ref_node.removeAttribute(name) ComLog.getLogger(__logStrLevel__).debug("ref_node: %s" % ref_node) self.__basemodelr.clear() self.__basemodelr.createStoreModelFromNode(ref_node)
def parseClusterConfFP(_clusterconffp, _clusterconf, _validate=False): from comoonics import ComLog from comoonics import XmlTools try: doc = XmlTools.parseXMLFP(_clusterconffp) except Exception, arg: ComLog.getLogger().critical("Problem while reading clusterconfiguration (%s): %s" %(_clusterconf, str(arg))) raise
def createAssistantHelper(classname, query): from ComClusterAssistantHelper import RedHatClusterAssistantHelper from ComStorageAssistantHelper import StorageAssistantHelper if classname: try: return eval(classname)(query) except Exception: ComLog.getLogger(__logStrLevel__).warning("Assitanthelper %s coud not be initialized" %classname)
def __init__(self, element, doc): CopysetJournaled.__init__(self, element, doc) try: __source = element.getElementsByTagName('source')[0] self.source = CopyObject(__source, doc) #except Exception, e: except Exception, e: ComLog.getLogger(__logStrLevel__).warning(e) raise ComException("source for copyset not defined")
def getRootPartition(self): _dev = self._scanRootDevice() ComLog.getLogger(__logStrLevel__).debug("detected rootdevice %s" %_dev) if not _dev: return _pv = self._getLVM_physicalVolume(_dev) if _pv: return [ self._normalizeDisk(_pv)[1] ] return [ self._normalizeDisk(_dev) [1] ]
def __init__(self, element, doc): CopysetJournaled.__init__(self, element, doc) try: __source = element.getElementsByTagName("source")[0] self.source = CopyObject(__source, doc) # except Exception, e: except Exception, e: ComLog.getLogger(__logStrLevel__).warning(e) raise ComException("source for copyset not defined")
def resolve(self): # print "ArchiveMetadata.resolve" from comoonics.storage.ComArchive import Archive earchive=self.getElement().getElementsByTagName("archive")[0] archive=Archive(earchive, self.getDocument()) # print "Created archive: %s" %(archive) element=archive.getNextDOMElement() ComLog.getLogger(self.__logStrLevel__).debug("Found element %s" %(element.tagName)) return element
def dtd_changed(self, filedialog, chooser): ComLog.getLogger(__logStrLevel__).debug("dtd changed pressed %s, %s." %(filedialog, chooser)) try: self.newFromDTDFile(filedialog.get_filename()) chooser.get_model().clear() for element_txt in self.dtd.get_elements(): chooser.append_text(element_txt) except: pass
def saveFile(self, _uri=None): if not _uri: _uri=self.filename ComLog.getLogger(__logStrLevel__).debug("file: %s" % _uri) stream=open(_uri,"w+") PrettyPrint(self.__basemodell.document, stream) self.filename=_uri self.status("save to file %s succeeded" % _uri) self.updateTitle(sefl.filename)
def getMetadataSerializer(element, doc): if isinstance(element, Node): archives = element.getElementsByTagName("archive") if len(archives) > 0: ComLog.getLogger(MetadataSerializer.__logStrLevel__).debug("Returning new object ArchiveMetadataSerializer") return ArchiveMetadataSerializer(element, doc) else: raise UnsupportedMetadataException("Unsupported Metadata type in element " % (element.tagName)) else: raise UnsupportedMetadataException("Unsupported Metadata type because no domelement given (%s)" % (element))
def undoModifications(self): """undos all modifications """ ComLog.getLogger(Modificationset.__logStrLevel__).debug("Modifications: %s" % self.modifications) self.modifications.reverse() for mod in self.modifications: try: mod.undoRequirements() mod.undoModification() except NotImplementedError, e: log.warning(e)
def parseClusterConfFP(_clusterconffp, _clusterconf, _validate=False): from comoonics import ComLog from comoonics import XmlTools try: doc = XmlTools.parseXMLFP(_clusterconffp) except Exception, arg: ComLog.getLogger().critical( "Problem while reading clusterconfiguration (%s): %s" % (_clusterconf, str(arg))) raise
def setPathElement(self, element): __parent=self.path.getElement().parentNode __newnode=element.cloneNode(True) __oldnode=self.path.getElement() self.path.setElement(__newnode) # only replace attributes try: __parent.replaceChild(__newnode, __oldnode) except Exception, e: ComLog.getLogger(PathCopyObject.__logStrLevel__).warning(e)
def getRootPartition(self): _dev = self._scanRootDevice() ComLog.getLogger(__logStrLevel__).debug("detected rootdevice %s" % _dev) if not _dev: return _pv = self._getLVM_physicalVolume(_dev) if _pv: return [self._normalizeDisk(_pv)[1]] return [self._normalizeDisk(_dev)[1]]
def getValidElementNamesAppend(self, element): ComLog.getLogger(__logStrLevel__).debug("in getValidElementNamesAppend") __elem=self.dtd.get_elem(element.tagName) __state=__elem.get_start_state() __nodes=element.childNodes for i in range(len(__nodes)): if __nodes[i].nodeType != __nodes[i].ELEMENT_NODE: continue ComLog.getLogger(__logStrLevel__).debug("found element %s" %__nodes[i].tagName) __state=__elem.next_state(__state, __nodes[i].tagName) return __elem.get_valid_elements(__state)
def undoModifications(self): """undos all modifications """ ComLog.getLogger(Modificationset.__logStrLevel__).debug( "Modifications: %s" % self.modifications) self.modifications.reverse() for mod in self.modifications: try: mod.undoRequirements() mod.undoModification() except NotImplementedError, e: log.warning(e)
def _getLVM_physicalVolume(self, device): from comoonics.storage.ComLVM import LogicalVolume, LinuxVolumeManager, VolumeGroup try: (vgname, lvname)=LogicalVolume.splitLVPath(device) _vg=VolumeGroup(vgname) _pv=LinuxVolumeManager.pvlist(_vg) ComLog.getLogger(__logStrLevel__).debug("detected physical volume %s" %_pv) return _pv[0].getAttribute("name") except LogicalVolume.LVMInvalidLVPathException, e: ComLog.errorTraceLog() return
def delete_element(self, item, model, iter): self.status("Menu Delete Element... pressed menuitem %s, model %s" % (item, model)) value = model.get_value(iter, DOMModel.COLUMN_NODE) ref_node=value.get_data(DOMModel.NODE_KEY) piter=model.iter_parent(iter) value=model.get_value(piter, DOMModel.COLUMN_NODE) parent_node=value.get_data(DOMModel.NODE_KEY) ComLog.getLogger(__logStrLevel__).debug("parentnode: %s" % parent_node) parent_node.removeChild(ref_node) citer=model.convert_iter_to_child_iter(iter) model.get_model().remove(citer)
def __new__(cls, *args, **kwds): if len (args) > 0 and isinstance(args[0], Node): archives=args[0].getElementsByTagName("archive") if len(archives) > 0: cls=ArchiveMetadataSerializer ComLog.getLogger(MetadataSerializer.__logStrLevel__).debug("Returning new object %s" %(cls)) return object.__new__(cls, *args, **kwds) else: raise UnsupportedMetadataException("Unsupported Metadata type in element " % (args[0].tagName)) else: raise UnsupportedMetadataException("Unsupported Metadata type because no domelement given (%u)" %(len(args)))
def _getLVM_physicalVolume(self, device): from comoonics.storage.ComLVM import LogicalVolume, LinuxVolumeManager, VolumeGroup try: (vgname, lvname) = LogicalVolume.splitLVPath(device) _vg = VolumeGroup(vgname) _pv = LinuxVolumeManager.pvlist(_vg) ComLog.getLogger(__logStrLevel__).debug( "detected physical volume %s" % _pv) return _pv[0].getAttribute("name") except LogicalVolume.LVMInvalidLVPathException, e: ComLog.errorTraceLog() return
def doModifications(self, file): # TODO create bckup of file ? # TODO raise Warning Exception cmd = "cp -a " cmd += file.getAttribute("sourcefile") cmd += " " cmd += file.getAttribute("name") rc, ret = ComSystem.execLocalStatusOutput(cmd) if rc: ComLog.getLogger("CopyModification").error("doCopy: " + cmd + " " + ret) else: ComLog.getLogger("CopyModification").debug("doCopy: " + cmd +" "+ ret)
def doModifications(self, _file): # TODO create bckup of file ? # TODO raise Warning Exception __cmd = "mv -f " __cmd += _file.getAttribute("sourcefile") __cmd += " " __cmd += _file.getAttribute("name") __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) if __rc: ComLog.getLogger("MoveModification").error("doMove: " + __cmd + " " + __ret) else: ComLog.getLogger("MoveModification").debug("doMove: " + __cmd +" "+ __ret)
def __init__(self, query): from comoonics.cluster import getClusterRepository, getClusterInfo, clusterconf ClusterAssistantHelper.__init__(self, query) self.error=False # create Reader object try: clusterRepository = getClusterRepository(clusterconf) #create comclusterinfo object self.clusterInfo = getClusterInfo(clusterRepository) except Exception, e: ComLog.getLogger(__logStrLevel__).error("Error parsing cluster.conf %s" %e) ComLog.errorTraceLog() self.error=True
def updateMetaData(self, element): ComLog.getLogger(self.__logStrLevel__).debug( "%u logical volumes cloning all from source" % (len(self.getVolumeGroup().getLogicalVolumes()))) #ComLog.getLogger(self.__logStrLevel__).debug("Element to copy %s" %(element)) if (len(self.getVolumeGroup().getLogicalVolumes()) == 0): #ComLog.getLogger(self.__logStrLevel__).debug("0 logical volumes cloning all from source") XmlTools.merge_trees_with_pk( element, self.getVolumeGroup().getElement(), self.document, "name", XmlTools.ElementFilter("logicalvolume")) self.vg = VolumeGroup(self.getVolumeGroup().getElement(), self.getDocument())
def createStoreModelFromNode(self, node): iter=self.append() ComLog.getLogger(__logStrLevel__).debug("Node: %s, %s" % (node, node.attributes)) gobj=gobject.GObject() gobj.set_data(DOMTreeModel.NODE_KEY, node) self.set_value(iter, DOMModel.COLUMN_NAME, node.nodeName) self.set_value(iter, DOMModel.COLUMN_VALUE, node.nodeValue) self.set_value(iter, DOMModel.COLUMN_EDITABLE, True) self.set_value(iter, DOMModel.COLUMN_NODE, gobj) if node.attributes and len(node.attributes) > 0: for child in node.attributes: self.createStoreModelFromNode(child)
def _createInfoDict(self, scan): from ComAssistantInfo import AttrAssistantInfo from ComAssistantHelper import createAssistantHelper self.infodict=InfoDict() # get the root element _info=self.value_def_doc.getElementsByTagName("info")[0] # For all <entry> elements for _elem in _info.getElementsByTagName("entry"): _elem = InfoElement(_elem) _node=None # OK, now get the list of <xpath> elements for _xpath in _elem.getXpathList(): _xpathname=_xpath.getAttribute("name") ComLog.getLogger(__logStrLevel__).debug("xpath %s" %_xpathname) try: _node=xpath.Evaluate(_xpathname, self.doc)[0] ComLog.getLogger(__logStrLevel__).debug("xpath %s does match" %_xpathname) break except Exception, e: ComLog.getLogger(__logStrLevel__).debug("xpath %s does not match" %_xpathname) pass if _node == None: ComLog.getLogger(__logStrLevel__).warning("element %s not found" %_elem.getName()) break _ainfo=AttrAssistantInfo(_node, _elem.getName(), \ _elem.getAttribute("type"),\ _elem.getComment(),\ None,\ createAssistantHelper(_elem.getHelperClassName(), _elem.getHelperQuery())) if scan: _ainfo.scan() self.infodict.addValue(_elem.getName(),_ainfo)
def doModifications(self, _file): # TODO create bckup of file ? # TODO raise Warning Exception __cmd = "mv -f " __cmd += _file.getAttribute("sourcefile") __cmd += " " __cmd += _file.getAttribute("name") __rc, __ret = ComSystem.execLocalStatusOutput(__cmd) if __rc: ComLog.getLogger("MoveModification").error("doMove: " + __cmd + " " + __ret) else: ComLog.getLogger("MoveModification").debug("doMove: " + __cmd + " " + __ret)
def parseline(self, line): self.last_line = line line = line.strip() if line and line[0] == '?': line = "help %s" % (line) if line and not line[0] == '?' and line[len(line) - 1] == '?': line = line[:len(line) - 2] line = "help %s" % (line) cmd1, arg1, line = cmd.Cmd.parseline(self, line) arg2, cmd2 = (None, None) arg3, cmd3 = (None, None) if arg1: cmd2, arg2, arg1 = cmd.Cmd.parseline(self, arg1) if arg2: cmd3, arg3, arg2 = cmd.Cmd.parseline(self, arg2) if cmd1: cmd1 = cmd1.lower() if cmd2: cmd2 = cmd2.lower() if cmd3: cmd3 = cmd3.lower() ComLog.getLogger().debug("parseline: %s, %s, %s, %s, %s" % (cmd1, cmd2, cmd3, arg3, line)) if hasattr(self, "do_%s_%s_%s" % (cmd1, cmd2, cmd3)): ComLog.getLogger().debug("%s_%s_%s(%s)" % (cmd1, cmd2, cmd3, arg3)) return "%s_%s_%s" % (cmd1, cmd2, cmd3), arg2, line elif hasattr(self, "do_%s_%s" % (cmd1, cmd2)): ComLog.getLogger().debug("%s_%s(%s)" % (cmd1, cmd2, arg2)) return "%s_%s" % (cmd1, cmd2), arg2, line else: ComLog.getLogger().debug("%s(%s)" % (cmd1, arg1)) return cmd1, arg1, line
def edit_attribute(self, cell, path_string, new_text, view): model=view.get_model() self.status("Menu Edit attribute... " + path_string + " pressed cell %s, model %s, new_text %s" % (cell, model, new_text)) iter = model.get_iter_from_string(path_string) piter= model.iter_parent(iter) parent_node=model.get_value(iter, DOMModel.COLUMN_NODE).get_data(DOMModel.NODE_KEY) value = model.get_value(iter, DOMModel.COLUMN_NODE) ref_node=value.get_data(DOMModel.NODE_KEY) ComLog.getLogger(__logStrLevel__).debug("Path: %s" % (path_string)) ComLog.getLogger(__logStrLevel__).debug("ref_node: %s" % ref_node) ref_node.nodeValue=new_text citer=model.convert_iter_to_child_iter(iter) model.get_model().set(citer, DOMModel.COLUMN_VALUE, new_text)
class EMCLegatoBackupHandler(BackupHandler): """ Class for the handling of backup applications """ log = ComLog.getLogger("comoonics.backup.EMCLegato.EMCLegatoBackupHandler") FORMAT = "legato" def __init__(self, name, properties): """ Initializes a new EMCLegatoBackupHandler from the given name @name: is the group to be used Within the properties the following keys have to be present: @client: which client is to be backuped @level: which backuplevel """ super(EMCLegatoBackupHandler, self).__init__(name, properties) self.networker = None self.openfiles = list() try: self.networker = LegatoNetworker(properties.getAttribute("client"), name, properties.getAttribute("server")) self.level = EMCLegatoBackupLevel.FULL if properties.has_key("level"): self.level = properties.getAttribute("level") except KeyError, ke: raise EMCLegatoBackupHandlerConfigurationError(ke.__str__(), None)
class MetadataSerializer(DataObject): """ The Metadata baseclass """ __logStrLevel__="MetadataSerializer" log=ComLog.getLogger(__logStrLevel__) TAG_NAME="metadata" def __new__(cls, *args, **kwds): if len (args) > 0 and isinstance(args[0], Node): archives=args[0].getElementsByTagName("archive") if len(archives) > 0: cls=ArchiveMetadataSerializer ComLog.getLogger(MetadataSerializer.__logStrLevel__).debug("Returning new object %s" %(cls)) return object.__new__(cls, *args, **kwds) else: raise UnsupportedMetadataException("Unsupported Metadata type in element " % (args[0].tagName)) else: raise UnsupportedMetadataException("Unsupported Metadata type because no domelement given (%u)" %(len(args))) def __init__(self, element, doc=None): DataObject.__init__(self, element, doc) """ resolves this metadata object. This is an abstract method and has to be implemented by the childrenclasses """ def resolve(self): return None """ Serializes the given element into this MetadataObject """ def serialize(self, element): pass
def createMenu(self, selection, dtd): __menu = gtk.Menu() __model, __i = selection.get_selected() __node = __model.get(__i, DOMModel.COLUMN_NODE)[0] if not __node.get_data(DOMTreeModel.NODE_KEY).parentNode.nodeType == __node.get_data(DOMTreeModel.NODE_KEY).parentNode.ELEMENT_NODE: return None ComLog.getLogger(__logStrLevel__).debug( __node.get_data(DOMTreeModel.NODE_KEY).parentNode) __attr = ContentModelHelper(dtd). \ getValidElementNamesInsert(__node.get_data(DOMTreeModel.NODE_KEY)) for i in range(len(__attr)): __item = gtk.MenuItem(__attr[i]) __menu.append(__item) self.items.append([__item, __model, __i, __attr[i]]) __item.show() __menu.show() return __menu