diff options
Diffstat (limited to '')
| -rw-r--r-- | portato/backend/portage/__init__.py | 8 | ||||
| -rw-r--r-- | portato/backend/portage/package.py | 572 | ||||
| -rw-r--r-- | portato/backend/portage/package_22.py | 10 | ||||
| -rw-r--r-- | portato/backend/portage/sets.py | 168 | ||||
| -rw-r--r-- | portato/backend/portage/settings.py | 78 | ||||
| -rw-r--r-- | portato/backend/portage/settings_22.py | 12 | ||||
| -rw-r--r-- | portato/backend/portage/system.py | 768 | ||||
| -rw-r--r-- | portato/backend/portage/system_22.py | 60 |
8 files changed, 838 insertions, 838 deletions
diff --git a/portato/backend/portage/__init__.py b/portato/backend/portage/__init__.py index be6cce6..02a4a82 100644 --- a/portato/backend/portage/__init__.py +++ b/portato/backend/portage/__init__.py @@ -17,8 +17,8 @@ from portage import VERSION as PV VERSION = tuple(map(int, (x.split("_")[0] for x in PV.split(".")))) if VERSION >= (2, 2): - from .system_22 import PortageSystem_22 as PortageSystem - from .package_22 import PortagePackage_22 as PortagePackage + from .system_22 import PortageSystem_22 as PortageSystem + from .package_22 import PortagePackage_22 as PortagePackage else: - from .system import PortageSystem - from .package import PortagePackage + from .system import PortageSystem + from .package import PortagePackage diff --git a/portato/backend/portage/package.py b/portato/backend/portage/package.py index 351b7e0..0270029 100644 --- a/portato/backend/portage/package.py +++ b/portato/backend/portage/package.py @@ -21,294 +21,294 @@ from ...helper import debug, error, unique_array import portage try: - import portage.dep as portage_dep + import portage.dep as portage_dep except ImportError: - import portage_dep + import portage_dep import os.path class PortagePackage (Package): - """This is a class abstracting a normal package which can be installed for the portage-system.""" - - def __init__ (self, cpv): - """Constructor. - - @param cpv: The cpv which describes the package to create. - @type cpv: string (cat/pkg-ver)""" - - Package.__init__(self, cpv) - self._scpv = system.split_cpv(self._cpv) - - if not self._scpv: - raise ValueError("invalid cpv: %s" % cpv) - - self._settings = system.settings - self._settingslock = system.settings.settingslock - self._settings_installed = None - - self._trees = system.settings.trees - - self.forced_flags = set() - - with self._settingslock: - self._init_settings(True) - self.forced_flags.update(self._settings.settings.usemask) - self.forced_flags.update(self._settings.settings.useforce) - - try: - self._status = portage.getmaskingstatus(self.get_cpv(), settings = self._settings.settings) - except KeyError: # package is not located in the system - self._status = None - - if self._status and len(self._status) == 1 and self._status[0] == "corrupted": - self._status = None - - def _init_settings (self, installed): - inst = (installed and self.is_installed()) or (self.is_installed() and not self.is_in_system()) - - if self._settings_installed is not None and self._settings_installed != inst: - self._settings.settings.reset() - - self._settings_installed = inst - - if inst: - dbapi = self._settings.vartree.dbapi - else: - dbapi = self._settings.porttree.dbapi - - self._settings.settings.setcpv(self.get_cpv(), mydb = dbapi) - - def get_name(self): - return self._scpv[1] - - def get_version(self): - v = self._scpv[2] - if self._scpv[3] != "r0": - v += "-" + self._scpv[3] - return v - - def get_category(self): - return self._scpv[0] - - def is_installed(self): - return self._settings.vartree.dbapi.cpv_exists(self._cpv) - - def is_in_overlay(self): - ovl = self.get_overlay_path() - return ovl != self._settings.settings["PORTDIR"] and str(ovl) != "0" - - def get_overlay_path (self): - dir,ovl = self._settings.porttree.dbapi.findname2(self._cpv) - return ovl - - def is_in_system (self): - return (self._status != None) - - def is_missing_keyword(self): - return self._status and "missing keyword" in self._status - - def is_testing(self, use_keywords = True): - testArch = "~" + self.get_global_settings("ARCH") - if not use_keywords: # keywords are NOT taken into account - return testArch in self.get_package_settings("KEYWORDS").split() - - else: # keywords are taken into account - status = flags.new_testing_status(self.get_cpv()) - if status is None: # we haven't changed it in any way - return self._status and testArch+" keyword" in self._status - else: - return status - - def is_masked (self, use_changed = True): - - if use_changed: - status = flags.new_masking_status(self.get_cpv()) - if status != None: # we have locally changed it - if status == "masked": return True - elif status == "unmasked": return False - else: - error(_("BUG in flags.new_masking_status. It returns \'%s\'"), status) - else: # we have not touched the status - return self._status and ("profile" in self._status or "package.mask" in self._status) - - else: # we want the original portage value XXX: bug if masked by user AND by system - - # get the normal masked ones - if self._status and ("profile" in self._status or "package.mask" in self._status): - return not flags.is_locally_masked(self, changes = False) # assume that if it is locally masked, it is not masked by the system - else: # more difficult: get the ones we unmasked, but are masked by the system - try: - masked = self._settings.settings.pmaskdict[self.get_cp()] - except KeyError: # key error: not masked - return False - - for cpv in masked: - if self.matches(cpv): - return not flags.is_locally_masked(self, changes = False) # assume that if it is locally masked, it is not masked by the system - - return False - - def get_masking_reason(self): - reason = portage.getmaskingreason(self.get_cpv(), settings = self._settings.settings) - - if reason: - return reason.strip() - else: - return reason - - def get_iuse_flags (self, installed = False, removeForced = True): - if not self.is_in_system(): - installed = True - - iuse = flags.filter_defaults(self.get_package_settings("IUSE", installed = installed).split()) - - iuse = set(iuse) - - if removeForced: - return list(iuse.difference(self.forced_flags)) - else: - return list(iuse) - - def get_matched_dep_packages (self, depvar): - # change the useflags, because we have internally changed some, but not made them visible for portage - actual = self.get_actual_use_flags() - - depstring = "" - try: - for d in depvar: - depstring += self.get_package_settings(d, installed = False)+" " - except KeyError: # not found in porttree - use vartree - depstring = "" - for d in depvar: - depstring += self.get_package_settings(d, installed = True)+" " - - deps = portage.dep_check(depstring, None, self._settings.settings, myuse = actual, trees = self._trees) - - if not deps: # FIXME: what is the difference to [1, []] ? - return [] - - if deps[0] == 0: # error - raise DependencyCalcError, deps[1] - - deps = deps[1] - - return [d for d in deps if d[0] != "!"] - - def get_dep_packages (self, depvar = ["RDEPEND", "PDEPEND", "DEPEND"], with_criterions = False, return_blocks = False): - dep_pkgs = [] # the package list - - # change the useflags, because we have internally changed some, but not made them visible for portage - actual = self.get_actual_use_flags() - - depstring = "" - for d in depvar: - depstring += self.get_package_settings(d, installed = False)+" " - - # let portage do the main stuff ;) - # pay attention to any changes here - deps = portage.dep_check (depstring, self._settings.vartree.dbapi, self._settings.settings, myuse = actual, trees = self._trees) - - if not deps: # FIXME: what is the difference to [1, []] ? - return [] - - if deps[0] == 0: # error - raise DependencyCalcError, deps[1] - - deps = deps[1] - - def create_dep_pkgs_data (dep, pkg): - """Returns the data to enter into the dep_pkgs list, which is either the package cpv or a tuple - consisting of the cpv and the criterion.""" - if with_criterions: - return (pkg.get_cpv(), dep) - else: - return pkg.get_cpv() - - for dep in deps: - if dep[0] == '!': # blocking sth - blocked = system.find_packages(dep, system.SET_INSTALLED) - if len(blocked) == 1: # only exact one match allowed to be harmless - if blocked[0].get_slot_cp() == self.get_slot_cp(): # blocks in the same slot are harmless - continue - - if return_blocks: - if with_criterions: - dep_pkgs.append((dep, dep)) - else: - dep_pkgs.append(dep) - else: - raise BlockedException, (self.get_cpv(), blocked[0].get_cpv()) - - continue # finished with the blocking one -> next - - pkg = system.find_best_match(dep) - if not pkg: # try to find masked ones - pkgs = system.find_packages(dep, masked = True) - if not pkgs: - raise PackageNotFoundException, dep - - pkgs = system.sort_package_list(pkgs) - pkgs.reverse() - done = False - for p in pkgs: - if not p.is_masked(): - dep_pkgs.append(create_dep_pkgs_data(dep, p)) - done = True - break - if not done: - dep_pkgs.append(create_dep_pkgs_data(dep, pkgs[0])) - else: - dep_pkgs.append(create_dep_pkgs_data(dep, pkg)) - - return dep_pkgs - - def get_global_settings(self, key, installed = True): - with self._settingslock: - self._init_settings(installed) - v = self._settings.settings[key] - - return v - - def get_ebuild_path(self): - if self.is_in_system(): - return self._settings.porttree.dbapi.findname(self._cpv) - else: - return self._settings.vartree.dbapi.findname(self._cpv) - - def get_files (self): - if self.is_installed(): - path = os.path.join(self.get_global_settings("ROOT"), portage.VDB_PATH, self.get_cpv(), "CONTENTS") - with open(path) as f: - for line in f: - yield line.split()[1].strip() - - def get_package_settings(self, var, installed = True): - if installed and self.is_installed(): - mytree = self._settings.vartree - else: - mytree = self._settings.porttree - - r = mytree.dbapi.aux_get(self._cpv,[var]) - - return r[0] - - def get_installed_use_flags(self): - if self.is_installed(): - return self.get_package_settings("USE", installed = True).split() - else: return [] - - def compare_version(self,other): - v1 = self._scpv - v2 = portage.catpkgsplit(other.get_cpv()) - # if category is different - if v1[0] != v2[0]: - return cmp(v1[0],v2[0]) - # if name is different - elif v1[1] != v2[1]: - return cmp(v1[1],v2[1]) - # Compare versions - else: - return portage.pkgcmp(v1[1:],v2[1:]) - - def matches (self, criterion): - return system.cpv_matches(self.get_cpv(), criterion) + """This is a class abstracting a normal package which can be installed for the portage-system.""" + + def __init__ (self, cpv): + """Constructor. + + @param cpv: The cpv which describes the package to create. + @type cpv: string (cat/pkg-ver)""" + + Package.__init__(self, cpv) + self._scpv = system.split_cpv(self._cpv) + + if not self._scpv: + raise ValueError("invalid cpv: %s" % cpv) + + self._settings = system.settings + self._settingslock = system.settings.settingslock + self._settings_installed = None + + self._trees = system.settings.trees + + self.forced_flags = set() + + with self._settingslock: + self._init_settings(True) + self.forced_flags.update(self._settings.settings.usemask) + self.forced_flags.update(self._settings.settings.useforce) + + try: + self._status = portage.getmaskingstatus(self.get_cpv(), settings = self._settings.settings) + except KeyError: # package is not located in the system + self._status = None + + if self._status and len(self._status) == 1 and self._status[0] == "corrupted": + self._status = None + + def _init_settings (self, installed): + inst = (installed and self.is_installed()) or (self.is_installed() and not self.is_in_system()) + + if self._settings_installed is not None and self._settings_installed != inst: + self._settings.settings.reset() + + self._settings_installed = inst + + if inst: + dbapi = self._settings.vartree.dbapi + else: + dbapi = self._settings.porttree.dbapi + + self._settings.settings.setcpv(self.get_cpv(), mydb = dbapi) + + def get_name(self): + return self._scpv[1] + + def get_version(self): + v = self._scpv[2] + if self._scpv[3] != "r0": + v += "-" + self._scpv[3] + return v + + def get_category(self): + return self._scpv[0] + + def is_installed(self): + return self._settings.vartree.dbapi.cpv_exists(self._cpv) + + def is_in_overlay(self): + ovl = self.get_overlay_path() + return ovl != self._settings.settings["PORTDIR"] and str(ovl) != "0" + + def get_overlay_path (self): + dir,ovl = self._settings.porttree.dbapi.findname2(self._cpv) + return ovl + + def is_in_system (self): + return (self._status != None) + + def is_missing_keyword(self): + return self._status and "missing keyword" in self._status + + def is_testing(self, use_keywords = True): + testArch = "~" + self.get_global_settings("ARCH") + if not use_keywords: # keywords are NOT taken into account + return testArch in self.get_package_settings("KEYWORDS").split() + + else: # keywords are taken into account + status = flags.new_testing_status(self.get_cpv()) + if status is None: # we haven't changed it in any way + return self._status and testArch+" keyword" in self._status + else: + return status + + def is_masked (self, use_changed = True): + + if use_changed: + status = flags.new_masking_status(self.get_cpv()) + if status != None: # we have locally changed it + if status == "masked": return True + elif status == "unmasked": return False + else: + error(_("BUG in flags.new_masking_status. It returns \'%s\'"), status) + else: # we have not touched the status + return self._status and ("profile" in self._status or "package.mask" in self._status) + + else: # we want the original portage value XXX: bug if masked by user AND by system + + # get the normal masked ones + if self._status and ("profile" in self._status or "package.mask" in self._status): + return not flags.is_locally_masked(self, changes = False) # assume that if it is locally masked, it is not masked by the system + else: # more difficult: get the ones we unmasked, but are masked by the system + try: + masked = self._settings.settings.pmaskdict[self.get_cp()] + except KeyError: # key error: not masked + return False + + for cpv in masked: + if self.matches(cpv): + return not flags.is_locally_masked(self, changes = False) # assume that if it is locally masked, it is not masked by the system + + return False + + def get_masking_reason(self): + reason = portage.getmaskingreason(self.get_cpv(), settings = self._settings.settings) + + if reason: + return reason.strip() + else: + return reason + + def get_iuse_flags (self, installed = False, removeForced = True): + if not self.is_in_system(): + installed = True + + iuse = flags.filter_defaults(self.get_package_settings("IUSE", installed = installed).split()) + + iuse = set(iuse) + + if removeForced: + return list(iuse.difference(self.forced_flags)) + else: + return list(iuse) + + def get_matched_dep_packages (self, depvar): + # change the useflags, because we have internally changed some, but not made them visible for portage + actual = self.get_actual_use_flags() + + depstring = "" + try: + for d in depvar: + depstring += self.get_package_settings(d, installed = False)+" " + except KeyError: # not found in porttree - use vartree + depstring = "" + for d in depvar: + depstring += self.get_package_settings(d, installed = True)+" " + + deps = portage.dep_check(depstring, None, self._settings.settings, myuse = actual, trees = self._trees) + + if not deps: # FIXME: what is the difference to [1, []] ? + return [] + + if deps[0] == 0: # error + raise DependencyCalcError, deps[1] + + deps = deps[1] + + return [d for d in deps if d[0] != "!"] + + def get_dep_packages (self, depvar = ["RDEPEND", "PDEPEND", "DEPEND"], with_criterions = False, return_blocks = False): + dep_pkgs = [] # the package list + + # change the useflags, because we have internally changed some, but not made them visible for portage + actual = self.get_actual_use_flags() + + depstring = "" + for d in depvar: + depstring += self.get_package_settings(d, installed = False)+" " + + # let portage do the main stuff ;) + # pay attention to any changes here + deps = portage.dep_check (depstring, self._settings.vartree.dbapi, self._settings.settings, myuse = actual, trees = self._trees) + + if not deps: # FIXME: what is the difference to [1, []] ? + return [] + + if deps[0] == 0: # error + raise DependencyCalcError, deps[1] + + deps = deps[1] + + def create_dep_pkgs_data (dep, pkg): + """Returns the data to enter into the dep_pkgs list, which is either the package cpv or a tuple + consisting of the cpv and the criterion.""" + if with_criterions: + return (pkg.get_cpv(), dep) + else: + return pkg.get_cpv() + + for dep in deps: + if dep[0] == '!': # blocking sth + blocked = system.find_packages(dep, system.SET_INSTALLED) + if len(blocked) == 1: # only exact one match allowed to be harmless + if blocked[0].get_slot_cp() == self.get_slot_cp(): # blocks in the same slot are harmless + continue + + if return_blocks: + if with_criterions: + dep_pkgs.append((dep, dep)) + else: + dep_pkgs.append(dep) + else: + raise BlockedException, (self.get_cpv(), blocked[0].get_cpv()) + + continue # finished with the blocking one -> next + + pkg = system.find_best_match(dep) + if not pkg: # try to find masked ones + pkgs = system.find_packages(dep, masked = True) + if not pkgs: + raise PackageNotFoundException, dep + + pkgs = system.sort_package_list(pkgs) + pkgs.reverse() + done = False + for p in pkgs: + if not p.is_masked(): + dep_pkgs.append(create_dep_pkgs_data(dep, p)) + done = True + break + if not done: + dep_pkgs.append(create_dep_pkgs_data(dep, pkgs[0])) + else: + dep_pkgs.append(create_dep_pkgs_data(dep, pkg)) + + return dep_pkgs + + def get_global_settings(self, key, installed = True): + with self._settingslock: + self._init_settings(installed) + v = self._settings.settings[key] + + return v + + def get_ebuild_path(self): + if self.is_in_system(): + return self._settings.porttree.dbapi.findname(self._cpv) + else: + return self._settings.vartree.dbapi.findname(self._cpv) + + def get_files (self): + if self.is_installed(): + path = os.path.join(self.get_global_settings("ROOT"), portage.VDB_PATH, self.get_cpv(), "CONTENTS") + with open(path) as f: + for line in f: + yield line.split()[1].strip() + + def get_package_settings(self, var, installed = True): + if installed and self.is_installed(): + mytree = self._settings.vartree + else: + mytree = self._settings.porttree + + r = mytree.dbapi.aux_get(self._cpv,[var]) + + return r[0] + + def get_installed_use_flags(self): + if self.is_installed(): + return self.get_package_settings("USE", installed = True).split() + else: return [] + + def compare_version(self,other): + v1 = self._scpv + v2 = portage.catpkgsplit(other.get_cpv()) + # if category is different + if v1[0] != v2[0]: + return cmp(v1[0],v2[0]) + # if name is different + elif v1[1] != v2[1]: + return cmp(v1[1],v2[1]) + # Compare versions + else: + return portage.pkgcmp(v1[1:],v2[1:]) + + def matches (self, criterion): + return system.cpv_matches(self.get_cpv(), criterion) diff --git a/portato/backend/portage/package_22.py b/portato/backend/portage/package_22.py index 4fe03d9..1dae1fe 100644 --- a/portato/backend/portage/package_22.py +++ b/portato/backend/portage/package_22.py @@ -15,8 +15,8 @@ from __future__ import absolute_import, with_statement from .package import PortagePackage class PortagePackage_22 (PortagePackage): - """ - The 2.2 specialization of the portage package. - Currently this is identical to the normal one. - """ - pass + """ + The 2.2 specialization of the portage package. + Currently this is identical to the normal one. + """ + pass diff --git a/portato/backend/portage/sets.py b/portato/backend/portage/sets.py index 24ceaca..8d8ef28 100644 --- a/portato/backend/portage/sets.py +++ b/portato/backend/portage/sets.py @@ -17,130 +17,130 @@ import itertools as itt import portage try: - import portage.dep as portage_dep + import portage.dep as portage_dep except ImportError: - import portage_dep + import portage_dep from .. import system from ...helper import debug class Set(object): - def get_pkgs(self, key, is_regexp, masked, with_version, only_cpv): - raise NotImplementedError + def get_pkgs(self, key, is_regexp, masked, with_version, only_cpv): + raise NotImplementedError - def find (self, key, masked = False, with_version = True, only_cpv = False): - if key is None: key = "" - - is_regexp = key == "" or ("*" in key and key[0] not in ("*","=","<",">","~","!")) + def find (self, key, masked = False, with_version = True, only_cpv = False): + if key is None: key = "" + + is_regexp = key == "" or ("*" in key and key[0] not in ("*","=","<",">","~","!")) - try: - t = self.get_pkgs(key, is_regexp, masked, with_version, only_cpv) - # catch the "ambigous package" Exception - except ValueError, e: - if isinstance(e[0], list): - t = set() - for cp in e[0]: - t.update(self.get_pkgs(cp, is_regexp, masked, with_version, only_cpv)) - else: - raise + try: + t = self.get_pkgs(key, is_regexp, masked, with_version, only_cpv) + # catch the "ambigous package" Exception + except ValueError, e: + if isinstance(e[0], list): + t = set() + for cp in e[0]: + t.update(self.get_pkgs(cp, is_regexp, masked, with_version, only_cpv)) + else: + raise - return t + return t class FilterSet (Set): - def get_list(self): - raise NotImplementedError - - def get_pkgs (self, key, is_regexp, masked, with_version, only_cpv): - t = set() - for pkg in self.get_list(): - if is_regexp: - if not re.match(key, pkg, re.I): continue + def get_list(self): + raise NotImplementedError + + def get_pkgs (self, key, is_regexp, masked, with_version, only_cpv): + t = set() + for pkg in self.get_list(): + if is_regexp: + if not re.match(key, pkg, re.I): continue - if not with_version: - t.add(portage_dep.dep_getkey(pkg)) - - t.add(system.find_best_match(pkg, only_cpv = True)) + if not with_version: + t.add(portage_dep.dep_getkey(pkg)) + + t.add(system.find_best_match(pkg, only_cpv = True)) - return t + return t class PortageSet (FilterSet): - def __init__ (self, name): - FilterSet.__init__(self) - debug("Loading portage set '%s'", name) - self.portageSet = system.settings.setsconfig.getSets()[name] + def __init__ (self, name): + FilterSet.__init__(self) + debug("Loading portage set '%s'", name) + self.portageSet = system.settings.setsconfig.getSets()[name] - def get_list(self): - return itt.imap(str, self.portageSet.getAtoms()) + def get_list(self): + return itt.imap(str, self.portageSet.getAtoms()) class SystemSet (FilterSet): - def get_list(self): - for cp in system.settings.settings.packages: - if cp[0] == "*": yield cp[1:] + def get_list(self): + for cp in system.settings.settings.packages: + if cp[0] == "*": yield cp[1:] class WorldSet (FilterSet): - def get_list(self): - with open(portage.WORLD_FILE) as f: - for cp in f: - cp = cp.strip() - if cp and cp[0] != "#": - yield cp + def get_list(self): + with open(portage.WORLD_FILE) as f: + for cp in f: + cp = cp.strip() + if cp and cp[0] != "#": + yield cp class InstalledSet (Set): - def get_pkgs (self, key, is_regexp, masked, with_version, only_cpv): - if is_regexp: - if with_version: - t = system.settings.vartree.dbapi.cpv_all() - else: - t = system.settings.vartree.dbapi.cp_all() + def get_pkgs (self, key, is_regexp, masked, with_version, only_cpv): + if is_regexp: + if with_version: + t = system.settings.vartree.dbapi.cpv_all() + else: + t = system.settings.vartree.dbapi.cp_all() - if key: - t = filter(lambda x: re.match(key, x, re.I), t) + if key: + t = filter(lambda x: re.match(key, x, re.I), t) - return set(t) - else: - return set(system.settings.vartree.dbapi.match(key)) + return set(t) + else: + return set(system.settings.vartree.dbapi.match(key)) class TreeSet (Set): - def get_pkgs (self, key, is_regexp, masked, with_version, only_cpv): - if is_regexp: - if with_version: - t = system.settings.porttree.dbapi.cpv_all() - else: - t = system.settings.porttree.dbapi.cp_all() + def get_pkgs (self, key, is_regexp, masked, with_version, only_cpv): + if is_regexp: + if with_version: + t = system.settings.porttree.dbapi.cpv_all() + else: + t = system.settings.porttree.dbapi.cp_all() - if key: - t = filter(lambda x: re.match(key, x, re.I), t) + if key: + t = filter(lambda x: re.match(key, x, re.I), t) - elif masked: - t = system.settings.porttree.dbapi.xmatch("match-all", key) - else: - t = system.settings.porttree.dbapi.match(key) + elif masked: + t = system.settings.porttree.dbapi.xmatch("match-all", key) + else: + t = system.settings.porttree.dbapi.match(key) - return set(t) + return set(t) class AllSet (Set): - - def __init__ (self): - Set.__init__(self) - self.tree = TreeSet() - self.installed = InstalledSet() + + def __init__ (self): + Set.__init__(self) + self.tree = TreeSet() + self.installed = InstalledSet() - def find (self, *args, **kwargs): - return self.tree.find(*args, **kwargs) | self.installed.find(*args, **kwargs) + def find (self, *args, **kwargs): + return self.tree.find(*args, **kwargs) | self.installed.find(*args, **kwargs) class UninstalledSet (Set): - def __init__ (self): - Set.__init__(self) - self.all = AllSet() - self.installed = InstalledSet() + def __init__ (self): + Set.__init__(self) + self.all = AllSet() + self.installed = InstalledSet() - def find (self, *args, **kwargs): - return self.all.find(*args, **kwargs) - self.installed.find(*args, **kwargs) + def find (self, *args, **kwargs): + return self.all.find(*args, **kwargs) - self.installed.find(*args, **kwargs) diff --git a/portato/backend/portage/settings.py b/portato/backend/portage/settings.py index 5d466ad..0e7eccb 100644 --- a/portato/backend/portage/settings.py +++ b/portato/backend/portage/settings.py @@ -17,42 +17,42 @@ import portage from threading import Lock class PortageSettings: - """Encapsulation of the portage settings. - - @ivar settings: portage settings - @ivar settingslock: a simple Lock - @ivar trees: a dictionary of the trees - @ivar porttree: shortcut to C{trees[root]["porttree"]} - @ivar vartree: shortcut to C{trees[root]["vartree"]} - @ivar virtuals: shortcut to C{trees[root]["virtuals"]}""" - - def __init__ (self): - """Initializes the instance. Calls L{load()}.""" - self.settingslock = Lock() - self.trees = None - self.load() - - def load(self): - """(Re)loads the portage settings and sets the variables.""" - - kwargs = {} - for k, envvar in (("config_root", "PORTAGE_CONFIGROOT"), ("target_root", "ROOT")): - kwargs[k] = os.environ.get(envvar, None) - self.trees = portage.create_trees(trees=self.trees, **kwargs) - - self.settings = self.trees["/"]["vartree"].settings - - for myroot in self.trees: - if myroot != "/": - self.settings = self.trees[myroot]["vartree"].settings - break - - self.settings.unlock() - - root = self.settings["ROOT"] - - self.porttree = self.trees[root]["porttree"] - self.vartree = self.trees[root]["vartree"] - self.virtuals = self.trees[root]["virtuals"] - - portage.settings = None # we use our own one ... + """Encapsulation of the portage settings. + + @ivar settings: portage settings + @ivar settingslock: a simple Lock + @ivar trees: a dictionary of the trees + @ivar porttree: shortcut to C{trees[root]["porttree"]} + @ivar vartree: shortcut to C{trees[root]["vartree"]} + @ivar virtuals: shortcut to C{trees[root]["virtuals"]}""" + + def __init__ (self): + """Initializes the instance. Calls L{load()}.""" + self.settingslock = Lock() + self.trees = None + self.load() + + def load(self): + """(Re)loads the portage settings and sets the variables.""" + + kwargs = {} + for k, envvar in (("config_root", "PORTAGE_CONFIGROOT"), ("target_root", "ROOT")): + kwargs[k] = os.environ.get(envvar, None) + self.trees = portage.create_trees(trees=self.trees, **kwargs) + + self.settings = self.trees["/"]["vartree"].settings + + for myroot in self.trees: + if myroot != "/": + self.settings = self.trees[myroot]["vartree"].settings + break + + self.settings.unlock() + + root = self.settings["ROOT"] + + self.porttree = self.trees[root]["porttree"] + self.vartree = self.trees[root]["vartree"] + self.virtuals = self.trees[root]["virtuals"] + + portage.settings = None # we use our own one ... diff --git a/portato/backend/portage/settings_22.py b/portato/backend/portage/settings_22.py index a43d69e..5274b3b 100644 --- a/portato/backend/portage/settings_22.py +++ b/portato/backend/portage/settings_22.py @@ -16,12 +16,12 @@ import portage.sets from .settings import PortageSettings class PortageSettings_22 (PortageSettings): - """Enhances the normal PortageSettings in ways, that it adds the setsconfig.""" + """Enhances the normal PortageSettings in ways, that it adds the setsconfig.""" - def __init__ (self): - PortageSettings.__init__(self) + def __init__ (self): + PortageSettings.__init__(self) - def load (self): - PortageSettings.load(self) + def load (self): + PortageSettings.load(self) - self.setsconfig = portage.sets.load_default_config(self.settings, self.trees[self.settings["ROOT"]]) + self.setsconfig = portage.sets.load_default_config(self.settings, self.trees[self.settings["ROOT"]]) diff --git a/portato/backend/portage/system.py b/portato/backend/portage/system.py index 2394a10..e81951e 100644 --- a/portato/backend/portage/system.py +++ b/portato/backend/portage/system.py @@ -15,9 +15,9 @@ from __future__ import absolute_import, with_statement import re, os, os.path import portage try: - import portage.dep as portage_dep + import portage.dep as portage_dep except ImportError: - import portage_dep + import portage_dep from collections import defaultdict import itertools as itt @@ -30,386 +30,386 @@ from ..system_interface import SystemInterface from ...helper import debug, info, warning, unique_array class PortageSystem (SystemInterface): - """This class provides access to the portage-system.""" - - # pre-compile the RE removing the ".svn" and "CVS" entries - unwantedPkgsRE = re.compile(r".*(\.svn|CVS)$") - withBdepsRE = re.compile(r"--with-bdeps\s*( |=)\s*y") + """This class provides access to the portage-system.""" + + # pre-compile the RE removing the ".svn" and "CVS" entries + unwantedPkgsRE = re.compile(r".*(\.svn|CVS)$") + withBdepsRE = re.compile(r"--with-bdeps\s*( |=)\s*y") - def __init__ (self): - """Constructor.""" - self.settings = PortageSettings() - portage.WORLD_FILE = os.path.join(self.settings.settings["ROOT"],portage.WORLD_FILE) - - self.use_descs = {} - self.local_use_descs = defaultdict(dict) - - self.setmap = { - self.SET_ALL : syssets.AllSet, - self.SET_INSTALLED : syssets.InstalledSet, - self.SET_UNINSTALLED : syssets.UninstalledSet, - self.SET_TREE : syssets.TreeSet, - "world" : syssets.WorldSet, - "system" : syssets.SystemSet - } - - def has_set_support (self): - return False - - def get_sets (self, description = False): - if description: - return (("world", "The world set."), ("system", "The system set.")) - else: - return ("world", "system") - - def get_version (self): - return "Portage %s" % portage.VERSION - - def new_package (self, cpv): - return PortagePackage(cpv) - - def get_config_path (self): - return portage.USER_CONFIG_PATH - - def get_merge_command (self): - return ["/usr/bin/python", "/usr/bin/emerge"] - - def get_sync_command (self): - return self.get_merge_command()+["--sync"] - - def get_oneshot_option (self): - return ["--oneshot"] - - def get_newuse_option (self): - return ["--newuse"] - - def get_deep_option (self): - return ["--deep"] - - def get_update_option (self): - return ["--update"] - - def get_pretend_option (self): - return ["--pretend", "--verbose"] - - def get_unmerge_option (self): - return ["--unmerge"] - - def get_environment (self): - default_opts = self.get_global_settings("EMERGE_DEFAULT_OPTS") - opts = dict(os.environ) - opts.update(TERM = "xterm") # emulate terminal :) - opts.update(PAGER = "less") # force less - - if default_opts: - opt_list = default_opts.split() - changed = False - - for option in ["--ask", "-a", "--pretend", "-p"]: - if option in opt_list: - opt_list.remove(option) - changed = True - - if changed: - opts.update(EMERGE_DEFAULT_OPTS = " ".join(opt_list)) - - return opts - - def cpv_matches (self, cpv, criterion): - if portage.match_from_list(criterion, [cpv]) == []: - return False - else: - return True - - def with_bdeps(self): - """Returns whether the "--with-bdeps" option is set to true. - - @returns: the value of --with-bdeps - @rtype: boolean - """ - - settings = self.get_global_settings("EMERGE_DEFAULT_OPTS").split() - for s in settings: - if self.withBdepsRE.match(s): - return True - - return False - - def find_lambda (self, name): - """Returns the function needed by all the find_all_*-functions. Returns None if no name is given. - - @param name: name to build the function of - @type name: string or RE - @returns: - 1. None if no name is given - 2. a lambda function - @rtype: function - """ - - if name != None: - if isinstance(name, str): - return lambda x: re.match(".*"+name+".*",x, re.I) - else: # assume regular expression - return lambda x: name.match(x) - else: - return lambda x: True - - def geneticize_list (self, list_of_packages, only_cpv = False): - """Convertes a list of cpv's into L{backend.Package}s. - - @param list_of_packages: the list of packages - @type list_of_packages: string[] - @param only_cpv: do nothing - return the passed list - @type only_cpv: boolean - @returns: converted list - @rtype: PortagePackage[] - """ - - if not only_cpv: - return [self.new_package(x) for x in list_of_packages] - elif not isinstance(list_of_packages, list): - return list(list_of_packages) - else: - return list_of_packages - - def get_global_settings (self, key): - self.settings.settings.reset() - return self.settings.settings[key] - - def find_best (self, list, only_cpv = False): - if only_cpv: - return portage.best(list) - else: - return self.new_package(portage.best(list)) - - def find_best_match (self, search_key, masked = False, only_installed = False, only_cpv = False): - t = [] - - if not only_installed: - pkgSet = self.SET_TREE - else: - pkgSet = self.SET_INSTALLED - - t = self.find_packages(search_key, pkgSet = pkgSet, masked = masked, with_version = True, only_cpv = True) - - if VERSION >= (2,1,5): - t += [pkg.get_cpv() for pkg in self.find_packages(search_key, self.SET_INSTALLED) if not (pkg.is_testing(True) or pkg.is_masked())] - elif not only_installed: # no need to run twice - t += self.find_packages(search_key, self.SET_INSTALLED, only_cpv=True) - - if t: - t = unique_array(t) - return self.find_best(t, only_cpv) - - return None - - def _get_set (self, pkgSet): - pkgSet = pkgSet.lower() - if pkgSet == "": pkgSet = self.SET_ALL - - return self.setmap[pkgSet]() - - def find_packages (self, key = "", pkgSet = SystemInterface.SET_ALL, masked = False, with_version = True, only_cpv = False): - return self.geneticize_list(self._get_set(pkgSet).find(key, masked, with_version, only_cpv), only_cpv or not with_version) - - def list_categories (self, name = None): - categories = self.settings.settings.categories - return filter(self.find_lambda(name), categories) - - def split_cpv (self, cpv): - cpv = portage.dep_getcpv(cpv) - return portage.catpkgsplit(cpv) - - def sort_package_list(self, pkglist): - pkglist.sort(PortagePackage.compare_version) # XXX: waaah ... direct package naming... =/ - return pkglist - - def reload_settings (self): - self.settings.load() - - def get_new_packages (self, packages): - """Gets a list of packages and returns the best choice for each in the portage tree. - - @param packages: the list of packages - @type packages: string[] - @returns: the list of packages - @rtype: backend.Package[] - """ - - new_packages = [] - - def append(crit, best, inst): - if not best: - return - - if not best.is_installed() and (best.is_masked() or best.is_testing(True)): # check to not update unnecessairily - for i in inst: - if i.matches(crit): - debug("The installed %s matches %s. Discarding upgrade to masked version.", i.get_cpv(), crit) - return - - new_packages.append(best) - - for p in packages: - inst = self.find_packages(p, self.SET_INSTALLED) - - best_p = self.find_best_match(p) - if best_p is None: - best_p = self.find_best_match(p, masked = True) - if best_p is None: - warning(_("No best match for %s. It seems not to be in the tree anymore.") % p) - continue - else: - debug("Best match for %s is masked" % p) - - if len(inst) > 1: - myslots = set() - for i in inst: # get the slots of the installed packages - myslots.add(i.get_package_settings("SLOT")) - - myslots.add(best_p.get_package_settings("SLOT")) # add the slot of the best package in portage - for slot in myslots: - crit = "%s:%s" % (p, slot) - append(crit, self.find_best_match(crit), inst) - else: - append(p, best_p, inst) - - return new_packages - - def get_updated_packages (self): - packages = self.get_new_packages(self.find_packages(pkgSet = self.SET_INSTALLED, with_version = False)) - packages = [x for x in packages if x is not None and not x.is_installed()] - return packages - - def update_world (self, sets = ("world", "system"), newuse = False, deep = False): - packages = set() - map(packages.add, itt.chain(*[self.find_packages(pkgSet = s, with_version = False) for s in sets])) - - states = [(["RDEPEND", "PDEPEND"], True)] - if self.with_bdeps(): - states.append((["DEPEND"], True)) - - checked = [] - updating = [] - raw_checked = {} - def check (p, add_not_installed = True, prev_appended = False): - """Checks whether a package is updated or not.""" - - if p.get_slot_cp() in checked: - return - else: - if (not p.is_installed()) and (not add_not_installed): - # don't add these packages to checked as we may see them again - # - and then we might have add_not_installed being True - return - else: - checked.append(p.get_slot_cp()) - - appended = False - tempDeep = False - - if not p.is_installed(): - oldList = self.find_packages(p.get_slot_cp(), self.SET_INSTALLED) - if oldList: - old = oldList[0] # we should only have one package here - else it is a bug - else: - oldList = self.sort_package_list(self.find_packages(p.get_cp(), self.SET_INSTALLED)) - if not oldList: - info(_("Found a not installed dependency: %s.") % p.get_cpv()) - oldList = [p] - - old = oldList[-1] - - updating.append((p, old)) - appended = True - p = old - - if newuse and p.is_installed() and p.is_in_system(): # there is no use to check newuse for a package which is not existing in portage anymore :) - - new_iuse = set(p.get_iuse_flags(installed = False)) # IUSE in the ebuild - old_iuse = set(p.get_iuse_flags(installed = True)) # IUSE in the vardb - - # add forced flags, as they might trigger a rebuild - new_iuse_f = set(p.get_iuse_flags(installed = False, removeForced = False)) - old_iuse_f = set(p.get_iuse_flags(installed = True, removeForced = False)) - - if new_iuse.symmetric_difference(old_iuse): # difference between IUSE (w/o forced) - tempDeep = True - if not appended: - updating.append((p,p)) - appended = True - - else: # check for difference between the _set_ useflags (w/ forced) - if new_iuse_f.intersection(p.get_actual_use_flags()).symmetric_difference(old_iuse_f.intersection(p.get_installed_use_flags())): - tempDeep = True - if not appended: - updating.append((p,p)) - appended = True - - if deep or tempDeep: - if (appended or prev_appended) and len(states) < 2: - real_states = states + [("PDEPEND", True), ("DEPEND", False)] - else: - real_states = states - for state in real_states: - for i in p.get_matched_dep_packages(state[0]): - if i not in raw_checked or raw_checked[i] == False: - raw_checked.update({i : state[1]}) - bm = self.get_new_packages([i]) - if not bm: - warning(_("Bug? No best match could be found for '%(package)s'. Needed by: '%(cpv)s'."), {"package" : i, "cpv": p.get_cpv()}) - else: - for pkg in bm: - if not pkg: continue - check(pkg, state[1], appended) # XXX: should be 'or'ed with prev_appended? - - for p in self.get_new_packages(packages): - if not p: continue # if a masked package is installed we have "None" here - check(p, True) - - return updating - - def get_use_desc (self, flag, package = None): - # In the first run the dictionaries 'use_descs' and 'local_use_descs' are filled. - - # fill cache if needed - if not self.use_descs and not self.local_use_descs: - for dir in [self.settings.settings["PORTDIR"]] + self.settings.settings["PORTDIR_OVERLAY"].split(): - - # read use.desc - try: - f = open(os.path.join(dir, "profiles/use.desc")) - for line in f: - line = line.strip() - if line and line[0] != '#': - fields = [x.strip() for x in line.split(" - ",1)] - if len(fields) == 2: - self.use_descs[fields[0]] = fields[1] - except IOError: - pass - finally: - f.close() - - # read use.local.desc - try: - f = open(os.path.join(dir, "profiles/use.local.desc")) - for line in f: - line = line.strip() - if line and line[0] != '#': - fields = [x.strip() for x in line.split(":",1)] - if len(fields) == 2: - subfields = [x.strip() for x in fields[1].split(" - ",1)] - if len(subfields) == 2: - self.local_use_descs[fields[0]].update([subfields]) - except IOError: - pass - finally: - f.close() - - # start - desc = self.use_descs.get(flag, "") - if package is not None: - if package in self.local_use_descs: - desc = self.local_use_descs[package].get(flag, desc) - - return desc + def __init__ (self): + """Constructor.""" + self.settings = PortageSettings() + portage.WORLD_FILE = os.path.join(self.settings.settings["ROOT"],portage.WORLD_FILE) + + self.use_descs = {} + self.local_use_descs = defaultdict(dict) + + self.setmap = { + self.SET_ALL : syssets.AllSet, + self.SET_INSTALLED : syssets.InstalledSet, + self.SET_UNINSTALLED : syssets.UninstalledSet, + self.SET_TREE : syssets.TreeSet, + "world" : syssets.WorldSet, + "system" : syssets.SystemSet + } + + def has_set_support (self): + return False + + def get_sets (self, description = False): + if description: + return (("world", "The world set."), ("system", "The system set.")) + else: + return ("world", "system") + + def get_version (self): + return "Portage %s" % portage.VERSION + + def new_package (self, cpv): + return PortagePackage(cpv) + + def get_config_path (self): + return portage.USER_CONFIG_PATH + + def get_merge_command (self): + return ["/usr/bin/python", "/usr/bin/emerge"] + + def get_sync_command (self): + return self.get_merge_command()+["--sync"] + + def get_oneshot_option (self): + return ["--oneshot"] + + def get_newuse_option (self): + return ["--newuse"] + + def get_deep_option (self): + return ["--deep"] + + def get_update_option (self): + return ["--update"] + + def get_pretend_option (self): + return ["--pretend", "--verbose"] + + def get_unmerge_option (self): + return ["--unmerge"] + + def get_environment (self): + default_opts = self.get_global_settings("EMERGE_DEFAULT_OPTS") + opts = dict(os.environ) + opts.update(TERM = "xterm") # emulate terminal :) + opts.update(PAGER = "less") # force less + + if default_opts: + opt_list = default_opts.split() + changed = False + + for option in ["--ask", "-a", "--pretend", "-p"]: + if option in opt_list: + opt_list.remove(option) + changed = True + + if changed: + opts.update(EMERGE_DEFAULT_OPTS = " ".join(opt_list)) + + return opts + + def cpv_matches (self, cpv, criterion): + if portage.match_from_list(criterion, [cpv]) == []: + return False + else: + return True + + def with_bdeps(self): + """Returns whether the "--with-bdeps" option is set to true. + + @returns: the value of --with-bdeps + @rtype: boolean + """ + + settings = self.get_global_settings("EMERGE_DEFAULT_OPTS").split() + for s in settings: + if self.withBdepsRE.match(s): + return True + + return False + + def find_lambda (self, name): + """Returns the function needed by all the find_all_*-functions. Returns None if no name is given. + + @param name: name to build the function of + @type name: string or RE + @returns: + 1. None if no name is given + 2. a lambda function + @rtype: function + """ + + if name != None: + if isinstance(name, str): + return lambda x: re.match(".*"+name+".*",x, re.I) + else: # assume regular expression + return lambda x: name.match(x) + else: + return lambda x: True + + def geneticize_list (self, list_of_packages, only_cpv = False): + """Convertes a list of cpv's into L{backend.Package}s. + + @param list_of_packages: the list of packages + @type list_of_packages: string[] + @param only_cpv: do nothing - return the passed list + @type only_cpv: boolean + @returns: converted list + @rtype: PortagePackage[] + """ + + if not only_cpv: + return [self.new_package(x) for x in list_of_packages] + elif not isinstance(list_of_packages, list): + return list(list_of_packages) + else: + return list_of_packages + + def get_global_settings (self, key): + self.settings.settings.reset() + return self.settings.settings[key] + + def find_best (self, list, only_cpv = False): + if only_cpv: + return portage.best(list) + else: + return self.new_package(portage.best(list)) + + def find_best_match (self, search_key, masked = False, only_installed = False, only_cpv = False): + t = [] + + if not only_installed: + pkgSet = self.SET_TREE + else: + pkgSet = self.SET_INSTALLED + + t = self.find_packages(search_key, pkgSet = pkgSet, masked = masked, with_version = True, only_cpv = True) + + if VERSION >= (2,1,5): + t += [pkg.get_cpv() for pkg in self.find_packages(search_key, self.SET_INSTALLED) if not (pkg.is_testing(True) or pkg.is_masked())] + elif not only_installed: # no need to run twice + t += self.find_packages(search_key, self.SET_INSTALLED, only_cpv=True) + + if t: + t = unique_array(t) + return self.find_best(t, only_cpv) + + return None + + def _get_set (self, pkgSet): + pkgSet = pkgSet.lower() + if pkgSet == "": pkgSet = self.SET_ALL + + return self.setmap[pkgSet]() + + def find_packages (self, key = "", pkgSet = SystemInterface.SET_ALL, masked = False, with_version = True, only_cpv = False): + return self.geneticize_list(self._get_set(pkgSet).find(key, masked, with_version, only_cpv), only_cpv or not with_version) + + def list_categories (self, name = None): + categories = self.settings.settings.categories + return filter(self.find_lambda(name), categories) + + def split_cpv (self, cpv): + cpv = portage.dep_getcpv(cpv) + return portage.catpkgsplit(cpv) + + def sort_package_list(self, pkglist): + pkglist.sort(PortagePackage.compare_version) # XXX: waaah ... direct package naming... =/ + return pkglist + + def reload_settings (self): + self.settings.load() + + def get_new_packages (self, packages): + """Gets a list of packages and returns the best choice for each in the portage tree. + + @param packages: the list of packages + @type packages: string[] + @returns: the list of packages + @rtype: backend.Package[] + """ + + new_packages = [] + + def append(crit, best, inst): + if not best: + return + + if not best.is_installed() and (best.is_masked() or best.is_testing(True)): # check to not update unnecessairily + for i in inst: + if i.matches(crit): + debug("The installed %s matches %s. Discarding upgrade to masked version.", i.get_cpv(), crit) + return + + new_packages.append(best) + + for p in packages: + inst = self.find_packages(p, self.SET_INSTALLED) + + best_p = self.find_best_match(p) + if best_p is None: + best_p = self.find_best_match(p, masked = True) + if best_p is None: + warning(_("No best match for %s. It seems not to be in the tree anymore.") % p) + continue + else: + debug("Best match for %s is masked" % p) + + if len(inst) > 1: + myslots = set() + for i in inst: # get the slots of the installed packages + myslots.add(i.get_package_settings("SLOT")) + + myslots.add(best_p.get_package_settings("SLOT")) # add the slot of the best package in portage + for slot in myslots: + crit = "%s:%s" % (p, slot) + append(crit, self.find_best_match(crit), inst) + else: + append(p, best_p, inst) + + return new_packages + + def get_updated_packages (self): + packages = self.get_new_packages(self.find_packages(pkgSet = self.SET_INSTALLED, with_version = False)) + packages = [x for x in packages if x is not None and not x.is_installed()] + return packages + + def update_world (self, sets = ("world", "system"), newuse = False, deep = False): + packages = set() + map(packages.add, itt.chain(*[self.find_packages(pkgSet = s, with_version = False) for s in sets])) + + states = [(["RDEPEND", "PDEPEND"], True)] + if self.with_bdeps(): + states.append((["DEPEND"], True)) + + checked = [] + updating = [] + raw_checked = {} + def check (p, add_not_installed = True, prev_appended = False): + """Checks whether a package is updated or not.""" + + if p.get_slot_cp() in checked: + return + else: + if (not p.is_installed()) and (not add_not_installed): + # don't add these packages to checked as we may see them again + # - and then we might have add_not_installed being True + return + else: + checked.append(p.get_slot_cp()) + + appended = False + tempDeep = False + + if not p.is_installed(): + oldList = self.find_packages(p.get_slot_cp(), self.SET_INSTALLED) + if oldList: + old = oldList[0] # we should only have one package here - else it is a bug + else: + oldList = self.sort_package_list(self.find_packages(p.get_cp(), self.SET_INSTALLED)) + if not oldList: + info(_("Found a not installed dependency: %s.") % p.get_cpv()) + oldList = [p] + + old = oldList[-1] + + updating.append((p, old)) + appended = True + p = old + + if newuse and p.is_installed() and p.is_in_system(): # there is no use to check newuse for a package which is not existing in portage anymore :) + + new_iuse = set(p.get_iuse_flags(installed = False)) # IUSE in the ebuild + old_iuse = set(p.get_iuse_flags(installed = True)) # IUSE in the vardb + + # add forced flags, as they might trigger a rebuild + new_iuse_f = set(p.get_iuse_flags(installed = False, removeForced = False)) + old_iuse_f = set(p.get_iuse_flags(installed = True, removeForced = False)) + + if new_iuse.symmetric_difference(old_iuse): # difference between IUSE (w/o forced) + tempDeep = True + if not appended: + updating.append((p,p)) + appended = True + + else: # check for difference between the _set_ useflags (w/ forced) + if new_iuse_f.intersection(p.get_actual_use_flags()).symmetric_difference(old_iuse_f.intersection(p.get_installed_use_flags())): + tempDeep = True + if not appended: + updating.append((p,p)) + appended = True + + if deep or tempDeep: + if (appended or prev_appended) and len(states) < 2: + real_states = states + [("PDEPEND", True), ("DEPEND", False)] + else: + real_states = states + for state in real_states: + for i in p.get_matched_dep_packages(state[0]): + if i not in raw_checked or raw_checked[i] == False: + raw_checked.update({i : state[1]}) + bm = self.get_new_packages([i]) + if not bm: + warning(_("Bug? No best match could be found for '%(package)s'. Needed by: '%(cpv)s'."), {"package" : i, "cpv": p.get_cpv()}) + else: + for pkg in bm: + if not pkg: continue + check(pkg, state[1], appended) # XXX: should be 'or'ed with prev_appended? + + for p in self.get_new_packages(packages): + if not p: continue # if a masked package is installed we have "None" here + check(p, True) + + return updating + + def get_use_desc (self, flag, package = None): + # In the first run the dictionaries 'use_descs' and 'local_use_descs' are filled. + + # fill cache if needed + if not self.use_descs and not self.local_use_descs: + for dir in [self.settings.settings["PORTDIR"]] + self.settings.settings["PORTDIR_OVERLAY"].split(): + + # read use.desc + try: + f = open(os.path.join(dir, "profiles/use.desc")) + for line in f: + line = line.strip() + if line and line[0] != '#': + fields = [x.strip() for x in line.split(" - ",1)] + if len(fields) == 2: + self.use_descs[fields[0]] = fields[1] + except IOError: + pass + finally: + f.close() + + # read use.local.desc + try: + f = open(os.path.join(dir, "profiles/use.local.desc")) + for line in f: + line = line.strip() + if line and line[0] != '#': + fields = [x.strip() for x in line.split(":",1)] + if len(fields) == 2: + subfields = [x.strip() for x in fields[1].split(" - ",1)] + if len(subfields) == 2: + self.local_use_descs[fields[0]].update([subfields]) + except IOError: + pass + finally: + f.close() + + # start + desc = self.use_descs.get(flag, "") + if package is not None: + if package in self.local_use_descs: + desc = self.local_use_descs[package].get(flag, desc) + + return desc diff --git a/portato/backend/portage/system_22.py b/portato/backend/portage/system_22.py index a329ab0..d5b605f 100644 --- a/portato/backend/portage/system_22.py +++ b/portato/backend/portage/system_22.py @@ -24,41 +24,41 @@ from . import sets as syssets class PortageSystem_22 (PortageSystem): - def __init__ (self): - self.settings = PortageSettings_22() - portage.WORLD_FILE = os.path.join(self.settings.settings["ROOT"],portage.WORLD_FILE) + def __init__ (self): + self.settings = PortageSettings_22() + portage.WORLD_FILE = os.path.join(self.settings.settings["ROOT"],portage.WORLD_FILE) - self.use_descs = {} - self.local_use_descs = defaultdict(dict) + self.use_descs = {} + self.local_use_descs = defaultdict(dict) - self.setmap = { - self.SET_ALL : syssets.AllSet, - self.SET_INSTALLED : syssets.InstalledSet, - self.SET_UNINSTALLED : syssets.UninstalledSet, - self.SET_TREE : syssets.TreeSet - } + self.setmap = { + self.SET_ALL : syssets.AllSet, + self.SET_INSTALLED : syssets.InstalledSet, + self.SET_UNINSTALLED : syssets.UninstalledSet, + self.SET_TREE : syssets.TreeSet + } - def get_update_option (self): - return ["--update", "--oneshot"] # --oneshot to not record the used sets in world file + def get_update_option (self): + return ["--update", "--oneshot"] # --oneshot to not record the used sets in world file - def has_set_support (self): - return True + def has_set_support (self): + return True - def get_sets (self, description = False): - if description: - return ((name, set.description) for name, set in self.settings.setsconfig.getSets().iteritems()) - else: - return tuple(self.settings.setsconfig.getSets()) + def get_sets (self, description = False): + if description: + return ((name, set.description) for name, set in self.settings.setsconfig.getSets().iteritems()) + else: + return tuple(self.settings.setsconfig.getSets()) - def _get_set (self, pkgSet): - pkgSet = pkgSet.lower() - if pkgSet == "": pkgSet = self.SET_ALL + def _get_set (self, pkgSet): + pkgSet = pkgSet.lower() + if pkgSet == "": pkgSet = self.SET_ALL - s = self.setmap.get(pkgSet, None) - if s is None: - return syssets.PortageSet(pkgSet) - else: - return s() + s = self.setmap.get(pkgSet, None) + if s is None: + return syssets.PortageSet(pkgSet) + else: + return s() - def new_package (self, cpv): - return PortagePackage_22(cpv) + def new_package (self, cpv): + return PortagePackage_22(cpv) |