#!/usr/bin/python -tt # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 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 Library General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. # Copyright 2006 Duke University """ Classes for manipulating and querying groups of packages. """ from Errors import PackageSackError import warnings import re import fnmatch import misc from packages import parsePackages import rpmUtils.miscutils from rpmUtils.miscutils import compareEVR class PackageSackVersion: def __init__(self): self._num = 0 self._chksum = misc.Checksums(['sha1']) def __str__(self): return "%u:%s" % (self._num, self._chksum.hexdigest()) def __eq__(self, other): if other is None: return False if type(other) in (type(''), type(u'')): return str(self) == other if self._num != other._num: return False if self._chksum.digest() != other._chksum.digest(): return False return True def __ne__(self, other): return not (self == other) def update(self, pkg, csum): self._num += 1 self._chksum.update(str(pkg)) if csum is not None: self._chksum.update(csum[0]) self._chksum.update(csum[1]) class PackageSackBase(object): """Base class that provides the interface for PackageSacks.""" def __init__(self): self.added = {} def __len__(self): return len(self.returnPackages()) def __iter__(self): ret = self.returnPackages() if hasattr(ret, '__iter__'): return ret.__iter__() else: return iter(ret) def __cmp__(self, other): if other is None: return 1 s_repos = list(self.added) o_repos = list(other.added) if len(s_repos) != len(o_repos): return len(s_repos) - len(o_repos) for (s_repo, o_repo) in zip(sorted(s_repos), sorted(o_repos)): ret = cmp(s_repo, o_repo) if ret: return ret return 0 def setCompatArchs(self, compatArchs): raise NotImplementedError() def populate(self, repo, mdtype, callback, cacheOnly): raise NotImplementedError() def packagesByTuple(self, pkgtup): """return a list of package objects by (n,a,e,v,r) tuple""" warnings.warn('packagesByTuple() will go away in a future version of Yum.\n', DeprecationWarning, stacklevel=2) return self.searchPkgTuple(pkgtup) def searchNevra(self, name=None, epoch=None, ver=None, rel=None, arch=None): """return list of pkgobjects matching the nevra requested""" raise NotImplementedError() def searchNames(self, names=[], return_pkgtups=False): raise NotImplementedError() def searchPO(self, po): """return list of package objects matching the name, epoch, ver, rel, arch of the package object passed in""" return self.searchNevra(name=po.name, epoch=po.epoch, ver=po.ver, rel=po.rel, arch=po.arch) def searchPkgTuple(self, pkgtup): """return list of pkgobject matching the (n,a,e,v,r) tuple""" (n,a,e,v,r) = pkgtup return self.searchNevra(name=n, arch=a, epoch=e, ver=v, rel=r) def contains(self, name=None, arch=None, epoch=None, ver=None, rel=None, po=None): """return if there are any packages in the sack that match the given NAEVR or the NAEVR of the given po""" if po: name = po.name arch = po.arch epoch = po.epoch ver = po.version rel = po.release return bool(self.searchNevra(name=name, arch=arch, epoch=epoch, ver=ver, rel=rel)) def getProvides(self, name, flags=None, version=(None, None, None)): """return dict { packages -> list of matching provides }""" raise NotImplementedError() def getRequires(self, name, flags=None, version=(None, None, None)): """return dict { packages -> list of matching requires }""" raise NotImplementedError() def searchRequires(self, name): """return list of package requiring the name (any evr and flag)""" raise NotImplementedError() def searchProvides(self, name): """return list of package providing the name (any evr and flag)""" raise NotImplementedError() def searchConflicts(self, name): """return list of package conflicting with the name (any evr and flag)""" raise NotImplementedError() def searchObsoletes(self, name): """return list of package obsoleting the name (any evr and flag)""" raise NotImplementedError() def returnObsoletes(self, newest=False): """returns a dict of obsoletes dict[obsoleting pkgtuple] = [list of obs]""" raise NotImplementedError() def have_fastReturnFileEntries(self): """ Is calling pkg.returnFileEntries(primary_only=True) faster than using searchFiles(). """ raise NotImplementedError() def searchFiles(self, name): """return list of packages by filename""" raise NotImplementedError() def addPackage(self, obj): """add a pkgobject to the packageSack""" raise NotImplementedError() def buildIndexes(self): """builds the useful indexes for searching/querying the packageSack This should be called after all the necessary packages have been added/deleted""" raise NotImplementedError() def delPackage(self, obj): """delete a pkgobject""" raise NotImplementedError() def returnPackages(self, repoid=None, patterns=None, ignore_case=False): """return list of all packages""" raise NotImplementedError() def addPackageExcluder(self, repoid, excluderid, excluder, *args): """ Add an "excluder" for all packages in the repo/sack. Can basically do anything based on nevra, changes lots of exclude decisions from "preload package; test; delPackage" into "load excluder". Excluderid is used so the caller doesn't have to track "have I loaded the excluder for this repo.", it's probably only useful when repoid is None ... if it turns out utterly worthless then it's still not a huge wart. """ raise NotImplementedError() def simpleVersion(self, main_only=False, groups={}): """ Return a simple version for all available packages. """ def _up_revs(arepos, repoid, rev, pkg, csum): arevs = arepos.setdefault(repoid, {}) rpsv = arevs.setdefault(None, PackageSackVersion()) rpsv.update(pkg, csum) if rev is not None: rpsv = arevs.setdefault(rev, PackageSackVersion()) rpsv.update(pkg, csum) main = PackageSackVersion() arepos = {} main_grps = {} arepos_grps = {} for pkg in sorted(self.returnPackages()): csum = pkg.returnIdSum() main.update(pkg, csum) for group in groups: if pkg.name in groups[group]: if group not in main_grps: main_grps[group] = PackageSackVersion() arepos_grps[group] = {} main_grps[group].update(pkg, csum) if main_only: continue rev = pkg.repo.repoXML.revision _up_revs(arepos, pkg.repoid, rev, pkg, csum) for group in groups: if pkg.name in groups[group]: _up_revs(arepos_grps[group], pkg.repoid, rev, pkg, csum) if groups: return [main, arepos, main_grps, arepos_grps] return [main, arepos] def returnNewestByNameArch(self, naTup=None, patterns=None, ignore_case=False): """return list of newest packages based on name, arch matching this means(in name.arch form): foo.i386 and foo.noarch are not compared to each other for highest version only foo.i386 and foo.i386 will be compared Note that given: foo-1.i386; foo-2.i386 and foo-3.x86_64 The last _two_ pkgs will be returned, not just one of them. """ raise NotImplementedError() def returnNewestByName(self, name=None, patterns=None, ignore_case=False): """return list of newest packages based on name matching this means(in name.arch form): foo.i386 and foo.noarch will be compared to each other for highest version.""" raise NotImplementedError() def simplePkgList(self, patterns=None, ignore_case=False): """returns a list of pkg tuples (n, a, e, v, r)""" raise NotImplementedError() def printPackages(self): raise NotImplementedError() def excludeArchs(self, archlist): """exclude incompatible arches. archlist is a list of compatible arches""" raise NotImplementedError() def searchPackages(self, fields, criteria_re, callback): raise NotImplementedError() def searchAll(self, arg, query_type): raise NotImplementedError() def matchPackageNames(self, pkgspecs): """take a list strings and match the packages in the sack against it this will match against: name name.arch name-ver-rel.arch name-ver name-ver-rel epoch:name-ver-rel.arch name-epoch:ver-rel.arch return [exact matches], [glob matches], [unmatch search terms] """ # Setup match() for the search we're doing matched = [] exactmatch = [] unmatched = set(pkgspecs) specs = {} for p in pkgspecs: specs[p] = misc.compile_pattern(p) # We don't use simplePkgList() here because that loads all of the # rpmdb, if we are Eg. doing a "remove PackageKit". pkgs = self.returnPackages(patterns=unmatched) for pkgtup in [pkg.pkgtup for pkg in pkgs]: (n,a,e,v,r) = pkgtup names = set(( n, '%s.%s' % (n, a), '%s-%s-%s.%s' % (n, v, r, a), '%s-%s' % (n, v), '%s-%s-%s' % (n, v, r), '%s:%s-%s-%s.%s' % (e, n, v, r, a), '%s-%s:%s-%s.%s' % (n, e, v, r, a), )) for (term,query) in specs.items(): if term in names: exactmatch.append(self.searchPkgTuple(pkgtup)[0]) unmatched.discard(term) else: for n in names: if query(n): matched.append(self.searchPkgTuple(pkgtup)[0]) unmatched.discard(term) return misc.unique(exactmatch), misc.unique(matched), list(unmatched) def returnLeafNodes(self, repoid=None): """returns a list of package objects that are not required by any other package in this repository""" def _return_all_provides(po): """ Return all the provides, via. yield. """ # These are done one by one, so that we get lazy loading for prov in po.provides_names: yield prov for prov in po.filelist: yield prov for prov in po.dirlist: yield prov for prov in po.ghostlist: yield prov # fixme - maybe cache this list? req = {} orphans = [] # prebuild the req dict for po in self.returnPackages(repoid=repoid): if not po.requires_names: continue for r in po.requires_names: if r not in req: req[r] = set() if len(req[r]) > 1: # We only need to know if another pkg. continue # reqs. the provide. So 2 pkgs. is enough. req[r].add(po.name) for po in self.returnPackages(repoid=repoid): preq = 0 for p in _return_all_provides(po): if p in req: # If this pkg provides something that is required by # anything but itself (or another version of itself) it # isn't an orphan. if len(req[p]) > 1 or po.name not in req[p]: preq += 1 break if preq == 0: orphans.append(po) return orphans class MetaSack(PackageSackBase): """Represents the aggregate of multiple package sacks, such that they can all be treated as one unified sack.""" def __init__(self): PackageSackBase.__init__(self) self.sacks = {} self.compatarchs = None def __len__(self): ret = 0 for sack in sorted(self.sacks.values()): ret += len(sack) return ret def dropCachedData(self): for sack in self.sacks.values(): if hasattr(sack, 'dropCachedData'): sack.dropCachedData() def addSack(self, repoid, sack): """Adds a repository's packageSack to this MetaSack.""" self.sacks[repoid] = sack # Make sure the new sack follows the same rules we have been given. sack.setCompatArchs(self.compatarchs) def populate(self, repo, mdtype, callback, cacheOnly): self.sacks[repo.id].populate(repo, mdtype, callback, cacheOnly) def setCompatArchs(self, compatArchs): for sack in self.sacks.values(): sack.setCompatArchs(compatArchs) def packagesByTuple(self, pkgtup): """return a list of package objects by (n,a,e,v,r) tuple""" warnings.warn('packagesByTuple() will go away in a future version of Yum.\n', DeprecationWarning, stacklevel=2) return self._computeAggregateListResult("packagesByTuple", pkgtup) def searchNevra(self, name=None, epoch=None, ver=None, rel=None, arch=None): """return list of pkgobjects matching the nevra requested""" return self._computeAggregateListResult("searchNevra", name, epoch, ver, rel, arch) def searchNames(self, names=[], return_pkgtups=False): return self._computeAggregateListResult("searchNames", names, return_pkgtups) def getProvides(self, name, flags=None, version=(None, None, None)): """return dict { packages -> list of matching provides }""" return self._computeAggregateDictResult("getProvides", name, flags, version) def getRequires(self, name, flags=None, version=(None, None, None)): """return dict { packages -> list of matching requires }""" return self._computeAggregateDictResult("getRequires", name, flags, version) def searchRequires(self, name): """return list of package requiring the name (any evr and flag)""" return self._computeAggregateListResult("searchRequires", name) def searchProvides(self, name): """return list of package providing the name (any evr and flag)""" return self._computeAggregateListResult("searchProvides", name) def searchConflicts(self, name): """return list of package conflicting with the name (any evr and flag)""" return self._computeAggregateListResult("searchConflicts", name) def searchObsoletes(self, name): """return list of package obsoleting the name (any evr and flag)""" return self._computeAggregateListResult("searchObsoletes", name) def returnObsoletes(self, newest=False): """returns a dict of obsoletes dict[obsoleting pkgtuple] = [list of obs]""" if not newest: return self._computeAggregateDictResult("returnObsoletes") obsdict = self._computeAggregateDictResult("returnObsoletes") names = set((obstup[0] for obstup in obsdict)) nobsdict = {} last_name = '' last_pkg = None last_pkgtup = None # It takes about 0.2 of a second to convert these into packages, just # so we can sort them, which is ~40% of this functions time. So we sort # the pkgtups "by hand". def _pkgtup_nevr_cmp(x, y): """ Compare two pkgtup's (ignore arch): n, a, e, v, r. """ ret = cmp(x[0], y[0]) if ret: return ret # This is negated so we get higher versions first, in the list. return -compareEVR((x[2], x[3], x[4]), (y[2], y[3], y[4])) def _pkgtup_nevr_eq(x, y): return _pkgtup_nevr_cmp(x, y) == 0 for pkgtup in sorted(self.searchNames(names, return_pkgtups=True), cmp=_pkgtup_nevr_cmp): name = pkgtup[0] if last_name == name and not _pkgtup_nevr_eq(last_pkgtup, pkgtup): continue last_name = name last_pkgtup = pkgtup if pkgtup in obsdict: nobsdict[pkgtup] = obsdict[pkgtup] return nobsdict def searchFiles(self, name): """return list of packages by filename""" return self._computeAggregateListResult("searchFiles", name) def addPackage(self, obj): """Add a pkgobject to the packageSack. This is a meaningless operation for the MetaSack.""" pass def buildIndexes(self): """builds the useful indexes for searching/querying the packageSack This should be called after all the necessary packages have been added/deleted""" for sack in self.sacks.values(): sack.buildIndexes() def delPackage(self, obj): """Delete a pkgobject if it exists in every sub-sack.""" obj.repo.sack.delPackage(obj) def returnPackages(self, repoid=None, patterns=None, ignore_case=False): """Returns a list of packages. Note that the packages are always filtered to those matching the patterns/case. An optional repoid allows you to easily get data for a specific repo. """ if not repoid: return self._computeAggregateListResult("returnPackages", None, patterns, ignore_case) return self.sacks[repoid].returnPackages(patterns=patterns, ignore_case=ignore_case) def addPackageExcluder(self, repoid, excluderid, excluder, *args): """ Add an "excluder" for all packages in the repo/sack. Can basically do anything based on nevra, changes lots of exclude decisions from "preload package; test; delPackage" into "load excluder". Excluderid is used so the caller doesn't have to track "have I loaded the excluder for this repo.", it's probably only useful when repoid is None ... if it turns out utterly worthless then it's still not a huge wart. """ if not repoid: calr = self._computeAggregateListResult return calr("addPackageExcluder", None, excluderid, excluder, *args) return self.sacks[repoid].addPackageExcluder(None, excluderid,excluder, *args) def returnNewestByNameArch(self, naTup=None, patterns=None, ignore_case=False): """return list of newest packages based on name, arch matching this means(in name.arch form): foo.i386 and foo.noarch are not compared to each other for highest version only foo.i386 and foo.i386 will be compared. Note that given: foo-1.i386; foo-2.i386 and foo-3.x86_64 The last _two_ pkgs will be returned, not just one of them. """ calr = self._computeAggregateListResult pkgs = calr("returnNewestByNameArch", naTup, patterns, ignore_case) pkgs = packagesNewestByNameArch(pkgs) if not pkgs and (naTup or patterns): ui_pats = ", ".join(patterns or []) raise PackageSackError, 'No Package Matching %s' % ui_pats return pkgs def returnNewestByName(self, name=None, patterns=None, ignore_case=False): """return list of newest packages based on name matching this means(in name.arch form): foo.i386 and foo.noarch will be compared to each other for highest version.""" pkgs = self._computeAggregateListResult("returnNewestByName", name, patterns, ignore_case) pkgs = packagesNewestByName(pkgs) if not pkgs and (name or patterns): if name: ui_pats = name else: ui_pats = ", ".join(patterns or []) raise PackageSackError, 'No Package Matching %s' % ui_pats return pkgs def simplePkgList(self, patterns=None, ignore_case=False): """returns a list of pkg tuples (n, a, e, v, r)""" return self._computeAggregateListResult("simplePkgList", patterns, ignore_case) def printPackages(self): for sack in self.sacks.values(): sack.printPackages() def excludeArchs(self, archlist): """exclude incompatible arches. archlist is a list of compatible arches""" for sack in self.sacks.values(): sack.excludeArchs(archlist) def searchPackages(self, fields, criteria_re, callback): return self._computeAggregateDictResult("searchPackages", fields, criteria_re, callback) def searchAll(self, arg, query_type): return self._computeAggregateListResult("searchAll", arg, query_type) def matchPackageNames(self, pkgspecs): matched = [] exactmatch = [] unmatched = None for sack in self.sacks.values(): if hasattr(sack, "matchPackageNames"): e, m, u = [], [], [] try: e, m, u = sack.matchPackageNames(pkgspecs) except PackageSackError: continue exactmatch.extend(e) matched.extend(m) if unmatched is None: unmatched = set(u) else: unmatched = unmatched.intersection(set(u)) matched = misc.unique(matched) exactmatch = misc.unique(exactmatch) if unmatched is None: unmatched = [] else: unmatched = list(unmatched) return exactmatch, matched, unmatched def _computeAggregateListResult(self, methodName, *args): result = [] for sack in sorted(self.sacks.values()): if hasattr(sack, methodName): method = getattr(sack, methodName) try: sackResult = apply(method, args) except PackageSackError: continue if sackResult: result.extend(sackResult) return result def _computeAggregateDictResult(self, methodName, *args): result = {} for sack in sorted(self.sacks.values()): if hasattr(sack, methodName): method = getattr(sack, methodName) try: sackResult = apply(method, args) except PackageSackError: continue if sackResult: result.update(sackResult) return result class PackageSack(PackageSackBase): """represents sets (sacks) of Package Objects""" def __init__(self): PackageSackBase.__init__(self) self.nevra = {} #nevra[(Name, Epoch, Version, Release, Arch)] = [] self.obsoletes = {} #obs[obsoletename] = [pkg1, pkg2, pkg3] #the package lists are packages that obsolete the key name self.requires = {} #req[reqname] = [pkg1, pkg2, pkg3] #the package lists are packages that require the key name self.provides = {} #ditto of above but for provides self.conflicts = {} #ditto of above but for conflicts self.filenames = {} # duh self.pkgsByRepo = {} #pkgsByRepo['repoid']= [pkg1, pkg2, pkg3] self.pkgsByID = {} #pkgsById[pkgid] = [pkg1, pkg2] (should really only ever be one value but #you might have repos with the same package in them self.compatarchs = None # dict of compatible archs for addPackage self.indexesBuilt = 0 def __len__(self): ret = 0 for repo in self.pkgsByRepo: ret += len(self.pkgsByRepo[repo]) return ret def _checkIndexes(self, failure='error'): """check to see if the indexes are built, if not do what failure demands either error out or build the indexes, default is to error out""" if not self.indexesBuilt: if failure == 'error': raise PackageSackError, 'Indexes not yet built, cannot search' elif failure == 'build': self.buildIndexes() def dropCachedData(self): """ Do nothing, mainly for the testing code. """ self.clearIndexes() def setCompatArchs(self, compatarchs): self.compatarchs = compatarchs def searchNevra(self, name=None, epoch=None, ver=None, rel=None, arch=None): """return list of pkgobjects matching the nevra requested""" self._checkIndexes(failure='build') if (name, epoch, ver, rel, arch) in self.nevra: return self.nevra[(name, epoch, ver, rel, arch)] elif name is not None: pkgs = self.nevra.get((name, None, None, None, None), []) else: pkgs = [] for pkgsbyRepo in self.pkgsByRepo.itervalues(): pkgs.extend(pkgsbyRepo) result = [ ] for po in pkgs: if ((name and name!=po.name) or (epoch and epoch!=po.epoch) or (ver and ver!=po.ver) or (rel and rel!=po.rel) or (arch and arch!=po.arch)): continue result.append(po) return result def searchNames(self, names=[], return_pkgtups=False): """return list of pkgobjects matching the names requested""" self._checkIndexes(failure='build') result = [] done = set() for name in names: if name in done: continue done.add(name) result.extend(self.nevra.get((name, None, None, None, None), [])) if return_pkgtups: return [pkg.pkgtup for pkg in result] return result def getProvides(self, name, flags=None, version=(None, None, None)): """return dict { packages -> list of matching provides }""" self._checkIndexes(failure='build') if version is None: version = (None, None, None) elif type(version) in (str, type(None), unicode): version = rpmUtils.miscutils.stringToVersion(version) result = { } for po in self.provides.get(name, []): hits = po.matchingPrcos('provides', (name, flags, version)) if hits: result[po] = hits if name[0] == '/': hit = (name, None, (None, None, None)) for po in self.searchFiles(name): result.setdefault(po, []).append(hit) return result def getRequires(self, name, flags=None, version=(None, None, None)): """return dict { packages -> list of matching requires }""" self._checkIndexes(failure='build') if version is None: version = (None, None, None) elif type(version) in (str, type(None), unicode): version = rpmUtils.miscutils.stringToVersion(version) result = { } for po in self.requires.get(name, []): hits = po.matchingPrcos('requires', (name, flags, version)) if hits: result[po] = hits return result def searchPrco(self, name, prcotype): self._checkIndexes(failure='build') prcodict = getattr(self, prcotype) (n,f,(e,v,r)) = misc.string_to_prco_tuple(name) basic_results = [] results = [] if n in prcodict: basic_results.extend(prcodict[n]) for po in basic_results: if po.checkPrco(prcotype, (n, f, (e,v,r))): results.append(po) if prcotype != "provides": return results if not misc.re_filename(n): return results results.extend(self.searchFiles(n)) return misc.unique(results) def searchRequires(self, name): """return list of package requiring the item requested""" return self.searchPrco(name, 'requires') def searchProvides(self, name): """return list of package providing the item requested""" return self.searchPrco(name, 'provides') def searchConflicts(self, name): """return list of package conflicting with item requested""" return self.searchPrco(name, 'conflicts') def searchObsoletes(self, name): """return list of package obsoleting the item requested""" return self.searchPrco(name, 'obsoletes') def returnObsoletes(self, newest=False): """returns a dict of obsoletes dict[obsoleting pkgtuple] = [list of obs]""" obs = {} for po in self.returnPackages(): if len(po.obsoletes) == 0: continue obs.setdefault(po.pkgtup, []).extend(po.obsoletes) if not newest: return obs # FIXME - this is slooooooooooooooooooooooooooooooow # get the dict back newest_tups = set((pkg.pkgtup for pkg in self.returnNewestByName())) # go through each of the keys of the obs dict and see if it is in the # sack of newest pkgs - if it is not - remove the entry togo = [] for obstup in obs: if obstup not in newest_tups: togo.append(obstup) for obstup in togo: del obs[obstup] return obs def have_fastReturnFileEntries(self): """ Is calling pkg.returnFileEntries(primary_only=True) faster than using searchFiles(). """ return True def searchFiles(self, name): """ Return list of packages by filename. """ self._checkIndexes(failure='build') if name in self.filenames: return self.filenames[name] else: return [] def _addToDictAsList(self, dict, key, data): if key not in dict: dict[key] = [] #if data not in dict[key]: - if I enable this the whole world grinds to a halt # need a faster way of looking for the object in any particular list dict[key].append(data) def _delFromListOfDict(self, dict, key, data): if key not in dict: return try: dict[key].remove(data) except ValueError: pass if len(dict[key]) == 0: # if it's an empty list of the dict, then kill it del dict[key] def addPackage(self, obj): """add a pkgobject to the packageSack""" repoid = obj.repoid (name, arch, epoch, ver, rel) = obj.pkgtup if not self.compatarchs or arch in self.compatarchs: self._addToDictAsList(self.pkgsByRepo, repoid, obj) if self.indexesBuilt: self._addPackageToIndex(obj) def buildIndexes(self): """builds the useful indexes for searching/querying the packageSack This should be called after all the necessary packages have been added/deleted""" self.clearIndexes() for repoid in self.pkgsByRepo: for obj in self.pkgsByRepo[repoid]: self._addPackageToIndex(obj) self.indexesBuilt = 1 def clearIndexes(self): # blank out the indexes self.obsoletes = {} self.requires = {} self.provides = {} self.conflicts = {} self.filenames = {} self.nevra = {} self.pkgsByID = {} self.indexesBuilt = 0 def _addPackageToIndex(self, obj): # store the things provided just on name, not the whole require+version # this lets us reduce the set of pkgs to search when we're trying to depSolve for (n, fl, (e,v,r)) in obj.returnPrco('obsoletes'): self._addToDictAsList(self.obsoletes, n, obj) for (n, fl, (e,v,r)) in obj.returnPrco('requires'): self._addToDictAsList(self.requires, n, obj) for (n, fl, (e,v,r)) in obj.returnPrco('provides'): self._addToDictAsList(self.provides, n, obj) for (n, fl, (e,v,r)) in obj.returnPrco('conflicts'): self._addToDictAsList(self.conflicts, n, obj) for ftype in obj.returnFileTypes(): for file in obj.returnFileEntries(ftype): self._addToDictAsList(self.filenames, file, obj) self._addToDictAsList(self.pkgsByID, obj.id, obj) (name, arch, epoch, ver, rel) = obj.pkgtup self._addToDictAsList(self.nevra, (name, epoch, ver, rel, arch), obj) self._addToDictAsList(self.nevra, (name, None, None, None, None), obj) def _delPackageFromIndex(self, obj): for (n, fl, (e,v,r)) in obj.returnPrco('obsoletes'): self._delFromListOfDict(self.obsoletes, n, obj) for (n, fl, (e,v,r)) in obj.returnPrco('requires'): self._delFromListOfDict(self.requires, n, obj) for (n, fl, (e,v,r)) in obj.returnPrco('provides'): self._delFromListOfDict(self.provides, n, obj) for (n, fl, (e,v,r)) in obj.returnPrco('conflicts'): self._delFromListOfDict(self.conflicts, n, obj) for ftype in obj.returnFileTypes(): for file in obj.returnFileEntries(ftype): self._delFromListOfDict(self.filenames, file, obj) self._delFromListOfDict(self.pkgsByID, obj.id, obj) (name, arch, epoch, ver, rel) = obj.pkgtup self._delFromListOfDict(self.nevra, (name, epoch, ver, rel, arch), obj) self._delFromListOfDict(self.nevra, (name, None, None, None, None), obj) def delPackage(self, obj): """delete a pkgobject""" self._delFromListOfDict(self.pkgsByRepo, obj.repoid, obj) if self.indexesBuilt: self._delPackageFromIndex(obj) def returnPackages(self, repoid=None, patterns=None, ignore_case=False): """return list of all packages, takes optional repoid""" returnList = [] if repoid is None: for repo in self.pkgsByRepo: returnList.extend(self.pkgsByRepo[repo]) else: try: returnList = self.pkgsByRepo[repoid] except KeyError: # nothing to return pass if patterns: returnList = parsePackages(returnList, patterns, not ignore_case, unique='repo-pkgkey') returnList = returnList[0] + returnList[1] return returnList def returnNewestByNameArch(self, naTup=None, patterns=None, ignore_case=False): """return list of newest packages based on name, arch matching this means(in name.arch form): foo.i386 and foo.noarch are not compared to each other for highest version only foo.i386 and foo.i386 will be compared Note that given: foo-1.i386; foo-2.i386 and foo-3.x86_64 The last _two_ pkgs will be returned, not just one of them. """ highdict = {} # If naTup is set, only iterate through packages that match that # name if (naTup): self._checkIndexes(failure='build') where = self.nevra.get((naTup[0],None,None,None,None)) if (not where): raise PackageSackError, 'No Package Matching %s.%s' % naTup else: where = self.returnPackages(patterns=patterns, ignore_case=ignore_case) for pkg in where: if (pkg.name, pkg.arch) not in highdict: highdict[(pkg.name, pkg.arch)] = pkg else: pkg2 = highdict[(pkg.name, pkg.arch)] if pkg.verGT(pkg2): highdict[(pkg.name, pkg.arch)] = pkg if naTup: if naTup in highdict: return [highdict[naTup]] else: raise PackageSackError, 'No Package Matching %s.%s' % naTup return highdict.values() def returnNewestByName(self, name=None, patterns=None, ignore_case=False): """return list of newest packages based on name matching this means(in name.arch form): foo.i386 and foo.noarch will be compared to each other for highest version.""" highdict = {} if patterns is None and name is not None: pkgs = self.searchNevra(name=name) else: pkgs = self.returnPackages(patterns=patterns, ignore_case=ignore_case) for pkg in pkgs: if pkg.name not in highdict: highdict[pkg.name] = [pkg] else: pkg2 = highdict[pkg.name][0] if pkg.verGT(pkg2): highdict[pkg.name] = [pkg] if pkg.verEQ(pkg2): highdict[pkg.name].append(pkg) if name: if name in highdict: return highdict[name] else: raise PackageSackError, 'No Package Matching %s' % name #this is a list of lists - break it back out into a single list returnlist = [] for polst in highdict.values(): for po in polst: returnlist.append(po) return returnlist def simplePkgList(self, patterns=None, ignore_case=False): """returns a list of pkg tuples (n, a, e, v, r) optionally from a single repoid""" # Don't cache due to excludes return [pkg.pkgtup for pkg in self.returnPackages(patterns=patterns, ignore_case=False)] def printPackages(self): for pkg in self.returnPackages(): print pkg def excludeArchs(self, archlist): """exclude incompatible arches. archlist is a list of compatible arches""" for pkg in self.returnPackages(): if pkg.arch not in archlist: self.delPackage(pkg) def searchPackages(self, fields, criteria_re, callback): matches = {} for po in self.returnPackages(): tmpvalues = [] for field in fields: value = getattr(po, field) if value and criteria_re.search(value): tmpvalues.append(value) if len(tmpvalues) > 0: if callback: callback(po, tmpvalues) matches[po] = tmpvalues return matches def packagesNewestByName(pkgs): """ Does the same as PackageSack.returnNewestByName(). Note that given: foo-1.i386; foo-2.i386 and foo-3.x86_64""" newest = {} for pkg in pkgs: key = pkg.name # Can't use pkg.__cmp__ because it takes .arch into account cval = 1 if key in newest: cval = pkg.verCMP(newest[key][0]) if cval > 0: newest[key] = [pkg] elif cval == 0: newest[key].append(pkg) ret = [] for vals in newest.itervalues(): ret.extend(vals) return ret def packagesNewestByNameArch(pkgs): """ Does the same as PackageSack.returnNewestByNameArch() The last _two_ pkgs will be returned, not just one of them.""" newest = {} for pkg in pkgs: key = (pkg.name, pkg.arch) if key in newest and pkg.verLE(newest[key]): continue newest[key] = pkg return newest.values() class ListPackageSack(PackageSack): """Derived class from PackageSack to build new Sack from list of pkgObjects - like one returned from self.returnNewestByNameArch() or self.returnNewestByName()""" def __init__(self, Objlist=None): PackageSack.__init__(self) if Objlist is not None: self.addList(Objlist) def addList(self, ObjList): for pkgobj in ObjList: self.addPackage(pkgobj)