Clean package cache for packages you are building.

cros_mark_as_stable.py

 #!/usr/bin/python
 
 # 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.
 
 """This module uprevs a given package's ebuild to the next revision."""
 
 
 import fileinput
 import gflags
 import os
 import re
 import shutil
 import subprocess
 import sys
 
 sys.path.append(os.path.join(os.path.dirname(__file__), 'lib'))
 from cros_build_lib import Info, RunCommand, Warning, Die
 
 
 gflags.DEFINE_string('board', 'x86-generic',
                      'Board for which the package belongs.', short_name='b')
-gflags.DEFINE_string('commit_ids', '',
-                     """Optional list of commit ids for each package.
-                     This list must either be empty or have the same length as
-                     the packages list.  If not set all rev'd ebuilds will have
-                     empty commit id's.""",
-                     short_name='i')
 gflags.DEFINE_string('packages', '',
                      'Space separated list of packages to mark as stable.',
                      short_name='p')
 gflags.DEFINE_string('push_options', '',
                      'Options to use with git-cl push using push command.')
 gflags.DEFINE_string('srcroot', '%s/trunk/src' % os.environ['HOME'],
                      'Path to root src directory.',
                      short_name='r')
 gflags.DEFINE_string('tracking_branch', 'cros/master',
                      'Used with commit to specify branch to track against.',
@@ skipping 24 matching lines @@
 
 # ======================= Global Helper Functions ========================
 
 
 def _Print(message):
   """Verbose print function."""
   if gflags.FLAGS.verbose:
     Info(message)
 
 
+def _CleanStalePackages(board, package_array):
+    """Cleans up stale package info from a previous build."""
+    Info('Cleaning up stale packages %s.' % package_array)
+    unmerge_board_cmd = ['emerge-%s' % board, '--unmerge']
+    unmerge_board_cmd.extend(package_array)
+    RunCommand(unmerge_board_cmd, env=env)
+
+    unmerge_host_cmd = ['sudo', 'emerge', '--unmerge']
+    unmerge_host_cmd.extend(package_array)
+    RunCommand(unmerge_host_cmd, env=env)
+
+    RunCommand(['eclean-%s' % board, '-d', 'packages'], redirect_stderr=True)
+    RunCommand(['sudo', 'eclean', '-d', 'packages'], redirect_stderr=True)
+
+
 def _BestEBuild(ebuilds):
   """Returns the newest EBuild from a list of EBuild objects."""
   from portage.versions import vercmp
   winner = ebuilds[0]
   for ebuild in ebuilds[1:]:
     if vercmp(winner.version, ebuild.version) < 0:
       winner = ebuild
   return winner
 
 
@@ skipping 12 matching lines @@
       if ebuild.is_workon:
         workon_dir = True
         if ebuild.is_stable:
           stable_ebuilds.append(ebuild)
         else:
           unstable_ebuilds.append(ebuild)
 
   # If we found a workon ebuild in this directory, apply some sanity checks.
   if workon_dir:
     if len(unstable_ebuilds) > 1:
-      Die('Found multiple unstable ebuilds in %s' % root)
+      Die('Found multiple unstable ebuilds in %s' % os.path.dirname(path))
     if len(stable_ebuilds) > 1:
       stable_ebuilds = [_BestEBuild(stable_ebuilds)]
 
       # Print a warning if multiple stable ebuilds are found in the same
       # directory. Storing multiple stable ebuilds is error-prone because
       # the older ebuilds will not get rev'd.
       #
       # We make a special exception for x11-drivers/xf86-video-msm for legacy
       # reasons.
       if stable_ebuilds[0].package != 'x11-drivers/xf86-video-msm':
-        Warning('Found multiple stable ebuilds in %s' % root)
+        Warning('Found multiple stable ebuilds in %s' % os.path.dirname(path))
 
     if not unstable_ebuilds:
-      Die('Missing 9999 ebuild in %s' % root)
+      Die('Missing 9999 ebuild in %s' % os.path.dirname(path))
     if not stable_ebuilds:
-      Die('Missing stable ebuild in %s' % root)
+      Die('Missing stable ebuild in %s' % os.path.dirname(path))
 
   if stable_ebuilds:
     return stable_ebuilds[0]
   else:
     return None
 
 
 def _BuildEBuildDictionary(overlays, all, packages):
   """Build a dictionary of the ebuilds in the specified overlays.
 
   overlays: A map which maps overlay directories to arrays of stable EBuilds
     inside said directories.
   all: Whether to include all ebuilds in the specified directories. If true,
     then we gather all packages in the directories regardless of whether
     they are in our set of packages.
   packages: A set of the packages we want to gather.
   """
   for overlay in overlays:
-    for root_dir, dirs, files in os.walk(overlay):
+    for package_dir, dirs, files in os.walk(overlay):
       # Add stable ebuilds to overlays[overlay].
-      paths = [os.path.join(root_dir, path) for path in files]
+      paths = [os.path.join(package_dir, path) for path in files]
       ebuild = _FindStableEBuilds(paths)
 
       # If the --all option isn't used, we only want to update packages that
       # are in packages.
       if ebuild and (all or ebuild.package in packages):
         overlays[overlay].append(ebuild)
 
 
 def _CheckOnStabilizingBranch():
   """Returns true if the git branch is on the stabilizing branch."""
@@ skipping 173 matching lines @@
       srcdir = os.path.join(srcroot, 'third_party/kernel/files')
 
     if not os.path.exists(srcdir):
       Die('Cannot find commit id for %s' % self.ebuild_path)
 
     # Verify that we're grabbing the commit id from the right project name.
     # NOTE: chromeos-kernel has the wrong project name, so it fails this
     # check.
     # TODO(davidjames): Fix the project name in the chromeos-kernel ebuild.
     cmd = 'cd %s && git config --get remote.cros.projectname' % srcdir
-    actual_project =_SimpleRunCommand(cmd).rstrip()
+    actual_project = _SimpleRunCommand(cmd).rstrip()
     if project not in (actual_project, 'chromeos-kernel'):
       Die('Project name mismatch for %s (%s != %s)' % (unstable_ebuild, project,
           actual_project))
 
     # Get commit id.
     output = _SimpleRunCommand('cd %s && git rev-parse HEAD' % srcdir)
     if not output:
       Die('Missing commit id for %s' % self.ebuild_path)
     return output.rstrip()
 
@@ skipping 21 matching lines @@
     revision = int(rev_string)
     return (ebuild_no_rev, ebuild_no_version, revision)
 
 
 class EBuildStableMarker(object):
   """Class that revs the ebuild and commits locally or pushes the change."""
 
   def __init__(self, ebuild):
     self._ebuild = ebuild
 
-  def RevEBuild(self, commit_id="", redirect_file=None):
+  def RevEBuild(self, commit_id='', redirect_file=None):
     """Revs an ebuild given the git commit id.
 
     By default this class overwrites a new ebuild given the normal
     ebuild rev'ing logic.  However, a user can specify a redirect_file
     to redirect the new stable ebuild to another file.
 
     Args:
         commit_id: String corresponding to the commit hash of the developer
           package to rev.
         redirect_file: Optional file to write the new ebuild.  By default
           it is written using the standard rev'ing logic.  This file must be
           opened and closed by the caller.
 
     Raises:
         OSError: Error occurred while creating a new ebuild.
         IOError: Error occurred while writing to the new revved ebuild file.
+    Returns:
+      True if the revved package is different than the old ebuild.
     """
     # TODO(sosa):  Change to a check.
     if not self._ebuild:
       Die('Invalid ebuild given to EBuildStableMarker')
 
     new_ebuild_path = '%s-r%d.ebuild' % (self._ebuild.ebuild_path_no_revision,
                                          self._ebuild.current_revision + 1)
 
     _Print('Creating new stable ebuild %s' % new_ebuild_path)
     workon_ebuild = '%s-9999.ebuild' % self._ebuild.ebuild_path_no_version
     if not os.path.exists(workon_ebuild):
       Die('Missing 9999 ebuild: %s' % workon_ebuild)
     shutil.copyfile(workon_ebuild, new_ebuild_path)
 
     for line in fileinput.input(new_ebuild_path, inplace=1):
       # Has to be done here to get changes to sys.stdout from fileinput.input.
       if not redirect_file:
         redirect_file = sys.stdout
       if line.startswith('KEYWORDS'):
         # Actually mark this file as stable by removing ~'s.
-        redirect_file.write(line.replace("~", ""))
+        redirect_file.write(line.replace('~', ''))
       elif line.startswith('EAPI'):
         # Always add new commit_id after EAPI definition.
         redirect_file.write(line)
         redirect_file.write('CROS_WORKON_COMMIT="%s"\n' % commit_id)
       elif not line.startswith('CROS_WORKON_COMMIT'):
         # Skip old CROS_WORKON_COMMIT definition.
         redirect_file.write(line)
     fileinput.close()
 
-    # If the new ebuild is identical to the old ebuild, return False and
-    # delete our changes.
     old_ebuild_path = self._ebuild.ebuild_path
     diff_cmd = ['diff', '-Bu', old_ebuild_path, new_ebuild_path]
-    if 0 == RunCommand(diff_cmd, exit_code=True,
-                       print_cmd=gflags.FLAGS.verbose):
+    if 0 == RunCommand(diff_cmd, exit_code=True, redirect_stdout=True,
+                       redirect_stderr=True, print_cmd=gflags.FLAGS.verbose):
       os.unlink(new_ebuild_path)
       return False
     else:
       _Print('Adding new stable ebuild to git')
       _SimpleRunCommand('git add %s' % new_ebuild_path)
 
       _Print('Removing old ebuild from git')
       _SimpleRunCommand('git rm %s' % old_ebuild_path)
       return True
 
@@ skipping 25 matching lines @@
   except gflags.FlagsError, e :
     _PrintUsageAndDie(str(e))
 
   package_list = gflags.FLAGS.packages.split()
   _CheckSaneArguments(package_list, command)
 
   overlays = {
     '%s/private-overlays/chromeos-overlay' % gflags.FLAGS.srcroot: [],
     '%s/third_party/chromiumos-overlay' % gflags.FLAGS.srcroot: []
   }
-  all = gflags.FLAGS.all
 
   if command == 'commit':
-    _BuildEBuildDictionary(overlays, all, package_list)
+    _BuildEBuildDictionary(overlays, gflags.FLAGS.all, package_list)
 
   for overlay, ebuilds in overlays.items():
-    if not os.path.exists(overlay):
-      continue
+    if not os.path.exists(overlay): continue
     os.chdir(overlay)
 
     if command == 'clean':
       _Clean()
     elif command == 'push':
       _PushChange()
     elif command == 'commit' and ebuilds:
+      work_branch = _GitBranch(_STABLE_BRANCH_NAME)
+      work_branch.CreateBranch()
+      if not work_branch.Exists():
+        Die('Unable to create stabilizing branch in %s' % overlay)
+
+      # Contains the array of packages we actually revved.
+      revved_packages = []
       for ebuild in ebuilds:
         try:
           _Print('Working on %s' % ebuild.package)
           worker = EBuildStableMarker(ebuild)
           commit_id = ebuild.GetCommitId()
           if worker.RevEBuild(commit_id):
-            if not _CheckOnStabilizingBranch():
-              work_branch = _GitBranch(_STABLE_BRANCH_NAME)
-              work_branch.CreateBranch()
-              if not work_branch.Exists():
-                Die('Unable to create stabilizing branch in %s' % overlay)
             message = _GIT_COMMIT_MESSAGE % (ebuild.package, commit_id)
             worker.CommitChange(message)
+            revved_packages.append(ebuild.package)
+
         except (OSError, IOError):
           Warning('Cannot rev %s\n' % ebuild.package,
                   'Note you will have to go into %s '
                   'and reset the git repo yourself.' % overlay)
           raise
 
+      if revved_packages:
+        _CleanStalePackages(gflags.FLAGS.board, revved_packages)
+      else:
+        work_branch.Delete()
+
 
 if __name__ == '__main__':
   main(sys.argv)
-