Merged from trunk 10480:10509

   | 10481   | Clean up reference to dropped_tasks when finished.           |
   | zmedico |                                                              |

   | 10482   | Clean up references to unsatisfied_parents.                  |
   | zmedico |                                                              |

   | 10485   | Use izip() to eliminate temporary dict instances.            |
   | zmedico |                                                              |

   | 10487   | Fix typo.                                                    |
   | zmedico |                                                              |

   | 10489   | Use a frozenset instead of a list for containment tests.     |
   | zmedico |                                                              |

   | 10491   | Use Package.metadata instead of calling dbapi.aux_get().     |
   | zmedico |                                                              |

   | 10493   | When dropping deps from the resume list, make sure that the  |
   | zmedico | loop can't be infinite.                                      |

   | 10495   | Create Atom instances earlier to avoid redundant validation. |
   | zmedico |                                                              |

   | 10497   | Fix Atom attribute handling in get_operator() and            |
   | zmedico | dep_getslot() to account for None return values.             |

   | 10499   | Simplify None Package.slot handling in match_from_list().    |
   | zmedico |                                                              |

   | 10501   | Make PackageSet.findAtomForPackage() just return the first   |
   | zmedico | atom found since best_match_to_list() won't work correctly   |
   |         | for atoms matched via PROVIDE.                               |

   | 10503   | Pass a mutable config instance into get_masking_status().    |
   | zmedico | Currently it doesn't matter for installed packages but it's  |
   |         | safer to be consistent to avoid accidental breakage in the   |
   |         | future.                                                      |

   | 10505   | Make the use_cache=0 listdir() implementation inside         |
   | zmedico | vardbapi.cpv_all() rains a PermissionDenied error when       |
   |         | appropriate.                                                 |

   | 10507   | For consistency, make sure that a normal iterator is always  |
   | zmedico | returned from dbapi._iter_match() (and never a list). This   |
   |         | way the caller can be sure that the returned object has a    |
   |         | next() method.                                               |

   | 10509   | Now that dbapi._iter_match() is guaranteed to return a real  |
   | zmedico | iterator with a next method(), we can just call next() and   |
   |         | handle StopIteration.                                        |

svn path=/main/branches/prefix/; revision=10543

diff --git a/bin/repoman b/bin/repoman
index d19bca8641b71576c994489ecda4e30182d04067..9a2267d5a1b267bbcd6b6a211fc3eb32c96a3cc8 100755 (executable)
--- a/bin/repoman
+++ b/bin/repoman
@@ -1249,14 +1249,15 @@ for x in scanlist:
                                        if token in operator_tokens or \
                                                token.endswith("?"):
                                                continue
-                                       if not portage.isvalidatom(token, allow_blockers=True):
+                                       try:
+                                               atom = portage.dep.Atom(token)
+                                       except portage.exception.InvalidAtom:
                                                badsyntax.append("'%s' not a valid atom" % token)
                                        else:
-                                               atom = token
-                                               is_blocker = atom.startswith("!")
-                                               if is_blocker:
-                                                       atom = token.lstrip("!")
-                                               atom = portage.dep.Atom(atom)
+                                               is_blocker = atom.blocker
+                                               if atom.blocker:
+                                                       atom = portage.dep.Atom(atom[1:])
+
                                                if mytype == "DEPEND" and \
                                                        not is_blocker and \
                                                        not inherited_java_eclass and \

diff --git a/pym/_emerge/__init__.py b/pym/_emerge/__init__.py
index c84e3beb0bb4d1c9aaf1a105c69f8a9a009653b2..7faeda8d1c7b0f198cca01cd7fb041808d45e2a8 100644 (file)
--- a/pym/_emerge/__init__.py
+++ b/pym/_emerge/__init__.py
@@ -515,8 +515,8 @@ class search(object):
                                else:
                                        db_keys = list(db._aux_cache_keys)
                                        for cpv in db.match(atom):
-                                               metadata = dict(izip(db_keys,
-                                                       db.aux_get(cpv, db_keys)))
+                                               metadata = izip(db_keys,
+                                                       db.aux_get(cpv, db_keys))
                                                if not self._visible(db, cpv, metadata):
                                                        continue
                                                matches.add(cpv)
@@ -538,8 +538,8 @@ class search(object):
                                        for cpv in reversed(db.match(atom)):
                                                if portage.cpv_getkey(cpv) != cp:
                                                        continue
-                                               metadata = dict(izip(db_keys,
-                                                       db.aux_get(cpv, db_keys)))
+                                               metadata = izip(db_keys,
+                                                       db.aux_get(cpv, db_keys))
                                                if not self._visible(db, cpv, metadata):
                                                        continue
                                                if not result or cpv == portage.best([cpv, result]):
@@ -759,6 +759,7 @@ def create_world_atom(pkg_key, metadata, args_set, root_config):
        be greedy with respect to slots.  Unslotted system packages will not be
        stored in world."""
        pkg = Package(cpv=pkg_key, root_config=root_config, metadata=metadata)
+       metadata = pkg.metadata
        arg_atom = args_set.findAtomForPackage(pkg)
        if not arg_atom:
                return None
@@ -2569,8 +2570,8 @@ class depgraph(object):
                                        os.path.realpath(self.trees[myroot]["bintree"].getname(mykey)):
                                        print colorize("BAD", "\n*** You need to adjust PKGDIR to emerge this package.\n")
                                        return 0, myfavorites
-                               metadata = dict(izip(self._mydbapi_keys,
-                                       bindb.aux_get(mykey, self._mydbapi_keys)))
+                               metadata = izip(self._mydbapi_keys,
+                                       bindb.aux_get(mykey, self._mydbapi_keys))
                                pkg = Package(type_name="binary", root_config=root_config,
                                        cpv=mykey, built=True, metadata=metadata,
                                        onlydeps=onlydeps)
@@ -2607,12 +2608,12 @@ class depgraph(object):
                                else:
                                        raise portage.exception.PackageNotFound(
                                                "%s is not in a valid portage tree hierarchy or does not exist" % x)
-                               metadata = dict(izip(self._mydbapi_keys,
-                                       portdb.aux_get(mykey, self._mydbapi_keys)))
-                               pkgsettings.setcpv(mykey, mydb=metadata)
-                               metadata["USE"] = pkgsettings["PORTAGE_USE"]
+                               metadata = izip(self._mydbapi_keys,
+                                       portdb.aux_get(mykey, self._mydbapi_keys))
                                pkg = Package(type_name="ebuild", root_config=root_config,
                                        cpv=mykey, metadata=metadata, onlydeps=onlydeps)
+                               pkgsettings.setcpv(pkg)
+                               pkg.metadata["USE"] = pkgsettings["PORTAGE_USE"]
                                self._pkg_cache[pkg] = pkg
                                args.append(PackageArg(arg=x, package=pkg,
                                        root_config=root_config))
@@ -3108,7 +3109,7 @@ class depgraph(object):
                                                        (pkg_type, root, pkg.cpv, "nomerge"))
                                                if inst_pkg is None:
                                                        metadata = izip(self._mydbapi_keys,
-                                                               vardb.aux_get(cpv, self._mydbapi_keys))
+                                                               vardb.aux_get(pkg.cpv, self._mydbapi_keys))
                                                        inst_pkg = Package(built=built, cpv=pkg.cpv,
                                                                installed=installed, metadata=metadata,
                                                                onlydeps=onlydeps, root_config=root_config,
@@ -3147,7 +3148,7 @@ class depgraph(object):
                                        if pkg is None:
                                                calculated_use = False
                                                try:
-                                                       metadata = zip(self._mydbapi_keys,
+                                                       metadata = izip(self._mydbapi_keys,
                                                                db.aux_get(cpv, self._mydbapi_keys))
                                                except KeyError:
                                                        continue
@@ -4772,10 +4773,9 @@ class depgraph(object):
                                        forced_flags.update(pkgsettings.useforce)
                                        forced_flags.update(pkgsettings.usemask)
 
-                                       cur_iuse = list(pkg.iuse.all)
-                                       cur_iuse.sort()
                                        cur_use = [flag for flag in pkg.use.enabled \
-                                               if flag in cur_iuse]
+                                               if flag in pkg.iuse.all]
+                                       cur_iuse = sorted(pkg.iuse.all)
 
                                        if myoldbest and myinslotlist:
                                                previous_cpv = myoldbest[0]
@@ -5180,7 +5180,7 @@ class depgraph(object):
                masked_packages = []
                for pkg in self._masked_installed:
                        root_config = pkg.root_config
-                       pkgsettings = root_config.settings
+                       pkgsettings = self.pkgsettings[pkg.root]
                        mreasons = get_masking_status(pkg, pkgsettings, root_config)
                        masked_packages.append((root_config, pkgsettings,
                                pkg.cpv, pkg.metadata, mreasons))
@@ -5264,8 +5264,7 @@ class depgraph(object):
                        pkg_type, root, pkg_key, pkg_status = x
                        if pkg_status != "nomerge":
                                continue
-                       metadata = dict(izip(self._mydbapi_keys,
-                               self.mydbapi[root].aux_get(pkg_key, self._mydbapi_keys)))
+                       metadata = x.metadata
                        try:
                                myfavkey = create_world_atom(pkg_key, metadata,
                                        args_set, root_config)
@@ -5322,7 +5321,7 @@ class depgraph(object):
                                continue
                        mydb = trees[myroot][self.pkg_tree_map[pkg_type]].dbapi
                        try:
-                               metadata = zip(self._mydbapi_keys,
+                               metadata = izip(self._mydbapi_keys,
                                        mydb.aux_get(pkg_key, self._mydbapi_keys))
                        except KeyError:
                                # It does no exist or it is corrupt.
@@ -8112,11 +8111,11 @@ def action_depclean(settings, trees, ldpath_mtimes,
                                continue
                        spinner.update()
                        fakedb.cpv_inject(pkg)
-                       myaux = dict(izip(aux_keys, vardb.aux_get(pkg, aux_keys)))
+                       myaux = izip(aux_keys, vardb.aux_get(pkg, aux_keys))
                        mydeps = []
 
                        usedef = vardb.aux_get(pkg, ["USE"])[0].split()
-                       for dep_type, depstr in myaux.iteritems():
+                       for dep_type, depstr in myaux:
 
                                if not depstr:
                                        continue
@@ -8247,10 +8246,10 @@ def action_depclean(settings, trees, ldpath_mtimes,
                del cleanlist[:]
                for node in clean_set:
                        graph.add(node, None)
-                       myaux = dict(izip(aux_keys, vardb.aux_get(node, aux_keys)))
+                       myaux = izip(aux_keys, vardb.aux_get(node, aux_keys))
                        mydeps = []
                        usedef = vardb.aux_get(node, ["USE"])[0].split()
-                       for dep_type, depstr in myaux.iteritems():
+                       for dep_type, depstr in myaux:
                                if not depstr:
                                        continue
                                try:
@@ -8472,11 +8471,12 @@ def action_build(settings, trees, mtimedb,
                                                        tuple(task) in unsatisfied_parents:
                                                        continue
                                                pruned_mergelist.append(task)
-                                       if not pruned_mergelist:
+                                       if not pruned_mergelist or \
+                                               len(pruned_mergelist) == len(mergelist):
                                                raise
                                        mergelist[:] = pruned_mergelist
                                        dropped_tasks.update(unsatisfied_parents)
-                                       del e
+                                       del e, unsatisfied_parents
                                        continue
                                else:
                                        break
@@ -8540,6 +8540,7 @@ def action_build(settings, trees, mtimedb,
                                for task in dropped_tasks:
                                        portage.writemsg("  " + str(task) + "\n", noiselevel=-1)
                                portage.writemsg("\n", noiselevel=-1)
+                       del dropped_tasks
                else:
                        mydepgraph.display_problems()
                        if not (ask or pretend):

diff --git a/pym/portage/dbapi/__init__.py b/pym/portage/dbapi/__init__.py
index 064309cf8ccbfcedfcc8a92c131873a10cd3f880..ba37c867e2ca2cec6fd0bda32440d4b2072f63fe 100644 (file)
--- a/pym/portage/dbapi/__init__.py
+++ b/pym/portage/dbapi/__init__.py
@@ -126,7 +126,7 @@ class dbapi(object):
                        self.cp_list(mydep.cp, use_cache=use_cache)))
 
        def _iter_match(self, atom, cpv_iter):
-               cpv_iter = match_from_list(atom, cpv_iter)
+               cpv_iter = iter(match_from_list(atom, cpv_iter))
                if atom.slot:
                        cpv_iter = self._iter_match_slot(atom, cpv_iter)
                if atom.use:

diff --git a/pym/portage/dbapi/porttree.py b/pym/portage/dbapi/porttree.py
index 685fd18c5adec34f824d46dd1fc912723fb55e0f..83069bd2c18e92d4b4c212dd7440670cd86f0db1 100644 (file)
--- a/pym/portage/dbapi/porttree.py
+++ b/pym/portage/dbapi/porttree.py
@@ -619,10 +619,10 @@ class portdbapi(dbapi):
                        cpv_iter = iter(self.cp_list(mykey))
                        if mydep != mykey:
                                cpv_iter = self._iter_match(mydep, cpv_iter)
-                       myval = ""
-                       for cpv in cpv_iter:
-                               myval = cpv
-                               break
+                       try:
+                               myval = cpv_iter.next()
+                       except StopIteration:
+                               myval = ""
 
                elif level in ("minimum-visible", "bestmatch-visible"):
                        # Find the minimum matching visible version. This is optimized to

diff --git a/pym/portage/dbapi/vartree.py b/pym/portage/dbapi/vartree.py
index 1cba9a55b4b362d3e23fc9326007d022d50abbc8..7e1cab2a54988d9a54ccbd3c25cfdcd046053ba1 100644 (file)
--- a/pym/portage/dbapi/vartree.py
+++ b/pym/portage/dbapi/vartree.py
@@ -574,7 +574,10 @@ class vardbapi(dbapi):
                                try:
                                        return [x for x in os.listdir(p) \
                                                if os.path.isdir(os.path.join(p, x))]
-                               except EnvironmentError:
+                               except EnvironmentError, e:
+                                       if e.errno == PermissionDenied.errno:
+                                               raise PermissionDenied(p)
+                                       del e
                                        return []
 
                for x in listdir(basepath, EmptyOnError=1, ignorecvs=1, dirsonly=1):

diff --git a/pym/portage/dep.py b/pym/portage/dep.py
index 993c23bdd220442544ac56b92dfb85dad31c4227..d0e487afc135646f33bc606d42043ae44e53be80 100644 (file)
--- a/pym/portage/dep.py
+++ b/pym/portage/dep.py
@@ -427,8 +427,8 @@ def get_operator(mydep):
        @return: The operator. One of:
                '~', '=', '>', '<', '=*', '>=', or '<='
        """
-       operator = getattr(mydep, "operator", None)
-       if operator is not None:
+       operator = getattr(mydep, "operator", False)
+       if operator is not False:
                return operator
        if mydep:
                mydep = remove_slot(mydep)
@@ -502,8 +502,8 @@ def dep_getslot(mydep):
        @rtype: String
        @return: The slot
        """
-       slot = getattr(mydep, "slot", None)
-       if slot is not None:
+       slot = getattr(mydep, "slot", False)
+       if slot is not False:
                return slot
        colon = mydep.find(":")
        if colon != -1:
@@ -885,8 +885,8 @@ def match_from_list(mydep, candidate_list):
                candidate_list = mylist
                mylist = []
                for x in candidate_list:
-                       xslot = getattr(x, "slot", None)
-                       if xslot is None and isinstance(x, basestring):
+                       xslot = getattr(x, "slot", False)
+                       if xslot is False:
                                xslot = dep_getslot(x)
                        if xslot is not None and xslot != slot:
                                continue

diff --git a/pym/portage/sets/base.py b/pym/portage/sets/base.py
index 3f85965bcf9b86d0b246acd99d9c2dcf24afe638..2ae4723fb30c5f0c0942f821e885bed2f865e87f 100644 (file)
--- a/pym/portage/sets/base.py
+++ b/pym/portage/sets/base.py
@@ -105,10 +105,10 @@ class PackageSet(object):
                None if there are no matches.  This matches virtual arguments against
                the PROVIDE metadata.  This can raise an InvalidDependString exception
                if an error occurs while parsing PROVIDE."""
-               atoms = list(self.iterAtomsForPackage(pkg))
-               if not atoms:
+               try:
+                       return self.iterAtomsForPackage(pkg).next()
+               except StopIteration:
                        return None
-               return best_match_to_list(pkg, atoms)
 
        def iterAtomsForPackage(self, pkg):
                """