rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
except Exception, msg: raise IOError, "ERROR: Could not get status64 on '%s'" % _fd | except Exception, (err, msg): if err == errno.ENXIO: raise IOError, "ERROR: Could not get status64 on '%s'" % _fd raise ValueError, "%s: %s" % (self.device, msg) | def _getInfo(self, fd=None): _fd = fd if not fd: try: _fd = open(self.device, "r") except: raise IOError, "ERROR: Could not open '%s'." % self.device info64 = self.__buildInfo64() try: info64 = fcntl.ioctl(_fd.fileno(), LOOP.LOOP_GET_STATUS64, info64) except Exception, msg: raise IOError, "ERROR: Could not get status64... |
except: | except IOError: | def lolist(): used = 0 free = 0 for i in xrange(LOOP.LOOP_MAX): dev = "/dev/loop%d" % i try: mode = os.stat(dev).st_mode except: continue if mode and stat.S_ISBLK(mode): l = LOOP(dev) try: l._getInfo() except: free += 1 continue used += 1 line = "%s: [%04x]:%d (%s)" % (dev, l.lo_device, l.lo_inode, l.lo_file_name) if l... |
del db for pkg in rpms: | for pkg in db.getPkgs(): | def __init__(self, config, rpms, operation): self.config = config self.list = HashList() # RpmPackage => RpmRelation self.__len__ = self.list.__len__ self.__getitem__ = self.list.__getitem__ self.has_key = self.list.has_key |
empty = 1 | l = len(self) | def __init__(self, config, rpms, operation): self.config = config self.list = HashList() # RpmPackage => RpmRelation self.__len__ = self.list.__len__ self.__getitem__ = self.list.__getitem__ self.has_key = self.list.has_key |
empty = 0 if empty: | if len(self) == l: | def __init__(self, config, rpms, operation): self.config = config self.list = HashList() # RpmPackage => RpmRelation self.__len__ = self.list.__len__ self.__getitem__ = self.list.__getitem__ self.has_key = self.list.has_key |
relations = RpmRelations(self.config, self.installs, OP_INSTALL) order2 = relations.genOrder() if order2 == None: return None order.extend(order2) | if len(self.installs) == 1: order.extend(self.installs) else: relations = RpmRelations(self.config, self.installs, OP_INSTALL) order2 = relations.genOrder() if order2 == None: return None order.extend(order2) | def genOrder(self): """Return an ordered list of RpmPackage's, first installs, then erases. |
relations = RpmRelations(self.config, self.erases, OP_ERASE) order2 = relations.genOrder() if order2 == None: return None order2.reverse() order.extend(order2) | if len(self.erases) == 1: order.extend(self.erases) else: relations = RpmRelations(self.config, self.erases, OP_ERASE) order2 = relations.genOrder() if order2 == None: return None order2.reverse() order.extend(order2) | def genOrder(self): """Return an ordered list of RpmPackage's, first installs, then erases. |
elif opt == "repo": self.parseSub(opt, args[1:], [ "url:" ]) | elif opt == "repo" or opt == "repository": self.parseSub("repository", args[1:], [ "url:" ]) | def parse(self, filename): self["filename"] = filename try: _fd = open(filename, "r") except: raise IOError, "Unable to open '%s'" % filename |
if self["device"] and self["device"].keys() not in [ "scsi", "eth" ]: raise ValueError, "device: type not valid." | if self["device"]: for key in self["device"].keys(): if key not in [ "scsi", "eth" ]: raise ValueError, "device: type %s not valid." % key | def verify(self): for tag in self.REQUIRED_TAGS: if not self[tag]: raise ValueError, "ERROR: %s is required." % tag |
if self["repo"]: for name in self["repo"]: repo = self["repo"][name] | if self["repository"]: for name in self["repository"]: repo = self["repository"][name] | def verify(self): for tag in self.REQUIRED_TAGS: if not self[tag]: raise ValueError, "ERROR: %s is required." % tag |
raise ValueError, "url not set for repo %s." % repo | raise ValueError, "url not set for repository %s." % repo | def verify(self): for tag in self.REQUIRED_TAGS: if not self[tag]: raise ValueError, "ERROR: %s is required." % tag |
print len(data) | def __removeId(self, db, tag, id, pkg, useidx=True, func=lambda x:str(x)): if not pkg.has_key(tag): return for idx in xrange(len(pkg[tag])): key = self.__getKey(tag, idx, pkg, useidx, func) if not db.has_key(key): continue data = db[key] ndata = "" print len(data) for i in xrange(0, len(data), 8): if not data[i:i+8] ==... | |
print len(ndata) | def __removeId(self, db, tag, id, pkg, useidx=True, func=lambda x:str(x)): if not pkg.has_key(tag): return for idx in xrange(len(pkg[tag])): key = self.__getKey(tag, idx, pkg, useidx, func) if not db.has_key(key): continue data = db[key] ndata = "" print len(data) for i in xrange(0, len(data), 8): if not data[i:i+8] ==... | |
print e | self.conf.printError(e) | def getDbFile(self, dbtype): cachebase = os.path.join(self.config.cachedir, self.reponame) cachepath = os.path.join(self.config.cachedir, self.reponame, "sqlite") |
print "X", csum, self.repomd[dbtype]["checksum"] | def getDbFile(self, dbtype): cachebase = os.path.join(self.config.cachedir, self.reponame) cachepath = os.path.join(self.config.cachedir, self.reponame, "sqlite") | |
result = [self.getPkgById(ob.pkgKey) for ob in cur.fetchall()] | result = [self.getPkgByKey(ob.pkgKey) for ob in cur.fetchall()] | def getPkgs(self): cur = self._primarydb.cursor() cur.execute('select pkgKey from packages') result = [self.getPkgById(ob.pkgKey) for ob in cur.fetchall()] return filter(None, result) |
dups[dirname + filename] = self.path[dirname][filename] | if len(self.path[dirname][filename]) > 1: dups[dirname + filename] = self.path[dirname][filename] | def duplicates(self): dups = { } for dirname in self.path.keys(): for filename in self.path[dirname].keys(): dups[dirname + filename] = self.path[dirname][filename] return dups |
if not self[opt]: | if not self.has_key(opt): | def parse(self, filename): self["filename"] = filename try: _fd = open(filename, "r") except: raise IOError, "Unable to open '%s'" % filename |
if self[opt]: | if self.has_key(opt): | def parse(self, filename): self["filename"] = filename try: _fd = open(filename, "r") except: raise IOError, "Unable to open '%s'" % filename |
e = self["epoch"] if e != None: return "%s:%s-%s" % (str(e[0]), self["version"], self["release"]) return "%s-%s" % (self["version"], self["release"]) | return "%s:%s-%s" % (self.getEpoch(), self["version"], self["release"]) | def getEVR(self): """Return [%epoch:]%version-%release.""" |
if self._pkgs.has_key(pkgKey): | if self._pkgs.has_key(pkgKey) and self._pkgs[pkgKey] is not None: | def addFilesToPkg(self, name, epoch, version, release, arch, filelist, filetypelist): """Add a package to the filelists cache""" cur = self._primarydb.cursor() fcur = self._filelistsdb.cursor() cur.execute('select pkgId, pkgKey from packages where name="%s" ' 'and epoch="%s" and version="%s" and release="%s" ' 'and arc... |
pkg.clearFilelist() | if pkg is not None: pkg.clearFilelist() | def importFilelist(self): # try mirror that just worked if self.getDbFile("filelists"): for pkg in self._pkgs.itervalues(): pkg.clearFilelist() return 1 for uri in self.source: self.nc = NetworkCache(uri, os.path.join(self.config.cachedir, self.reponame)) if not self.getDbFile("filelists"): continue for pkg in self._pk... |
if pkg.has_key("oldfilenames"): | if pkg is not None: | def importFilelist(self): # try mirror that just worked if self.getDbFile("filelists"): for pkg in self._pkgs.itervalues(): pkg.clearFilelist() return 1 for uri in self.source: self.nc = NetworkCache(uri, os.path.join(self.config.cachedir, self.reponame)) if not self.getDbFile("filelists"): continue for pkg in self._pk... |
"archivesize": (1046, RPM_INT32, 1, 1) | "archivesize": (1046, RPM_INT32, 1, 1), | def isErasePreReq(x): return (x & _ERASE_ONLY_MASK) |
"triggerpostun": (1102, RPM_STRING, None, 5), | "triggerpostun": (1102, RPM_STRING, None, 5) | def isErasePreReq(x): return (x & _ERASE_ONLY_MASK) |
"triggerpostun": (1102, RPM_STRING, None, 5) | "triggerpostun": (1102, RPM_STRING, None, 5), "install_size_in_sig": (257, RPM_INT32, 1, 0), "install_md5": (261, RPM_BIN, 16, 0), "install_dsaheader": (267, RPM_BIN, 16, 0), "install_sh1header": (269, RPM_STRING, None, 0), "installtime": (1008, RPM_INT32, None, 0), "filestates": (1029, RPM_INT32, None, 0), "installc... | def isErasePreReq(x): return (x & _ERASE_ONLY_MASK) != 0 |
for name, f, v, prog, scripts in l: | for name, f, v, prog, script in l: | def __executeTriggers(self, tlist, triggername, tnumPkgs): """execute a list of given triggers Return 1 on success, 0 on failure.""" result = 1 for spkg, l in tlist.iteritems(): snumPkgs = str(len(self.db.getPkgsByName(spkg["name"]))) for name, f, v, prog, scripts in l: try: runScript(prog, script, [snumPkgs, tnumPkgs... |
opkg = rethash[key1] key3 = opkg["name"]+"."+buildarchtranslate[opkg["arch"]] if key2 != key3: | if rethash.has_key(key2): opkg = rethash[key2] else: opkg = rethash[key1] if not pkg["arch"] == "noarch" and \ not opkg["arch"] == "noarch" and \ not archDuplicate(pkg["arch"], opkg["arch"]): if rethash.has_key(key2): raiseFatal("Impossible entry in selectNewestPkgs() found.") | def selectNewestPkgs(pkglist): """Filter the newest packages from given list and return new list""" rethash = {} for pkg in pkglist: key1 = pkg["name"]+".noarch" key2 = pkg["name"]+"."+buildarchtranslate[pkg["arch"]] if not rethash.has_key(key1): rethash[key1] = pkg rethash[key2] = pkg continue opkg = rethash[key1] key... |
try: | if rethash.has_key(key3): | def selectNewestPkgs(pkglist): """Filter the newest packages from given list and return new list""" rethash = {} for pkg in pkglist: key1 = pkg["name"]+".noarch" key2 = pkg["name"]+"."+buildarchtranslate[pkg["arch"]] if not rethash.has_key(key1): rethash[key1] = pkg rethash[key2] = pkg continue opkg = rethash[key1] key... |
except: pass | def selectNewestPkgs(pkglist): """Filter the newest packages from given list and return new list""" rethash = {} for pkg in pkglist: key1 = pkg["name"]+".noarch" key2 = pkg["name"]+"."+buildarchtranslate[pkg["arch"]] if not rethash.has_key(key1): rethash[key1] = pkg rethash[key2] = pkg continue opkg = rethash[key1] key... | |
print "ERROR: Failed to open '%s':" % buildroot+source, msg | print "ERROR: Failed to open '%s':" % source, msg | def copy_file(source, target): try: source_fd = open(source, "r") except Exception, msg: print "ERROR: Failed to open '%s':" % buildroot+source, msg return 1 try: target_fd = open(target, "w") except Exception, msg: print "ERROR: Failed to open '%s':" % buildroot+target, msg source_fd.close() return 1 data = source_fd.... |
print "ERROR: Failed to open '%s':" % buildroot+target, msg | print "ERROR: Failed to open '%s':" % target, msg | def copy_file(source, target): try: source_fd = open(source, "r") except Exception, msg: print "ERROR: Failed to open '%s':" % buildroot+source, msg return 1 try: target_fd = open(target, "w") except Exception, msg: print "ERROR: Failed to open '%s':" % buildroot+target, msg source_fd.close() return 1 data = source_fd.... |
self.config.printDebug(1, "-- STRONLY CONNECTED COMPONENTS --") | self.config.printDebug(1, "-- STRONGLY CONNECTED COMPONENTS --") | def genOrder(self): """Order rpms in orderer.RpmRelations relations. |
except Exception, msg: | except: | def setCloseOnExec(): import fcntl for fd in range(3, resource.getrlimit(resource.RLIMIT_NOFILE)[1]): try: fcntl.fcntl(fd, fcntl.F_SETFD, 1) #sys.stderr.write("set close-on-exec for fd=%d\n" % fd) except Exception, msg: #print msg pass |
self.io = None | self.io = None self.issrc = None | def __init__(self, config, source, verify=None, hdronly=None, db=None): RpmData.__init__(self, config) self.config = config self.clear() self.source = source self.verify = verify # Verify file format constraints and signatures self.hdronly = hdronly # Don't open the payload self.db = db # RpmDatabase sel... |
if self.io: return self.io.issrc | if self.issrc != None: return self.issrc | def isSourceRPM(self): """Return 1 if the package is a SRPM.""" |
sys.stdout.write(data) | self.fd.write(data) self.flush() | def write(self, data, level): sys.stdout.write(data) |
pass | self.flush() | def close(self): pass |
pass class _StdErrLog: def __init__(self): pass def open(self): pass | self.fd.flush() class _StderrLog(_StdoutLog): fd = sys.stderr class _SyslogLog(_StdoutLog): fd = None | def flush(self): pass |
sys.stderr.write(data) def close(self): pass def flush(self): pass class _SyslogLog: def __init__(self): pass def open(self): pass def write(self, data, level): if level == Logger.FATAL: priority = syslog.LOG_CRIT | if level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG elif level >= Logger.INFO1: priority = syslog.LOG_INFO elif level == Logger.WARNING: priority = syslog.LOG_WARNING | def write(self, data, level): sys.stderr.write(data) |
elif level == Logger.WARNING: priority = syslog.LOG_WARNING elif level == Logger.INFO: priority = syslog.LOG_INFO elif level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG | elif level == Logger.FATAL: priority = syslog.LOG_CRIT | def write(self, data, level): if level == Logger.FATAL: priority = syslog.LOG_CRIT elif level == Logger.ERROR: priority = syslog.LOG_ERR elif level == Logger.WARNING: priority = syslog.LOG_WARNING elif level == Logger.INFO: priority = syslog.LOG_INFO elif level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG if data.end... |
def close(self): pass | def close(self): pass | |
""" Format string | r""" Format string: | def flush(self): pass |
log.setLogLevel(log.DEBUG2) log.setLogLabel(log.INFO, "INFO: ") | log.setLogLevel(log.INFO1) log.setDebugLogLevel(log.NO_DEBUG) for i in xrange(1, log.INFO_MAX-log.NO_INFO+1): log.setLogLabel(i+log.NO_INFO, "INFO%d: " % i) | def flush(self): pass |
log.addLogging("*", FileLog("/tmp/log", "a")) log.debug3ln("debug3") log.debug2ln("debug2") log.debug1ln("debug1") log.infoln("info") | log.addLogging("*", Logger.syslog, format="%(label)s%(message)s") log.debug3Ln("debug3") log.debug2Ln("debug2") log.debug1Ln("debug1") log.infoLn("info") | def flush(self): pass |
log.fatalln("fatal") log.logln(log.INFO, "raw info") | log.fatalLn("fatal") log.logLn(log.INFO, "raw info") | def flush(self): pass |
ALL = None FATAL = -3 ERROR = -2 WARNING = -1 INFO = 0 DEBUG1 = 1 DEBUG2 = 2 DEBUG3 = 3 DEBUG4 = 4 DEBUG5 = 5 DEBUG6 = 6 DEBUG7 = 7 DEBUG8 = 8 DEBUG9 = 9 DEBUG10 = 10 stdout = _StdOutLog() stderr = _StdErrLog() | ALL = -1 NOTHING = 0 FATAL = 1 ERROR = 2 WARNING = 3 stdout = _StdoutLog() stderr = _StderrLog() | def flush(self): pass |
def __init__(self): self._level = -10 | def __init__(self, info_max=5, debug_max=10): """ Logger class initialization """ self._level = 0 self._debug_level = 0 | def __init__(self): self._level = -10 self._format = "" self._date_format = "" self._label = { } self._logging = { } |
self.setLogLevel(self.INFO) | self._domains = { } if info_max < 2: raise ValueError, "Logger: info_max %d is too low" % info_max if debug_max < 2: raise ValueError, "Logger: debug_max %d is too low" % debug_max self.NO_INFO = self.WARNING self.INFO_MAX = self.NO_INFO + info_max self.NO_DEBUG = self.INFO_MAX self.DEBUG_MAX = self.NO_DEBUG + de... | def __init__(self): self._level = -10 self._format = "" self._date_format = "" self._label = { } self._logging = { } |
self.setLogLabel(self.INFO, "") for _level in xrange(self.DEBUG1, self.DEBUG10+1): self.setLogLabel(_level, "DEBUG%d: ") | for _level in xrange(1, self.INFO_MAX-self.NO_INFO+1): setattr(self, "INFO%d" % _level, _level+self.NO_INFO) self.setLogLabel(_level+self.NO_INFO, "") setattr(self, "info%d" % (_level), (lambda self, x: lambda message, *args: self.info(x, message, *args))(self, _level)) setattr(self, "info%dLn" % (_level), (lambda self... | def __init__(self): self._level = -10 self._format = "" self._date_format = "" self._label = { } self._logging = { } |
[ i for i in xrange(self.WARNING, self.DEBUG10+1) ]) def _checkLogLevel(self, level, min=FATAL, max=DEBUG10): | [ i for i in xrange(self.WARNING, self.DEBUG_MAX+1) ]) def close(self): """ Close all logging targets """ for level in xrange(self.FATAL, self.DEBUG_MAX+1): if not self._logging.has_key(level): continue for (domain, target, _format) in self._logging[level]: target.close() def _checkLogLevel(self, level, min, max): | def __init__(self): self._level = -10 self._format = "" self._date_format = "" self._label = { } self._logging = { } |
self._checkLogLevel(level) | self._checkLogLevel(level, min=self.FATAL, max=self.INFO_MAX) | def setLogLevel(self, level): self._checkLogLevel(level) self._level = level |
def setLogLabel(self, level, label): self._checkLogLevel(level) self._label[level] = label | def setDebugLogLevel(self, level): """ Set debug log level [NO_DEBUG .. DEBUG_MAX] """ self._checkLogLevel(level-self.NO_DEBUG, min=0, max=self.DEBUG_MAX-self.NO_DEBUG) self._debug_level = level - self.NO_DEBUG | def setLogLabel(self, level, label): self._checkLogLevel(level) self._label[level] = label |
def setLogging(self, domain, target, level=ALL, format=None): if level: | def _getLevels(self, level): """ Generate log level array. """ if level != self.ALL: | def setLogging(self, domain, target, level=ALL, format=None): if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] for level in leve... |
self._checkLogLevel(level) | self._checkLogLevel(level, min=self.FATAL, max=self.DEBUG_MAX) | def setLogging(self, domain, target, level=ALL, format=None): if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] for level in leve... |
levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] | levels = [ i for i in xrange(self.FATAL, self.DEBUG_MAX+1) ] return levels def setLogLabel(self, level, label): """ Set log label for level. Level can be a single level or an array of levels. """ levels = self._getLevels(level) for level in levels: self._checkLogLevel(level, min=self.FATAL, max=self.DEBUG_MAX) self._l... | def setLogging(self, domain, target, level=ALL, format=None): if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] for level in leve... |
if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] | levels = self._getLevels(level) | def addLogging(self, domain, target, level=ALL, format=None): if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] for level in leve... |
if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] | levels = self._getLevels(level) | def delLogging(self, domain, target, level=ALL, format=None): if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] for level in leve... |
if self._logging.has_key(level): if (domain, target, format) in self._logging[level]: self._logging[level].remove( (domain, target, format) ) if len(self._logging[level]) == 0: del self._logging[level] return | if not self._logging.has_key(level): continue if (domain, target, format) in self._logging[level]: self._logging[level].remove( (domain, target, format) ) if len(self._logging[level]) == 0: del self._logging[level] return | def delLogging(self, domain, target, level=ALL, format=None): if level: if isinstance(level, types.ListType) or \ isinstance(level, types.TupleType): levels = level else: levels = [ level ] for level in levels: self._checkLogLevel(level) else: levels = [ i for i in xrange(self.FATAL, self.DEBUG10+1) ] for level in leve... |
self._checkLogLevel(level) | self._checkLogLevel(level, min=self.FATAL, max=self.DEBUG_MAX) | def log(self, level, data): self._checkLogLevel(level) self._log(level, 0, 1, "%s", data) |
def logln(self, level, data): self._checkLogLevel(level) | def logLn(self, level, data): """ Log data without and prefix, but append a newline. """ self._checkLogLevel(level, min=self.FATAL, max=self.DEBUG_MAX) | def logln(self, level, data): self._checkLogLevel(level) self._log(level, 1, 1, "%s", data) |
self._checkLogLevel(min=Logger.DEBUG1) self._log(level, 0, 0, format, *args) def debugln(self, level, format, *args): self._checkLogLevel(level, min=Logger.DEBUG1) self._log(level, 1, 0, format, *args) def info(self, format, *args): self._log(Logger.INFO, 0, 0, format, *args) def infoln(self, format, *args): self._l... | self._checkLogLevel(level, min=self.DEBUG1-self.NO_DEBUG, max=self.DEBUG_MAX-self.NO_DEBUG) self._log(level+self.NO_DEBUG, 0, 0, format, *args) def debugLn(self, level, format, *args): """ Debug log with newline using debug level [1..debug_max]. There are additional debugxLn functions according to debug_max from __ini... | def debug(self, level, format, *args): self._checkLogLevel(min=Logger.DEBUG1) self._log(level, 0, 0, format, *args) |
self._log(Logger.WARNING, 0, 0, format, *args) def warningln(self, format, *args): self._log(Logger.WARNING, 1, 0, format, *args) | self._log(self.WARNING, 0, 0, format, *args) def warningLn(self, format, *args): """ Warning log with newline. """ self._log(self.WARNING, 1, 0, format, *args) | def warning(self, format, *args): self._log(Logger.WARNING, 0, 0, format, *args) |
self._log(Logger.ERROR, 0, 0, format, *args) def errorln(self, format, *args): self._log(Logger.ERROR, 1, 0, format, *args) | self._log(self.ERROR, 0, 0, format, *args) def errorLn(self, format, *args): """ Error log with newline. """ self._log(self.ERROR, 1, 0, format, *args) | def error(self, format, *args): self._log(Logger.ERROR, 0, 0, format, *args) |
self._log(Logger.FATAL, 0, 0, format, *args) def fatalln(self, format, *args): self._log(Logger.FATAL, 1, 0, format, *args) | self._log(self.FATAL, 0, 0, format, *args) def fatalLn(self, format, *args): """ Fatal error log with newline. """ self._log(self.FATAL, 1, 0, format, *args) | def fatal(self, format, *args): self._log(Logger.FATAL, 0, 0, format, *args) |
if level > self._level: return | if level > self.INFO_MAX: if level-self.INFO_MAX > self._debug_level: return else: if level > self._level: return | def _log(self, level, newline, raw, format, *args): # log level higher than logging level? if level > self._level: return |
domains = [ ] for (domain, target, _format) in self._logging[level]: if domain == "": domain = "*" if domain not in domains: domains.append(domain) | def _log(self, level, newline, raw, format, *args): # log level higher than logging level? if level > self._level: return | |
if len(domains) < 0: | if not self._domains.has_key(level) or len(self._domains[level]) < 1: | def _log(self, level, newline, raw, format, *args): # log level higher than logging level? if level > self._level: return |
for domain in domains: | for domain in self._domains[level]: | def _log(self, level, newline, raw, format, *args): # log level higher than logging level? if level > self._level: return |
if self._format.find("%(domain)") >= 0 or \ self._format.find("%(class)") >= 0 or \ (len(domains) > 1 and domains[0] != "*"): | if self._format.find("%(domain)") >= 0 \ or self._format.find("%(class)") >= 0 \ or len(self._domains[level]) > 1 \ or self._domains[level][0] != "*": | def _log(self, level, newline, raw, format, *args): # log level higher than logging level? if level > self._level: return |
if domain == "*" or point_domain.startswith(domain) or \ fnmatch.fnmatch(dict["domain"], domain): | if domain == "*" or point_domain.startswith(domain) \ or fnmatch.fnmatch(dict["domain"], domain): | def _log(self, level, newline, raw, format, *args): # log level higher than logging level? if level > self._level: return |
for _level in xrange(Logger.DEBUG1, Logger.DEBUG10+1): setattr(Logger, "debug%d" % (_level), (lambda x: lambda self, message, *args: self.debug(x, message, *args))(_level)) setattr(Logger, "debug%dln" % (_level), (lambda x: lambda self, message, *args: self.debugln(x, message, *args))(_level)) del _level | def _log(self, level, newline, raw, format, *args): # log level higher than logging level? if level > self._level: return | |
if self.fd: self.fd.flush() | if not self.fd: return self.fd.flush() | def flush(self): if self.fd: self.fd.flush() |
log.setLogLevel(log.DEBUG2) log.setLogLabel(log.INFO, "INFO: ") | log.setLogLevel(log.INFO2) log.setDebugLogLevel(log.DEBUG3) for i in xrange(1, log.INFO_MAX-log.NO_INFO+1): log.setLogLabel(i+log.NO_INFO, "INFO%d: " % i) | def flush(self): if self.fd: self.fd.flush() |
log.debug3ln("debug3") log.debug2ln("debug2") log.debug1ln("debug1") log.infoln("info") | log.debug10Ln("debug10") log.debug9Ln("debug9") log.debug8Ln("debug8") log.debug7Ln("debug7") log.debug6Ln("debug6") log.debug5Ln("debug5") log.debug4Ln("debug4") log.debug3Ln("debug3") log.debug2Ln("debug2") log.debug1Ln("debug1") log.info5Ln("info5") log.info4Ln("info4") log.info3Ln("info3") log.info2Ln("info2") log.... | def flush(self): if self.fd: self.fd.flush() |
log.fatalln("fatal") log.logln(log.INFO, "raw info") | log.fatalLn("fatal") log.logLn(log.INFO1, "raw info") | def flush(self): if self.fd: self.fd.flush() |
coll = RpmDistributonCollection(self, name, abbr) | coll = RpmDistributionCollection(self, name, abbr) | def readConfig(self, filename): """read distribution definition from config file""" config = ConfigParser.ConfigParser() config.readfp(open(filename)) self.name = config.get(self.CONF_MAIN, self.CONF_NAME) self.abbr = config.get(self.CONF_MAIN, self.CONF_ABBR) if len(self.name)==0 or len(self.abbr)==0: raise ParsingErr... |
coll.appendDirecorty(o, config.get(x, o)) | coll.appendDirectory(o, config.get(x, o)) | def readConfig(self, filename): """read distribution definition from config file""" config = ConfigParser.ConfigParser() config.readfp(open(filename)) self.name = config.get(self.CONF_MAIN, self.CONF_NAME) self.abbr = config.get(self.CONF_MAIN, self.CONF_ABBR) if len(self.name)==0 or len(self.abbr)==0: raise ParsingErr... |
class RpmDistributonCollection: """part of distrinution, an exmaple GA, updates, extras ...""" | class RpmDistributionCollection: """part of distribution, for example GA, updates, extras ...""" | def getRpmPackagesLists(self, arch, tags=None): pkgs = [] for c in self.colls: pkgs.append(c.getRpmPackages(arch, tags)) return pkgs |
def appendDirecorty(self, arch, path): | def appendDirectory(self, arch, path): | def appendDirecorty(self, arch, path): """add directory with files to collection""" if not self.dirs.has_key(arch): self.dirs[arch] = [] if path not in self.dirs[arch]: self.dirs[arch].append(path) |
return self._level = level | return self._level | def getLogLevel(self): """ Get log level. """ return self._level = level |
if level < self.NO_LOG: level = self.NO_LOG | if level < self.NOTHING: level = self.NOTHING | def setLogLevel(self, level): """ Set log level [NOTHING .. INFO_MAX] """ if level < self.NO_LOG: level = self.NO_LOG if level > self.INFO_MAX: level = self.INFO_MAX self._level = level |
elif skip_tags and skip_tags.has_key(tagname): | elif skip_tags.has_key(tagname): | def writeHeader(tags, taghash, region, skip_tags, useinstall, rpmgroup): """Use the data "tags" and change it into a rpmtag header.""" (offset, store, stags1, stags2, stags3) = (0, [], [], [], []) # Sort by number and also first normal tags, then install_keys tags # and at the end the region tag. for tagname in tags.ke... |
if filename.startswith("http://") or \ filename.startswith("ftp://") or \ filename.startswith("file://"): return 1 | for url in ("http://", "ftp://", "file://"): if filename.startswith(url): return 1 | def isUrl(filename): if filename.startswith("http://") or \ filename.startswith("ftp://") or \ filename.startswith("file://"): return 1 return 0 |
print "warning: user %s not found, using uid 0" % uid | print "Warning: user %s not found, using uid 0." % uid | def transform(self, buildroot): # "uid=0" if no /etc/passwd exists at all. if not os.path.isfile(buildroot + "/etc/passwd"): for uid in self.ugid.keys(): self.ugid[uid] = 0 if uid != "root": print "warning: user %s not found, using uid 0" % uid return # Parse /etc/passwd if glibc is not yet installed. if buildroot or n... |
print "warning: group %s not found, using gid 0" % gid | print "Warning: group %s not found, using gid 0." % gid | def transform(self, buildroot): # "gid=0" if no /etc/group exists at all. if not os.path.isfile(buildroot + "/etc/group"): for gid in self.ugid.keys(): self.ugid[gid] = 0 if gid != "root": print "warning: group %s not found, using gid 0" % gid return # Parse /etc/group if glibc is not yet installed. if buildroot or not... |
def __openFd(self, offset=None): | def __openFd(self, offset=None, headerend=None): | def __openFd(self, offset=None): if not self.fd: if isUrl(self.filename): import urlgrabber try: self.fd = urlgrabber.urlopen(self.filename) #except urlgrabber.grabber.URLGrabError, e: # raise IOError, str(e) except urlgrabber.grabber.URLGrabError: self.printErr("could not open file") return 1 else: try: self.fd = o... |
self.fd = urlgrabber.urlopen(self.filename) | if offset or headerend: self.fd = urlgrabber.urlopen(self.filename, range=(offset, headerend)) else: self.fd = urlgrabber.urlopen(self.filename) | def __openFd(self, offset=None): if not self.fd: if isUrl(self.filename): import urlgrabber try: self.fd = urlgrabber.urlopen(self.filename) #except urlgrabber.grabber.URLGrabError, e: # raise IOError, str(e) except urlgrabber.grabber.URLGrabError: self.printErr("could not open file") return 1 else: try: self.fd = o... |
def readHeader(self, sigtags, hdrtags, keepdata=None, rpmdb=None): | def setHdr(self): self.__getitem__ = self.hdr.__getitem__ self.__delitem__ = self.hdr.__delitem__ self.__setitem__ = self.hdr.__setitem__ self.__contains__ = self.hdr.__contains__ self.has_key = self.hdr.has_key self.__repr__ = self.hdr.__repr__ def readHeader(self, sigtags, hdrtags, keepdata=None, rpmdb=None, headere... | def readHeader(self, sigtags, hdrtags, keepdata=None, rpmdb=None): if rpmdb == None: if self.__openFd(): return 1 leaddata = doRead(self.fd, 96) if leaddata[:4] != "\xed\xab\xee\xdb": self.printErr("no rpm magic found") return 1 self.issrc = (leaddata[7] == "\x01") if self.verify: self.__verifyLead(leaddata) sigdata = ... |
if self.__openFd(): | if self.__openFd(None, headerend): | def readHeader(self, sigtags, hdrtags, keepdata=None, rpmdb=None): if rpmdb == None: if self.__openFd(): return 1 leaddata = doRead(self.fd, 96) if leaddata[:4] != "\xed\xab\xee\xdb": self.printErr("no rpm magic found") return 1 self.issrc = (leaddata[7] == "\x01") if self.verify: self.__verifyLead(leaddata) sigdata = ... |
self.__getitem__ = self.hdr.__getitem__ self.__delitem__ = self.hdr.__delitem__ self.__setitem__ = self.hdr.__setitem__ self.__contains__ = self.hdr.__contains__ self.has_key = self.hdr.has_key self.__repr__ = self.hdr.__repr__ | self.setHdr() | def readHeader(self, sigtags, hdrtags, keepdata=None, rpmdb=None): if rpmdb == None: if self.__openFd(): return 1 leaddata = doRead(self.fd, 96) if leaddata[:4] != "\xed\xab\xee\xdb": self.printErr("no rpm magic found") return 1 self.issrc = (leaddata[7] == "\x01") if self.verify: self.__verifyLead(leaddata) sigdata = ... |
self.printErr("non-zero hardlink file, but not the last: %s" % filename) | self.printErr("non-zero hardlink file, " + \ "but not the last: %s" % filename) | def verifyCpio(self, filedata, read_data, filenamehash, devinode, _): # Overall result is that apart from the filename information # we should not depend on any data from the cpio header. # Data is also stored in rpm tags and the cpio header has # been broken in enough details to ignore it. (filename, inode, mode, nlin... |
def getNVR(self): return "%s-%s-%s" % (self["name"], self["version"], self["release"]) def getNA(self): return "%s.%s" % (self["name"], self["arch"]) def getEVR(self): e = self["epoch"] if e != None: return "%d:%s-%s" % (e[0], self["version"], self["release"]) return "%s-%s" % (self["version"], self["release"]) | def getNVR(self): return "%s-%s-%s" % (self["name"], self["version"], self["release"]) | |
None, useinstall, rpmgroup) | {}, useinstall, rpmgroup) | def __verifyWriteHeader(self, hdrhash, taghash, region, hdrdata, useinstall, rpmgroup): (indexNo, storeSize, fmt, fmt2) = writeHeader(hdrhash, taghash, region, None, useinstall, rpmgroup) if (indexNo, storeSize, fmt, fmt2) != (hdrdata[0], hdrdata[1], hdrdata[3], hdrdata[4]): self.printErr("(rpm-%s) writeHeader() would ... |
if "-" in self["version"] or ":" in self["version"]: self.printErr("version contains wrong char") if ":" in self["release"]: self.printErr("version contains wrong char") | def __doVerify(self): self.__verifyWriteHeader(self.hdr.hash, rpmtag, "immutable", self.hdrdata, 1, self.rpmgroup) if self.strict: self.__verifyWriteHeader(self.sig.hash, rpmsigtag, "header_signatures", self.sigdata, 0, None) # disable the utf-8 test per default, should check against self.verbose: if self.strict and No... | |
if "," in self["version"] or "," in self["release"]: self.printErr("version contains wrong char") | for i in ("-", ":"): if i in self["version"] or i in self["release"]: self.printErr("version/release contains wrong char") for i in (",", " ", "\t"): if i in self["name"] or i in self["version"] or \ i in self["release"]: self.printErr("name/version/release contains wrong char") | def __doVerify(self): self.__verifyWriteHeader(self.hdr.hash, rpmtag, "immutable", self.hdrdata, 1, self.rpmgroup) if self.strict: self.__verifyWriteHeader(self.sig.hash, rpmsigtag, "header_signatures", self.sigdata, 0, None) # disable the utf-8 test per default, should check against self.verbose: if self.strict and No... |
def verifyRpm(filename, verify, strict, payload, nodigest, hdrtags, keepdata): | def verifyRpm(filename, verify, strict, payload, nodigest, hdrtags, keepdata, headerend): | def verifyRpm(filename, verify, strict, payload, nodigest, hdrtags, keepdata): """Read in a complete rpm and verify its integrity.""" rpm = ReadRpm(filename, verify, strict=strict, nodigest=nodigest) if rpm.readHeader(rpmsigtag, hdrtags, keepdata): return None if payload: rpm.readPayload(rpm.verifyCpio) rpm.closeFd() r... |
if rpm.readHeader(rpmsigtag, hdrtags, keepdata): | if not nodigest or payload: headerend = None if rpm.readHeader(rpmsigtag, hdrtags, keepdata, headerend=headerend): | def verifyRpm(filename, verify, strict, payload, nodigest, hdrtags, keepdata): """Read in a complete rpm and verify its integrity.""" rpm = ReadRpm(filename, verify, strict=strict, nodigest=nodigest) if rpm.readHeader(rpmsigtag, hdrtags, keepdata): return None if payload: rpm.readPayload(rpm.verifyCpio) rpm.closeFd() r... |
if os.geteuid() == 0: owner = 1 | def extractRpm(filename, buildroot, owner=None): """Extract a rpm into a directory.""" if isinstance(filename, basestring): rpm = ReadRpm(filename) if rpm.readHeader(rpmsigtag, rpmtag): return None else: rpm = filename rpm.buildroot = buildroot if rpm.issrc: if not buildroot.endswith("/") and buildroot != "": buildroot... | |
def cmpRpms(one, two): evr1 = (one.getEpoch(), one["version"], one["release"]) evr2 = (two.getEpoch(), two["version"], two["release"]) return labelCompare(evr1, evr2) | class HashList: """ hash list """ def __init__(self): self.list = [] self.hash = {} self.__len__ = self.list.__len__ self.__repr__ = self.list.__repr__ self.has_key = self.hash.has_key self.keys = self.hash.keys def __getitem__(self, key): if isinstance(key, IntType): return self.list[key] return self.hash.get(key) ... | def cmpRpms(one, two): evr1 = (one.getEpoch(), one["version"], one["release"]) evr2 = (two.getEpoch(), two["version"], two["release"]) return labelCompare(evr1, evr2) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.