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
