rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
if operation == OP_UPDATE: if pkg1["name"] == pkg2["name"]: return 0 else: if pkg1.getNEVR() == pkg2.getNEVR() and \ buildarchtranslate[pkg1["arch"]] != \ buildarchtranslate[pkg2["arch"]] and \ pkg1["arch"] != "noarch" and \ pkg2["arch"] != "noarch": return 0 fi = pkg2.getRpmFileInfo(filename) | def _hasFileConflict(self, pkg1, pkg2, filename, pkg1_fi, operation=OP_INSTALL): """RpmPackage's pkg1 and pkg2 share filename. | |
for r in self[name]: self.config.printDebug(1, "Checking dependencies for %s" % r.getNEVRA()) (unresolved, resolved) = self.getPkgDependencies(r) | for pkg in self[name]: unresolved = [ ] for u in pkg["requires"]: if u[0].startswith("rpmlib("): continue s = self.searchDependency(u, pkg["arch"]) if len(s) > 0: continue if self.config.checkinstalled == 0 and \ pkg in self.installed_unresolved and \ u in self.installed_unresolved[pkg]: continue unresolved.append(u) | def getUnresolvedDependencies(self): """Get all unresolved dependencies. |
if r not in all_unresolved: all_unresolved[r] = [ ] all_unresolved[r].extend(unresolved) | if pkg not in all_unresolved: all_unresolved[pkg] = [ ] all_unresolved[pkg].extend(unresolved) | def getUnresolvedDependencies(self): """Get all unresolved dependencies. |
if self.config.verbose > 1: for f,r in conflicts[pkg]: self.config.printError("\t'%s' <=> %s" % (f, r.getNEVRA())) else: pkgs = [ ] for f,r in conflicts[pkg]: if r not in pkgs: self.config.printError("\t%s" % r.getNEVRA()) pkgs.append(r) | for f,r in conflicts[pkg]: self.config.printError("\t'%s' on %s" % (r.getNEVRA(), r)) | def checkFileConflicts(self): """Check file conflicts, report errors. |
"checkrpmdb", "buildroot=", "installroot=", "root=", "version", "baseurl=", "createrepo", "mercurial"]) | "checkrpmdb", "checkdeps", "buildroot=", "installroot=", "root=", "version", "baseurl=", "createrepo", "mercurial"]) | def main(): import getopt global cachedir if len(sys.argv) <= 1: usage() return 0 (_, hostname, kernelversion, _, arch) = os.uname() owner = None if os.geteuid() == 0: owner = 1 homedir = os.environ.get("HOME", "") if homedir and not owner: cachedir = homedir + "/.pyrpm/cache/" if not os.path.isdir(cachedir): print "Cr... |
if strict or wait: | if checkdeps or strict or wait: | def main(): import getopt global cachedir if len(sys.argv) <= 1: usage() return 0 (_, hostname, kernelversion, _, arch) = os.uname() owner = None if os.geteuid() == 0: owner = 1 homedir = os.environ.get("HOME", "") if homedir and not owner: cachedir = homedir + "/.pyrpm/cache/" if not os.path.isdir(cachedir): print "Cr... |
if os.path.exists(path): return os.path.join(path) return None if self.__isURI(uri): sourceurl = uri else: sourceurl = os.path.join(self.baseurl, uri) | try: return path except: return None sourceurl = self.__createSourceURI(uri) | def cache(self, uri, force=0): """Cache the given uri/file. If the uri is a real uri then we cache it in our external cache, otherwise we use our baseurl and treat the parameter as a relative path to it.""" |
except URLGrabError, e: | except Exception, e: | def cache(self, uri, force=0): """Cache the given uri/file. If the uri is a real uri then we cache it in our external cache, otherwise we use our baseurl and treat the parameter as a relative path to it.""" |
for p in pkg["provides"]: sr = self.database.searchRequires(p[0], p[1], p[2]) if len(sr) > 0: sp = self.database.searchProvides(p[0], p[1], p[2]) if len(sp) > 0: continue for p in sr: all_unresolved.setdefault(p, [ ]).extend(sr[p]) | for dep in pkg["provides"]: sr = self.database.searchRequires(dep[0], dep[1], dep[2]) for p in sr: for d in sr[p]: sp = self.database.searchProvides(d[0], d[1], d[2]) if len(sp) > 0: continue all_unresolved.setdefault(p, [ ]).append(d) | def getUnresolvedDependencies(self): """Get all unresolved dependencies. |
unresolved = [ ] | def getUnresolvedDependencies(self): """Get all unresolved dependencies. | |
unresolved.append(u) if len(unresolved) > 0: all_unresolved.setdefault(pkg, [ ]).extend(unresolved) | all_unresolved.setdefault(pkg, [ ]).append(u) | def getUnresolvedDependencies(self): """Get all unresolved dependencies. |
self.repos_read = 1 | def prepareTransaction(self): """Open the RPM database and prepare the transaction. | |
ret = self.__handleUpdatePkglist(pkg, pkg_list) | ret = self.__handleUpdatePkglist(pkg, pkg_list, dep[0][0] == '/') | def __resolveDep(self, pkg, dep): """Attempt to resolve (name, RPMSENSE_* flag, EVR string) dependency of RpmPackage pkg. |
def __handleUpdatePkglist(self, pkg, pkg_list): | def __handleUpdatePkglist(self, pkg, pkg_list, is_filereq=0): | def __handleUpdatePkglist(self, pkg, pkg_list): """Choose a package from a list of RpmPackage's pkg_list that has the same base arch as RpmPackage pkg, and add it to self.opresolver. |
if not (upkg["arch"] == "noarch" or \ pkg["arch"] == "noarch" or \ buildarchtranslate[upkg["arch"]] == buildarchtranslate[pkg["arch"]]): | if not (is_filereq or \ archDuplicate(upkg["arch"], pkg["arch"]) or \ archCompat(upkg["arch"], pkg["arch"]) or \ archCompat(pkg["arch"], upkg["arch"])): | def __handleUpdatePkglist(self, pkg, pkg_list): """Choose a package from a list of RpmPackage's pkg_list that has the same base arch as RpmPackage pkg, and add it to self.opresolver. |
if pkg != None and not pkg in s: continue | if not pkg in s: continue | def __handleObsoletes(self, pkg=None): """Try to replace RpmPackage pkg in self.opresolver by a package obsoleting it, iterate until no obsoletes: applies. |
for p in header["provides"]: if p[0] != header["name"]: continue if (p[1] & RPMSENSE_EQUAL) != 8: continue if p[2] == header.getEVR(): found_selfprovide = 1 | if header["provides"]: for p in header["provides"]: if p[0] != header["name"]: continue if (p[1] & RPMSENSE_EQUAL) != 8: continue if p[2] == header.getEVR(): found_selfprovide = 1 | def _generateHeader(self, header, padding=1, skip_tags=[]): """Return (index data, data area) representing signature header (tag name => tag value). |
if self.has_key(name): return self.get(name) | if dict.has_key(self, name): return dict.get(self, name) | def __getitem__(self, name): if self.has_key(name): return self.get(name) if name in ('requires','provides','conflicts','obsoletes'): self[name] = self.yumrepo.getDependencies(name, self['pkgKey']) return self[name] if name in ('basenames', 'dirnames', 'dirindexes', 'oldfilenames'): if (not self.has_key('basenames') an... |
self[name] = self.yumrepo.getDependencies(name, self['pkgKey']) return self[name] if name in ('basenames', 'dirnames', 'dirindexes', 'oldfilenames'): if (not self.has_key('basenames') and not self.has_key('oldfilenames')): self.yumrepo.getFiles(self) return self.get(name, None) | deps = self.yumrepo.getDependencies(name, self['pkgKey']) self[name] = deps return deps if (name in ('basenames', 'dirnames', 'dirindexes', 'oldfilenames') and not self.filesloaded): self.filesloaded = True self.yumrepo.getFiles(self) return self.get(name, None) def get(self, key, value=None): if self.has_key(key): re... | def __getitem__(self, name): if self.has_key(name): return self.get(name) if name in ('requires','provides','conflicts','obsoletes'): self[name] = self.yumrepo.getDependencies(name, self['pkgKey']) return self[name] if name in ('basenames', 'dirnames', 'dirindexes', 'oldfilenames'): if (not self.has_key('basenames') an... |
self._db.commit() | self._filelistsdb.commit() | def createFilelistsTables(self): """Create the required tables for filelists metadata in the sqlite database""" cur = self._filelistsdb.cursor() self.createDbInfo(cur) # This table is needed to match pkgKeys to pkgIds cur.execute("""CREATE TABLE packages( pkgKey INTEGER PRIMARY KEY, pkgId TEXT) """) cur.execute("""CREA... |
self._db.commit() | self._othersdb.commit() | def createOthersTables(self): """Create the required tables for other.xml.gz metadata in the sqlite database""" cur = self._othersdb.cursor() self.createDbInfo(cur) # This table is needed to match pkgKeys to pkgIds cur.execute("""CREATE TABLE packages( pkgKey INTEGER PRIMARY KEY, pkgId TEXT) """) cur.execute("""CREATE ... |
pkg['basenames'] = basenames pkg['dirnames'] = dirnames pkg['dirindexes'] = dirindexes | if basenames: pkg['basenames'] = basenames pkg['dirnames'] = dirnames pkg['dirindexes'] = dirindexes | def getFiles(self, pkg): pkgKey = pkg['pkgKey'] if self._filelistsdb: cur = self._filelistsdb.cursor() cur.execute("SELECT * FROM filelist WHERE pkgKey=%s" % pkgKey) basenames = [] dirnames = [] dirindexes = [] for ob in cur.fetchall(): idx = len(dirnames) base = ob.filenames.split('/') dirnames.append(ob.dirname + '/'... |
pkg['oldfilenames'] = [ob.name for ob in cur.fetchall()] | files = [ob.name for ob in cur.fetchall()] if files: pkg['oldfilenames'] = files pkg.generateFileNames() | def getFiles(self, pkg): pkgKey = pkg['pkgKey'] if self._filelistsdb: cur = self._filelistsdb.cursor() cur.execute("SELECT * FROM filelist WHERE pkgKey=%s" % pkgKey) basenames = [] dirnames = [] dirindexes = [] for ob in cur.fetchall(): idx = len(dirnames) base = ob.filenames.split('/') dirnames.append(ob.dirname + '/'... |
pkg[name] = data[key] | val = data[key] if val is not None and name in base.rpmtag: pkg[name] = val | def _buildRpm(self, data): pkg = SqliteRpmPackage(self.config, source='', db=self) pkg.yumrepo = self for key in data.keys(): name = self.DB2PKG.get(key, key) pkg[name] = data[key] pkg['epoch'] = [int(pkg['epoch'])] pkg.source = data['location_href'] pkg.issrc = 0 pkg["triggers"] = [] return pkg |
(ttype == RPM_STRING or ttype == RPM_I18N_STRING): | (ttype == RPM_STRING or ttype == RPM_I18NSTRING): | def __verifyTag(self, index, fmt, hdrtags): (tag, ttype, offset, count) = index if not hdrtags.has_key(tag): self.printErr("hdrtags has no tag %d" % tag) else: t = hdrtags[tag] if t[1] != None and t[1] != ttype: if t[1] == RPM_ARGSTRING and \ (ttype == RPM_STRING or ttype == RPM_STRING_ARRAY): pass # special excepti... |
if self["arch"] in arch_compats[pkg["arch"]]: | if not archDuplicate(self["arch"], pkg["arch"]) and \ self["arch"] in arch_compats[pkg["arch"]]: | def __verifyFileInstall(self, rfi, db): # No db -> overwrite file ;) if not db: return 1 # File is not a regular file -> just do it if not S_ISREG(rfi.mode): return 1 # File not already in db -> write it if not db.filenames.has_key(rfi.filename): return 1 # Don't install ghost files ;) if rfi.flags & RPMFILE_GHOST: ret... |
pkg) self.__writeDB4(self.sigmd5_db, "install_md5", pkgid, pkg) | pkg, False) self.__writeDB4(self.sigmd5_db, "install_md5", pkgid, pkg, False) | def addPkg(self, pkg, nowrite=None): self._addPkg(pkg) |
pkg) self.__removeId(self.sigmd5_db, "install_md5", pkgid, pkg) | pkg, False) self.__removeId(self.sigmd5_db, "install_md5", pkgid, pkg, False) | def erasePkg(self, pkg, nowrite=None): self._erasePkg(pkg) |
if pkg: if pkg["prefixes"]: if len(pkg["prefixes"]) == 1: e["RPM_INSTALL_PREFIX"] = pkg["prefixes"][0] else: idx = 1 for prefix in pkg["prefixes"]: e["RPM_INSTALL_PREFIX%d" % idx] = prefix idx += 1 | if pkg and pkg["prefixes"]: e["RPM_INSTALL_PREFIX"] = pkg["prefixes"][0] idx = 1 for prefix in pkg["prefixes"]: e["RPM_INSTALL_PREFIX%d" % idx] = prefix idx += 1 | def runScript(prog=None, script=None, otherargs=[], force=False, rusage=False, tmpdir="/var/tmp", chroot=None, pkg = None): """Run (script otherargs) with interpreter prog (which can be a list containing initial arguments). If pkg is supplied, it's used to populate environment. The following env. variables are defined... |
for pkg in conflicts: | for pkg in conflicts.keys(): | def checkConflicts(self): conflicts = self.getConflicts() if len(conflicts) == 0: return self.OK |
if pkgCompare(list[i], list[j]) < 0: | if distance[i] == distance[j] and pkgCompare(list[i], list[j]) < 0: | def orderList(list, arch): """ order list by machine distance and evr """ distance = [ machineDistance(l["arch"], arch) for l in list ] for i in xrange(len(list)): for j in xrange(i + 1, len(list)): if distance[i] > distance[j]: (list[i], list[j]) = (list[j], list[i]) continue if pkgCompare(list[i], list[j]) < 0: (list... |
del operations gc.collect() | def runOperations(self, operations): """Perform (operation, RpmPackage) from list operation. | |
self.db.close() sys.exit(0) | if self.config.buildroot: self.db.close() sys.exit(0) | def runOperations(self, operations): """Perform (operation, RpmPackage) from list operation. |
self.config.printInfo(1, "Unresolved conflict for %s\n" % | self.config.printInfo(1, "Unresolved conflicts for %s\n" % | def __runDepResolution(self): """Try to resolve all dependencies and remove all conflicts.. |
for dep in unresolved[pkg]: | for dep in conflicts[pkg]: | def __runDepResolution(self): """Try to resolve all dependencies and remove all conflicts.. |
tmplist = [(l, -machineDistance(l["arch"], arch)) for l in list ] tmplist.sort() | tmplist = [(l, machineDistance(l["arch"], arch)) for l in list ] tmplist.sort(pkgmdcmp) | def orderList(list, arch): """Order RpmPackage list by "distance" to arch (ascending) and EVR (descending), in that order.""" tmplist = [(l, -machineDistance(l["arch"], arch)) for l in list ] tmplist.sort() tmplist.reverse() list[:] = [l[0] for l in tmplist] |
self.clear() | RpmDatabase.clear(self) | def __init__(self, config, source, buildroot=None): self.config = config self.source = source self.buildroot = buildroot self.clear() self.keyring = openpgp.PGPKeyRing() self.is_read = 0 # 1 if the database was already read |
self.check_installed = check_installed | print self.installed_unresolved | def __init__(self, installed, operation, check_installed=0): RpmList.__init__(self, installed, operation) self.installed_unresolved = self.getUnresolvedDependencies() self.check_installed = check_installed |
self.basenames_cache.clear() | def addPkg(self, pkg, nowrite=None): if nowrite: return 1 result = self._addPkg(pkg) if result: self._pkgs[pkg.key] = pkg if self.obsoletes_list: self.obsoletes_list.addPkg(pkg) self.basenames_cache.clear() return result | |
self.basenames_cache.clear() | def removePkg(self, pkg, nowrite=None): if nowrite: return 1 if (not hasattr(pkg, 'key') or not hasattr(pkg, 'db') or pkg.db is not self): return 0 result = self._removePkg(pkg) self._pkgs.pop(pkg.key, None) if self.obsoletes_list and result: self.obsoletes_list.removePkg(pkg) self.basenames_cache.clear() return resul... | |
filedict.setdefault(filename, []).append((pkg, idx)) | f = pkg.iterFilenames()[idx] filedict.setdefault(f, []).append(pkg) | def numFileDuplicates(self, filename): (dirname, basename) = os.path.split(filename) if len(dirname) > 0 and dirname[-1] != "/": dirname += "/" if not self.basenames_cache.has_key(basename): data = self.basenames_db.get(basename, '') #if len(data) > 80: # 8 byte/entry |
return len(self.path.get(dirname, {}, get(basename, {})) > 0 | return len(self.path.get(dirname, {}).get(basename, {})) > 0 | def isDuplicate(self, filename): (dirname, basename) = os.path.split(filename) if len(dirname) > 0 and dirname[-1] != "/": dirname += "/" return len(self.path.get(dirname, {}, get(basename, {})) > 0 |
if upkg in self.erase_list or upkg in self.opresolver.getDatabase(): continue | upkg = pkgnamehash[upkg["name"]] | def __handleUpdatePkglist(self, pkg, pkg_list, is_filereq=0): """Choose a package from a list of RpmPackage's pkg_list that has the same base arch as RpmPackage pkg, and add it to self.opresolver. |
return (0, None) | return (0, None, "") | def runScript(prog=None, script=None, otherargs=[], force=False, rusage=False, tmpdir="/var/tmp", chroot=None): """Run (script otherargs) with interpreter prog (which can be a list containing initial arguments). Return None, or getrusage() stats of the script if rusage. Disable ldconfig optimization if force. Raise ... |
if fi1.flag & base.RPMFILE_GHOST or \ fi2.flag & base.RPMFILE_GHOST: | if fi1.flags & base.RPMFILE_GHOST or \ fi2.flags & base.RPMFILE_GHOST: | def _checkFileConflict(self, pkg, filename, operation=OP_INSTALL): ret = 0 |
npos = self.numobjects | npos = self.hashlength | def nextObject(self, finish=None): if finish: npos = self.numobjects else: self.num += 1 npos = (self.num * self.hashlength) / self.numobjects if npos > self.numobjects: npos = self.numobjects msg = "" if self.hashpos < npos: msg = "#" * (npos - self.hashpos) self.hashpos = npos if finish: msg += "\n" if msg: self._dop... |
if npos > self.numobjects: npos = self.numobjects | if npos > self.hashlength: npos = self.hashlength | def nextObject(self, finish=None): if finish: npos = self.numobjects else: self.num += 1 npos = (self.num * self.hashlength) / self.numobjects if npos > self.numobjects: npos = self.numobjects msg = "" if self.hashpos < npos: msg = "#" * (npos - self.hashpos) self.hashpos = npos if finish: msg += "\n" if msg: self._dop... |
return parch in arch_compats.get(arch, []) | return (arch == "noarch" or parch in arch_compats.get(arch, [])) | def archCompat(parch, arch): """Return True if package with architecture parch can be installed on machine with arch arch.""" return parch in arch_compats.get(arch, []) #return (parch == "noarch" or arch == "noarch" or parch == arch or # parch in arch_compats.get(arch, [])) |
dirname = os.path.dirname(filename)+"/" | dirname = os.path.dirname(filename) if dirname[-1] != "/": dirname += "/" | def generateFileNames(self): """Generate basenames, dirnames and dirindexes for old packages from oldfilenames""" if self["oldfilenames"] != None and len(self["oldfilenames"]) > 0: self["basenames"] = [ ] self["dirnames"] = [ ] self["dirindexes"] = [ ] for filename in self["oldfilenames"]: basename = os.path.basename(f... |
if not rpmconfig.test and not rpmconfig.justdb: print >> sys.stderr, "Arch option can only be used for tests" | if not rpmconfig.test and \ not rpmconfig.justdb and \ not rpmconfig.ignorearch: rpmconfig.printError("Arch option can only be used for tests") | def parseYumOptions(argv, yum): """Parse yum-like config options from argv to config.rpmconfig and RpmYum yum. Return list of non-option operands on success, None if a help message should be written. sys.exit () on --version, some invalid arguments or errors in config files.""" # Argument parsing try: opts, args = g... |
print >> sys.stderr, "Unknown arch %s" % rpmconfig.arch | rpmconfig.printError("Unknown arch %s" % rpmconfig.arch) | def parseYumOptions(argv, yum): """Parse yum-like config options from argv to config.rpmconfig and RpmYum yum. Return list of non-option operands on success, None if a help message should be written. sys.exit () on --version, some invalid arguments or errors in config files.""" # Argument parsing try: opts, args = g... |
size = bytes - self.bufferlen | size = (bytes or 65536) - self.bufferlen | def read(self, bytes=None): """Decompress up to bytes bytes from input. |
crc32 = unpack("<i", self.enddata[0:4]) isize = unpack("<I", self.enddata[4:8]) | crc32 = unpack("<I", self.enddata[0:4])[0] isize = unpack("<I", self.enddata[4:8])[0] | def read(self, bytes=None): """Decompress up to bytes bytes from input. |
sys.stdout.flush(msg) | sys.stdout.flush() | def raw_input2(msg): sys.stdout.write(msg) sys.stdout.flush(msg) return raw_input() |
_fstype = parted.file_system_type_get(fstype) | if fstype == "raid": _fstype = None else: _fstype = parted.file_system_type_get(fstype) | def add_partition(self, id, start, end, type, fstype): _fstype = None if fstype: _fstype = parted.file_system_type_get(fstype) |
print "WARNING: Partition %d is an extended partition" % i | print "WARNING: Partition %d is an extended partition," % i, \ "unable to set boot flag." return 0 | def set_boot(self, i): partition = self["partition"] if i in partition.keys(): if partition[i].ped_partition.type & parted.PARTITION_EXTENDED: print "WARNING: Partition %d is an extended partition" % i return partition[i].ped_partition.set_flag(parted.PARTITION_BOOT, 1) return 0 |
partition["native_type"], Partition.nativeType[partition["native_type"]]) | partition["native_type"], type) | def print_partitions(self): if not self.has_disklabel(): return print l = len("Device") for part in self["partition"]: partition = self["partition"][part] if partition["disk"].has_key("image"): device = "%s%d" % (self["image"], partition["id"]) else: device = partition["device"] if l < len(device): l = len(device) prin... |
self.repos = [ ] | self.resolvers = [ ] | def __init__(self, config): self.config = config # Default: Don't autoerase packages that have unresolved symbols in # install or update self.autoerase = 0 # Default: Ask user for confirmation of complete operation self.confirm = 1 # Default: No command self.command = None # List of repository resolvers self.repos = [ ... |
self.__filterExcludes(pkglist, excludes) self.repos.append(resolver) def addRepoByDir(self, dirname, excludes): pkg_list = [] for f in os.listdir(dirname): fn = "%s/%s" % (dirname, f) if not f.endswith(".rpm") or not os.path.isfile(fn): continue pkg = readRpmPackage(self.config, fn, db=self.pydb, tags=self.config.reso... | self.__filterExcludes(pkg_list, excludes) r = RpmResolver(self.config, pkg_list) self.repos.append(repo) self.resolvers.append(r) | def addRepo(self, baseurl, excludes): repo = RpmRepo(self.config, baseurl) repo.read() pkg_list = repo.getPkgList() self.__filterExcludes(pkglist, excludes) self.repos.append(resolver) |
for repo in self.repos: | for repo in self.resolvers: | def processArgs(self, args): # Create and read db self.pydb = RpmPyDB(self.config, self.config.dbpath, self.config.buildroot) self.pydb.read() self.__generateObsoletesList() self.opresolver = RpmResolver(self.config, self.pydb.getPkgList()) # If we do a group operation handle it accordingly if self.command.startswith("... |
for repo in self.repos: | for repo in self.resolvers: | def runCommand(self): for repo in self.repos: del repo self.repos = [] if len(self.erase_list) > 0: self.config.printInfo(0, "Warning: Following packages will be automatically removed:\n") for pkg in self.erase_list: self.config.printInfo(0, "\t%s\n" % pkg.getNEVRA()) if self.confirm: choice = raw_input("Is this ok [y/... |
self.repos = [] | self.resolvers = [] | def runCommand(self): for repo in self.repos: del repo self.repos = [] if len(self.erase_list) > 0: self.config.printInfo(0, "Warning: Following packages will be automatically removed:\n") for pkg in self.erase_list: self.config.printInfo(0, "\t%s\n" % pkg.getNEVRA()) if self.confirm: choice = raw_input("Is this ok [y/... |
for repo in self.repos: | for repo in self.resolvers: | def __generateObsoletesList(self): self.__obsoleteslist = [] for repo in self.repos: for pkg in repo.getList(): if pkg.has_key("obsoletes"): self.__obsoleteslist.append(pkg) |
for repo in self.repos: | for repo in self.resolvers: | def __runDepResolution(self): # Special erase list for unresolvable package dependancies or conflicts self.erase_list = [] unresolved = self.opresolver.getUnresolvedDependencies() iteration = 1 while len(unresolved) > 0: self.config.printInfo(1, "Dependency iteration " + str(iteration) + "\n") iteration += 1 unresolved... |
pkg = list[i] | def filterArchList(list, arch=None): # stage 1: filter packages which are not in compat arch if arch != None and arch != "noarch": error = 0 for pkg in list: pkg = list[i] if pkg["arch"] not in possible_archs: error = 1 printError(0, "%s: Unknow rpm package architecture %s" % (pkg.source, pkg["arch"])) if pkg["arch"] !... | |
printError(0, "%s: Unknow rpm package architecture %s" % (pkg.source, pkg["arch"])) | printError("%s: Unknow rpm package architecture %s" % (pkg.source, pkg["arch"])) | def filterArchList(list, arch=None): # stage 1: filter packages which are not in compat arch if arch != None and arch != "noarch": error = 0 for pkg in list: pkg = list[i] if pkg["arch"] not in possible_archs: error = 1 printError(0, "%s: Unknow rpm package architecture %s" % (pkg.source, pkg["arch"])) if pkg["arch"] !... |
printError(0, "%s: Architecture not compatible with machine %s" % (pkg.source, arch)) | printError("%s: Architecture not compatible with machine %s" % (pkg.source, arch)) | def filterArchList(list, arch=None): # stage 1: filter packages which are not in compat arch if arch != None and arch != "noarch": error = 0 for pkg in list: pkg = list[i] if pkg["arch"] not in possible_archs: error = 1 printError(0, "%s: Unknow rpm package architecture %s" % (pkg.source, pkg["arch"])) if pkg["arch"] !... |
printError(prog) printError(args) | printError(str(prog)) printError(str(args)) | def runScript(prog=None, script=None, arg1=None, arg2=None): if prog == None: prog = "/bin/sh" if not os.path.exists("/var/tmp"): os.makedirs("/var/tmp") (fd, tmpfilename) = tempfile.mkstemp(dir="/var/tmp/", prefix="rpm-tmp.") if fd == None: return 0 if script != None: os.write(fd, script) os.close(fd) fd = None args =... |
fd = sys.stderr | def __init__(self): _StdoutLog.__init__(self) self.fd = sys.stderr | def flush(self): self.fd.flush() |
def write(self, data, level): if level >= Logger.DEBUG1: | def write(self, data, level, logger): if level > logger.NO_DEBUG: | def write(self, data, level): if level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG elif level >= Logger.INFO1: priority = syslog.LOG_INFO elif level == Logger.WARNING: priority = syslog.LOG_WARNING elif level == Logger.ERROR: priority = syslog.LOG_ERR elif level == Logger.FATAL: priority = syslog.LOG_CRIT if data.en... |
elif level >= Logger.INFO1: | elif level >= logger.INFO1: | def write(self, data, level): if level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG elif level >= Logger.INFO1: priority = syslog.LOG_INFO elif level == Logger.WARNING: priority = syslog.LOG_WARNING elif level == Logger.ERROR: priority = syslog.LOG_ERR elif level == Logger.FATAL: priority = syslog.LOG_CRIT if data.en... |
elif level == Logger.WARNING: | elif level == logger.WARNING: | def write(self, data, level): if level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG elif level >= Logger.INFO1: priority = syslog.LOG_INFO elif level == Logger.WARNING: priority = syslog.LOG_WARNING elif level == Logger.ERROR: priority = syslog.LOG_ERR elif level == Logger.FATAL: priority = syslog.LOG_CRIT if data.en... |
elif level == Logger.ERROR: | elif level == logger.ERROR: | def write(self, data, level): if level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG elif level >= Logger.INFO1: priority = syslog.LOG_INFO elif level == Logger.WARNING: priority = syslog.LOG_WARNING elif level == Logger.ERROR: priority = syslog.LOG_ERR elif level == Logger.FATAL: priority = syslog.LOG_CRIT if data.en... |
elif level == Logger.FATAL: | elif level == logger.FATAL: | def write(self, data, level): if level >= Logger.DEBUG1: priority = syslog.LOG_DEBUG elif level >= Logger.INFO1: priority = syslog.LOG_INFO elif level == Logger.WARNING: priority = syslog.LOG_WARNING elif level == Logger.ERROR: priority = syslog.LOG_ERR elif level == Logger.FATAL: priority = syslog.LOG_CRIT if data.en... |
self._level = 0 self._debug_level = 0 | self._level = { } self._debug_level = { } | def __init__(self, info_max=5, debug_max=10): """ Logger class initialization """ self._level = 0 self._debug_level = 0 self._format = "" self._date_format = "" self._label = { } self._logging = { } self._domains = { } |
def getLogLevel(self): | def _checkDomain(self, domain): if not domain or domain == "": raise ValueError, "Domain '%s' is not valid." % domain def getLogLevel(self, domain="*"): | def getLogLevel(self): """ Get log level. """ return self._level |
return self._level def setLogLevel(self, level): | self._checkDomain(domain) if self._level.has_key(domain): return self._level[domain] return self.NOTHING def setLogLevel(self, level, domain="*"): | def getLogLevel(self): """ Get log level. """ return self._level |
self._level = level def getDebugLogLevel(self, level): | self._level[domain] = level def getDebugLogLevel(self, domain="*"): | def setLogLevel(self, level): """ Set log level [NOTHING .. INFO_MAX] """ if level < self.NOTHING: level = self.NOTHING if level > self.INFO_MAX: level = self.INFO_MAX self._level = level |
return self._debug_level def setDebugLogLevel(self, level): | self._checkDomain(domain) if self._debug_level.has_key(domain): return self._debug_level[domain] - self.NO_DEBUG return self.NO_DEBUG def setDebugLogLevel(self, level, domain="*"): | def getDebugLogLevel(self, level): """ Get debug log level. """ return self._debug_level |
self._debug_level = level - self.NO_DEBUG | self._debug_level[domain] = level - self.NO_DEBUG | def setDebugLogLevel(self, level): """ Set debug log level [NO_DEBUG .. DEBUG_MAX] """ if level < 0: level = 0 if level > self.DEBUG_MAX - self.NO_DEBUG: level = self.DEBUG_MAX - self.NO_DEBUG self._debug_level = level - self.NO_DEBUG |
if domain == "": domain = "*" | def _genDomains(self): """ Generate dict with domain by level. """ if len(self._domains) > 0: self._domains = { } 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]: if domain == "": domain = "*" if domain not in self._d... | |
self._logging[level] = [ (domain, target, format) ] | for target in targets: self._logging[level] = [ (domain, target, format) ] | def setLogging(self, domain, target, level=ALL, format=None): """ Set log target for domain and level. Level can be a single level or an array of levels. Use level ALL to set for all levels. If no format is specified, the default format will be used. """ levels = self._getLevels(level) for level in levels: self._loggin... |
self._logging.setdefault(level, [ ]).append((domain, target, format)) | for target in targets: self._logging.setdefault(level, [ ]).append((domain, target, format)) | def addLogging(self, domain, target, level=ALL, format=None): """ Add log target for domain and level. Level can be a single level or an array of levels. Use level ALL to set for all levels. If no format is specified, the default format will be used. """ levels = self._getLevels(level) for level in levels: self._loggin... |
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 raise ValueError, "No mathing logging for " \ "level %d, domain %s, target %s and format %s." % \ ... | for target in targets: 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 raise ValueError, "No mathing logging for " \ "level %d, domain %s, target ... | def delLogging(self, domain, target, level=ALL, format=None): """ Delete log target for domain and level. Level can be a single level or an array of levels. Use level ALL to set for all levels. If no format is specified, the default format will be used. """ levels = self._getLevels(level) for level in levels: if not se... |
def isLogging(self, level): if level > self.INFO_MAX: if level-self.INFO_MAX > self._debug_level: return False else: if level > self._level: return False if not self._logging.has_key(level): return False if not self._domains.has_key(level) or len(self._domains[level]) < 1: return False return True | def delLogging(self, domain, target, level=ALL, format=None): """ Delete log target for domain and level. Level can be a single level or an array of levels. Use level ALL to set for all levels. If no format is specified, the default format will be used. """ levels = self._getLevels(level) for level in levels: if not se... | |
if domain == "" or domain == "*" \ or point_domain.startswith(domain) \ or fnmatch.fnmatchcase(dict["domain"], domain): | if domain == "*" or \ point_domain.startswith(domain) or \ fnmatch.fnmatchcase(dict["domain"], domain): | def isLoggingHere(self, level): """ Is there currently any logging for this log level (and domain)? """ dict = self._genDict(level) if not dict: return False |
self._checkLogLevel(level, min=self.DEBUG1-self.NO_DEBUG, max=self.DEBUG_MAX-self.NO_DEBUG) | self._checkLogLevel(level, min=1, max=self.DEBUG_MAX-self.NO_DEBUG) | def debug(self, level, format, *args): """ Debug log using debug level [1..debug_max]. There are additional debugx functions according to debug_max from __init__""" 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) |
self._checkLogLevel(level, min=self.DEBUG1-self.NO_DEBUG, max=self.DEBUG_MAX-self.NO_DEBUG) | self._checkLogLevel(level, min=1, max=self.DEBUG_MAX-self.NO_DEBUG) | 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 __init__""" self._checkLogLevel(level, min=self.DEBUG1-self.NO_DEBUG, max=self.DEBUG_MAX-self.NO_DEBUG) self._log(level+self.NO_DEBUG, 1, 0, format, *... |
if domain == "" or domain == "*" \ or point_domain.startswith(domain) \ | if domain == "*" \ or point_domain.startswith(domain+".") \ | def _log(self, level, newline, raw, format, *args): dict = self._genDict(level) if not dict: return |
target.write(dict["message"], level) | target.write(dict["message"], level, self) | def _log(self, level, newline, raw, format, *args): dict = self._genDict(level) if not dict: return |
target.write(_format % dict, level) | target.write(_format % dict, level, self) | def _log(self, level, newline, raw, format, *args): dict = self._genDict(level) if not dict: return |
target.write("\n", level) | target.write("\n", level, self) | def _log(self, level, newline, raw, format, *args): dict = self._genDict(level) if not dict: return |
if not self.isLogging(level): | check_domains = [ ] simple_match = False if level > self.INFO_MAX: _dict = self._debug_level else: _dict = self._level for domain in _dict: if domain == "*": if _dict[domain] >= level: simple_match = True if len(check_domains) > 0: check_domains = [ ] break else: if _dict[domain] >= level: check_domains.append(dom... | def _genDict(self, level): """ Internal function. """ if not self.isLogging(level): return None |
if domain == "*" or domain == "": | if domain == "*": | def _genDict(self, level): """ Internal function. """ if not self.isLogging(level): return None |
if self._format.find("%(domain)") >= 0 \ or self._format.find("%(class)") >= 0 \ or domain_needed: | if self._format.find("%(domain)") >= 0 or \ self._format.find("%(class)") >= 0 or \ domain_needed or \ len(check_domains) > 0: | def _genDict(self, level): """ Internal function. """ if not self.isLogging(level): return None |
return dict | if len(check_domains) < 1: return dict point_domain = dict["domain"] + "." for domain in check_domains: if point_domain.startswith(domain) or \ fnmatch.fnmatchcase(dict["domain"], domain): return dict return None | def _genDict(self, level): """ Internal function. """ if not self.isLogging(level): return None |
class FileLog: | class FileLog(LogTarget): | def _genDict(self, level): """ Internal function. """ if not self.isLogging(level): return None |
self.fd = None | def __init__(self, filename, mode="w"): self.filename = filename self.mode = mode self.fd = None | |
def write(self, data, level): | def write(self, data, level, logger): | def write(self, data, level): if not self.fd: self.open() self.fd.write(data) self.fd.flush() |
def _checkConflict(self, pkg, name, flag, version, arch=None, operation=OP_INSTALL): s = self.conflicts.search(name, flag, version, arch) ret = 0 if len(s) != 0: if pkg in s: s.remove(pkg) for r in s: if self.config.checkinstalled == 0 and \ pkg in self.installed_conflicts and \ (name,flag,version) in self.installed_co... | def _checkConflict(self, pkg, name, flag, version, arch=None, operation=OP_INSTALL): s = self.conflicts.search(name, flag, version, arch) ret = 0 if len(s) != 0: if pkg in s: s.remove(pkg) for r in s: if self.config.checkinstalled == 0 and \ pkg in self.installed_conflicts and \ (name,flag,version) in self.installed_co... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.