Add support to pushing unstable changes for the chrome pfq.

bin/cros_mark_chrome_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 Chrome for cbuildbot.
 
 After calling, it prints outs CHROME_VERSION_ATOM=(version atom string).  A
 caller could then use this atom with emerge to build the newly uprevved version
@@ skipping 91 matching lines @@
     chrome_version_re = re.compile('^%s\.\d+.*' % branch)
   else:
     chrome_version_re = re.compile('^[0-9]\..*')
   for chrome_version in sorted_ls.splitlines():
     if chrome_version_re.match(chrome_version):
       current_version = chrome_version
 
   return current_version.rstrip('/')
 
 
-def _GetStickyVersion(stable_ebuilds):
-  """Discovers the sticky version from the current stable_ebuilds."""
+def _GetStickyEBuild(stable_ebuilds):
+  """Returns the sticky ebuild."""
   sticky_ebuilds = []
   non_sticky_re = re.compile(_NON_STICKY_REGEX)
   for ebuild in stable_ebuilds:
     if not non_sticky_re.match(ebuild.version):
       sticky_ebuilds.append(ebuild)
 
   if not sticky_ebuilds:
     raise Exception('No sticky ebuilds found')
   elif len(sticky_ebuilds) > 1:
     Warning('More than one sticky ebuild found')
 
-  return cros_mark_as_stable.BestEBuild(sticky_ebuilds).chrome_version
+  return cros_mark_as_stable.BestEBuild(sticky_ebuilds)
 
 
 class ChromeEBuild(cros_mark_as_stable.EBuild):
   """Thin sub-class of EBuild that adds a chrome_version field."""
   chrome_version_re = re.compile('.*chromeos-chrome-(%s|9999).*' % (
       _CHROME_VERSION_REGEX))
   chrome_version = ''
 
   def __init__(self, path):
     cros_mark_as_stable.EBuild.__init__(self, path)
@@ skipping 60 matching lines @@
     Returns the EBuild, otherwise None if none found.
   """
   candidates = []
   if chrome_rev == TIP_OF_TRUNK:
     chrome_branch_re = re.compile('%s.*_alpha.*' % _CHROME_VERSION_REGEX)
     for ebuild in stable_ebuilds:
       if chrome_branch_re.search(ebuild.version):
         candidates.append(ebuild)
 
   elif chrome_rev == STICKY:
-    chrome_branch_re = re.compile('%s\.\d+.*_rc.*' % sticky_branch)
+    chrome_branch_re = re.compile('%s\..*' % sticky_branch)
     for ebuild in stable_ebuilds:
       if chrome_branch_re.search(ebuild.version):
         candidates.append(ebuild)
 
   else:
     chrome_branch_re = re.compile('%s.*_rc.*' % _CHROME_VERSION_REGEX)
     for ebuild in stable_ebuilds:
       if chrome_branch_re.search(ebuild.version) and (
           not ebuild.chrome_version.startswith(sticky_branch)):
         candidates.append(ebuild)
 
   if candidates:
     return cros_mark_as_stable.BestEBuild(candidates)
   else:
     return None
 
 
 def MarkChromeEBuildAsStable(stable_candidate, unstable_ebuild, chrome_rev,
-                             chrome_version, commit, overlay_dir):
+                             chrome_version, commit, overlay_dir,
+                             sticky_ebuild):
   """Uprevs the chrome ebuild specified by chrome_rev.
 
   This is the main function that uprevs the chrome_rev from a stable candidate
   to its new version.
 
   Args:
     stable_candidate: ebuild that corresponds to the stable ebuild we are
       revving from.  If None, builds the a new ebuild given the version
       and logic for chrome_rev type with revision set to 1.
     unstable_ebuild:  ebuild corresponding to the unstable ebuild for chrome.
     chrome_rev: one of CHROME_REV
       TIP_OF_TRUNK -  Requires commit value.  Revs the ebuild for the TOT
         version and uses the portage suffix of _alpha.
       LATEST_RELEASE - This uses the portage suffix of _rc as they are release
         candidates for the next sticky version.
       STICKY -  Revs the sticky version.
     chrome_version:  The \d.\d.\d.\d version of Chrome.
     commit:  Used with TIP_OF_TRUNK.  The svn revision of chrome.
     overlay_dir:  Path to the chromeos-chrome package dir.
+    sticky_ebuild: EBuild class for the sticky ebuild.
   Returns:
     Full portage version atom (including rc's, etc) that was revved.
   """
   base_path = os.path.join(overlay_dir, 'chromeos-chrome-%s' % chrome_version)
   # Case where we have the last stable candidate with same version just rev.
   if stable_candidate and stable_candidate.chrome_version == chrome_version:
     new_ebuild_path = '%s-r%d.ebuild' % (
         stable_candidate.ebuild_path_no_revision,
         stable_candidate.current_revision + 1)
   else:
     if chrome_rev == TIP_OF_TRUNK:
       portage_suffix = '_alpha'
     else:
       portage_suffix = '_rc'
 
     new_ebuild_path = base_path + ('%s-r1.ebuild' % portage_suffix)
 
   cros_mark_as_stable.EBuildStableMarker.MarkAsStable(
-      unstable_ebuild.ebuild_path, new_ebuild_path, 'CROS_SVN_COMMIT', commit)
+      unstable_ebuild.ebuild_path, new_ebuild_path, 'CROS_SVN_COMMIT', commit,
+      make_stable=False)
+  new_ebuild = ChromeEBuild(new_ebuild_path)
+  if stable_candidate and (
+      stable_candidate.chrome_version == new_ebuild.chrome_version):
+    if 0 == RunCommand(['diff', '-Bu', stable_candidate.ebuild_path,
+                        new_ebuild_path],
+                       redirect_stderr=True,
+                       redirect_stdout=True,
+                       exit_code=True):
+      os.unlink(new_ebuild_path)
+      return None
+
   RunCommand(['git', 'add', new_ebuild_path])
-  if stable_candidate:
+  if stable_candidate and stable_candidate != sticky_ebuild:
     RunCommand(['git', 'rm', stable_candidate.ebuild_path])
 
   cros_mark_as_stable.EBuildStableMarker.CommitChange(
       _GIT_COMMIT_MESSAGE % {'chrome_rev': chrome_rev,
                              'chrome_version': chrome_version})
 
   new_ebuild = ChromeEBuild(new_ebuild_path)
   return '%s-%s' % (new_ebuild.package, new_ebuild.version)
 
 
@@ skipping 10 matching lines @@
   if len(args) != 1 or args[0] not in CHROME_REV:
     parser.error('Commit requires arg set to one of %s.' % CHROME_REV)
 
   overlay_dir = os.path.abspath(_CHROME_OVERLAY_DIR %
                                 {'srcroot': options.srcroot})
   chrome_rev = args[0]
   version_to_uprev = None
   commit_to_use = None
 
   (unstable_ebuild, stable_ebuilds) = FindChromeCandidates(overlay_dir)
-  sticky_version = _GetStickyVersion(stable_ebuilds)
+  sticky_ebuild = _GetStickyEBuild(stable_ebuilds)
+  sticky_version = sticky_ebuild.chrome_version
   sticky_branch = sticky_version.rpartition('.')[0]
 
-
   if chrome_rev == TIP_OF_TRUNK:
     version_to_uprev = _GetTipOfTrunkVersion()
     commit_to_use = _GetTipOfTrunkSvnRevision()
   elif chrome_rev == LATEST_RELEASE:
     version_to_uprev = _GetLatestRelease()
   else:
     version_to_uprev = _GetLatestRelease(sticky_branch)
 
   stable_candidate = FindChromeUprevCandidate(stable_ebuilds, chrome_rev,
                                               sticky_branch)
-  # There are some cases we don't need to do anything.  Check for them.
-  if stable_candidate and (version_to_uprev == stable_candidate.chrome_version
-                           and not commit_to_use):
-    Info('Found nothing to do for chrome_rev %s with version %s.' % (
-        chrome_rev, version_to_uprev))
-  else:
-    os.chdir(overlay_dir)
-    work_branch = cros_mark_as_stable.GitBranch(
-        cros_mark_as_stable.STABLE_BRANCH_NAME, options.tracking_branch)
-    work_branch.CreateBranch()
-    try:
-      chrome_version_atom = MarkChromeEBuildAsStable(
-          stable_candidate, unstable_ebuild, chrome_rev, version_to_uprev,
-          commit_to_use, overlay_dir)
-      # Explicit print to communicate to caller.
+
+  os.chdir(overlay_dir)
+  work_branch = cros_mark_as_stable.GitBranch(
+      cros_mark_as_stable.STABLE_BRANCH_NAME, options.tracking_branch)
+  work_branch.CreateBranch()
+  try:
+    chrome_version_atom = MarkChromeEBuildAsStable(
+        stable_candidate, unstable_ebuild, chrome_rev, version_to_uprev,
+        commit_to_use, overlay_dir, sticky_ebuild)
+    # Explicit print to communicate to caller.
+    if chrome_version_atom:
       print 'CHROME_VERSION_ATOM=%s' % chrome_version_atom
-    except:
+    else:
       work_branch.Delete()
-      raise
+  except:
+    work_branch.Delete()
+    raise
 
 
 if __name__ == '__main__':
   main()