Update parallel_emerge to restart after upgrading portage in root.

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]
                    [emerge args] package"
@@ skipping 199 matching lines @@
   Typical usage:
     deps = DepGraphGenerator()
     deps.Initialize(sys.argv[1:])
     deps_tree, deps_info = deps.GenDependencyTree()
     deps_graph = deps.GenDependencyGraph(deps_tree, deps_info)
     deps.PrintTree(deps_tree)
     PrintDepsMap(deps_graph)
   """
 
   __slots__ = ["board", "emerge", "mandatory_source", "no_workon_deps",
-               "package_db", "rebuild", "show_output"]
+               "nomerge", "package_db", "rebuild", "show_output"]
 
   def __init__(self):
     self.board = None
     self.emerge = EmergeData()
     self.mandatory_source = set()
     self.no_workon_deps = False
+    self.nomerge = set()
     self.package_db = {}
     self.rebuild = False
     self.show_output = False
 
   def ParseParallelEmergeArgs(self, argv):
     """Read the parallel emerge arguments from the command-line.
 
     We need to be compatible with emerge arg format.  We scrape arguments that
     are specific to parallel_emerge, and pass through the rest directly to
     emerge.
     Args:
       argv: arguments list
     Returns:
       Arguments that don't belong to parallel_emerge
     """
     emerge_args = []
     for arg in argv:
       # Specifically match arguments that are specific to parallel_emerge, and
       # pass through the rest.
       if arg.startswith("--board="):
         self.board = arg.replace("--board=", "")
       elif arg.startswith("--workon="):
         workon_str = arg.replace("--workon=", "")
         package_list = shlex.split(" ".join(shlex.split(workon_str)))
         self.mandatory_source.update(package_list)
+      elif arg.startswith("--nomerge="):
+        nomerge_str = arg.replace("--nomerge=", "")
+        package_list = shlex.split(" ".join(shlex.split(nomerge_str)))
+        self.nomerge.update(package_list)
       elif arg == "--no-workon-deps":
         self.no_workon_deps = True
       elif arg == "--rebuild":
         self.rebuild = True
       elif arg == "--show-output":
         self.show_output = True
       else:
         # Not one of our options, so pass through to emerge.
         emerge_args.append(arg)
 
@@ skipping 506 matching lines @@
             print "Skipping %s (is it in package.provided?)" % pkg
 
       # Schedule packages that aren't on the install list for removal
       rm_pkgs = set(deps_map.keys()) - set(deps_info.keys())
 
       # Schedule optional packages for removal
       for pkg, info in deps_info.items():
         if info["optional"]:
           rm_pkgs.add(pkg)
 
+      # Schedule nomerge packages for removal
+      for pkg in self.nomerge:
+        for db_pkg in final_db.match_pkgs(pkg):
+          if db_pkg.cpv in deps_map:
+            rm_pkgs.add(str(db_pkg.cpv))
+
       # Remove the packages we don't want, simplifying the graph and making
       # it easier for us to crack cycles.
       for pkg in sorted(rm_pkgs):
         this_pkg = deps_map[pkg]
         needs = this_pkg["needs"]
         provides = this_pkg["provides"]
         for dep in needs:
           dep_provides = deps_map[dep]["provides"]
           dep_provides.update(provides)
           dep_provides.discard(pkg)
@@ skipping 816 matching lines @@
   #
   # NOTE: Even if you're running --pretend, it's a good idea to run
   #       parallel_emerge with root access so that portage can write to the
   #       dependency cache. This is important for performance.
   if "--pretend" not in emerge.opts and portage.secpass < 2:
     print "parallel_emerge: superuser access is required."
     sys.exit(1)
 
   if "--quiet" not in emerge.opts:
     cmdline_packages = " ".join(emerge.cmdline_packages)
+    nomerge_packages = " ".join(deps.nomerge)
     print "Starting fast-emerge."
     print " Building package %s on %s" % (cmdline_packages,
                                           deps.board or "root")
+    if nomerge_packages:
+      print " Skipping package %s on %s" % (nomerge_packages,
+                                            deps.board or "root")
 
   deps_tree, deps_info = deps.GenDependencyTree()
 
   # You want me to be verbose? I'll give you two trees! Twice as much value.
   if "--tree" in emerge.opts and "--verbose" in emerge.opts:
     deps.PrintTree(deps_tree)
 
   deps_graph = deps.GenDependencyGraph(deps_tree, deps_info)
 
   # OK, time to print out our progress so far.
   deps.PrintInstallPlan(deps_graph)
   if "--tree" in emerge.opts:
     PrintDepsMap(deps_graph)
 
+  # Are we upgrading portage? If so, and there are more packages to merge,
+  # schedule a restart of parallel_emerge to merge the rest. This ensures that
+  # we pick up all updates to portage settings before merging any more
+  # packages.
+  portage_upgrade = False
+  root = emerge.settings["ROOT"]
+  final_db = emerge.depgraph._dynamic_config.mydbapi[root]
+  if root == "/":
+    for db_pkg in final_db.match_pkgs("sys-apps/portage"):
+      portage_pkg = deps_graph.get(db_pkg.cpv)
+      if portage and len(deps_graph) > 1:
+        deps_graph = { str(db_pkg.cpv): portage_pkg }
+        portage_upgrade = True
+        if "--quiet" not in emerge.opts:
+          print "Upgrading portage first, then restarting..."
+
   # Run the queued emerges.
   scheduler = EmergeQueue(deps_graph, emerge, deps.package_db, deps.show_output)
   scheduler.Run()
 
   # Update world.
   if ("--oneshot" not in emerge.opts and
       "--pretend" not in emerge.opts):
     world_set = emerge.root_config.sets["selected"]
     new_world_pkgs = []
-    root = emerge.settings["ROOT"]
-    final_db = emerge.depgraph._dynamic_config.mydbapi[root]
     for pkg in emerge.cmdline_packages:
       for db_pkg in final_db.match_pkgs(pkg):
         print "Adding %s to world" % db_pkg.cp
         new_world_pkgs.append(db_pkg.cp)
     if new_world_pkgs:
       world_set.update(new_world_pkgs)
 
   # Update environment (library cache, symlinks, etc.)
   if deps.board and "--pretend" not in emerge.opts:
     portage.env_update()
 
+  # If we already upgraded portage, we don't need to do so again. But we do
+  # 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"
 
 if __name__ == "__main__":
   main()