Teach parallel_emerge to uninstall packages.

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 548 matching lines @@
 
   def _Status(self):
     """Print status."""
     seconds = time.time() - GLOBAL_START
     line = ("Pending %s, Ready %s, Running %s, Retrying %s, Total %s "
             "[Time %dm%ds Load %s]")
     print line % (len(self._deps_map), len(self._emerge_queue),
                   len(self._jobs), len(self._retry_queue), self._total_jobs,
                   seconds / 60, seconds % 60, self._LoadAvg())
 
-  def _LaunchOneEmerge(self, target):
+  def _LaunchOneEmerge(self, target, action):
     """Run emerge --nodeps to do a single package install.
 
     If this is a pseudopackage, that means we're done, and can select in in the
     world file.
     Args:
       target: The full package name of the package to install.
               eg. "sys-apps/portage-2.17"
     Returns:
       Triplet containing (target name, subprocess object, output buffer object).
     """
     if target.startswith("original-"):
       # "original-" signifies one of the packages we originally requested.
       # Since we have explicitly installed the versioned package as a dep of
       # this, we only need to tag in "world" that we are done with this
       # install request.
       # --nodeps: Ignore dependencies -- we handle them internally.
       # --noreplace: Don't replace or upgrade any packages. (In this case, the
       #              package is already installed, so we are just updating the
       #              world file.)
       # --selective: Make sure that --noreplace sticks even if --selective=n is
       #              specified by the user on the command-line.
       # NOTE: If the user specifies --oneshot on the command-line, this command
       #       will do nothing. That is desired, since the user requested not to
       #       update the world file.
       newtarget = target.replace("original-", "")
       cmdline = (EmergeCommand() + " --nodeps --selective --noreplace " +
                  newtarget)
+    elif action == "uninstall":
+      cmdline = EmergeCommand() + " --nodeps --unmerge =" + target
     else:
       # This package is a dependency of something we specifically
       # requested. Therefore we should install it but not allow it
       # in the "world" file, which represents explicit installs.
       # --oneshot" here will prevent it from being tagged in world.
       cmdline = EmergeCommand() + " --nodeps --oneshot "
       this_pkg = self._deps_map[target]
       if this_pkg["workon"]:
         # --usepkg=n --getbinpkg=n: Build from source
         # --selective=n: Re-emerge even if package is already installed.
@@ skipping 57 matching lines @@
         # We maintain a tree of all deps, if this doesn't need
         # to be installed just free up it's children and continue.
         # It is possible to reinstall deps of deps, without reinstalling
         # first level deps, like so:
         # chromeos (merge) -> eselect (nomerge) -> python (merge)
         if action == "nomerge":
           self._Finish(target)
         else:
           # Kick off the build if it's marked to be built.
           print "Emerging %s (%s)" % (target, action)
-          job = self._LaunchOneEmerge(target)
+          job = self._LaunchOneEmerge(target, action)
           # Append it to the active jobs list.
           self._jobs.append(job)
         continue
       # Wait a bit to see if maybe some jobs finish. You can't
       # wait on a set of jobs in python, so we'll just poll.
       time.sleep(1)
       secs += 1
       if secs % 30 == 0:
         # Print an update.
         self._Status()
@@ skipping 101 matching lines @@
 
 if VERBOSE:
   PrintDepsMap(dependency_graph)
 
 # Run the queued emerges.
 scheduler = EmergeQueue(dependency_graph)
 scheduler.Run()
 
 print "Done"