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

pym/_emerge/FakeVartree.py

 # Copyright 1999-2010 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
 import sys
 
 import portage
 from portage import os
 from _emerge.Package import Package
 from _emerge.PackageVirtualDbapi import PackageVirtualDbapi
 from portage.const import VDB_PATH
@@ skipping 82 matching lines @@
                                 raise KeyError(pkg)
                         self.dbapi.aux_update(pkg, live_metadata)
                 except (KeyError, portage.exception.PortageException):
                         if self._global_updates is None:
                                 self._global_updates = \
                                         grab_global_updates(self._portdb)
                         perform_global_updates(
                                 pkg, self.dbapi, self._global_updates)
                 return self._aux_get(pkg, wants)
 
+        def cpv_discard(self, pkg):
+                """
+                Discard a package from the fake vardb if it exists.
+                """
+                old_pkg = self.dbapi.get(pkg)
+                if old_pkg is not None:
+                        self.dbapi.cpv_remove(old_pkg)
+                        self._pkg_cache.pop(old_pkg, None)
+                        self._aux_get_history.discard(old_pkg.cpv)
+
         def sync(self, acquire_lock=1):
                 """
                 Call this method to synchronize state with the real vardb
                 after one or more packages may have been installed or
                 uninstalled.
                 """
                 vdb_path = os.path.join(self.settings['EROOT'], portage.VDB_PATH)
                 try:
                         # At least the parent needs to exist for the lock file.
                         portage.util.ensure_dirs(vdb_path)
@@ skipping 21 matching lines @@
 
                 real_vardb = self._root_config.trees["vartree"].dbapi
                 current_cpv_set = frozenset(real_vardb.cpv_all())
                 pkg_vardb = self.dbapi
                 pkg_cache = self._pkg_cache
                 aux_get_history = self._aux_get_history
 
                 # Remove any packages that have been uninstalled.
                 for pkg in list(pkg_vardb):
                         if pkg.cpv not in current_cpv_set:
-                                pkg_vardb.cpv_remove(pkg)
-                                pkg_cache.pop(pkg, None)
-                                aux_get_history.discard(pkg.cpv)
+                                self.cpv_discard(pkg)
 
                 # Validate counters and timestamps.
                 slot_counters = {}
                 root = self.root
                 validation_keys = ["COUNTER", "_mtime_"]
                 for cpv in current_cpv_set:
 
                         pkg_hash_key = ("installed", root, cpv, "nomerge")
                         pkg = pkg_vardb.get(pkg_hash_key)
                         if pkg is not None:
                                 counter, mtime = real_vardb.aux_get(cpv, validation_keys)
                                 try:
                                         counter = long(counter)
                                 except ValueError:
                                         counter = 0
 
                                 if counter != pkg.counter or \
                                         mtime != pkg.mtime:
-                                        pkg_vardb.cpv_remove(pkg)
-                                        pkg_cache.pop(pkg, None)
-                                        aux_get_history.discard(pkg.cpv)
+                                        self.cpv_discard(pkg)
                                         pkg = None
 
                         if pkg is None:
                                 pkg = self._pkg(cpv)
 
                         other_counter = slot_counters.get(pkg.slot_atom)
                         if other_counter is not None:
                                 if other_counter > pkg.counter:
                                         continue
 
@@ skipping 61 matching lines @@
                         mycommands = myupdates['DEFAULT']
                 except KeyError:
                         return
 
         if not mycommands:
                 return
 
         updates = update_dbentries(mycommands, aux_dict)
         if updates:
                 mydb.aux_update(mycpv, updates)