Update Portage to sync BlockerDB at init, rather than before every package.

pym/_emerge/BlockerDB.py

 # Copyright 1999-2009 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 import sys
 
 import portage
 from portage import os
 from portage import digraph
 from portage._sets.base import InternalPackageSet
 
@@ skipping 12 matching lines @@
                 self._portdb = root_config.trees["porttree"].dbapi
 
                 self._dep_check_trees = None
                 self._fake_vartree = fake_vartree
                 self._dep_check_trees = {
                         self._vartree.root : {
                                 "porttree"    :  fake_vartree,
                                 "vartree"     :  fake_vartree,
                 }}
 
-        def _get_fake_vartree(self, acquire_lock=0):
-                fake_vartree = self._fake_vartree
-                fake_vartree.sync(acquire_lock=acquire_lock)
-                return fake_vartree
-
-        def findInstalledBlockers(self, new_pkg, acquire_lock=0):
+        def findInstalledBlockers(self, new_pkg):

[diandersAtChromium, 2011/03/22 02:57:59]

This is a public function.  Any issues with compatibility with other people
using portage as a python library?

...if so, those people would need to know that they can't pass acquire_lock
anymore, that they should call sync manually (at some point) and that they
should call discard_blocker.

[davidjames, 2011/03/23 20:19:11]

As we discussed in person, the _emerge package is a private namespace. So we
only need to worry about callers outside of Portage itself.

                 """
                 Search for installed run-time blockers in the root where
                 new_pkg is planned to be installed. This ignores build-time
                 blockers, since new_pkg is assumed to be built already.
                 """
                 blocker_cache = BlockerCache(self._vartree.root, self._vartree.dbapi)
                 dep_keys = ["RDEPEND", "PDEPEND"]
                 settings = self._vartree.settings
                 stale_cache = set(blocker_cache)
-                fake_vartree = self._get_fake_vartree(acquire_lock=acquire_lock)
+                fake_vartree = self._fake_vartree

[diandersAtChromium, 2011/03/22 02:57:59]

Summary: removed the sync() of self._fake_vartree

[davidjames, 2011/03/23 20:19:11]

Exactly. No need to sync every time we search for blockers.

                 dep_check_trees = self._dep_check_trees
                 vardb = fake_vartree.dbapi
                 installed_pkgs = list(vardb)
 
                 for inst_pkg in installed_pkgs:
                         stale_cache.discard(inst_pkg.cpv)
                         cached_blockers = blocker_cache.get(inst_pkg.cpv)
                         if cached_blockers is not None and \
                                 cached_blockers.counter != long(inst_pkg.metadata["COUNTER"]):
                                 cached_blockers = None
@@ skipping 52 matching lines @@
                         blocker_atoms = InternalPackageSet(initial_atoms=blocker_atoms)
                         for inst_pkg in installed_pkgs:
                                 try:
                                         next(blocker_atoms.iterAtomsForPackage(inst_pkg))
                                 except (portage.exception.InvalidDependString, StopIteration):
                                         continue
                                 blocking_pkgs.add(inst_pkg)
 
                 return blocking_pkgs
 
+        def discardBlocker(self, pkg):
+                """Discard a package from the list of potential blockers."""
+                self._fake_vartree.cpv_discard(pkg)
+