Refactoring: Extract git checks in push and merge scripts.

tools/push-to-trunk/push_to_trunk.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 79 matching lines @@
     self.CommonPrepare()
     self.PrepareBranch()
     self.DeleteBranch(self.Config(TRUNKBRANCH))
 
 
 class FreshBranch(Step):
   MESSAGE = "Create a fresh branch."
 
   def RunStep(self):
     args = "checkout -b %s svn/bleeding_edge" % self.Config(BRANCHNAME)
-    if self.Git(args) is None:
-      self.Die("Creating branch %s failed." % self.Config(BRANCHNAME))
+    self.Git(args)
 
 
 class DetectLastPush(Step):
   MESSAGE = "Detect commit ID of last push to trunk."
 
   def RunStep(self):
     last_push_trunk = self._options.l or self.FindLastTrunkPush()
     while True:
       # Print assumed commit, circumventing git's pager.
       print self.Git("log -1 %s" % last_push_trunk)
@@ skipping 149 matching lines @@
         "Now working on version %s.%s.%s." % (self["new_major"],
                                               self["new_minor"],
                                               self["new_build"]))
 
     # Include optional TBR only in the git command. The persisted commit
     # message is used for finding the commit again later.
     if self._options.tbr_commit:
       review = "\n\nTBR=%s" % self._options.reviewer
     else:
       review = ""
-    if self.Git("commit -a -m \"%s%s\""
-                % (self["prep_commit_msg"], review)) is None:
-      self.Die("'git commit -a' failed.")
+    self.Git("commit -a -m \"%s%s\"" % (self["prep_commit_msg"], review))
 
 
 class CommitRepository(Step):
   MESSAGE = "Commit to the repository."
 
   def RunStep(self):
     self.WaitForLGTM()
     # Re-read the ChangeLog entry (to pick up possible changes).
     # FIXME(machenbach): This was hanging once with a broken pipe.
     TextToFile(GetLastChangeLogEntries(self.Config(CHANGELOG_FILE)),
                self.Config(CHANGELOG_ENTRY_FILE))
 
-    if self.Git("cl presubmit", "PRESUBMIT_TREE_CHECK=\"skip\"") is None:
-      self.Die("'git cl presubmit' failed, please try again.")
-
-    if self.Git("cl dcommit -f --bypass-hooks",
-                retry_on=lambda x: x is None) is None:
-      self.Die("'git cl dcommit' failed, please try again.")
+    self.Git("cl presubmit", "PRESUBMIT_TREE_CHECK=\"skip\"")
+    self.Git("cl dcommit -f --bypass-hooks", retry_on=lambda x: x is None)
 
 
 class StragglerCommits(Step):
   MESSAGE = ("Fetch straggler commits that sneaked in since this script was "
              "started.")
 
   def RunStep(self):
-    if self.Git("svn fetch") is None:
-      self.Die("'git svn fetch' failed.")
+    self.Git("svn fetch")
     self.Git("checkout svn/bleeding_edge")
     args = "log -1 --format=%%H --grep=\"%s\"" % self["prep_commit_msg"]
     self["prepare_commit_hash"] = self.Git(args).strip()
 
 
 class SquashCommits(Step):
   MESSAGE = "Squash commits into one."
 
   def RunStep(self):
     # Instead of relying on "git rebase -i", we'll just create a diff, because
@@ skipping 24 matching lines @@
     if not text:
       self.Die("Commit message editing failed.")
     TextToFile(text, self.Config(COMMITMSG_FILE))
     os.remove(self.Config(CHANGELOG_ENTRY_FILE))
 
 
 class NewBranch(Step):
   MESSAGE = "Create a new branch from trunk."
 
   def RunStep(self):
-    if self.Git("checkout -b %s svn/trunk" % self.Config(TRUNKBRANCH)) is None:
-      self.Die("Checking out a new branch '%s' failed." %
-               self.Config(TRUNKBRANCH))
+    self.Git("checkout -b %s svn/trunk" % self.Config(TRUNKBRANCH))
 
 
 class ApplyChanges(Step):
   MESSAGE = "Apply squashed changes."
 
   def RunStep(self):
     self.ApplyPatch(self.Config(PATCH_FILE))
     Command("rm", "-f %s*" % self.Config(PATCH_FILE))
 
 
@@ skipping 15 matching lines @@
         line = re.sub("\d+$", "0", line)
       output += "%s\n" % line
     TextToFile(output, self.Config(VERSION_FILE))
 
 
 class CommitTrunk(Step):
   MESSAGE = "Commit to local trunk branch."
 
   def RunStep(self):
     self.Git("add \"%s\"" % self.Config(VERSION_FILE))
-    if self.Git("commit -F \"%s\"" % self.Config(COMMITMSG_FILE)) is None:
-      self.Die("'git commit' failed.")
+    self.Git("commit -F \"%s\"" % self.Config(COMMITMSG_FILE))
     Command("rm", "-f %s*" % self.Config(COMMITMSG_FILE))
 
 
 class SanityCheck(Step):
   MESSAGE = "Sanity check."
 
   def RunStep(self):
     if not self.Confirm("Please check if your local checkout is sane: Inspect "
         "%s, compile, run tests. Do you want to commit this new trunk "
         "revision to the repository?" % self.Config(VERSION_FILE)):
@@ skipping 21 matching lines @@
       self.DieNoManualMode("Can't prompt in forced mode.")
       while not self["trunk_revision"]:
         print "> ",
         self["trunk_revision"] = self.ReadLine()
 
 
 class TagRevision(Step):
   MESSAGE = "Tag the new revision."
 
   def RunStep(self):
-    if self.Git(("svn tag %s -m \"Tagging version %s\""
-                 % (self["version"], self["version"])),
-                retry_on=lambda x: x is None) is None:
-      self.Die("'git svn tag' failed.")
+    self.Git(("svn tag %s -m \"Tagging version %s\""
+              % (self["version"], self["version"])),
+             retry_on=lambda x: x is None)
 
 
 class CheckChromium(Step):
   MESSAGE = "Ask for chromium checkout."
 
   def Run(self):
     self["chrome_path"] = self._options.c
     if not self["chrome_path"]:
       self.DieNoManualMode("Please specify the path to a Chromium checkout in "
                           "forced mode.")
@@ skipping 19 matching lines @@
     if not os.path.exists(self.Config(DEPS_FILE)):
       self.Die("DEPS file not present.")
 
 
 class UpdateChromiumCheckout(Step):
   MESSAGE = "Update the checkout and create a new branch."
   REQUIRES = "chrome_path"
 
   def RunStep(self):
     os.chdir(self["chrome_path"])
-    if self.Git("checkout master") is None:
-      self.Die("'git checkout master' failed.")
-    if self.Git("pull") is None:
-      self.Die("'git pull' failed, please try again.")
-
-    args = "checkout -b v8-roll-%s" % self["trunk_revision"]
-    if self.Git(args) is None:
-      self.Die("Failed to checkout a new branch.")
+    self.Git("checkout master")
+    self.Git("pull")
+    self.Git("checkout -b v8-roll-%s" % self["trunk_revision"])
 
 
 class UploadCL(Step):
   MESSAGE = "Create and upload CL."
   REQUIRES = "chrome_path"
 
   def RunStep(self):
     os.chdir(self["chrome_path"])
 
     # Patch DEPS file.
     deps = FileToText(self.Config(DEPS_FILE))
     deps = re.sub("(?<=\"v8_revision\": \")([0-9]+)(?=\")",
                   self["trunk_revision"],
                   deps)
     TextToFile(deps, self.Config(DEPS_FILE))
 
     if self._options.reviewer:
       print "Using account %s for review." % self._options.reviewer
       rev = self._options.reviewer
     else:
       print "Please enter the email address of a reviewer for the roll CL: ",
       self.DieNoManualMode("A reviewer must be specified in forced mode.")
       rev = self.ReadLine()
-    args = ("commit -am \"Update V8 to version %s "
-            "(based on bleeding_edge revision r%s).\n\nTBR=%s\""
-            % (self["version"], self["svn_revision"], rev))
-    if self.Git(args) is None:
-      self.Die("'git commit' failed.")
+    self.Git("commit -am \"Update V8 to version %s "
+             "(based on bleeding_edge revision r%s).\n\nTBR=%s\""
+             % (self["version"], self["svn_revision"], rev))
     author_option = self._options.author
     author = " --email \"%s\"" % author_option if author_option else ""
     force_flag = " -f" if self._options.force_upload else ""
-    if self.Git("cl upload%s --send-mail%s" % (author, force_flag),
-                pipe=False) is None:
-      self.Die("'git cl upload' failed, please try again.")
+    self.Git("cl upload%s --send-mail%s" % (author, force_flag), pipe=False)
     print "CL uploaded."
 
 
 class SwitchV8(Step):
   MESSAGE = "Returning to V8 checkout."
   REQUIRES = "chrome_path"
 
   def RunStep(self):
     os.chdir(self["v8_path"])
 
@@ skipping 103 matching lines @@
 def Main():
   parser = BuildOptions()
   (options, args) = parser.parse_args()
   if not ProcessOptions(options):
     parser.print_help()
     return 1
   RunPushToTrunk(CONFIG, PushToTrunkOptions(options))
 
 if __name__ == "__main__":
   sys.exit(Main())