def __init__(self, basepath, url, version, arches, components, groups,
rawurl, blacklist, whitelist, recommended):
self.basepath = basepath
self.version = version
self.components = components
self.url = url
self.rawurl = rawurl
self.groups = groups
self.arches = arches
self.deps = dict()
self.provides = dict()
self.blacklist = set(blacklist)
self.whitelist = set(whitelist)
self.cachefile = '%s/cache-%s' % (self.basepath, md5(cPickle.dumps( \
[self.version, self.components, self.url, \
self.rawurl, self.groups, self.arches])).hexdigest())
self.recommended = recommended
self.url_map = []
def cachekey(self):
return md5(cPickle.dumps([self.version, self.components, self.url,
self.rawurl, self.arches])).hexdigest()
def cachekey(self):
return md5(
cPickle.dumps([
self.version, self.components, self.url, self.rawurl,
self.arches
])).hexdigest()
def complete(self, packagelist):
if not self.use_yum:
return Collection.complete(self, packagelist)
cachekey = cPickle.dumps(sorted(packagelist))
try:
packages = self.pkgset_cache[cachekey]
except KeyError:
packages = set()
pkgs = set(packagelist).difference(packages)
requires = set()
satisfied = set()
unknown = set()
final_pass = False
while requires or pkgs:
# infinite loop protection
start_reqs = len(requires)
while pkgs:
package = pkgs.pop()
if package in packages:
continue
if not self.is_package(package):
# try this package out as a requirement
requires.add((package, None, (None, None, None)))
continue
packages.add(package)
reqs = set(self.get_deps(package)).difference(satisfied)
if reqs:
requires.update(reqs)
reqs_satisfied = set()
for req in requires:
if req in satisfied:
reqs_satisfied.add(req)
continue
if req[1] is None and self.is_package(req[0]):
if req[0] not in packages:
pkgs.add(req[0])
reqs_satisfied.add(req)
continue
self.logger.debug("Packages: Handling requirement '%s'" %
self.get_package_name(req))
providers = list(set(self.get_provides(req)))
if len(providers) > 1:
# hopefully one of the providing packages is already
# included
best = [p for p in providers if p in packages]
if best:
providers = best
else:
# pick a provider whose name matches the requirement
best = [p for p in providers if p == req[0]]
if len(best) == 1:
providers = best
elif not final_pass:
# found no "best" package, so defer
providers = None
# else: found no "best" package, but it's the
# final pass, so include them all
if providers:
self.logger.debug("Packages: Requirement '%s' satisfied "
"by %s" %
(self.get_package_name(req),
",".join([self.get_package_name(p)
for p in providers])))
newpkgs = set(providers).difference(packages)
if newpkgs:
for package in newpkgs:
if self.is_package(package):
pkgs.add(package)
else:
unknown.add(package)
reqs_satisfied.add(req)
elif providers is not None:
# nothing provided this requirement at all
unknown.add(req)
reqs_satisfied.add(req)
# else, defer
requires.difference_update(reqs_satisfied)
# infinite loop protection
if len(requires) == start_reqs and len(pkgs) == 0:
final_pass = True
if final_pass and requires:
unknown.update(requires)
requires = set()
self.filter_unknown(unknown)
unknown = [self.get_package_name(p) for p in unknown]
# we do not cache unknown packages, since those are likely to
# be fixed
self.pkgset_cache[cachekey] = packages
return packages, unknown
