Update parallel_emerge to correct use flags, fixing a regression.

parallel_emerge

 #!/usr/bin/python2.6
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Program to run emerge in parallel, for significant speedup.
 
 Usage:
  ./parallel_emerge [--board=BOARD] [--workon=PKGS] [--no-workon-deps]
                    [--force-remote-binary=PKGS] [emerge args] package
@@ skipping 446 matching lines @@
 
     # Grab the set of flags that are requested for the given package.
     # This includes flags that don't affect the package, and includes
     # all sources of flags (e.g. USE environment variable, make.conf,
     # make.defaults, package.use.{mask,force}, etc.).
     #
     # This is used by portage in the _reinstall_for_flags function below.
     forced_flags = set(pkgsettings.useforce).union(pkgsettings.usemask)
 
     depgraph = self.emerge.depgraph
-
     flags = depgraph._reinstall_for_flags(forced_flags, cur_use,
                                           cur_iuse, now_use, now_iuse)
     return not flags
 
   def GenDependencyTree(self, remote_pkgs):
     """Get dependency tree info from emerge.
 
     TODO(): Update cros_extract_deps to also use this code.
     Returns:
       Dependency tree
     """
     start = time.time()
 
     # Setup emerge options.
     #
     # We treat dependency info a bit differently than emerge itself. Unless
     # you're using --usepkgonly, we disable --getbinpkg and --usepkg here so
     # that emerge will look at the dependencies of the source ebuilds rather
     # than the binary dependencies. This helps ensure that we have the option
     # of merging a package from source, if we want to switch to it with
     # --workon and the dependencies have changed.
     emerge = self.emerge
     emerge_opts = emerge.opts.copy()
-    if self.mandatory_source or self.rebuild or self.force_remote_binary:
-      # Enable --emptytree so that we get the full tree, which we need for
-      # dependency analysis. By default, with this option, emerge optimizes
-      # the graph by removing uninstall instructions from the graph. By
-      # specifying --tree as well, we tell emerge that it's not safe to remove
-      # uninstall instructions because we're planning on analyzing the output.
-      emerge_opts["--tree"] = True
-      emerge_opts["--emptytree"] = True
 
-      # Tell emerge not to worry about use flags yet. We handle those inside
-      # parallel_emerge itself. Further, when we use the --force-remote-binary
-      # flag, we don't emerge to reject a package just because it has different
-      # use flags.
-      emerge_opts.pop("--newuse", None)
-      emerge_opts.pop("--reinstall", None)
+    # Enable --emptytree so that we get the full tree, which we need for
+    # dependency analysis. By default, with this option, emerge optimizes
+    # the graph by removing uninstall instructions from the graph. By
+    # specifying --tree as well, we tell emerge that it's not safe to remove
+    # uninstall instructions because we're planning on analyzing the output.
+    emerge_opts["--tree"] = True
+    emerge_opts["--emptytree"] = True
+
+    # Tell emerge not to worry about use flags yet. We handle those inside
+    # parallel_emerge itself. Further, when we use the --force-remote-binary
+    # flag, we don't emerge to reject a package just because it has different
+    # use flags.
+    emerge_opts.pop("--newuse", None)
+    emerge_opts.pop("--reinstall", None)
 
     # Create a list of packages to merge
     packages = set(emerge.cmdline_packages[:])
     if self.mandatory_source:
       packages.update(self.mandatory_source)
     if self.force_remote_binary:
       forced_pkgs = {}
       for pkg in remote_pkgs:
         category, pkgname, _, _ = portage.catpkgsplit(pkg)
         full_pkgname = "%s/%s" % (category, pkgname)
@@ skipping 70 matching lines @@
 
     # Ask portage for its install plan, so that we can only throw out
     # dependencies that portage throws out. Also, keep track of the old
     # versions of packages that we're either upgrading or replacing.
     #
     # The "vardb" is the database of installed packages.
     root = emerge.settings["ROOT"]
     frozen_config = depgraph._frozen_config
     vardb = frozen_config.trees[root]["vartree"].dbapi
     pkgsettings = frozen_config.pkgsettings[root]
+
+    # It's time to start worrying about use flags, if necessary.
+    for flag in ("--newuse", "--reinstall"):
+      if flag in emerge.opts:
+        emerge_opts[flag] = emerge.opts[flag]
+
     deps_info = {}
     for pkg in depgraph.altlist():
       if isinstance(pkg, Package):
+        # If we're not using --force-remote-binary, check what flags are being
+        # used by the real package.
+        if "--usepkgonly" not in emerge.opts:
+          try:
+            pkg = emerge.depgraph._pkg(pkg.cpv, "ebuild", emerge.root_config)
+          except portage.exception.PackageNotFound:
+            # This is a --force-remote-binary package.
+            pass
+        self.package_db[pkg.cpv] = pkg
+
         # If we're not in emptytree mode, and we're going to replace a package
         # that is already installed, then this operation is possibly optional.
         # ("--selective" mode is handled later, in RemoveInstalledPackages())
         optional = False
         if not emptytree:
           for vardb_pkg in vardb.match_pkgs(pkg.cpv):
             if self.CheckUseFlags(pkgsettings, vardb_pkg, pkg):
               optional = True
               break
 
@@ skipping 533 matching lines @@
           mtime = int(db_vals.pop() or 0)
           metadata = zip(db_keys, db_vals)
           db_pkg = Package(built=True, cpv=pkg, installed=False,
                            metadata=metadata, onlydeps=False, mtime=mtime,
                            operation="merge", root_config=root_config,
                            type_name="binary")
           prebuilt_pkgs[pkg] = db_pkg
 
       # Calculate what packages need to be rebuilt due to changes in use flags.
       for pkg, db_pkg in prebuilt_pkgs.iteritems():
-        db_pkg_src = self.package_db.get(pkg)
-        if db_pkg_src and not self.CheckUseFlags(pkgsettings, db_pkg,
-                                                 db_pkg_src):
+        if not self.CheckUseFlags(pkgsettings, db_pkg, self.package_db[pkg]):
           MergeChildren(pkg, "mandatory_source")
 
       # Convert eligible packages to binaries.
       for pkg, info in deps_map.iteritems():
         if info and info["action"] == "merge" and pkg in prebuilt_pkgs:
           if not info["mandatory_source"] or info["force_remote_binary"]:
             self.package_db[pkg] = prebuilt_pkgs[pkg]
 
       seconds = time.time() - start
       if "--quiet" not in emerge.opts:
         print "Prebuilt DB populated in %dm%.1fs" % (seconds / 60, seconds % 60)
 
       return prebuilt_pkgs
 
-    def AddRemainingPackages():
-      """Fill in packages that don't have entries in the package db.
-
-      Every package we are installing needs an entry in the package db.
-      This function should only be called after we have removed the
-      packages that are not being merged from our deps_map.
-      """
-      for pkg in deps_map:
-        if pkg not in self.package_db:
-          if deps_map[pkg]["action"] != "merge":
-            # We should only fill in packages that are being merged. If
-            # there's any other packages here, something funny is going on.
-            print "Missing entry for %s in package db" % pkg
-            sys.exit(1)
-
-          db_pkg = emerge.depgraph._pkg(pkg, "ebuild", emerge.root_config)
-          self.package_db[pkg] = db_pkg
-
     ReverseTree(deps_tree)
     BuildFinalPackageSet()
     AddSecretDeps()
 
     # Mark that we want to use remote binaries only for a particular package.
     vardb = emerge.depgraph._frozen_config.trees[root]["vartree"].dbapi
     for pkg in self.force_remote_binary:
       for db_pkg in final_db.match_pkgs(pkg):
         match = deps_map.get(str(db_pkg.cpv))
         if match:
@@ skipping 19 matching lines @@
 
     # We need to remove installed packages so that we can use the dependency
     # ordering of the install process to show us what cycles to crack. Once
     # we've done that, we also need to recalculate our list of cycles so that
     # we don't include the installed packages in our cycles.
     RemoveInstalledPackages()
     SanitizeTree()
     if deps_map:
       if "--usepkg" in emerge.opts:
         UsePrebuiltPackages(remote_pkgs)
-      AddRemainingPackages()
     return deps_map
 
   def PrintInstallPlan(self, deps_map):
     """Print an emerge-style install plan.
 
     The install plan lists what packages we're installing, in order.
     It's useful for understanding what parallel_emerge is doing.
 
     Args:
       deps_map: The dependency graph.
@@ skipping 599 matching lines @@
   # need to upgrade the rest of the packages. So we'll go ahead and do that.
   if portage_upgrade:
     args = sys.argv[1:] + ["--nomerge=sys-apps/portage"]
     os.execvp(os.path.realpath(sys.argv[0]), args)
 
   print "Done"
   sys.exit(0)
 
 if __name__ == "__main__":
   main()