Mirrors/overte-lubosz
3
0
Fork 0
mirror of https://github.com/lubosz/overte.git synced 2025-04-05 14:05:02 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Switch to GitPython

Browse source
This commit is contained in:
Clement 2018-11-21 18:26:31 -08:00
parent d86fcbe5c6
commit cc2546d7f2
5 changed files with 80 additions and 394 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
tools/scripts/Readme.md Normal file
View file

@ -0,0 +1,13 @@
## Setup
Run the following command to install all the dependencies:
```pip install -r requirements.txt```
## Usage
```
./rc-branches.py check v0.76.1
./rc-branches.py create v0.77.0
```

156
tools/scripts/rc-branches.py
View file

@ -7,7 +7,7 @@ import sys
import argparse
from utils import git
from git import Repo
FORMAT = '[%(levelname)s] %(message)s'
logging.basicConfig(format=FORMAT, level=logging.DEBUG)
@ -58,129 +58,102 @@ def checkVersionBranches(version):
"""Check that the branches for a given version were created properly."""
parser = VersionParser(version)
major = parser.major
minor = parser.minor
patch = parser.patch
previous_version = parser.previous_version
version = parser.version
is_major_release = parser.is_major_release
is_minor_release = parser.is_minor_release
is_patch_release = parser.is_patch_release
remote_previous_rc_branch = parser.remote_previous_rc_branch
remote_base_branch = parser.remote_base_branch
remote_rc_branch = parser.remote_rc_branch
repo = git.Repository(git.Repository.get_base_directory())
repo = Repo(os.getcwd(), search_parent_directories=True)
assert not repo.bare
# Verify the branches' existance
if not repo.does_branch_exist(remote_previous_rc_branch):
raise ValueError("Previous RC branch not found: {}".format(remote_previous_rc_branch))
if parser.remote_previous_rc_branch not in repo.refs:
raise ValueError("Previous RC branch not found: {}".format(parser.remote_previous_rc_branch))
if not repo.does_branch_exist(remote_base_branch):
raise ValueError("Base branch not found: {}".format(remote_base_branch))
if parser.remote_base_branch not in repo.refs:
raise ValueError("Base branch not found: {}".format(parser.remote_base_branch))
if not repo.does_branch_exist(remote_rc_branch):
raise ValueError("RC branch not found: {}".format(remote_rc_branch))
if parser.remote_rc_branch not in repo.refs:
raise ValueError("RC branch not found: {}".format(parser.remote_rc_branch))
# Figure out SHA for each of the branches
previous_rc_commit = repo.git_rev_parse([remote_previous_rc_branch])
base_commit = repo.git_rev_parse([remote_base_branch])
rc_commit = repo.git_rev_parse([remote_rc_branch])
previous_rc = repo.refs[parser.remote_previous_rc_branch]
current_rc_base = repo.refs[parser.remote_base_branch]
current_rc = repo.refs[parser.remote_rc_branch]
master = repo.refs[remote_master_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(remote_base_branch, remote_rc_branch))
if not repo.is_ancestor(current_rc_base, current_rc):
raise ValueError("{} is not an ancesctor of {}".format(current_rc_base, current_rc))
# 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(remote_previous_rc_branch, remote_rc_branch))
merge_base = repo.merge_base(previous_rc, current_rc)
if current_rc_base.commit not in merge_base:
raise ValueError("Base branch is not the merge base between {} and {}".format(previous_rc, current_rc))
# 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 {} has not been released.".format(version, version))
if parser.is_patch_release:
if parser.previous_version not in repo.tags:
logging.warning("The tag {0} does not exist, which suggests {0} has not been released.".format(parser.previous_version))
if base_commit != previous_rc_commit:
if current_rc_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));
logging.warning("Type \"git diff {}..{}\" to see the commit list".format(current_rc_base, previous_rc));
# 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(remote_base_branch, remote_rc_branch))
previous_rc_base_commit = repo.merge_base(previous_rc, master)
if repo.is_ancestor(current_rc_base, previous_rc_base_commit):
raise ValueError("{} is older than {}".format(current_rc_base, previous_rc))
print("[SUCCESS] Checked {}".format(version))
print("[SUCCESS] Checked {}".format(parser.version))
def createVersionBranches(version):
"""Create the branches for a given version."""
parser = VersionParser(version)
major = parser.major
minor = parser.minor
patch = parser.patch
previous_version = parser.previous_version
version = parser.version
is_major_release = parser.is_major_release
is_minor_release = parser.is_minor_release
is_patch_release = parser.is_patch_release
previous_rc_branch = parser.previous_rc_branch
base_branch = parser.base_branch
rc_branch = parser.rc_branch
remote_previous_rc_branch = parser.remote_previous_rc_branch
remote_base_branch = parser.remote_base_branch
remote_rc_branch = parser.remote_rc_branch
repo = git.Repository(git.Repository.get_base_directory())
repo = Repo(os.getcwd(), search_parent_directories=True)
assert not repo.bare
# Validate the user is on a local branch that has the right merge base
if repo.is_detached():
if repo.head.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():
if repo.is_dirty():
raise ValueError("Your working tree has pending changes. You must have a clean working tree before proceeding.")
# Make sure the remote is up to date
repo.git_fetch([remote_name])
remote = repo.remotes[remote_name]
remote.fetch(prune=True)
# 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))
if parser.remote_previous_rc_branch not in repo.refs:
raise ValueError("Previous RC branch not found: {}".format(parser.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 parser.remote_base_branch in repo.refs:
raise ValueError("Base branch already exists: {}".format(parser.remote_base_branch))
if repo.does_branch_exist(remote_rc_branch):
raise ValueError("RC branch already exists: {}".format(remote_rc_branch))
if parser.remote_rc_branch in repo.refs:
raise ValueError("RC branch already exists: {}".format(parser.remote_rc_branch))
if repo.does_branch_exist(base_branch):
raise ValueError("Base branch already exists locally: {}".format(base_branch))
if parser.base_branch in repo.refs:
raise ValueError("Base branch already exists locally: {}".format(parser.base_branch))
if repo.does_branch_exist(rc_branch):
raise ValueError("RC branch already exists locally: {}".format(rc_branch))
if parser.rc_branch in repo.refs:
raise ValueError("RC branch already exists locally: {}".format(parser.rc_branch))
# Save current branch name
current_branch_name = repo.get_branch_name()
current_branch_name = repo.active_branch
# Create the RC branches
if is_patch_release:
if parser.is_patch_release:
# Check tag exists, if it doesn't, print warning and ask for comfirmation
if not repo.does_tag_exist(previous_version):
logging.warning("The tag {} does not exist, which suggests {} has not yet been released.".format(previous_version, previous_version))
logging.warning("Creating the branches now means that {} will diverge from {} if anything is merged into {}.".format(version, previous_version, previous_version))
if parser.previous_version not in repo.tags:
logging.warning("The tag {0} does not exist, which suggests {0} has not yet been released.".format(parser.previous_version))
logging.warning("Creating the branches now means that {0} will diverge from {1} if anything is merged into {1}.".format(parser.version, parser.previous_version))
logging.warning("This is not recommended 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()
answer = input("Are you sure you want to do this? [y/n] ").strip().lower()
askCount += 1
validAnswer = answer == "y" or answer == "n"
@ -193,23 +166,26 @@ def createVersionBranches(version):
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)
previous_rc = repo.refs[parser.remote_previous_rc_branch]
repo.create_head(parser.base_branch, previous_rc)
remote.push("{0}:{0}".format(parser.base_branch))
repo.create_head(parser.rc_branch, previous_rc)
remote.push("{0}:{0}".format(parser.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)
previous_rc = repo.refs[parser.remote_previous_rc_branch]
master = repo.refs[remote_master_branch]
merge_base = repo.merge_base(previous_rc, master)
repo.git_checkout([current_branch_name])
repo.create_head(parser.base_branch, merge_base[0])
remote.push("{0}:{0}".format(parser.base_branch))
repo.create_head(parser.rc_branch, master)
remote.push("{0}:{0}".format(parser.rc_branch))
print("[SUCCESS] Created {} and {}".format(base_branch, rc_branch))
print("[SUCCESS] Created {} and {}".format(parser.base_branch, parser.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))
if is_patch_release:
print("[SUCCESS] https://github.com/highfidelity/hifi/compare/{}...{}".format(parser.base_branch, parser.rc_branch))
if parser.is_patch_release:
print("[SUCCESS] NOTE: You will have to wait for the first fix to be merged into the RC branch to be able to create the PR")
def main():
@ -234,7 +210,7 @@ def main():
createVersionBranches(args.version)
else:
parser.print_help()
except Exception as ex:
except ValueError as ex:
logging.error(ex)
sys.exit(1)

1
tools/scripts/requirements.txt Normal file
View file

@ -0,0 +1 @@
GitPython

1
tools/scripts/utils/__init__.py
View file

@ -1 +0,0 @@
"""Empty."""

303
tools/scripts/utils/git.py
View file

@ -1,303 +0,0 @@
"""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)