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 _testCdsls(self, repository, clusterinfo, results):
self.cwd.pushd(os.path.join(repository.root, repository.getMountpoint()))
# setupCDSLRepository._createCDSLFiles(".")
_dirs=results.keys()
_dirs.sort()
repository.buildInfrastructure(clusterinfo)
for _path in _dirs:
_cdsl=None
try:
_cdsl=repository.getCdsl(_path)
except CdslNotFoundException:
if results[_path][1] == True:
_cdsl=getCdsl(_path, CDSL_HOSTDEPENDENT_TYPE, repository, clusterinfo)
elif results[_path][1] == False:
_cdsl=getCdsl(_path, CDSL_SHARED_TYPE, repository, clusterinfo)
if _cdsl:
self.assert_(repository.commit(_cdsl))
ComLog.setLevel(logging.DEBUG, "comoonics.cdsl")
repository.refresh()
ComLog.setLevel(logging.INFO, "comoonics.cdsl")
for cdsl in repository.getCdsls():
self.assert_(repository.delete(cdsl))
repository.removeInfrastructure(clusterinfo)
# setupCDSLRepository._removeCDSLFiles(".")
self.cwd.popd()
def getIP(self):
"""
@return: Returns ip-address of interface
@rtype: string
"""
#optional attribute, return empty string if not set
try:
self.log.debug("get ip attribute: " + self.getAttribute(ComoonicsClusterRepository.attribute_netdev_ip))
# special case for dhcp we'll return the given ipaddress
if self.isDHCP():
from comoonics import ComSystem
import re
try:
output=ComSystem.execLocalOutput("PATH=/sbin:/usr/sbin ip addr show %s" %self.getName(), True)
_mac=re.search("link/ether (?P<mac>\S+)", output).group("mac")
_ip=re.search(".*inet (?P<ip>[0-9.]+)", output).group("ip")
if _mac.upper() == self.getMac().upper():
return _ip
else:
return self.getAttribute(ComoonicsClusterRepository.attribute_netdev_ip)
except:
ComLog.debugTraceLog(self.log)
return self.getAttribute(ComoonicsClusterRepository.attribute_netdev_ip)
else:
return self.getAttribute(ComoonicsClusterRepository.attribute_netdev_ip)
except NameError:
return ""
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 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 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 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 __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 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 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 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 setUp(self):
import inspect
import os.path
self.filename=os.path.join(os.path.dirname(inspect.getfile(self.__class__)), "loggingconfig.xml")
self.cp=ConfigParser()
self.cp.read(self.filename)
self.loggers=["atix", "atix.atix1", "atix.atix2"]
ComLog.fileConfig(self.filename)
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 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 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 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 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 setVerbose(flag):
if flag:
try:
import logging
from comoonics import ComLog
logging.basicConfig()
ComLog.setLevel(logging.DEBUG)
except ImportError:
pass
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 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 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 _fromDB(self):
_rs=self._getRecordSet()
if _rs.num_rows()>0:
_obj=_rs.fetch_row(1, 1)
for _key, _value in _obj[0].items():
setattr(self, self.__dict__["schemarev"][_key], _value)
else:
ComLog.debugTraceLog(self.logger)
raise NoDataFoundForObjectException("No data found for object. ID: %s/%s" %(str(self.tablename), str(self.id)))
self._fromdb=True
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 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 getBlockDeviceForWWWNLun(wwwn, lun, hosts=None):
""" returns the scsidevicename of wwwn, lun combination searching on all hosts or the given ones. """
blockdev_file=None
if not hosts:
try:
hosts=getFCHosts()
except SCSIException:
ComLog.debugTraceLog(log)
hosts=getQlaHosts()
for host in hosts:
device_dir=FCPATH_HOST_DEVICE %(host)
try:
for device_file in os.listdir(device_dir):
match=re.match(SCSITARGET_PATTERN, device_file)
if match:
(scsi_hostid, scsi_busid, scsi_id)=match.groups()
_wwwn=getWWWN(scsi_hostid, scsi_busid, scsi_id)
log.debug("Found WWWN: %s==%s" %(_wwwn, wwwn))
if _wwwn==wwwn:
blockdev_file=FCPATH_HOST_LUN %(host, int(scsi_hostid), int(scsi_busid), int(scsi_id), int(scsi_hostid), int(scsi_busid), int(scsi_id), int(scsi_hostid), int(scsi_busid), int(scsi_id), int(lun))
for filename in os.listdir(blockdev_file):
if filename.startswith("block:"):
blockdev_file=os.path.join(blockdev_file, filename)
break
except IOError:
hostid=getHostId(host)
busid=0
qlafile=QLA_SCSIPATH_PROC+"/%u" %(int(hostid))
if os.path.exists(qlafile):
qla=open(qlafile, "r")
regexp_lun=re.compile(QLALUN_PATTERN)
regexp_port=re.compile(QLAPORT_PATTERN)
scsi_ids=list()
for line in qla:
match=regexp_port.match(line)
if match:
(scsi_hostid, scsi_id, wwpn, wwnn, _x, _y)=match.groups()
log.debug("match: %s, %s, %s" %(wwpn, wwnn, scsi_id))
if wwnn==wwwn or wwpn==wwwn:
scsi_ids.append(int(scsi_id))
if not match:
match=regexp_lun.match(line)
if match:
(scsi_id, scsi_lun)=match.groups()
if int(scsi_id) in scsi_ids and int(scsi_lun) == int(lun):
blockdev_file=SCSIPATH_TARGET_BLOCK %(int(hostid), int(busid), int(scsi_id), int(scsi_lun))
qla.close()
if blockdev_file and os.path.exists(blockdev_file):
log.debug("blockdevfile: %s" %(blockdev_file))
if os.path.exists(blockdev_file):
return "/dev/"+os.path.basename(os.readlink(blockdev_file))
else:
raise SCSIException("Could not find blockdevice for wwwn: %s, lun: %u" %(wwwn, int(lun)))
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 replayJournal(self):
"""
replays the journal from top to buttom. The last inserted method first.
"""
self.__journal__.reverse()
for je in self.__journal__:
ComLog.getLogger(JournaledObject.__logStrLevel__).debug("Journalentry: %s, %s" %(je.method, je.ref.__class__))
undomethod=""
try:
if inspect.ismodule(je.ref):
undomethod=self.__undomap__[str(je.ref.__name__+"."+je.method)]
else:
undomethod=self.__undomap__[str(je.ref.__class__.__name__+"."+je.method)]
ComLog.getLogger(JournaledObject.__logStrLevel__).debug("Undomethod: %s(%s)" % (undomethod, je.params))
if not je.params or (type(je.params)==list and len(je.params) == 0):
# changed call of replay
# __class__.__dict__[undomethod] does not work with inherited methods
#je.ref.__class__.__dict__[undomethod](je.ref)
getattr(je.ref,undomethod)()
elif type(je.params)!=list and type(je.params)!=tuple:
getattr(je.ref, undomethod)(je.params)
elif len(je.params) == 1:
#je.ref.__class__.__dict__[undomethod](je.ref, je.params[0])
getattr(je.ref,undomethod)(je.params[0])
else:
#je.ref.__class__.__dict__[undomethod](je.ref, je.params)
getattr(je.ref,undomethod)(*je.params)
except Exception, e:
ComLog.getLogger(JournaledObject.__logStrLevel__).warn("Caught exception e during journal replay of method %s => %s on %s: %s" % (je.method, undomethod, je.ref.__class__.__name__, e))
ComLog.debugTraceLog(ComLog.getLogger(JournaledObject.__logStrLevel__))
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 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)
class Plugin(object):
"""
Plugin Interface
"""
logger = ComLog.getLogger("comoonics.fenceacksv.plugins.ComPlugin.Plugin")
def __init__(self,
_name=None,
stdout=sys.stdout,
stdin=sys.stdin,
stderr=sys.stderr):
self._commands = dict()
self._commands_help = dict()
self.stdout = stdout
self.stdin = stdin
self.stderr = stderr
self.name = _name
def getName(self):
return self.name
def addCommand(self, _name, methodref, *params, **kwds):
self._commands[_name] = Method(methodref, *params, **kwds)
def getCommands(self):
return self._commands.keys()
def hasCommand(self, _name):
return self._commands.has_key(_name)
def getCommand(self, _name):
"""
returns a Methodtype
"""
if isinstance(self._commands[_name], Method):
return self._commands[_name]
else:
return Method(self._commands[_name])
def doCommand(self, _name, *params, **kwds):
self.doPre(_name, *params, **kwds)
_ret = self.getCommand(_name).do(*params, **kwds)
self.doPost(_name, *params, **kwds)
return _ret
def doPre(self, _name, *params, **kwds):
pass
def doPost(self, _name, *params, **kwds):
pass
def help_short(self):
buf = inspect.getdoc(self)
if not buf:
buf = ""
return buf
def help(self, _command=None):
"""
Help about this plugin
"""
Plugin.logger.debug("help(%s)" % _command)
if not _command or _command == "" or _command == "help":
buf = inspect.getdoc(self)
if not buf:
buf = ""
buf += "\nCommands:\n" + ", ".join(self.getCommands())
return buf
else:
if self._commands_help.has_key(_command):
return self._commands_help[_command]
else:
return self.getCommand(_command).help()
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
__version__= "$Revision $"
from comoonics import ComLog
logger=ComLog.getLogger("comoonics.DictTools")
def searchDict(hash,searchedElement):
"""
Searches for a given key in a nested dictionary
@param hash: Dictionary to seach in
@type hash: L{dict}
@param searchedElement: key to search for
@type searchedElement: L{string}
@return: Returns if the given string is found as key in given hash
@rtype: L{Boolean}
"""
for (key, value) in hash.items():
if key == searchedElement:
return True
else:
class ISOFSModificationset(ModificationsetJournaled):
""" implementation class for this modificationset """
__logStrLevel__ = "comoonics.enterprisecopy.ComISOFSModificationset.ISOFSModificationset"
logger = ComLog.getLogger(__logStrLevel__)
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 doPre(self):
ISOFSModificationset.logger.debug("doPre() CWD: " + os.getcwd())
super(ISOFSModificationset, self).doPre()
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 _get_mkisofs_command(self):
_knownopts = ["bootcd", "cdlabel"]
_opts = ["-o " + self.isoname, "-J", "-R", "-D"]
if self.getProperties() and self.getProperties().has_key("bootcd"):
if self.getProperties().getProperty(
"bootcd").getValue() == "livecd":
_opts.append("-no-emul-boot")
_opts.append("-boot-info-table")
_opts.append("-boot-load-size 4")
_opts.append("-b boot/isolinux.bin")
_opts.append("-c boot/isolinux.boot")
if self.getProperties() and self.getProperties().has_key("cdlabel"):
key = self.getProperties().getProperty("cdlabel")
_opts.append("-A '%s'" % key.getValue())
_opts.append("-V '%s'" % key.getValue())
for _property in self.getProperties().keys():
if _property in _knownopts:
continue
_value = self.getProperties()[_property].getValue()
if _value == "":
_opts.append("-%s" % _property)
else:
_opts.append("-%s %s" % (_property, _value))
for _element in self.pathlist:
_opts.append(Path(_element, self.getDocument()).getPath())
return CMD_MKISOFS + " " + " ".join(_opts)
# $Id: testlog.py,v 1.3 2007-06-13 09:17:22 marc Exp $
import sys
import traceback
sys.path.append("../lib")
#print sys.path
try:
from comoonics import ComLog
from comoonics import ComSystem
except ImportError:
print "Exception in import "
print traceback.print_exc()
log = ComLog.getLogger()
print log
log.critical("This is really critical")
try:
raise TypeError, "bogus typerror for testing"
except Exception, e:
log.exception("Huston, we have a problem")
#ComSystem.execLocal("echo \"hallo du\"")
#################
# $Log: testlog.py,v $
# Revision 1.3 2007-06-13 09:17:22 marc
# - better testing, but obsolete??
#
def parse_cmdline(args=sys.argv):
parser = OptionParser(description=__doc__,
usage="usage: %prog [options] action [arguments]",
version=__version__)
# Flags
parser.add_option("-v",
"--verbose",
default=False,
action="store_true",
help="toggle debugmode and be more helpful")
# parser.add_option("-a", "--ask", dest="ask", default=False, action="store_true", help="ask before any being command executed")
# parser.add_option("-S", "--simulate", dest="simulate", default=False, action="store_true", help="don't execute anything just simulate. Only valid for developer. It might not do what you expect!")
# Options
backup_options = OptionGroup(parser, "Backup Options")
backup_options.add_option(
"-t",
"--taskname",
default="",
help="Specify the name of the job to be executed. Default %default")
backup_options.add_option(
"-T",
"--type",
default=comoonics.storage.ComArchive.ArchiveHandler.NONE,
help="Set the backup format type. Default: %default")
backup_options.add_option(
"-c",
"--compression",
default=comoonics.storage.ComArchive.ArchiveHandler.NONE,
help=
"Set the compression of this backup handler (if any). Default %default."
)
backup_options.add_option(
"-f",
"--format",
default=comoonics.storage.ComArchive.ArchiveHandler.NONE,
help=
"Set the backup format of this backup handler (if any). Default %default."
)
backup_options.add_option(
"-p",
"--property",
dest="properties",
default=list(),
action="append",
help=
"List of properties to be added to initialization (dependent on implementation). Each property must be name=value pair. Default %default"
)
parser.add_option_group(backup_options)
try:
parser.setGlobalDefaultsFilename(get_defaultsfiles()[0])
parser.setLocalDefaultsFilename(get_defaultsfiles()[1],
get_defaultsenvkey())
except (TypeError, NameError):
pass
(options, args) = parser.parse_args(args)
if options.verbose:
ComLog.setLevel(logging.DEBUG)
else:
ComLog.setLevel(logging.INFO)
if not args or len(args) < 3:
parser.error("To few arguments given to command.")
properties = dict()
for property in options.properties:
try:
name, value = property.split("=", 1)
properties[name] = value
except ValueError:
warnings.warn(
"Skipping property %s because of wrong format. Expecting name=value."
% property)
return (options, args[1], args[2:], properties)
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
__version__ = "$Revision: 1.19 $"
# $Source: /atix/ATIX/CVSROOT/nashead2004/management/comoonics-clustersuite/python/lib/comoonics/cluster/ComClusterRepository.py,v $
from comoonics import ComLog
from comoonics.ComDataObject import DataObject
from comoonics.ComExceptions import ComException
from comoonics.DictTools import searchDict, createDomFromHash
import comoonics.XmlTools
log = ComLog.getLogger("comoonics.cdsl.ComClusterRepository")
class ClusterMacNotFoundException(ComException):
pass
class ClusterIdNotFoundException(ComException):
pass
class ClusterRepositoryConverterNotFoundException(ComException):
pass
class ClusterObject(DataObject):
"python" + sys.version[:3], "site-packages"))
try:
from comoonics.tools.poptparse import PersistentOptionParser as OptionParser
except ImportError:
from optparse import OptionParser
from optparse import OptionGroup
import comoonics.storage
from comoonics import ComLog
__logStrLevel__ = "com-backup"
import logging
logging.basicConfig()
ComLog.setLevel(logging.INFO)
def parse_cmdline(args=sys.argv):
parser = OptionParser(description=__doc__,
usage="usage: %prog [options] action [arguments]",
version=__version__)
# Flags
parser.add_option("-v",
"--verbose",
default=False,
action="store_true",
help="toggle debugmode and be more helpful")
# parser.add_option("-a", "--ask", dest="ask", default=False, action="store_true", help="ask before any being command executed")
# parser.add_option("-S", "--simulate", dest="simulate", default=False, action="store_true", help="don't execute anything just simulate. Only valid for developer. It might not do what you expect!")
from ConfigParser import ConfigParser as oldConfigParser
from comoonics.ComExceptions import ComException
from comoonics.ComProperties import Properties
from comoonics import ComLog
from comoonics import XmlTools
from xml.dom import Node
class NoLoggingConfigFound(ComException):
pass
class IncompatibleConfigFileType(ComException):
def __str__(self):
return "The file %s seems to be not compatible to XMLConfigParser." %self.value
mylogger=ComLog.getLogger("comoonics.XMLConfigParser")
#mylogger.setLevel(logging.DEBUG)
class ConfigParser(oldConfigParser):
LOGGING_TAGNAME="logging"
LOGGERS_TAGNAME="loggers"
LOGGER_TAGNAME="logger"
FORMATTERS_TAGNAME="formatters"
FORMATTER_TAGNAME="formatter"
HANDLERS_TAGNAME="handlers"
HANDLER_TAGNAME="handler"
ARGS_TAGNAME="args"
ARG_TAGNAME="arg"
#PROPERTIES_TAGNAME="properties"
#PROPERTY_TAGNAME="property"
def getBlockDeviceForWWWNLun(wwwn, lun, hosts=None):
""" returns the scsidevicename of wwwn, lun combination searching on all hosts or the given ones. """
blockdev_file = None
if not hosts:
try:
hosts = getFCHosts()
except SCSIException:
ComLog.debugTraceLog(log)
hosts = getQlaHosts()
for host in hosts:
device_dir = FCPATH_HOST_DEVICE % (host)
if os.path.isdir(device_dir):
for device_file in os.listdir(device_dir):
match = re.match(SCSITARGET_PATTERN, device_file)
if match:
(scsi_hostid, scsi_busid, scsi_id) = match.groups()
_wwwn = getWWWN(scsi_hostid, scsi_busid, scsi_id)
log.debug("Found WWWN: %s==%s" % (_wwwn, wwwn))
if _wwwn == wwwn:
blockdev_file = FCPATH_HOST_LUN % (
host, int(scsi_hostid), int(scsi_busid),
int(scsi_id), int(scsi_hostid), int(scsi_busid),
int(scsi_id), int(lun))
blockdev_file += "/block"
hostid = getHostId(host)
busid = 0
qlafile = QLA_SCSIPATH_PROC + "/%u" % (int(hostid))
if os.path.exists(qlafile):
qla = open(qlafile, "r")
regexp_lun = re.compile(QLALUN_PATTERN)
regexp_port = re.compile(QLAPORT_PATTERN)
nodename = None
scsi_ids = list()
for line in qla:
match = regexp_port.match(line)
if match:
(scsi_hostid, scsi_id, wwpn, wwnn, _x, _y) = match.groups()
log.debug("match: %s, %s, %s" % (wwpn, wwnn, scsi_id))
if wwnn == wwwn or wwpn == wwwn:
scsi_ids.append(int(scsi_id))
if not match:
match = regexp_lun.match(line)
if match:
(scsi_id, scsi_lun) = match.groups()
if int(scsi_id) in scsi_ids and int(scsi_lun) == int(
lun):
blockdev_file = SCSIPATH_TARGET_BLOCK % (
int(hostid), int(busid), int(scsi_id),
int(scsi_lun))
qla.close()
if blockdev_file and os.path.exists(blockdev_file):
log.debug("blockdevfile: %s" % (blockdev_file))
if os.path.exists(blockdev_file):
return "/dev/" + os.path.basename(os.readlink(blockdev_file))
else:
raise SCSIException(
"Could not find blockdevice for wwwn: %s, lun: %u" %
(wwwn, int(lun)))
def setConfigPath(option, opt, value, parser):
print "setConfigPath %s" % value
print option
print opt
print parser
CONFIGURATION_PATH = value
def exit(value, text=""):
print text
sys.exit(value)
ComLog.setLevel(logging.INFO)
log = ComLog.getLogger("comoonics-assistant")
parser = OptionParser(description=__doc__, version=__version__)
# Default Options
parser.add_option("-D",
"--debug",
dest="debug",
default=False,
action="callback",
callback=setDebug,
help="Debug")
parser.add_option("-s",
"--simulate",
dest="debug",
def setDebug(option, opt, value, parser):
ComLog.setLevel(logging.DEBUG)
setattr(parser.values, option.dest, True)
"""
Init this package
"""
from comoonics import ComLog
from ComDBLogger import DBLogger
from ComDBObject import DBObject, NoDataFoundForObjectException, loadDBObjectsRegistry, setDBObjectsRegistry, registerDBObjectProperties, getDBObjectProperties, hasDBObjectProperties
from ComDBJobs import DBJobs, DBJob, DBAction, DBJob2Action, registerActionObject, JobException
ComLog.registerHandler("DBLogger", DBLogger)
########
# $Log: __init__.py,v $
# Revision 1.4 2008-02-28 14:19:09 marc
# - added autoimports.
# - added the dbobject and dbjobs
#
# Revision 1.3 2007/06/19 15:10:07 marc
# fixed importing
#
# Revision 1.2 2007/06/13 09:03:52 marc
# - using new ComLog api
# - default importing of ComDBLogger and registering at ComLog
#
# Revision 1.1 2007/04/02 11:21:23 marc
# For Hilti RPM Control:
# - initial revision
#
# Revision 1.1 2007/03/05 16:10:30 marc
# first rpm version
class SysrqModification(Modification):
logger = ComLog.getLogger(
"comoonics.enterprisecopy.ComSysrq.SysrqModification")
type = None
child = None
_log = None
def _createElement(**kwds):
import xml.dom
_impl = xml.dom.getDOMImplementation()
_doc = _impl.createDocument(None, Modification.TAGNAME, None)
_element = _doc.documentElement
_element.setAttribute("type", "sysrq")
if kwds.has_key("command"):
_element.appendChild(
Sysrq._createElement(kwds.get("command"),
kwds.get("settrigger")))
elif kwds.has_key("commands"):
_element.appendChild(
Sysrq._createElement(kwds.get("commands"),
kwds.get("settrigger")))
return (_element, _doc)
_createElement = staticmethod(_createElement)
def __init__(self, *params, **kwds):
"""
Constructors:
__init__(element, doc)
__init__(self, command=cmd, [settrigger=*True|False])
__init__(self, commands=list<cmd>, [settrigger=*True|False])
__init__(element=element, doc=doc)
@element: the element of the modification
@doc: the root document
@command: sysrq command to be executed
@commands: list of sysrq commands to be executed
@settrigger: set the trigger or not
"""
if len(params) == 2:
_element = params[0]
_doc = params[0]
elif kwds:
if kwds.has_key("element") and kwds.has_key("doc"):
_element = kwds["element"]
_doc = kwds["doc"]
else:
(_element, _doc) = self._createElement(**kwds)
else:
raise TypeError(
"__init__() takes exactly 2 arguments or different keys. (%u given)"
% len(params))
Modification.__init__(self, _element, _doc)
self.sysrqs = list()
for _sysrq in self.getElement().getElementsByTagName(Sysrq.TAGNAME):
self.sysrqs.append(Sysrq(_sysrq, _doc))
def doRealModifications(self):
"""
calls doCatifAction for every action
"""
for _sysrq in self.sysrqs:
_sysrq.doCommands()
# here is some internal information
# $Id: ComSCSI.py,v 1.4 2010-03-08 12:30:48 marc Exp $
#
__version__ = "$Revision: 1.4 $"
# $Source: /atix/ATIX/CVSROOT/nashead2004/management/comoonics-clustersuite/python/lib/comoonics/scsi/ComSCSI.py,v $
from comoonics import ComLog
from comoonics.ComExceptions import ComException
import os.path
import re
from comoonics import ComSystem
log = ComLog.getLogger("comoonics.scsi.ComSCSI")
class SCSIException(ComException):
def __str__(self):
return "SCSI-Error: %s" % (self.value)
FCPATH_2_HOST = "/sys/class/fc_host"
FCPATH_TRANSPORT = "/sys/class/fc_transport"
FCPATH_TRANSPORT_TARGET = FCPATH_TRANSPORT + "/target:%u:%u:%u"
FCPATH_TRANSPORT_TARGET_NODENAME = FCPATH_TRANSPORT_TARGET + "/node_name"
FCPATH_HOST_DEVICE = FCPATH_2_HOST + "/%s/device"
FCPATH_HOST_TARGET = FCPATH_2_HOST + "/target:%u:%u:%u"
FCPATH_HOST_LUN = FCPATH_HOST_TARGET + "/%u:%u:%u:%u"
SCSIPATH_2_PROC = "/proc/scsi"
class HostDisk(Disk):
log=ComLog.getLogger("comoonics.ComDisk.HostDisk")
LABEL_PREFIX="LABEL="
TAGNAME="disk"
class DeviceNameResolver(object):
key=None
def getKey(self):
return self.key
def resolve(self, value):
pass
class DeviceNameResolverError(ComException):
pass
resolver=dict()
def __init__(self, *params):
""" Disk represents a raw disk
Possible constructors:
__init__(self, element, doc=None) type(element)=Node
__init__(self, name, doc=None) type(name)==str
"""
if len(params)==1:
doc=xml.dom.getDOMImplementation().createDocument(None, self.TAGNAME, None)
elif len(params)==2:
doc=params[1]
else:
raise exceptions.TypeError("""Wrong number of arguments to constructor of HostDisk.
Either __init__(self, element, doc=None) or
__init__(self, name, doc=None) are supported.""")
if isinstance(params[0], basestring):
element=doc.createElement(self.TAGNAME)
element.setAttribute("name", params[0])
else:
element=params[0]
super(HostDisk, self).__init__(element, doc)
self.log.debug("__init__")
self.devicename=None
self.stabilizedfile="/proc/partitions"
self.stabilizedtype="hash"
self.stabilizedgood=2
def is_lvm(self):
return hasattr(self, "volumegroup") and hasattr(self, "logicalvolume")
def is_lvm_activated(self):
return self.is_lvm() and self.logicalvolume.isActivated()
def lvm_vg_activate(self):
self.volumegroup.activate()
def lvm_vg_deactivate(self):
self.volumegroup.deactivate()
def getLog(self):
return self.log
def exists(self):
return ComSystem.execMethod(os.path.exists, self.getDeviceName())
def sameSize(self):
"""
"""
return self.getAttributeBoolean("samesize", False)
def getDeviceName(self):
""" returns the Disks device name (e.g. /dev/sda) """
if hasattr(self, "devicename") and self.devicename != None:
return self.devicename
else:
return self.getAttribute("name")
def getDevicePath(self):
return self.getDeviceName()
def getSize(self):
""" returns the size of the disk in sectors"""
pass
def refByLabel(self):
"""
is disk referenced by Label? returns True or False
Format <disk name="LABEL=..."/>
"""
return self.getDeviceName()[:len(self.LABEL_PREFIX)]==self.LABEL_PREFIX
def resolveDeviceNameByKeyValue(self, key, value):
"""
resolves a device name by searching for a method to resolve it by key and the resolve via value as
Parameter
"""
if self.resolver.has_key(key):
name=self.resolver[key].resolve(value)
if name and name != "":
self.devicename=name
else:
raise HostDisk.DeviceNameResolverError("Could not resolve device \"%s\" for type \"%s\"" %(value, key))
else:
raise HostDisk.DeviceNameResolverError("Could not find resolver for device referrenced by %s=%s" %(key, value))
def resolveDeviceName(self):
"""
resolves the given devicenames and returns a list of executed commands.
"""
journal_cmds=list()
if len(self.getDeviceName().split("="))==2:
(key, value)=self.getDeviceName().split("=")[:2]
self.resolveDeviceNameByKeyValue(key, value)
if LogicalVolume.isValidLVPath(self.getDeviceName()):
self.initLVM()
self.lvm_activated=False
if self.getAttribute("options", "") != "skipactivate" and not self.is_lvm_activated():
self.lvm_vg_activate()
self.lvm_activated=True
journal_cmds.append("lvm_vg_activate")
return journal_cmds
def initLVM(self):
(vgname, lvname)=LogicalVolume.splitLVPath(self.getDeviceName())
self.volumegroup=VolumeGroup(vgname, self.getDocument())
self.logicalvolume=LogicalVolume(lvname, self.volumegroup, self.getDocument())
self.volumegroup.init_from_disk()
self.logicalvolume.init_from_disk()
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 initFromDiskPartedCmd(self):
raise ImportError("No pyparted found. You might want to install pyparted.")
def initFromDiskParted(self):
import parted
import ComParted
phelper=ComParted.PartedHelper()
dev=parted.PedDevice.get(self.getDeviceName())
try:
disk=parted.PedDisk.new(dev)
partlist=phelper.get_primary_partitions(disk)
for part in partlist:
self.appendChild(Partition(part, self.getDocument()))
except parted.error:
HostDisk.log.debug("no partitions found")
def restore(self):
if hasattr(self, "lvm_activated") and self.lvm_activated:
self.lvm_vg_deactivate()
def createPartitions(self):
""" creates new partition table """
try:
self.createPartitionsParted()
except ImportError:
self.createPartitionsPartedCmd()
def createPartitionsPartedCmd(self):
pass
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))
class Source(BaseDB):
"""
Source Class
"""
log=ComLog.getLogger("Source")
def __init__(self, **kwds):
"""
Creates a connection to the database
__init__(hostname=.., user=.., password=.., database=.., tablename=..)
__init__(dbhandle=.., tablename=..)
"""
if not kwds.has_key("tablename"):
kwds["tablename"]="sources"
super(Source, self).__init__(**kwds)
def getSourcesAsSysteminformations(self, name=None):
sysinfos=list()
# to be compatible with mysql-python rhel4 and mysql4.1 dateformat it has to be formated
selectquery="SELECT source_type AS type, name, category, architecture, operating_system AS operatingsystem, "+\
"kernel_version AS kernelversion, uptime, DATE_FORMAT(lastimport, '%Y%m%d%H%i%s') AS lastimport FROM sources"
if name and name != "":
selectquery+=" WHERE name LIKE \"%"+name+"%\";"
Source.log.debug("getSourcesAsSysteminformations: %s" %(selectquery))
rs=self.selectQuery(selectquery)
row=rs.fetch_row(1,1)
while row:
from comoonics.ComSystemInformation import SystemInformation
sysinfos.append(SystemInformation(**row[0]))
row=rs.fetch_row(1,1)
return sysinfos
def getSourceAsSysteminformation(self, name):
selectquery="SELECT source_type AS type, name, category, architecture, operating_system AS operatingsystem, kernel_version AS kernelversion, uptime, lastimport FROM sources WHERE name=\""+name+"\";"
rs=self.selectQuery(selectquery)
if rs.num_rows > 0:
row=rs.fetch_row(1,1)
from comoonics.ComSystemInformation import SystemInformation
systeminformation=SystemInformation(**row[0])
else:
return None
def getCategories(self):
"""
Returns the first found channel channelversion combination from the dsl of the given rpm
rpm: is a rpm_header as defined by python-rpm
"""
selectquery="SELECT DISTINCT category FROM %s;" %(self.tablename)
self.log.debug("select %s" % selectquery)
rs=self.selectQuery(selectquery)
categories=list()
row=rs.fetch_row()
while row:
categories.append(row[0][0])
row=rs.fetch_row()
return categories
def getSourcesForCategory(self, category):
"""
Returns the category for the given sourcename
"""
selectquery="SELECT DISTINCT name FROM %s WHERE category=\"%s\";" %(self.tablename, category)
rs=self.selectQuery(selectquery)
sources=list()
row=rs.fetch_row()
while row:
sources.append(row[0][0])
row=rs.fetch_row()
self.log.debug("select %s %u, %u" %(selectquery, rs.num_rows(), len(sources)))
return sources
def updateSystemInformation(self, sysinfo, category):
values=dict()
if isinstance(sysinfo, RedhatClusterSystemInformation):
source_type="cluster"
else:
source_type="single"
# values["uptime"]=sysinfo.getUptime()
# values["source_type"]=source_type
# values["category"]=category
# values["architecture"]=sysinfo.getArchitecture()
# values["operating_system"]=sysinfo.getOperatingsystem()
# values["kernel_version"]=sysinfo.getKernelversion()
ret=super(Source, self).updateRPM("INSERT INTO %s VALUES(\"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", \"%s\", NOW());" % (self.tablename, source_type, sysinfo.getName(), category, sysinfo.getArchitecture(), sysinfo.getOperatingsystem(), sysinfo.getKernelversion(), sysinfo.getUptime()),
"UPDATE %s SET source_type=\"%s\", category=\"%s\", architecture=\"%s\", operating_system=\"%s\", kernel_version=\"%s\", uptime=\"%s\", lastimport=Now() WHERE name=\"%s\";" % (self.tablename, source_type, category, sysinfo.getArchitecture(), sysinfo.getOperatingsystem(), sysinfo.getKernelversion(), sysinfo.getUptime(), sysinfo.getName()),
"SELECT name, source_type, category, architecture, operating_system, kernel_version, uptime FROM %s WHERE name=\"%s\";" %(self.tablename, sysinfo.getName()), None)
if ret==1:
self.dblog.log(DBLogger.DB_LOG_LEVEL, "Added new system %s, %s (table: %s)" %(sysinfo.getName(), category, self.tablename))
elif ret>1:
self.dblog.log(DBLogger.DB_LOG_LEVEL, "Updated existing system %s, %s (table: %s)" %(sysinfo.getName(), category, self.tablename))
All files created by lockfile will be read-only, and therefore will have to be removed with rm -f.
If you specify a locktimeout then a lockfile will be removed by force after locktimeout seconds have passed since the lockfile was last modified/created (most
likely by some other program that unexpectedly died a long time ago, and hence could not clean up any leftover lockfiles). Lockfile is clock skew immune. After
a lockfile has been removed by force, a suspension of suspend seconds (defaults to 16) is taken into account, in order to prevent the inadvertent immediate
removal of any newly created lockfile by another program (compare SUSPEND in procmail(1)).
Mailbox locks
If the permissions on the system mail spool directory allow it, or if lockfile is suitably setgid, it will be able to lock and unlock your system mailbox by using
the options -ml and -mu respectively
"""
from comoonics import ComLog, ComSystem, ComExceptions
logger = ComLog.getLogger("comoonics.lockfile")
class lockfileTimeout(ComExceptions.ComException):
def __str__(self):
return "Sorry, giving up on \"%s\"\nAnother process seems to have locked this file. You may try again later." % self.value
class lockfile(object):
COMMAND = "lockfile"
"""
The lockfile class
"""
def __init__(self, _filename):
self.filename = _filename
class TimeExpression(object):
logger=ComLog.getLogger("TimeExpression")
months_map={"Jan.*":1, "Feb.*":2, "Mar.*":3, "Apr.*":4, "May":5, "Jun.*":6, "Jul.*":7, "Aug.*":8, "Sep.*":9, "Oct.*":10, "Nov.*":11, "Dec.*":12}
months=("Jan\w*", "Feb\w*", "Mar\w*", "Apr\w*", "Mai", "Jun\w*", "Jul\w*", "Aug\w*", "Sep\w*", "Oct\w*", "Nov\w*", "Dec\w*")
def __init__(self, time_expression):
super(TimeExpression, self).__init__()
#self.timezone=".*"
#time_expression=TimeExpression.toRegExp(time_expression)
if time_expression=="now":
import time
time_expression=time.strftime("%Y/%m/%d %H:%M:*")
(date, time)=split(time_expression, " ", 2)
(self.year, self.month, self.day)=split(date, "/", 3)
(self.hour, self.minute, self.second)=split(time, ":", 3)
def __str__(self):
return "%s/%s/%s %s:%s:%s" %(self.year, self.month, self.day, self.hour, self.minute, self.second)
def format(self, _format):
time_format=TimeFormat(_format)
TimeExpression.logger.debug("time_format: %s" %(time_format))
return time_format.format(self)
def now():
return TimeExpression("now")
def toRegExp(string, format="[A-Za-z0-9]"):
regexps=( ("(\d{1,4})-(\d{1,4})", "[\g<1>-\g<2>]"),
("(\B|[^\.])\*", "\g<1>%s" %(format)),
("(\B|[^\.])\+","\g<1>%s" %(format) ))
import re
for (regexp,subs) in regexps:
string=re.sub(regexp, subs, string)
return string
def toHourRegExp(string):
return "(?P<hour>"+TimeExpression.toRegExp(string,"\d{1,2}")+")"
def toMinuteRegExp(string):
return "(?P<minute>"+TimeExpression.toRegExp(string,"\d{1,2}")+")"
def toSecondRegExp(string):
return "(?P<second>"+TimeExpression.toRegExp(string,"\d{1,2}")+")"
def toYearRegExp(string):
return "(?P<year>"+TimeExpression.toRegExp(string,"\d{2,4}")+")"
def toMonthnumberRegExp(string):
string=TimeExpression.toRegExp(string, "1-12")
import re
regexp=re.compile("%s" %("|".join(TimeExpression.months)))
return "(?P<month>["+regexp.sub(TimeExpression.toMonthnumber, string)+"])"
def toMonthnameRegExp(string):
#ComLog.getLogger().debug("toMonthnameRegExp(%s)" %(str))
import re
# resolve the [\d+-\d+] expressions to name1|name2|name3..
regexp=re.compile("(\d{1,2})-(\d{1,2})")
_match=regexp.match(string)
if _match:
low=int(_match.group(1))
if low > 0:
low=low-1
high=int(_match.group(2))
# print "%s, %s" %(_match.group(1), _match.group(2))
string="|".join(TimeExpression.months[low:high])
elif re.match("^\.\*", string) or re.match("^\*", string):
string="|".join(TimeExpression.months)
regexp=re.compile("\d{1,2}")
return "(?P<month>"+regexp.sub(TimeExpression.toMonthname, string)+")"
def toMonthDayRegExp(string):
return "(?P<day>"+TimeExpression.toRegExp(string,"\d{1,2}")+")"
def toMonthname(number, isregexp=True):
if isregexp:
_number=int(number.group(0))
else:
_number=int(number)
#print "%u=>%s" %(_number, TimeExpression.months[_number-1])
return TimeExpression.months[_number-1]
def toMonthnumber(name, isregexp=True):
import re
if isregexp:
_name=name.group(0)
else:
_name=name
for key in TimeExpression.months_map.keys():
if re.match(key, _name):
#print "%s=>%u" %(_name, int(TimeExpression.months_map[key]))
return str(TimeExpression.months_map[key])
return None
now=staticmethod(now)
toRegExp=staticmethod(toRegExp)
toMonthname=staticmethod(toMonthname)
toMonthnumber=staticmethod(toMonthnumber)
toYearRegExp=staticmethod(toYearRegExp)
toMonthnameRegExp=staticmethod(toMonthnameRegExp)
toMonthnumberRegExp=staticmethod(toMonthnumberRegExp)
toMonthDayRegExp=staticmethod(toMonthDayRegExp)
toHourRegExp=staticmethod(toHourRegExp)
toMinuteRegExp=staticmethod(toMinuteRegExp)
toSecondRegExp=staticmethod(toSecondRegExp)
class DateFormat(TimeFormat):
logger=ComLog.getLogger("comoonics.search.datatime.DateFormat")
format_string=""
_formated=False
def __init__(self, _searchfor=None, _formatstring="%d/%b/%Y:%h:%M:%S"):
super(DateFormat, self).__init__(_searchfor, _formatstring)
#def clear(self):
# super(DateFormat, self).clear()
# self._formated=False
def format(self, time_expression=None):
#DateFormat.logger.debug("format: formated: %s" %self._formated)
if not self._formated:
if not time_expression:
time_expression=TimeExpression(self.searchfor)
if isinstance(time_expression, basestring):
time_expression=TimeExpression(time_expression)
DateFormat.logger.debug("format: time_expression: %s" %time_expression)
regexps=list()
if self.format_string.find("%Y")>=0:
regexps.append(("%Y", "%s" %(TimeExpression.toYearRegExp(time_expression.year))))
if self.format_string.find("%m")>=0:
regexps.append(("%m", "%s" %(TimeExpression.toMonthnumberRegExp(time_expression.month))))
if self.format_string.find("%d")>=0:
regexps.append(("%d", "%s" %(TimeExpression.toMonthDayRegExp(time_expression.day))))
if self.format_string.find("%h")>=0:
regexps.append(("%h", "%s" %(TimeExpression.toHourRegExp(time_expression.hour))))
if self.format_string.find("%M")>=0:
regexps.append(("%M", "%s" %(TimeExpression.toMinuteRegExp(time_expression.minute))))
if self.format_string.find("%S")>=0:
regexps.append(("%S", "%s" %(TimeExpression.toSecondRegExp(time_expression.second))))
if self.format_string.find("%b")>=0:
regexps.append(("%b", "%s" %(TimeExpression.toMonthnameRegExp(time_expression.month))))
import re
_format=self.format_string
for (regexp,subs) in regexps:
_format=re.sub(regexp, subs, _format)
self._format=_format
self._formated=True
return self._format
def getYear(self, default=""):
return self._getMatchValue("year", default)
def getMonth(self, default=""):
return self._getMatchValue("month", default)
def getDay(self, default=""):
return self._getMatchValue("day", default)
def getHour(self, default=""):
return self._getMatchValue("hour", default)
def getMinute(self, default=""):
return self._getMatchValue("minute", default)
def getSecond(self, default=""):
return self._getMatchValue("second", default)
def timeHash(self):
#if self.getMatch():
# DateFormat.logger.debug("%s/%s/%s:%s:%s:%s, match: %s" %(int(self.getYear("0")),\
# TimeExpression.toMonthnumber(self.getMonth("Jan"), False), int(self.getDay("0")),\
# int(self.getHour("0")),int(self.getMinute("0")), int(self.getSecond("0")), self.getMatch()))
return "%04u%02u%02u%02u%02u%02u" %(int(self.getYear("0")),\
int(TimeExpression.toMonthnumber(self.getMonth("Jan"), False)), int(self.getDay("0")),\
int(self.getHour("0")),int(self.getMinute("0")), int(self.getSecond("0")))
def _getMatchValue(self, _key, _default=""):
_value=_default
if self.getMatch():
try:
_value=self.getMatch().group(_key)
except IndexError:
pass
return _value
# here is some internal information
# $Id: ComUtils.py,v 1.1 2011-02-15 14:51:50 marc Exp $
#
__version__ = "$Revision: 1.1 $"
# $Source: /atix/ATIX/CVSROOT/nashead2004/management/comoonics-clustersuite/python/lib/comoonics/ecbase/ComUtils.py,v $
from exceptions import *
import re
from comoonics import ComLog
from comoonics import ComSystem
from comoonics.ComExceptions import ComException
log = ComLog.getLogger("ComUtils")
CMD_SFDISK = "/sbin/sfdisk"
def isInt(str):
""" Is the given string an integer? """
ok = 1
try:
num = int(str)
#log.debug(str + " is of int")
except ValueError:
#log.debug(str + " is not of int")
ok = 0
return ok
