From 27ecaeb1b6b18127c9a982b5ae5d803c47223457 Mon Sep 17 00:00:00 2001 From: Clement Date: Thu, 15 Nov 2018 16:06:47 -0800 Subject: [PATCH] Add RC branch creation script --- tools/scripts/rc-branches.py | 241 +++++++++++++++++++++++++ tools/scripts/utils/__init__.py | 1 + tools/scripts/utils/git.py | 303 ++++++++++++++++++++++++++++++++ 3 files changed, 545 insertions(+) create mode 100755 tools/scripts/rc-branches.py create mode 100644 tools/scripts/utils/__init__.py create mode 100644 tools/scripts/utils/git.py diff --git a/tools/scripts/rc-branches.py b/tools/scripts/rc-branches.py new file mode 100755 index 0000000000..a9e1c8c304 --- /dev/null +++ b/tools/scripts/rc-branches.py @@ -0,0 +1,241 @@ +#!/usr/bin/env python + +import logging +import os +import re +import sys + +from optparse import OptionParser + +from utils import git + +FORMAT = '[%(levelname)s] %(message)s' +logging.basicConfig(format=FORMAT, level=logging.DEBUG) + +remote_name = "upstream" +remote_master_branch = "{}/master".format(remote_name) + +def checkVersionBranches(version): + """Check the branches for a given version were created properly.""" + + repo = git.Repository(git.Repository.get_base_directory()) + + # Validate that user passed a valid version + VERSION_RE = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)$") + match = VERSION_RE.match(version) + if not match: + raise ValueError("Invalid version (should be X.Y.Z)") + + # Parse the version component and build proper version strings + major = int(match.group(1)) + minor = int(match.group(2)) + patch = int(match.group(3)) + version = "v{}.{}.{}".format(major, minor, patch) # clean up version + + is_major_release = False + is_minor_release = False + is_patch_release = False + if patch != 0: + is_patch_release = True + previous_version = "v{}.{}.{}".format(major, minor, patch - 1) + elif minor != 0: + is_minor_release = True + previous_version = "v{}.{}.{}".format(major, minor - 1, 0) + else: + is_major_release = True + raise ValueError("Major releases not yet supported") + + # Build the branch names + previous_rc_branch = "{}/{}-rc".format(remote_name, previous_version) + base_branch = "{}/{}-rc-base".format(remote_name, version) + rc_branch = "{}/{}-rc".format(remote_name, version) + + # Verify the branches' existance + if not repo.does_branch_exist(previous_rc_branch): + raise ValueError("Previous RC branch not found: {}".format(previous_rc_branch)) + + if not repo.does_branch_exist(base_branch): + raise ValueError("Base branch not found: {}".format(base_branch)) + + if not repo.does_branch_exist(rc_branch): + raise ValueError("RC branch not found: {}".format(rc_branch)) + + # Figure out SHA for each of the branches + previous_rc_commit = repo.git_rev_parse([previous_rc_branch]) + base_commit = repo.git_rev_parse([base_branch]) + rc_commit = repo.git_rev_parse([rc_branch]) + + # Check the base branch is an ancestor of the rc branch + if not repo.is_ancestor(base_commit, rc_commit): + raise ValueError("{} is not an ancesctor of {}".format(base_branch, rc_branch)) + + # Check that the base branch is the merge base of the previous and current RCs + merge_base = repo.get_merge_base(previous_rc_commit, rc_commit) + if base_commit != merge_base: + raise ValueError("Base branch is not the merge base between {} and {}".format(previous_rc_branch, rc_branch)) + + # For patch releases, warn if the base commit is not the previous RC commit + if is_patch_release: + if not repo.does_tag_exist(version): + logging.warning("The tag {} does not exist, which suggests {} hasn't yet been cut.".format(version, version)) + + if base_commit != previous_rc_commit: + logging.warning("Previous version has commits not in this patch"); + logging.warning("Type \"git diff {}..{}\" to see the commit list".format(base_commit, previous_rc_commit)); + + # Check base branch is part of the previous RC + previous_rc_base_commit = repo.get_merge_base(previous_rc_commit, remote_master_branch) + if repo.is_ancestor(base_commit, previous_rc_base_commit): + raise ValueError("{} is older than {}".format(base_branch, rc_branch)) + + print("[SUCCESS] Checked {}".format(version)) + +def createVersionBranches(version): + """Create the branches for a given version.""" + + repo = git.Repository(git.Repository.get_base_directory()) + + # Validate the user is on a local branch that has the right merge base + if repo.is_detached(): + raise ValueError("You must not run this script in a detached HEAD state") + + # Validate the user has no pending changes + if repo.is_working_tree_dirty(): + raise ValueError("Your working tree has pending changes. You must have a clean working tree before proceeding.") + + # Validate that user passed a valid version + VERSION_RE = re.compile(r"^v?(\d+)\.(\d+)\.(\d+)$") + match = VERSION_RE.match(version) + if not match: + raise ValueError("Invalid version (should be X.Y.Z)") + + # Parse the version component and build proper version strings + major = int(match.group(1)) + minor = int(match.group(2)) + patch = int(match.group(3)) + version = "v{}.{}.{}".format(major, minor, patch) # clean up version + + is_major_release = False + is_minor_release = False + is_patch_release = False + if patch != 0: + is_patch_release = True + previous_version = "v{}.{}.{}".format(major, minor, patch - 1) + elif minor != 0: + is_minor_release = True + previous_version = "v{}.{}.{}".format(major, minor - 1, 0) + else: + is_major_release = True + raise ValueError("Major releases not yet supported") + + # Build the branch names + previous_rc_branch = "{}-rc".format(previous_version) + base_branch = "{}-rc-base".format(version) + rc_branch = "{}-rc".format(version) + remote_previous_rc_branch = "{}/{}".format(remote_name, previous_rc_branch) + remote_base_branch = "{}/{}".format(remote_name, base_branch) + remote_rc_branch = "{}/{}".format(remote_name, rc_branch) + + # Make sure the remote is up to date + repo.git_fetch([remote_name]) + + # Verify the previous RC branch exists + if not repo.does_branch_exist(remote_previous_rc_branch): + raise ValueError("Previous RC branch not found: {}".format(remote_previous_rc_branch)) + + # Verify the branches don't already exist + if repo.does_branch_exist(remote_base_branch): + raise ValueError("Base branch already exists: {}".format(remote_base_branch)) + + if repo.does_branch_exist(remote_rc_branch): + raise ValueError("RC branch already exists: {}".format(remote_rc_branch)) + + if repo.does_branch_exist(base_branch): + raise ValueError("Base branch already exists locally: {}".format(base_branch)) + + if repo.does_branch_exist(rc_branch): + raise ValueError("RC branch already exists locally: {}".format(rc_branch)) + + # Save current branch name + current_branch_name = repo.get_branch_name() + + # Create the RC branches + if is_patch_release: + + # Check tag exists, if it doesn't, print warning and ask for comfirmation + if not repo.does_tag_exist(version): + logging.warning("The tag {} does not exist, which suggests {} hasn't yet been cut.".format(version, version)) + logging.warning("Creating the branches now means that they will diverge from {} if anything is merge into it.".format(previous_version)) + logging.warning("This is not recommanded unless necessary.") + + validAnswer = False + askCount = 0 + while not validAnswer and askCount < 3: + answer = input("Are you sure you want to do this? [y/n]").strip().lower() + askCount += 1 + validAnswer = answer == "y" or answer == "n" + + if not validAnswer: + raise ValueError("Did not understand response") + + if answer == "n": + print("Aborting") + return + else: + print("Creating branches") + + repo.git_checkout(["-b", base_branch, remote_previous_rc_branch]) + repo.push_to_remote_branch(remote_name, base_branch) + repo.git_checkout(["-b", rc_branch, remote_previous_rc_branch]) + repo.push_to_remote_branch(remote_name, rc_branch) + else: + merge_base = repo.get_merge_base(remote_previous_rc_branch, remote_master_branch) + repo.git_checkout(["-b", base_branch, merge_base]) + repo.push_to_remote_branch(remote_name, base_branch) + repo.git_checkout(["-b", rc_branch, remote_master_branch]) + repo.push_to_remote_branch(remote_name, rc_branch) + + repo.git_checkout([current_branch_name]) + + print("[SUCCESS] Created {} and {}".format(base_branch, rc_branch)) + print("[SUCCESS] You can make the PR from the following webpage:") + print("[SUCCESS] https://github.com/highfidelity/hifi/compare/{}...{}".format(base_branch, rc_branch)) + +def usage(): + """Print usage.""" + print("rc-branches.py supports the following commands:") + print("\ncheck ") + print(" - version to check of the form \"X.Y.Z\"") + print("\ncreate ") + print(" - version to create branches for of the form \"X.Y.Z\"") + +def main(): + """Execute Main entry point.""" + global remote_name + + parser = OptionParser() + parser.add_option("-r", "--remote", type="string", dest="remote_name", default=remote_name) + (options, args) = parser.parse_args(args=sys.argv) + + remote_name = options.remote_name + + if len(args) < 3: + usage() + return + + command = args[1] + version = args[2] + + try: + if command == "check": + checkVersionBranches(version) + elif command == "create": + createVersionBranches(version) + else: + usage() + except Exception as ex: + logging.error(ex) + sys.exit(1) + +if __name__ == "__main__": + main() diff --git a/tools/scripts/utils/__init__.py b/tools/scripts/utils/__init__.py new file mode 100644 index 0000000000..4b7a2bb941 --- /dev/null +++ b/tools/scripts/utils/__init__.py @@ -0,0 +1 @@ +"""Empty.""" diff --git a/tools/scripts/utils/git.py b/tools/scripts/utils/git.py new file mode 100644 index 0000000000..156d2240c3 --- /dev/null +++ b/tools/scripts/utils/git.py @@ -0,0 +1,303 @@ +"""Module to run git commands on a repository.""" + +# Copied from https://github.com/mongodb/mongo under Apache 2.0 +# Modified by Clement Brisset on 11/14/18. + +import logging +import os +import sys + +# The subprocess32 module resolves the thread-safety issues of the subprocess module in Python 2.x +# when the _posixsubprocess C extension module is also available. Additionally, the _posixsubprocess +# C extension module avoids triggering invalid free() calls on Python's internal data structure for +# thread-local storage by skipping the PyOS_AfterFork() call when the 'preexec_fn' parameter isn't +# specified to subprocess.Popen(). See SERVER-22219 for more details. +# +# The subprocess32 module is untested on Windows and thus isn't recommended for use, even when it's +# installed. See https://github.com/google/python-subprocess32/blob/3.2.7/README.md#usage. +if os.name == "posix" and sys.version_info[0] == 2: + try: + import subprocess32 as subprocess + except ImportError: + import warnings + warnings.warn(("Falling back to using the subprocess module because subprocess32 isn't" + " available. When using the subprocess module, a child process may trigger" + " an invalid free(). See SERVER-22219 for more details."), RuntimeWarning) + import subprocess # type: ignore +else: + import subprocess + +LOGGER = logging.getLogger(__name__) + + +class Repository(object): # pylint: disable=too-many-public-methods + """Represent a local git repository.""" + + def __init__(self, directory): + """Initialize Repository.""" + self.directory = directory + + def git_add(self, args): + """Run a git add command.""" + return self._callgito("add", args) + + def git_cat_file(self, args): + """Run a git cat-file command.""" + return self._callgito("cat-file", args) + + def git_checkout(self, args): + """Run a git checkout command.""" + return self._callgito("checkout", args) + + def git_commit(self, args): + """Run a git commit command.""" + return self._callgito("commit", args) + + def git_diff(self, args): + """Run a git diff command.""" + return self._callgito("diff", args) + + def git_log(self, args): + """Run a git log command.""" + return self._callgito("log", args) + + def git_push(self, args): + """Run a git push command.""" + return self._callgito("push", args) + + def git_fetch(self, args): + """Run a git fetch command.""" + return self._callgito("fetch", args) + + def git_ls_files(self, args): + """Run a git ls-files command and return the result as a str.""" + return self._callgito("ls-files", args) + + def git_rebase(self, args): + """Run a git rebase command.""" + return self._callgito("rebase", args) + + def git_reset(self, args): + """Run a git reset command.""" + return self._callgito("reset", args) + + def git_rev_list(self, args): + """Run a git rev-list command.""" + return self._callgito("rev-list", args) + + def git_rev_parse(self, args): + """Run a git rev-parse command.""" + return self._callgito("rev-parse", args).rstrip() + + def git_rm(self, args): + """Run a git rm command.""" + return self._callgito("rm", args) + + def git_show(self, args): + """Run a git show command.""" + return self._callgito("show", args) + + def get_origin_url(self): + """Return the URL of the origin repository.""" + return self._callgito("config", ["--local", "--get", "remote.origin.url"]).rstrip() + + def get_branch_name(self): + """ + Get the current branch name, short form. + + This returns "master", not "refs/head/master". + Raises a GitException if the current branch is detached. + """ + branch = self.git_rev_parse(["--abbrev-ref", "HEAD"]) + if branch == "HEAD": + raise GitException("Branch is currently detached") + return branch + + def get_current_revision(self): + """Retrieve the current revision of the repository.""" + return self.git_rev_parse(["HEAD"]).rstrip() + + def configure(self, parameter, value): + """Set a local configuration parameter.""" + return self._callgito("config", ["--local", parameter, value]) + + def is_detached(self): + """Return True if the current working tree in a detached HEAD state.""" + # symbolic-ref returns 1 if the repo is in a detached HEAD state + return self._callgit("symbolic-ref", ["--quiet", "HEAD"]) == 1 + + def is_ancestor(self, parent_revision, child_revision): + """Return True if the specified parent hash an ancestor of child hash.""" + # If the common point between parent_revision and child_revision is + # parent_revision, then parent_revision is an ancestor of child_revision. + merge_base = self._callgito("merge-base", [parent_revision, child_revision]).rstrip() + return parent_revision == merge_base + + def is_commit(self, revision): + """Return True if the specified hash is a valid git commit.""" + # cat-file -e returns 0 if it is a valid hash + return not self._callgit("cat-file", ["-e", "{0}^{{commit}}".format(revision)]) + + def is_working_tree_dirty(self): + """Return True if the current working tree has changes.""" + # diff returns 1 if the working tree has local changes + return self._callgit("diff", ["--quiet"]) == 1 + + def does_branch_exist(self, branch): + """Return True if the branch exists.""" + # rev-parse returns 0 if the branch exists + return not self._callgit("rev-parse", ["--verify", "--quiet", branch]) + + def does_tag_exist(self, tag): + """Return True if the tag exists.""" + # rev-parse returns 0 if the tag exists + return not self._callgit("rev-parse", ["--verify", "--quiet", tag]) + + def get_merge_base(self, commit1, commit2 = "HEAD"): + """Get the merge base between 'commit' and HEAD.""" + return self._callgito("merge-base", [commit1, commit2]).rstrip() + + def commit_with_message(self, message): + """Commit the staged changes with the given message.""" + return self.git_commit(["--message", message]) + + def push_to_remote_branch(self, remote, remote_branch): + """Push the current branch to the specified remote repository and branch.""" + refspec = "{}:{}".format(self.get_branch_name(), remote_branch) + return self.git_push([remote, refspec]) + + def fetch_remote_branch(self, repository, branch): + """Fetch the changes from a remote branch.""" + return self.git_fetch([repository, branch]) + + def rebase_from_upstream(self, upstream, ignore_date=False): + """Rebase the repository on an upstream reference. + + If 'ignore_date' is True, the '--ignore-date' option is passed to git. + """ + args = [upstream] + if ignore_date: + args.append("--ignore-date") + return self.git_rebase(args) + + @staticmethod + def clone(url, directory, branch=None, depth=None): + """Clone the repository designed by 'url' into 'directory'. + + Return a Repository instance. + """ + params = ["git", "clone"] + if branch: + params += ["--branch", branch] + if depth: + params += ["--depth", depth] + params += [url, directory] + result = Repository._run_process("clone", params) + result.check_returncode() + return Repository(directory) + + @staticmethod + def get_base_directory(directory=None): + """Return the base directory of the repository the given directory belongs to. + + If no directory is specified, then the current working directory is used. + """ + if directory is not None: + params = ["git", "-C", directory] + else: + params = ["git"] + params.extend(["rev-parse", "--show-toplevel"]) + result = Repository._run_process("rev-parse", params) + result.check_returncode() + return os.path.normpath(result.stdout.rstrip()) + + @staticmethod + def current_repository(): + """Return the Repository the current working directory belongs to.""" + return Repository(Repository.get_base_directory()) + + def _callgito(self, cmd, args): + """Call git for this repository, and return the captured output.""" + result = self._run_cmd(cmd, args) + result.check_returncode() + return result.stdout + + def _callgit(self, cmd, args, raise_exception=False): + """ + Call git for this repository without capturing output. + + This is designed to be used when git returns non-zero exit codes. + """ + result = self._run_cmd(cmd, args) + if raise_exception: + result.check_returncode() + return result.returncode + + def _run_cmd(self, cmd, args): + """Run the git command and return a GitCommandResult instance.""" + + LOGGER.debug("Running: git {} {}".format(cmd, " ".join(args))) + params = ["git", cmd] + args + return self._run_process(cmd, params, cwd=self.directory) + + @staticmethod + def _run_process(cmd, params, cwd=None): + process = subprocess.Popen(params, text=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=cwd) + (stdout, stderr) = process.communicate() + if process.returncode: + if stdout: + LOGGER.error("Output of '%s': %s", " ".join(params), stdout.rstrip()) + if stderr: + LOGGER.error("Error output of '%s': %s", " ".join(params), stderr.rstrip()) + return GitCommandResult(cmd, params, process.returncode, stdout=stdout, stderr=stderr) + + +class GitException(Exception): + """Custom Exception for the git module. + + Args: + message: the exception message. + returncode: the return code of the failed git command, if any. + cmd: the git subcommand that was run, if any. + process_args: a list containing the git command and arguments (includes 'git' as its first + element) that were run, if any. + stderr: the error output of the git command. + """ + + def __init__( # pylint: disable=too-many-arguments + self, message, returncode=None, cmd=None, process_args=None, stdout=None, stderr=None): + """Initialize GitException.""" + Exception.__init__(self, message) + self.returncode = returncode + self.cmd = cmd + self.process_args = process_args + self.stdout = stdout + self.stderr = stderr + + +class GitCommandResult(object): + """The result of running git subcommand. + + Args: + cmd: the git subcommand that was executed (e.g. 'clone', 'diff'). + process_args: the full list of process arguments, starting with the 'git' command. + returncode: the return code. + stdout: the output of the command. + stderr: the error output of the command. + """ + + def __init__( # pylint: disable=too-many-arguments + self, cmd, process_args, returncode, stdout=None, stderr=None): + """Initialize GitCommandResult.""" + self.cmd = cmd + self.process_args = process_args + self.returncode = returncode + self.stdout = stdout + self.stderr = stderr + + def check_returncode(self): + """Raise GitException if the exit code is non-zero.""" + if self.returncode: + raise GitException("Command '{0}' failed with code '{1}'".format( + " ".join(self.process_args), self.returncode), self.returncode, self.cmd, + self.process_args, self.stdout, self.stderr)