Make prepare() accept a revision argument.

checkout.py

 # coding=utf8
 # Copyright (c) 2011 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 """Manages a project checkout.
 
 Includes support for svn, git-svn and git.
 """
 
 from __future__ import with_statement
@@ skipping 62 matching lines @@
       self.project_path = os.path.join(self.root_dir, self.project_name)
     # Only used for logging purposes.
     self._last_seen_revision = None
     self.post_processors = None
     assert self.root_dir
     assert self.project_path
 
   def get_settings(self, key):
     return get_code_review_setting(self.project_path, key)
 
-  def prepare(self):
+  def prepare(self, revision):
     """Checks out a clean copy of the tree and removes any local modification.
 
     This function shouldn't throw unless the remote repository is inaccessible,
     there is no free disk space or hard issues like that.
+
+    Args:
+      revision: The revision it should sync to, SCM specific.
     """
     raise NotImplementedError()
 
   def apply_patch(self, patches):
     """Applies a patch and returns the list of modified files.
 
     This function should throw patch.UnsupportedPatchFormat or
     PatchApplicationFailed when relevant.
 
     Args:
       patches: patch.PatchSet object.
     """
     raise NotImplementedError()
 
   def commit(self, commit_message, user):
     """Commits the patch upstream, while impersonating 'user'."""
     raise NotImplementedError()
 
 
 class RawCheckout(CheckoutBase):
   """Used to apply a patch locally without any intent to commit it.
 
   To be used by the try server.
   """
-  def prepare(self):
+  def prepare(self, revision):
     """Stubbed out."""
     pass
 
   def apply_patch(self, patches):
     """Ignores svn properties."""
     for p in patches:
       try:
         stdout = ''
         filename = os.path.join(self.project_path, p.filename)
         if p.is_delete:
@@ skipping 114 matching lines @@
 class SvnCheckout(CheckoutBase, SvnMixIn):
   """Manages a subversion checkout."""
   def __init__(self, root_dir, project_name, commit_user, commit_pwd, svn_url,
       post_processors=None):
     super(SvnCheckout, self).__init__(root_dir, project_name, post_processors)
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     self.svn_url = svn_url
     assert bool(self.commit_user) >= bool(self.commit_pwd)
 
-  def prepare(self):
+  def prepare(self, revision):
     # Will checkout if the directory is not present.
     assert self.svn_url
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
-    revision = self._revert()
-    if revision != self._last_seen_revision:
-      logging.info('Updated at revision %d' % revision)
-      self._last_seen_revision = revision
-    return revision
+    return self._revert(revision)
 
   def apply_patch(self, patches):
     for p in patches:
       try:
         # It is important to use credentials=False otherwise credentials could
         # leak in the error message. Credentials are not necessary here for the
         # following commands anyway.
         stdout = ''
         if p.is_delete:
           stdout += self._check_output_svn(
@@ skipping 76 matching lines @@
     finally:
       os.remove(commit_filename)
     lines = filter(None, out.splitlines())
     match = re.match(r'^Committed revision (\d+).$', lines[-1])
     if not match:
       raise PatchApplicationFailed(
           None,
           'Couldn\'t make sense out of svn commit message:\n' + out)
     return int(match.group(1))
 
-  def _revert(self):
+  def _revert(self, revision):
     """Reverts local modifications or checks out if the directory is not
     present. Use depot_tools's functionality to do this.
     """
     flags = ['--ignore-externals']
+    if revision:
+      flags.extend(['--revision', str(revision)])
     if not os.path.isdir(self.project_path):
       logging.info(
           'Directory %s is not present, checking it out.' % self.project_path)
       self._check_call_svn(
           ['checkout', self.svn_url, self.project_path] + flags, cwd=None)
     else:
       scm.SVN.Revert(self.project_path)
       # Revive files that were deleted in scm.SVN.Revert().
       self._check_call_svn(['update', '--force'] + flags)
+    return self._get_revision()
 
+  def _get_revision(self):
     out = self._check_output_svn(['info', '.'])
-    return int(self._parse_svn_info(out, 'revision'))
+    revision = int(self._parse_svn_info(out, 'revision'))
+    if revision != self._last_seen_revision:
+      logging.info('Updated at revision %d' % revision)

[Dirk Pranke, 2011/06/10 21:07:45]

Nit: "Updated to revision" ?

+      self._last_seen_revision = revision
+    return revision
 
 
 class GitCheckoutBase(CheckoutBase):
   """Base class for git checkout. Not to be used as-is."""
   def __init__(self, root_dir, project_name, remote_branch,
       post_processors=None):
     super(GitCheckoutBase, self).__init__(
         root_dir, project_name, post_processors)
     # There is no reason to not hardcode it.
     self.remote = 'origin'
     self.remote_branch = remote_branch
     self.working_branch = 'working_branch'
 
-  def prepare(self):
+  def prepare(self, revision):
     """Resets the git repository in a clean state.
 
     Checks it out if not present and deletes the working branch.
     """
     assert self.remote_branch
     assert os.path.isdir(self.project_path)
     self._check_call_git(['reset', '--hard', '--quiet'])
-    branches, active = self._branches()
-    if active != 'master':
-      self._check_call_git(['checkout', 'master', '--force', '--quiet'])
-    self._check_call_git(['pull', self.remote, self.remote_branch, '--quiet'])
-    if self.working_branch in branches:
-      self._call_git(['branch', '-D', self.working_branch])
+    if revision:
+      try:
+        revision = self._check_output_git(['rev-parse', revision])
+      except subprocess.CalledProcessError:
+        self._check_call_git(
+            ['fetch', self.remote, self.remote_branch, '--quiet'])
+        revision = self._check_output_git(['rev-parse', revision])
+      self._check_call_git(['checkout', '--force', '--quiet', revision])
+    else:
+      branches, active = self._branches()
+      if active != 'master':
+        self._check_call_git(['checkout', '--force', '--quiet', 'master'])
+      self._check_call_git(['pull', self.remote, self.remote_branch, '--quiet'])
+      if self.working_branch in branches:
+        self._call_git(['branch', '-D', self.working_branch])
 
   def apply_patch(self, patches):
     """Applies a patch on 'working_branch' and switch to it.
 
     Also commits the changes on the local branch.
 
     Ignores svn properties and raise an exception on unexpected ones.
     """
     # It this throws, the checkout is corrupted. Maybe worth deleting it and
     # trying again?
@@ skipping 95 matching lines @@
     self.commit_user = commit_user
     self.commit_pwd = commit_pwd
     # svn_url in this case is the root of the svn repository.
     self.svn_url = svn_url
     self.trunk = trunk
     assert bool(self.commit_user) >= bool(self.commit_pwd)
     assert self.svn_url
     assert self.trunk
     self._cache_svn_auth()
 
-  def prepare(self):
+  def prepare(self, revision):
     """Resets the git repository in a clean state."""
     self._check_call_git(['reset', '--hard', '--quiet'])
-    branches, active = self._branches()
-    if active != 'master':
-      if not 'master' in branches:
+    if revision:
+      try:
+        revision = self._check_output_git(
+            ['svn', 'find-rev', 'r%d' % revision])
+      except subprocess.CalledProcessError:
         self._check_call_git(
-            ['checkout', '--quiet', '-b', 'master',
-             '%s/%s' % (self.remote, self.remote_branch)])
-      else:
-        self._check_call_git(['checkout', 'master', '--force', '--quiet'])
-    # git svn rebase --quiet --quiet doesn't work, use two steps to silence it.
-    self._check_call_git_svn(['fetch', '--quiet', '--quiet'])
-    self._check_call_git(
-        ['rebase', '--quiet', '--quiet',
-          '%s/%s' % (self.remote, self.remote_branch)])
-    if self.working_branch in branches:
-      self._call_git(['branch', '-D', self.working_branch])
-    return int(self._git_svn_info('revision'))
+            ['fetch', self.remote, self.remote_branch, '--quiet'])
+        revision = self._check_output_git(
+            ['svn', 'find-rev', 'r%d' % revision])
+      super(GitSvnCheckoutBase, self).prepare(revision)
+    else:
+      branches, active = self._branches()
+      if active != 'master':
+        if not 'master' in branches:
+          self._check_call_git(
+              ['checkout', '--quiet', '-b', 'master',
+              '%s/%s' % (self.remote, self.remote_branch)])
+        else:
+          self._check_call_git(['checkout', 'master', '--force', '--quiet'])
+      # git svn rebase --quiet --quiet doesn't work, use two steps to silence
+      # it.
+      self._check_call_git_svn(['fetch', '--quiet', '--quiet'])
+      self._check_call_git(
+          ['rebase', '--quiet', '--quiet',
+            '%s/%s' % (self.remote, self.remote_branch)])
+      if self.working_branch in branches:
+        self._call_git(['branch', '-D', self.working_branch])
+    return self._get_revision()
 
   def _git_svn_info(self, key):
     """Calls git svn info. This doesn't support nor need --config-dir."""
     return self._parse_svn_info(self._check_output_git(['svn', 'info']), key)
 
   def commit(self, commit_message, user):
     """Commits a patch."""
     logging.info('Committing patch for %s' % user)
     # Fix the commit message and author. It returns the git hash, which we
     # ignore unless it's None.
@@ skipping 46 matching lines @@
       root_dir, project_name, remote_branch,
       commit_user, commit_pwd,
       svn_url, trunk, git_url, post_processors=None):
     super(GitSvnPremadeCheckout, self).__init__(
         root_dir, project_name, remote_branch,
         commit_user, commit_pwd,
         svn_url, trunk, post_processors)
     self.git_url = git_url
     assert self.git_url
 
-  def prepare(self):
+  def prepare(self, revision):
     """Creates the initial checkout for the repo."""
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
       assert self.remote == 'origin'
       # self.project_path doesn't exist yet.
       self._check_call_git(
           ['clone', self.git_url, self.project_name, '--quiet'],
           cwd=self.root_dir,
           stderr=subprocess2.STDOUT)
     try:
       configured_svn_url = self._check_output_git(
           ['config', 'svn-remote.svn.url']).strip()
     except subprocess.CalledProcessError:
       configured_svn_url = ''
 
     if configured_svn_url.strip() != self.svn_url:
       self._check_call_git_svn(
           ['init',
            '--prefix', self.remote + '/',
            '-T', self.trunk,
            self.svn_url])
     self._check_call_git_svn(['fetch'])
-    super(GitSvnPremadeCheckout, self).prepare()
-    return self._get_revision()
+    return super(GitSvnPremadeCheckout, self).prepare(revision)
 
 
 class GitSvnCheckout(GitSvnCheckoutBase):
   """Manages a git-svn clone.
 
   Using git-svn hides some of the complexity of using a svn checkout.
   """
   def __init__(self,
       root_dir, project_name,
       commit_user, commit_pwd,
       svn_url, trunk, post_processors=None):
     super(GitSvnCheckout, self).__init__(
         root_dir, project_name, 'trunk',
         commit_user, commit_pwd,
         svn_url, trunk, post_processors)
 
-  def prepare(self):
+  def prepare(self, revision):
     """Creates the initial checkout for the repo."""
+    assert not revision, 'Implement revision if necessary'
     if not os.path.isdir(self.project_path):
       logging.info('Checking out %s in %s' %
           (self.project_name, self.project_path))
       # TODO: Create a shallow clone.
       # self.project_path doesn't exist yet.
       self._check_call_git_svn(
           ['clone',
            '--prefix', self.remote + '/',
            '-T', self.trunk,
            self.svn_url, self.project_path,
            '--quiet'],
           cwd=self.root_dir,
           stderr=subprocess2.STDOUT)
-    super(GitSvnCheckout, self).prepare()
-    return self._get_revision()
+    return super(GitSvnCheckout, self).prepare(revision)
 
 
 class ReadOnlyCheckout(object):
   """Converts a checkout into a read-only one."""
   def __init__(self, checkout):
     self.checkout = checkout
 
-  def prepare(self):
-    return self.checkout.prepare()
+  def prepare(self, revision):
+    return self.checkout.prepare(revision)
 
   def get_settings(self, key):
     return self.checkout.get_settings(key)
 
   def apply_patch(self, patches):
     return self.checkout.apply_patch(patches)
 
   def commit(self, message, user):  # pylint: disable=R0201
     logging.info('Would have committed for %s with message: %s' % (
         user, message))
     return 'FAKE'
 
   @property
   def project_name(self):
     return self.checkout.project_name
 
   @property
   def project_path(self):
     return self.checkout.project_path