First cut at stable script

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
+
+# TODO(sosa):  Refactor Die into common library.
+sys.path.append(os.path.dirname(__file__))
+import generate_test_report
+
+
+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_boolean('push', False,
+                      'Creates, commits and pushes the stable ebuild.')
+gflags.DEFINE_boolean('verbose', False,
+                      'Prints out verbose information about what is going on.',
+                      short_name='v')
+
+
+# TODO(sosa):  Remove hard-coding of overlays directory once there is a better
+# way.
+_CHROMIUMOS_OVERLAYS_DIRECTORY = \
+    '%s/trunk/src/third_party/chromiumos-overlay' % os.environ['HOME']
+
+# Takes two strings, package_name and commit_id.
+_GIT_COMMIT_MESSAGE = \
+  'Marking 9999 ebuild for %s with commit %s as stable.'
+
+
+# ======================= Global Helper Functions ========================
+
+
+def _Print(message):
+  """Verbose print function."""
+  if gflags.FLAGS.verbose:
+    print message
+
+
+def _CheckSaneArguments(package_list, commit_id_list):
+  """Checks to make sure the flags are sane.  Dies if arguments are not sane"""
+  if not gflags.FLAGS.packages:
+    generate_test_report.Die('Please specify at least one package')
+  if not gflags.FLAGS.board:
+    generate_test_report.Die('Please specify a board')
+  if commit_id_list and (len(package_list) != len(commit_id_list)):
+    print commit_id_list
+    print len(commit_id_list)
+    generate_test_report.Die(
+        'Package list is not the same length as the commit id list')
+
+
+def _PrintUsageAndDie():
+  """Prints the usage and returns an error exit code."""
+  generate_test_report.Die('Usage: %s ARGS\n%s' % (sys.argv[0], gflags.FLAGS))
+
+
+def _RunCommand(command):
+  """Runs a shell command and returns stdout back to caller."""
+  _Print('  + %s' % command)
+  proc_handle = subprocess.Popen(command, stdout=subprocess.PIPE, shell=True)
+  return proc_handle.communicate()[0]
+
+
+# ======================= End Global Helper Functions ========================
+
+
+class _GitBranch(object):
+  """Wrapper class for a git branch."""
+
+  def __init__(self, branch_name):
+    """Sets up variables but does not create the branch."""
+    self.branch_name = branch_name
+    self._cleaned_up = False
+
+  def __del__(self):
+    """Ensures we're checked back out to the master branch."""
+    if not self._cleaned_up:
+      self.CleanUp()
+
+  def CreateBranch(self):
+    """Creates a new git branch or replaces an existing one."""
+    if self.Exists():
+      self.Delete()
+    self._Checkout(self.branch_name)
+
+  def CleanUp(self):
+    """Does a git checkout back to the master branch."""
+    self._Checkout('master', create=False)
+    self._cleaned_up = True
+
+  def _Checkout(self, target, create=True):
+    """Function used internally to create and move between branches."""
+    if create:
+      git_cmd = 'git checkout -b %s origin' % target
+    else:
+      git_cmd = 'git checkout %s' % target
+    _RunCommand(git_cmd)
+
+  def Exists(self):
+    """Returns True if the branch exists."""
+    branch_cmd = 'git branch'
+    branches = _RunCommand(branch_cmd)
+    return self.branch_name in branches.split()
+
+  def Delete(self):
+    """Deletes the branch and returns the user to the master branch.
+
+    Returns True on success.
+    """
+    self._Checkout('master', create=False)
+    delete_cmd = 'git branch -D %s' % self.branch_name
+    _RunCommand(delete_cmd)
+
+
+class _EBuild(object):
+  """Wrapper class for an ebuild."""
+
+  def __init__(self, package, commit_id=None):
+    """Initializes all data about an ebuild.
+
+    Uses equery to find the ebuild path and sets data about an ebuild for
+    easy reference.
+    """
+    self.package = package
+    self.ebuild_path = self._FindEBuildPath(package)
+    (self.ebuild_path_no_revision,
+     self.ebuild_path_no_version,
+     self.current_revision) = self._ParseEBuildPath(self.ebuild_path)
+    self.commit_id = commit_id
+
+  @classmethod
+  def _FindEBuildPath(cls, package):
+    """Static method that returns the full path of an ebuild."""
+    _Print('Looking for unstable ebuild for %s' % package)
+    equery_cmd = 'equery-%s which %s 2> /dev/null' \
+      % (gflags.FLAGS.board, package)
+    path = _RunCommand(equery_cmd)
+    if path:
+      _Print('Unstable ebuild found at %s' % path)
+    return path
+
+  @classmethod
+  def _ParseEBuildPath(cls, ebuild_path):
+    """Static method that parses the path of an ebuild
+
+    Returns a tuple containing the (ebuild path without the revision
+    string, without the version string, and the current revision number for
+    the ebuild).
+    """
+     # Get the ebuild name without the revision string.
+    (ebuild_no_rev, _, rev_string) = ebuild_path.rpartition('-')
+
+    # Verify the revision string starts with the revision character.
+    if rev_string.startswith('r'):
+      # Get the ebuild name without the revision and version strings.
+      ebuild_no_version = ebuild_no_rev.rpartition('-')[0]
+      rev_string = rev_string[1:].rpartition('.ebuild')[0]
+    else:
+      # Has no revision so we stripped the version number instead.
+      ebuild_no_version = ebuild_no_rev
+      ebuild_no_rev = ebuild_path.rpartition('.ebuild')[0]
+      rev_string = "0"
+    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):
+    """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.
+    """
+    # TODO(sosa):  Change to a check.
+    if not self._ebuild:
+      generate_test_report.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)
+    shutil.copyfile('%s-9999.ebuild' % self._ebuild.ebuild_path_no_version,
+                    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("~", ""))
+      elif line.startswith('EAPI'):
+        # Always add new commit_id after EAPI definition.
+        redirect_file.write(line)
+        redirect_file.write('EGIT_COMMIT="%s"' % commit_id)
+      elif not line.startswith('EGIT_COMMIT'):
+        # Skip old EGIT_COMMIT definition.
+        redirect_file.write(line)
+    fileinput.close()
+
+    _Print('Adding new stable ebuild to git')
+    _RunCommand('git add %s' % new_ebuild_path)
+
+    _Print('Removing old ebuild from git')
+    _RunCommand('git rm %s' % self._ebuild.ebuild_path)
+
+  def CommitChange(self, message):
+    """Commits current changes in git locally.
+
+    This method will take any changes from invocations to RevEBuild
+    and commits them locally in the git repository that contains os.pwd.
+
+    Args:
+        message: the commit string to write when committing to git.
+
+    Raises:
+        OSError: Error occurred while committing.
+    """
+    _Print('Committing changes for %s with commit message %s' % \
+           (self._ebuild.package, message))
+    git_commit_cmd = 'git commit -am "%s"' % message
+    _RunCommand(git_commit_cmd)
+
+  # TODO(sosa):  This doesn't work yet.  Want to directly push without a prompt.
+  def PushChange(self):
+    """Pushes changes to the git repository.
+
+    Pushes locals commits from calls to CommitChange to the remote git
+    repository specified by os.pwd.
+
+    Raises:
+        OSError: Error occurred while pushing.
+    """
+    print 'Push currently not implemented'
+    # TODO(sosa):  Un-comment once PushChange works.
+    # _Print('Pushing changes for %s' % self._ebuild.package)
+    # git_commit_cmd = 'git push'
+    # _RunCommand(git_commit_cmd)
+
+
+def main(argv):
+  try:
+    argv = gflags.FLAGS(argv)
+  except gflags.FlagsError:
+    _PrintUsageAndDie()
+
+  package_list = gflags.FLAGS.packages.split(' ')
+  if gflags.FLAGS.commit_ids:
+    commit_id_list = gflags.FLAGS.commit_ids.split(' ')
+  else:
+    commit_id_list = None
+  _CheckSaneArguments(package_list, commit_id_list)
+
+  pwd = os.curdir
+  os.chdir(_CHROMIUMOS_OVERLAYS_DIRECTORY)
+
+  work_branch = _GitBranch('stabilizing_branch')
+  work_branch.CreateBranch()
+  if not work_branch.Exists():
+    generate_test_report.Die('Unable to create stabilizing branch')
+  index = 0
+  try:
+    for index in range(len(package_list)):
+      # Gather the package and optional commit id to work on.
+      package = package_list[index]
+      commit_id = ""
+      if commit_id_list:
+        commit_id = commit_id_list[index]
+
+      _Print('Working on %s' % package)
+      worker = EBuildStableMarker(_EBuild(package, commit_id))
+      worker.RevEBuild(commit_id)
+      worker.CommitChange(_GIT_COMMIT_MESSAGE % (package, commit_id))
+      if gflags.FLAGS.push:
+        worker.PushChange()
+
+  except (OSError, IOError):
+    print 'An exception occurred %s' % sys.exc_info()[0]
+    print 'Only the following packages were revved: %s' % package_list[:index]
+    print '''Note you will have to go into the chromiumos-overlay directory and
+          reset the git repo yourself.
+          '''
+  finally:
+    # Always run the last two cleanup functions.
+    work_branch.CleanUp()
+    os.chdir(pwd)
+
+
+if __name__ == '__main__':
+  main(sys.argv)
+