[Release] Update merge script to leverage auto-tag bot

tools/release/merge_to_branch.py

 #!/usr/bin/env python
 # Copyright 2014 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 29 matching lines @@
 
   def RunStep(self):
     if os.path.exists(self.Config("ALREADY_MERGING_SENTINEL_FILE")):
       if self._options.force:
         os.remove(self.Config("ALREADY_MERGING_SENTINEL_FILE"))
       elif self._options.step == 0:  # pragma: no cover
         self.Die("A merge is already in progress")
     open(self.Config("ALREADY_MERGING_SENTINEL_FILE"), "a").close()
 
     self.InitialEnvironmentChecks(self.default_cwd)
-    if self._options.branch:
-      self["merge_to_branch"] = self._options.branch
-    else:  # pragma: no cover
-      self.Die("Please specify a branch to merge to")
+
+    self["merge_to_branch"] = self._options.branch
 
     self.CommonPrepare()
     self.PrepareBranch()
 
 
 class CreateBranch(Step):
   MESSAGE = "Create a fresh branch for the patch."
 
   def RunStep(self):
     self.GitCreateBranch(self.Config("BRANCHNAME"),
                          self.vc.RemoteBranch(self["merge_to_branch"]))
 
 
 class SearchArchitecturePorts(Step):
   MESSAGE = "Search for corresponding architecture ports."
 
   def RunStep(self):
     self["full_revision_list"] = list(OrderedDict.fromkeys(
         self._options.revisions))
     port_revision_list = []
     for revision in self["full_revision_list"]:
       # Search for commits which matches the "Port XXX" pattern.
       git_hashes = self.GitLog(reverse=True, format="%H",
-                               grep="Port %s" % revision,
+                               grep="^[Pp]ort %s" % revision,
                                branch=self.vc.RemoteMasterBranch())
       for git_hash in git_hashes.splitlines():
         revision_title = self.GitLog(n=1, format="%s", git_hash=git_hash)
 
         # Is this revision included in the original revision list?
         if git_hash in self["full_revision_list"]:
           print("Found port of %s -> %s (already included): %s"
                 % (revision, git_hash, revision_title))
         else:
           print("Found port of %s -> %s: %s"
                 % (revision, git_hash, revision_title))
           port_revision_list.append(git_hash)
 
     # Do we find any port?
     if len(port_revision_list) > 0:
       if self.Confirm("Automatically add corresponding ports (%s)?"
                       % ", ".join(port_revision_list)):
         #: 'y': Add ports to revision list.
         self["full_revision_list"].extend(port_revision_list)
 
 
 class CreateCommitMessage(Step):
   MESSAGE = "Create commit message."
 
+  def _create_commit_description(self, commit_hash):
+    patch_merge_desc = self.GitLog(n=1, format="%s", git_hash=commit_hash)
+    description = "Merged: " + patch_merge_desc + "\n"
+    description += "Revision: " + commit_hash + "\n\n"

[Michael Achenbach, 2016/07/22 06:45:56]

Is this revision to be processed by scripts or informational? If the latter,
maybe include a full link with short hash, so that folks can just click on it?

[Michael Hablich, 2016/07/22 08:55:59]

Scripts

+    return description
+
   def RunStep(self):
 
     # Stringify: ["abcde", "12345"] -> "abcde, 12345"
     self["revision_list"] = ", ".join(self["full_revision_list"])
 
     if not self["revision_list"]:  # pragma: no cover
       self.Die("Revision list is empty.")
 
-    action_text = "Merged %s"
+    msg_pieces = []
 
-    # The commit message title is added below after the version is specified.
-    msg_pieces = [
-      "\n".join(action_text % s for s in self["full_revision_list"]),
-    ]
-    msg_pieces.append("\n\n")
-
-    for commit_hash in self["full_revision_list"]:
-      patch_merge_desc = self.GitLog(n=1, format="%s", git_hash=commit_hash)
-      msg_pieces.append("%s\n\n" % patch_merge_desc)
+    if len(self["full_revision_list"]) > 1:
+      self["commit_title"] = "Merged: Squashed multiple commits."
+      for commit_hash in self["full_revision_list"]:
+        msg_pieces.append(self._create_commit_description(commit_hash))
+    else:
+      commit_hash = self["full_revision_list"][0]
+      full_description = self._create_commit_description(commit_hash).split("\n")
+      self["commit_title"] = full_description[0]

[Michael Achenbach, 2016/07/22 06:45:57]

We might need to ensure the length of the title here and cut off if too long.
Please check with tandrii for rietveld's limit. If the limit is breached,
rietveld acts weirdly.

[Michael Hablich, 2016/07/22 08:55:59]

The web interface gives me the ability to create a string 100 characters long. I
am taking the safe route and cut off after 80 characters.

[Michael Achenbach, 2016/07/22 09:12:24]

Wondering if 80 is too aggressive. We have commit titles a lot longer. I think
rietveld might allow 256 or something?

+      msg_pieces.append(full_description[1] + "\n\n")
 
     bugs = []
     for commit_hash in self["full_revision_list"]:
       msg = self.GitLog(n=1, git_hash=commit_hash)
       for bug in re.findall(r"^[ \t]*BUG[ \t]*=[ \t]*(.*?)[ \t]*$", msg, re.M):
         bugs.extend(s.strip() for s in bug.split(","))
     bug_aggregate = ",".join(sorted(filter(lambda s: s and s != "none", bugs)))
     if bug_aggregate:
       msg_pieces.append("BUG=%s\nLOG=N\n" % bug_aggregate)
 
+    msg_pieces.append("NOTRY=true\nNOPRESUBMIT=true\n")
+
     self["new_commit_msg"] = "".join(msg_pieces)
 
 
 class ApplyPatches(Step):
   MESSAGE = "Apply patches for selected revisions."
 
   def RunStep(self):
     for commit_hash in self["full_revision_list"]:
       print("Applying patch for %s to %s..."
             % (commit_hash, self["merge_to_branch"]))
       patch = self.GitGetPatch(commit_hash)
       TextToFile(patch, self.Config("TEMPORARY_PATCH_FILE"))
       self.ApplyPatch(self.Config("TEMPORARY_PATCH_FILE"))
     if self._options.patch:
       self.ApplyPatch(self._options.patch)
 
-
-class PrepareVersion(Step):
-  MESSAGE = "Prepare version file."
-
-  def RunStep(self):
-    # This is used to calculate the patch level increment.
-    self.ReadAndPersistVersion()
-
-
-class IncrementVersion(Step):
-  MESSAGE = "Increment version number."
-
-  def RunStep(self):
-    new_patch = str(int(self["patch"]) + 1)
-    if self.Confirm("Automatically increment V8_PATCH_LEVEL? (Saying 'n' will "
-                    "fire up your EDITOR on %s so you can make arbitrary "
-                    "changes. When you're done, save the file and exit your "
-                    "EDITOR.)" % VERSION_FILE):
-      text = FileToText(os.path.join(self.default_cwd, VERSION_FILE))
-      text = MSub(r"(?<=#define V8_PATCH_LEVEL)(?P<space>\s+)\d*$",
-                  r"\g<space>%s" % new_patch,
-                  text)
-      TextToFile(text, os.path.join(self.default_cwd, VERSION_FILE))
-    else:
-      self.Editor(os.path.join(self.default_cwd, VERSION_FILE))
-    self.ReadAndPersistVersion("new_")
-    self["version"] = "%s.%s.%s.%s" % (self["new_major"],
-                                       self["new_minor"],
-                                       self["new_build"],
-                                       self["new_patch"])
-
-
 class CommitLocal(Step):
   MESSAGE = "Commit to local branch."
 
   def RunStep(self):
     # Add a commit message title.
-    self["commit_title"] = "Version %s (cherry-pick)" % self["version"]
     self["new_commit_msg"] = "%s\n\n%s" % (self["commit_title"],
                                            self["new_commit_msg"])
     TextToFile(self["new_commit_msg"], self.Config("COMMITMSG_FILE"))
     self.GitCommit(file_name=self.Config("COMMITMSG_FILE"))
 
+class AddInformationalComment(Step):
+  MESSAGE = 'Show additional information.'
+
+  def RunStep(self):
+    message = ("IMPORTANT: This script will no longer automatically "

[Michael Achenbach, 2016/07/22 06:45:56]

I like it. I'd substitute IMPORTANT with NOTE or something similar that's less
important. I've the feeling that the word important creates a notion of an
action that needs to be taken.

[Michael Hablich, 2016/07/22 08:55:59]

Done.

+     "update include/v8-version.h "
+     "and create a tag. This is done automatically by the autotag bot. "
+     "Please call the merge_to_branch.py with --help for more information.")
+
+    self.GitCLAddComment(message)
 
 class CommitRepository(Step):
   MESSAGE = "Commit to the repository."
 
   def RunStep(self):
     self.GitCheckout(self.Config("BRANCHNAME"))
     self.WaitForLGTM()

[Michael Achenbach, 2016/07/22 06:45:56]

How about we change the default behavior to end this script after upload? With a
note to check the CQ after lgtm and that no further action is required?

We could keep the old behavior behind a flag.

[Michael Hablich, 2016/07/22 08:55:59]

Good idea for the next iteration. The most important thing is deprecating the
versioning for now. Afterwards we can make all the other little changes
incrementally.

     self.GitPresubmit()
     self.vc.CLLand()
 
-
-class TagRevision(Step):
-  MESSAGE = "Create the tag."
-
-  def RunStep(self):
-    print "Creating tag %s" % self["version"]
-    self.vc.Tag(self["version"],
-                self.vc.RemoteBranch(self["merge_to_branch"]),
-                self["commit_title"])
-
-
 class CleanUp(Step):
   MESSAGE = "Cleanup."
 
   def RunStep(self):
     self.CommonCleanup()
     print "*** SUMMARY ***"
-    print "version: %s" % self["version"]
     print "branch: %s" % self["merge_to_branch"]
     if self["revision_list"]:
       print "patches: %s" % self["revision_list"]
 
 
 class MergeToBranch(ScriptsBase):
   def _Description(self):
     return ("Performs the necessary steps to merge revisions from "
-            "master to other branches, including candidates.")
+            "master to release branches like 4.5. This script does not "
+            "version the commit. See http://goo.gl/9ke2Vw for more "
+            "information.")
 
   def _PrepareOptions(self, parser):
     group = parser.add_mutually_exclusive_group(required=True)
     group.add_argument("--branch", help="The branch to merge to.")
     parser.add_argument("revisions", nargs="*",
                         help="The revisions to merge.")
     parser.add_argument("-f", "--force",
                         help="Delete sentinel file.",
                         default=False, action="store_true")
     parser.add_argument("-m", "--message",
                         help="A commit message for the patch.")
     parser.add_argument("-p", "--patch",
                         help="A patch file to apply as part of the merge.")
 
   def _ProcessOptions(self, options):
     if len(options.revisions) < 1:
       if not options.patch:
         print "Either a patch file or revision numbers must be specified"
         return False
       if not options.message:
         print "You must specify a merge comment if no patches are specified"
         return False
     options.bypass_upload_hooks = True
     # CC ulan to make sure that fixes are merged to Google3.
     options.cc = "ulan@chromium.org"
 
+    if len(options.branch.split('.')) > 2:
+      print ("This script does not support merging to roll branches. "
+             "Please use tools/release/roll_merge.py for this use case.")
+      return False
+
     # Make sure to use git hashes in the new workflows.
     for revision in options.revisions:
       if (IsSvnNumber(revision) or
           (revision[0:1] == "r" and IsSvnNumber(revision[1:]))):
         print "Please provide full git hashes of the patches to merge."
         print "Got: %s" % revision
         return False
     return True
 
   def _Config(self):
     return {
       "BRANCHNAME": "prepare-merge",
       "PERSISTFILE_BASENAME": "/tmp/v8-merge-to-branch-tempfile",
       "ALREADY_MERGING_SENTINEL_FILE":
           "/tmp/v8-merge-to-branch-tempfile-already-merging",
       "TEMPORARY_PATCH_FILE": "/tmp/v8-prepare-merge-tempfile-temporary-patch",
       "COMMITMSG_FILE": "/tmp/v8-prepare-merge-tempfile-commitmsg",
     }
 
   def _Steps(self):
     return [
       Preparation,
       CreateBranch,
       SearchArchitecturePorts,
       CreateCommitMessage,
       ApplyPatches,
-      PrepareVersion,
-      IncrementVersion,
       CommitLocal,
       UploadStep,
+      AddInformationalComment,
       CommitRepository,
-      TagRevision,
       CleanUp,
     ]
 
 
 if __name__ == "__main__":  # pragma: no cover
   sys.exit(MergeToBranch().Run())