Refactoring: Extract interface for VC in release scripts.

tools/push-to-trunk/common_includes.py

 #!/usr/bin/env python
 # Copyright 2013 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
@@ skipping 237 matching lines @@
   def GetUTCStamp(self):
     return time.mktime(datetime.datetime.utcnow().timetuple())
 
 DEFAULT_SIDE_EFFECT_HANDLER = SideEffectHandler()
 
 
 class NoRetryException(Exception):
   pass
 
 
+class VCInterface(object):
+  def InjectStep(self, step):
+    self.step=step
+
+  def Pull(self):
+    raise Exception()

[tandrii(chromium), 2014/09/25 12:50:08]

any reason why not
raise NotImplementedError

[Michael Achenbach, 2014/09/25 13:13:48]

Done.

+
+  def Fetch(self):
+    raise Exception()
+
+  def GetTags(self):
+    raise Exception()
+
+  def GetBranches(self):
+    raise Exception()
+
+  def GitSvn(self, hsh, branch=""):
+    raise Exception()
+
+  def SvnGit(self, rev, branch=""):
+    raise Exception()
+
+  def RemoteMasterBranch(self):
+    raise Exception()
+
+  def RemoteCandidateBranch(self):
+    raise Exception()
+
+  def RemoteBranch(self, name):
+    raise Exception()
+
+  def Land(self):
+    raise Exception()
+
+  def CLLand(self):
+    raise Exception()
+
+  # TODO(machenbach): There is some svn knowledge in this interface. In svn,
+  # tag and commit are different remote commands, while in git we would commit
+  # and tag locally and then push/land in one unique step.
+  def Tag(self, tag):
+    raise Exception()
+
+
+class GitSvnInterface(VCInterface):
+  def Pull(self):
+    self.step.GitSVNRebase()
+
+  def Fetch(self):
+    self.step.GitSVNFetch()
+
+  def GetTags(self):
+    # Get remote tags.
+    tags = filter(lambda s: re.match(r"^svn/tags/[\d+\.]+$", s),
+                  self.step.GitRemotes())
+
+    # Remove 'svn/tags/' prefix.
+    return map(lambda s: s[9:], tags)
+
+  def GetBranches(self):
+    # Get relevant remote branches, e.g. "svn/3.25".
+    branches = filter(lambda s: re.match(r"^svn/\d+\.\d+$", s),
+                      self.step.GitRemotes())
+    # Remove 'svn/' prefix.
+    return map(lambda s: s[4:], branches)
+
+  def GitSvn(self, hsh, branch=""):
+    return self.step.GitSVNFindSVNRev(hsh, branch)
+
+  def SvnGit(self, rev, branch=""):
+    return self.step.GitSVNFindGitHash(rev, branch)
+
+  def RemoteMasterBranch(self):
+    return "svn/bleeding_edge"
+
+  def RemoteCandidateBranch(self):
+    return "svn/trunk"
+
+  def RemoteBranch(self, name):
+    return "svn/%s" % name
+
+  def Land(self):
+    return self.step.GitSVNDCommit()
+
+  def CLLand(self):
+    return self.step.GitDCommit()
+
+  def Tag(self, tag):
+    self.step.GitSVNTag(tag)
+
+
+
 class Step(GitRecipesMixin):
   def __init__(self, text, number, config, state, options, handler):
     self._text = text
     self._number = number
     self._config = config
     self._state = state
     self._options = options
     self._side_effect_handler = handler
+    self.vc = GitSvnInterface()
+    self.vc.InjectStep(self)
 
     # The testing configuration might set a different default cwd.
     self.default_cwd = self._config.get("DEFAULT_CWD") or DEFAULT_CWD
 
     assert self._number >= 0
     assert self._config is not None
     assert self._state is not None
     assert self._side_effect_handler is not None
 
   def __getitem__(self, key):
@@ skipping 139 matching lines @@
 
   def CommonPrepare(self):
     # Check for a clean workdir.
     if not self.GitIsWorkdirClean():  # pragma: no cover
       self.Die("Workspace is not clean. Please commit or undo your changes.")
 
     # Persist current branch.
     self["current_branch"] = self.GitCurrentBranch()
 
     # Fetch unfetched revisions.
-    self.GitSVNFetch()
+    self.vc.Fetch()
 
   def PrepareBranch(self):
     # Delete the branch that will be created later if it exists already.
     self.DeleteBranch(self._config["BRANCHNAME"])
 
   def CommonCleanup(self):
     self.GitCheckout(self["current_branch"])
     if self._config["BRANCHNAME"] != self["current_branch"]:
       self.GitDeleteBranch(self._config["BRANCHNAME"])
 
@@ skipping 50 matching lines @@
     except GitFailedException:
       self.WaitForResolvingConflicts(patch_file)
 
   def FindLastTrunkPush(
       self, parent_hash="", branch="", include_patches=False):
     push_pattern = "^Version [[:digit:]]*\.[[:digit:]]*\.[[:digit:]]*"
     if not include_patches:
       # Non-patched versions only have three numbers followed by the "(based
       # on...) comment."
       push_pattern += " (based"
-    branch = "" if parent_hash else branch or "svn/trunk"
+    branch = "" if parent_hash else branch or self.vc.RemoteCandidateBranch()
     return self.GitLog(n=1, format="%H", grep=push_pattern,
                        parent_hash=parent_hash, branch=branch)
 
   def ArrayToVersion(self, prefix):
     return ".".join([self[prefix + "major"],
                      self[prefix + "minor"],
                      self[prefix + "build"],
                      self[prefix + "patch"]])
 
   def SetVersion(self, version_file, prefix):
@@ skipping 189 matching lines @@
     for (number, step_class) in enumerate(step_classes):
       steps.append(MakeStep(step_class, number, self._state, self._config,
                             options, self._side_effect_handler))
     for step in steps[options.step:]:
       if step.Run():
         return 0
     return 0
 
   def Run(self, args=None):
     return self.RunSteps(self._Steps(), args)