Switch release scripts to pure git.

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 254 matching lines @@
 
   def Fetch(self):
     raise NotImplementedError()
 
   def GetTags(self):
     raise NotImplementedError()
 
   def GetBranches(self):
     raise NotImplementedError()
 
-  def GitSvn(self, hsh, branch=""):
-    raise NotImplementedError()
-
-  def SvnGit(self, rev, branch=""):
-    raise NotImplementedError()
-
   def MasterBranch(self):
     raise NotImplementedError()
 
   def CandidateBranch(self):
     raise NotImplementedError()
 
   def RemoteMasterBranch(self):
     raise NotImplementedError()
 
   def RemoteCandidateBranch(self):
     raise NotImplementedError()
 
   def RemoteBranch(self, name):
     raise NotImplementedError()
 
   def Land(self):
     raise NotImplementedError()
 
   def CLLand(self):
     raise NotImplementedError()
 
-  # 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, remote, message):
     """Sets a tag for the current commit.
 
     Assumptions: The commit already landed and the commit message is unique.
     """
     raise NotImplementedError()
 
 
-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 MasterBranch(self):
-    return "bleeding_edge"
-
-  def CandidateBranch(self):
-    return "trunk"
-
-  def RemoteMasterBranch(self):
-    return "svn/bleeding_edge"
-
-  def RemoteCandidateBranch(self):
-    return "svn/trunk"
-
-  def RemoteBranch(self, name):
-    return "svn/%s" % name
-
-  def Land(self):
-    self.step.GitSVNDCommit()
-
-  def CLLand(self):
-    self.step.GitDCommit()
-
-  def Tag(self, tag, remote, _):
-    self.step.GitSVNFetch()
-    self.step.Git("rebase %s" % remote)
-    self.step.GitSVNTag(tag)
-
-
-class GitTagsOnlyMixin(VCInterface):
+class GitInterface(VCInterface):
   def Pull(self):
     self.step.GitPull()
 
   def Fetch(self):
     self.step.Git("fetch")
-    self.step.GitSVNFetch()
 
   def GetTags(self):
      return self.step.Git("tag").strip().splitlines()
 
   def GetBranches(self):
     # Get relevant remote branches, e.g. "branch-heads/3.25".
     branches = filter(
         lambda s: re.match(r"^branch\-heads/\d+\.\d+$", s),
         self.step.GitRemotes())
     # Remove 'branch-heads/' prefix.
     return map(lambda s: s[13:], branches)
 
   def MasterBranch(self):
     return "master"
 
   def CandidateBranch(self):
     return "candidates"
 
   def RemoteMasterBranch(self):
     return "origin/master"
 
   def RemoteCandidateBranch(self):
     return "origin/candidates"
 
   def RemoteBranch(self, name):
     if name in ["candidates", "master"]:
       return "origin/%s" % name
     return "branch-heads/%s" % name
 
-  def PushRef(self, ref):
-    self.step.Git("push origin %s" % ref)
-
   def Tag(self, tag, remote, message):
     # Wait for the commit to appear. Assumes unique commit message titles (this
     # is the case for all automated merge and push commits - also no title is
     # the prefix of another title).
     commit = None
     for wait_interval in [3, 7, 15, 35, 45, 60]:
       self.step.Git("fetch")
       commit = self.step.GitLog(n=1, format="%H", grep=message, branch=remote)
       if commit:
         break
       print("The commit has not replicated to git. Waiting for %s seconds." %
             wait_interval)
       self.step._side_effect_handler.Sleep(wait_interval)
     else:
       self.step.Die("Couldn't determine commit for setting the tag. Maybe the "
                     "git updater is lagging behind?")
 
     self.step.Git("tag %s %s" % (tag, commit))
-    self.PushRef(tag)
-
-
-class GitReadSvnWriteInterface(GitTagsOnlyMixin, GitSvnInterface):
-  pass
-
-
-class GitInterface(GitTagsOnlyMixin):
-  def Fetch(self):
-    self.step.Git("fetch")
-
-  def GitSvn(self, hsh, branch=""):
-    return ""
-
-  def SvnGit(self, rev, branch=""):
-    raise NotImplementedError()
+    self.step.Git("push origin %s" % tag)
 
   def Land(self):
-    # FIXME(machenbach): This will not work with checkouts from bot_update
-    # after flag day because it will push to the cache. Investigate if it
-    # will work with "cl land".
     self.step.Git("push origin")
 
   def CLLand(self):
     self.step.GitCLLand()
 
-  def PushRef(self, ref):
-    self.step.Git("push https://chromium.googlesource.com/v8/v8 %s" % ref)
-
-
-VC_INTERFACES = {
-  "git_svn": GitSvnInterface,
-  "git_read_svn_write": GitReadSvnWriteInterface,
-  "git": GitInterface,
-}
-
 
 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 = VC_INTERFACES[options.vc_interface]()
+    self.vc = GitInterface()
     self.vc.InjectStep(self)
 
     # The testing configuration might set a different default cwd.
     self.default_cwd = (self._config.get("DEFAULT_CWD") or
                         os.path.join(self._options.work_dir, "v8"))
 
     assert self._number >= 0
     assert self._config is not None
     assert self._state is not None
     assert self._side_effect_handler is not None
@@ skipping 73 matching lines @@
     return self.Retry(cmd, None, [5])
 
   def Git(self, args="", prefix="", pipe=True, retry_on=None, cwd=None):
     cmd = lambda: self._side_effect_handler.Command(
         "git", args, prefix, pipe, cwd=cwd or self.default_cwd)
     result = self.Retry(cmd, retry_on, [5, 30])
     if result is None:
       raise GitFailedException("'git %s' failed." % args)
     return result
 
-  def SVN(self, args="", prefix="", pipe=True, retry_on=None, cwd=None):
-    cmd = lambda: self._side_effect_handler.Command(
-        "svn", args, prefix, pipe, cwd=cwd or self.default_cwd)
-    return self.Retry(cmd, retry_on, [5, 30])
-
   def Editor(self, args):
     if self._options.requires_editor:
       return self._side_effect_handler.Command(
           os.environ["EDITOR"],
           args,
           pipe=False,
           cwd=self.default_cwd)
 
   def ReadURL(self, url, params=None, retry_on=None, wait_plan=None):
     wait_plan = wait_plan or [3, 60, 600]
@@ skipping 141 matching lines @@
         line = re.sub("\d+$", self[prefix + "major"], line)
       elif line.startswith("#define MINOR_VERSION"):
         line = re.sub("\d+$", self[prefix + "minor"], line)
       elif line.startswith("#define BUILD_NUMBER"):
         line = re.sub("\d+$", self[prefix + "build"], line)
       elif line.startswith("#define PATCH_LEVEL"):
         line = re.sub("\d+$", self[prefix + "patch"], line)
       output += "%s\n" % line
     TextToFile(output, version_file)
 
-  def SVNCommit(self, root, commit_message):
-    patch = self.GitDiff("HEAD^", "HEAD")
-    TextToFile(patch, self._config["PATCH_FILE"])
-    self.Command("svn", "update", cwd=self._options.svn)
-    if self.Command("svn", "status", cwd=self._options.svn) != "":
-      self.Die("SVN checkout not clean.")
-    if not self.Command("patch", "-d %s -p1 -i %s" %
-                        (root, self._config["PATCH_FILE"]),
-                        cwd=self._options.svn):
-      self.Die("Could not apply patch.")
-    for line in self.Command(
-        "svn", "status", cwd=self._options.svn).splitlines():
-      # Check for added and removed items. Svn status has seven status columns.
-      # The first contains ? for unknown and ! for missing.
-      match = re.match(r"^(.)...... (.*)$", line)
-      if match and match.group(1) == "?":
-        self.Command("svn", "add --force %s" % match.group(2),
-                     cwd=self._options.svn)
-      if match and match.group(1) == "!":
-        self.Command("svn", "delete --force %s" % match.group(2),
-                     cwd=self._options.svn)
-
-    self.Command(
-        "svn",
-        "commit --non-interactive --username=%s --config-dir=%s -m \"%s\"" %
-            (self._options.author, self._options.svn_config, commit_message),
-        cwd=self._options.svn)
-
 
 class BootstrapStep(Step):
   MESSAGE = "Bootstapping v8 checkout."
 
   def RunStep(self):
     if os.path.realpath(self.default_cwd) == os.path.realpath(V8_BASE):
       self.Die("Can't use v8 checkout with calling script as work checkout.")
     # Directory containing the working v8 checkout.
     if not os.path.exists(self._options.work_dir):
       os.makedirs(self._options.work_dir)
@@ skipping 98 matching lines @@
     parser.add_argument("--dry-run", default=False, action="store_true",
                         help="Perform only read-only actions.")
     parser.add_argument("-g", "--googlers-mapping",
                         help="Path to the script mapping google accounts.")
     parser.add_argument("-r", "--reviewer", default="",
                         help="The account name to be used for reviews.")
     parser.add_argument("--sheriff", default=False, action="store_true",
                         help=("Determine current sheriff to review CLs. On "
                               "success, this will overwrite the reviewer "
                               "option."))
-    parser.add_argument("--svn",
-                        help=("Optional full svn checkout for the commit."
-                              "The folder needs to be the svn root."))
-    parser.add_argument("--svn-config",
-                        help=("Optional folder used as svn --config-dir."))
     parser.add_argument("-s", "--step",
         help="Specify the step where to start work. Default: 0.",
         default=0, type=int)
-    parser.add_argument("--vc-interface",
-                        help=("Choose VC interface out of git_svn|"
-                              "git_read_svn_write."))
     parser.add_argument("--work-dir",
                         help=("Location where to bootstrap a working v8 "
                               "checkout."))
     self._PrepareOptions(parser)
 
     if args is None:  # pragma: no cover
       options = parser.parse_args()
     else:
       options = parser.parse_args(args)
 
     # Process common options.
     if options.step < 0:  # pragma: no cover
       print "Bad step number %d" % options.step
       parser.print_help()
       return None
     if options.sheriff and not options.googlers_mapping:  # pragma: no cover
       print "To determine the current sheriff, requires the googler mapping"
       parser.print_help()
       return None
-    if options.svn and not options.svn_config:
-      print "Using pure svn for committing requires also --svn-config"
-      parser.print_help()
-      return None
 
     # Defaults for options, common to all scripts.
     options.manual = getattr(options, "manual", True)
     options.force = getattr(options, "force", False)
     options.bypass_upload_hooks = False
 
     # Derived options.
     options.requires_editor = not options.force
     options.wait_for_lgtm = not options.force
     options.force_readline_defaults = not options.manual
     options.force_upload = not options.manual
 
     # Process script specific options.
     if not self._ProcessOptions(options):
       parser.print_help()
       return None
 
-    if not options.vc_interface:
-      options.vc_interface = "git_read_svn_write"
     if not options.work_dir:
       options.work_dir = "/tmp/v8-release-scripts-work-dir"
     return options
 
   def RunSteps(self, step_classes, args=None):
     options = self.MakeOptions(args)
     if not options:
       return 1
 
     state_file = "%s-state.json" % self._config["PERSISTFILE_BASENAME"]
     if options.step == 0 and os.path.exists(state_file):
       os.remove(state_file)
 
     steps = []
     for (number, step_class) in enumerate([BootstrapStep] + 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)