--- /dev/null
+#!/usr/bin/env python
+from __future__ import print_function
+
+COPYRIGHT = """\
+Copyright (C) 2011-2012 OpenStack LLC.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied.
+
+See the License for the specific language governing permissions and
+limitations under the License."""
+
+import datetime
+import json
+import os
+import re
+import shlex
+import subprocess
+import sys
+import time
+
+if sys.version < '3':
+ import ConfigParser
+ import urllib
+ import urlparse
+ urlopen = urllib.urlopen
+ urlparse = urlparse.urlparse
+ do_input = raw_input
+else:
+ import configparser as ConfigParser
+ import urllib.parse
+ import urllib.request
+ urlopen = urllib.request.urlopen
+ urlparse = urllib.parse.urlparse
+ do_input = input
+
+from distutils import version as du_version
+
+version = "1.22"
+
+VERBOSE = False
+UPDATE = False
+CONFIGDIR = os.path.expanduser("~/.config/git-review")
+GLOBAL_CONFIG = "/etc/git-review/git-review.conf"
+USER_CONFIG = os.path.join(CONFIGDIR, "git-review.conf")
+PYPI_URL = "http://pypi.python.org/pypi/git-review/json"
+PYPI_CACHE_TIME = 60 * 60 * 24 # 24 hours
+DEFAULTS = dict(hostname='gerrit.lud.stericsson.com', port='29418', project=False,
+ defaultbranch='master', defaultremote="gerrit",
+ defaultrebase="0")
+
+_branch_name = None
+_has_color = None
+_no_color_support = False
+
+
+class colors:
+ yellow = '\033[33m'
+ green = '\033[92m'
+ reset = '\033[0m'
+
+
+class GitReviewException(Exception):
+ pass
+
+
+class CommandFailed(GitReviewException):
+
+ def __init__(self, *args):
+ Exception.__init__(self, *args)
+ (self.rc, self.output, self.argv, self.envp) = args
+ self.quickmsg = dict([
+ ("argv", " ".join(self.argv)),
+ ("rc", self.rc),
+ ("output", self.output)])
+
+ def __str__(self):
+ return self.__doc__ + """
+The following command failed with exit code %(rc)d
+ "%(argv)s"
+-----------------------
+%(output)s
+-----------------------""" % self.quickmsg
+
+
+class ChangeSetException(GitReviewException):
+
+ def __init__(self, e):
+ GitReviewException.__init__(self)
+ self.e = str(e)
+
+ def __str__(self):
+ return self.__doc__ % self.e
+
+
+def parse_review_number(review):
+ parts = review.split(',')
+ if len(parts) < 2:
+ parts.append(None)
+ return parts
+
+
+def build_review_number(review, patchset):
+ if patchset is not None:
+ return '%s,%s' % (review, patchset)
+ return review
+
+
+def run_command_status(*argv, **env):
+ if VERBOSE:
+ print(datetime.datetime.now(), "Running:", " ".join(argv))
+ if len(argv) == 1:
+ argv = shlex.split(str(argv[0]))
+ newenv = os.environ
+ newenv.update(env)
+ p = subprocess.Popen(argv, stdout=subprocess.PIPE,
+ stderr=subprocess.STDOUT, env=newenv)
+ (out, nothing) = p.communicate()
+ out = out.decode('utf-8')
+ return (p.returncode, out.strip())
+
+
+def run_command(*argv, **env):
+ (rc, output) = run_command_status(*argv, **env)
+ return output
+
+
+def run_command_exc(klazz, *argv, **env):
+ """Run command *argv, on failure raise 'klazz
+
+ klass should be derived from CommandFailed
+ """
+ (rc, output) = run_command_status(*argv, **env)
+ if rc != 0:
+ raise klazz(rc, output, argv, env)
+ return output
+
+
+def update_latest_version(version_file_path):
+ """Cache the latest version of git-review for the upgrade check."""
+
+ if not os.path.exists(CONFIGDIR):
+ os.makedirs(CONFIGDIR)
+
+ if os.path.exists(version_file_path) and not UPDATE:
+ if (time.time() - os.path.getmtime(version_file_path)) < 28800:
+ return
+
+ latest_version = version
+ try:
+ latest_version = json.load(urlopen(PYPI_URL))['info']['version']
+ except Exception:
+ pass
+
+ with open(version_file_path, "w") as version_file:
+ version_file.write(latest_version)
+
+
+def latest_is_newer():
+ """Check if there is a new version of git-review."""
+
+ # Skip version check if distro package turns it off
+ if os.path.exists(GLOBAL_CONFIG):
+ config = dict(check=False)
+ configParser = ConfigParser.ConfigParser(config)
+ configParser.read(GLOBAL_CONFIG)
+ if not configParser.getboolean("updates", "check"):
+ return False
+
+ version_file_path = os.path.join(CONFIGDIR, "latest-version")
+ update_latest_version(version_file_path)
+
+ latest_version = None
+ with open(version_file_path, "r") as version_file:
+ latest_version = du_version.StrictVersion(version_file.read())
+ if latest_version > du_version.StrictVersion(version):
+ return True
+ return False
+
+
+def git_directories():
+ """Determine (absolute git work directory path, .git subdirectory path)."""
+ cmd = ("git", "rev-parse", "--show-toplevel", "--git-dir")
+ out = run_command_exc(GitDirectoriesException, *cmd)
+ try:
+ return out.split()
+ except ValueError:
+ raise GitDirectoriesException(0, out, cmd, {})
+
+
+class GitDirectoriesException(CommandFailed):
+ "Cannot determine where .git directory is."
+ EXIT_CODE = 70
+
+
+class CustomScriptException(CommandFailed):
+ """Custom script execution failed."""
+ EXIT_CODE = 71
+
+
+def run_custom_script(action):
+ """Get status and output of .git/hooks/$action-review or/and
+ ~/.config/hooks/$action-review if existing.
+ """
+ returns = []
+ script_file = "%s-review" % (action)
+ (top_dir, git_dir) = git_directories()
+ paths = [os.path.join(CONFIGDIR, "hooks", script_file),
+ os.path.join(git_dir, "hooks", script_file)]
+ for fpath in paths:
+ if os.path.isfile(fpath) and os.access(fpath, os.X_OK):
+ status, output = run_command_status(fpath)
+ returns.append((status, output, fpath))
+
+ for (status, output, path) in returns:
+ if status is not None and status != 0:
+ raise CustomScriptException(status, output, [path], {})
+ elif output and VERBOSE:
+ print("script %s output is:" % (path))
+ print(output)
+
+
+def git_config_get_value(section, option, default=None):
+ try:
+ return run_command_exc(GitConfigException,
+ "git", "config",
+ "--get",
+ "%s.%s" % (section, option)).strip()
+ except GitConfigException as exc:
+ if exc.rc == 1:
+ return default
+ raise
+
+
+class GitConfigException(CommandFailed):
+ """Git config value retrieval failed."""
+ EXIT_CODE = 128
+
+
+class CannotInstallHook(CommandFailed):
+ "Problems encountered installing commit-msg hook"
+ EXIT_CODE = 2
+
+
+def set_hooks_commit_msg(remote, target_file):
+ """Install the commit message hook if needed."""
+
+ # Create the hooks directory if it's not there already
+ hooks_dir = os.path.dirname(target_file)
+ if not os.path.isdir(hooks_dir):
+ os.mkdir(hooks_dir)
+
+ (hostname, username, port, project_name) = \
+ parse_git_show(remote, "Push")
+
+ if not os.path.exists(target_file) or UPDATE:
+ if VERBOSE:
+ print("Fetching commit hook from: scp://%s:%s" % (hostname, port))
+ if port is not None:
+ port = "-P %s" % port
+ else:
+ port = ""
+ if username is None:
+ userhost = hostname
+ else:
+ userhost = "%s@%s" % (username, hostname)
+ run_command_exc(
+ CannotInstallHook,
+ "scp", port,
+ userhost + ":hooks/commit-msg",
+ target_file)
+
+ if not os.access(target_file, os.X_OK):
+ os.chmod(target_file, os.path.stat.S_IREAD | os.path.stat.S_IEXEC)
+
+
+def test_remote(username, hostname, port, project):
+ """Tests that a possible gerrit remote works."""
+
+ if port is not None:
+ port = "-p %s" % port
+ else:
+ port = ""
+ if username is None:
+ userhost = hostname
+ else:
+ userhost = "%s@%s" % (username, hostname)
+
+ (status, ssh_output) = run_command_status(
+ "ssh", "-x", port, userhost,
+ "gerrit", "ls-projects")
+
+ if status == 0:
+ if VERBOSE:
+ print("%s@%s:%s worked." % (username, hostname, port))
+ return True
+ else:
+ if VERBOSE:
+ print("%s@%s:%s did not work." % (username, hostname, port))
+ return False
+
+
+def make_remote_url(username, hostname, port, project):
+ """Builds a gerrit remote URL."""
+ if username is None:
+ return "ssh://%s:%s/%s" % (hostname, port, project)
+ else:
+ return "ssh://%s@%s:%s/%s" % (username, hostname, port, project)
+
+
+def add_remote(hostname, port, project, remote):
+ """Adds a gerrit remote."""
+ asked_for_username = False
+
+ username = os.getenv("USERNAME")
+ if not username:
+ username = git_config_get_value("gitreview", "username")
+ if not username:
+ username = os.getenv("USER")
+ if port is None:
+ port = 29418
+
+ remote_url = make_remote_url(username, hostname, port, project)
+ if VERBOSE:
+ print("No remote set, testing %s" % remote_url)
+ if not test_remote(username, hostname, port, project):
+ print("Could not connect to gerrit.")
+ username = do_input("Enter your gerrit username: ")
+ remote_url = make_remote_url(username, hostname, port, project)
+ print("Trying again with %s" % remote_url)
+ if not test_remote(username, hostname, port, project):
+ raise Exception("Could not connect to gerrit at %s" % remote_url)
+ asked_for_username = True
+
+ print("Creating a git remote called \"%s\" that maps to:" % remote)
+ print("\t%s" % remote_url)
+ cmd = "git remote add -f %s %s" % (remote, remote_url)
+ (status, remote_output) = run_command_status(cmd)
+
+ if status != 0:
+ raise Exception("Error running %s" % cmd)
+
+ if asked_for_username:
+ print()
+ print("This repository is now set up for use with git-review.")
+ print("You can set the default username for future repositories with:")
+ print(' git config --global --add gitreview.username "%s"' % username)
+ print()
+
+
+def parse_git_show(remote, verb):
+ fetch_url = ""
+ for line in run_command("git remote show -n %s" % remote).split("\n"):
+ if line.strip().startswith("%s" % verb):
+ fetch_url = line.split()[2]
+
+ parsed_url = urlparse(fetch_url)
+ project_name = parsed_url.path.lstrip("/")
+ if project_name.endswith(".git"):
+ project_name = project_name[:-4]
+
+ hostname = parsed_url.netloc
+ username = None
+ port = parsed_url.port
+
+ if VERBOSE:
+ print("Found origin %s URL:" % verb, fetch_url)
+
+ # Workaround bug in urlparse on OSX
+ if parsed_url.scheme == "ssh" and parsed_url.path[:2] == "//":
+ hostname = parsed_url.path[2:].split("/")[0]
+
+ if "@" in hostname:
+ (username, hostname) = hostname.split("@")
+ if ":" in hostname:
+ (hostname, port) = hostname.split(":")
+
+ # Is origin an ssh location? Let's pull more info
+ if parsed_url.scheme == "ssh" and port is None:
+ port = 22
+
+ return (hostname, username, str(port), project_name)
+
+
+def check_color_support():
+ global _has_color
+ global _no_color_support
+ if _has_color is None:
+ test_command = "git log --color=never --oneline HEAD^1..HEAD"
+ (status, output) = run_command_status(test_command)
+ if status == 0:
+ _has_color = True
+ else:
+ _has_color = False
+
+ if _no_color_support:
+ _has_color = False
+
+ return _has_color
+
+
+def get_config(config_file=None):
+ """Generate the configuration map by starting with some built-in defaults
+ and then loading GLOBAL_CONFIG, USER_CONFIG, and a repository-specific
+ .gitreview file, if they exist. In case of conflict, the configuration file
+ with the narrowest scope wins.
+ """
+ config = DEFAULTS.copy()
+ for filename in (GLOBAL_CONFIG, USER_CONFIG, config_file):
+ if filename is not None and os.path.exists(filename):
+ config.update(load_config_file(filename))
+ return config
+
+
+def load_config_file(config_file):
+ """Load configuration options from a file."""
+ configParser = ConfigParser.ConfigParser()
+ configParser.read(config_file)
+ options = {
+ 'hostname': 'host',
+ 'port': 'port',
+ 'project': 'project',
+ 'defaultbranch': 'defaultbranch',
+ 'defaultremote': 'defaultremote',
+ 'defaultrebase': 'defaultrebase',
+ }
+ config = {}
+ for config_key, option_name in options.items():
+ if configParser.has_option('gerrit', option_name):
+ config[config_key] = configParser.get('gerrit', option_name)
+ return config
+
+
+def update_remote(remote):
+ cmd = "git remote update %s" % remote
+ (status, output) = run_command_status(cmd)
+ if VERBOSE:
+ print(output)
+ if status != 0:
+ print("Problem running '%s'" % cmd)
+ if not VERBOSE:
+ print(output)
+ return False
+ return True
+
+
+def check_remote(branch, remote, hostname, port, project):
+ """Check that a Gerrit Git remote repo exists, if not, set one."""
+
+ has_color = check_color_support()
+ if has_color:
+ color_never = "--color=never"
+ else:
+ color_never = ""
+
+ if remote in run_command("git remote").split("\n"):
+
+ remotes = run_command("git branch -a %s" % color_never).split("\n")
+ for current_remote in remotes:
+ if (current_remote.strip() == "remotes/%s/%s" % (remote, branch)
+ and not UPDATE):
+ return
+ # We have the remote, but aren't set up to fetch. Fix it
+ if VERBOSE:
+ print("Setting up gerrit branch tracking for better rebasing")
+ update_remote(remote)
+ return
+
+ if hostname is False or port is False or project is False:
+ # This means there was no .gitreview file
+ print("No '.gitreview' file found in this repository.")
+ print("We don't know where your gerrit is. Please manually create ")
+ print("a remote named \"%s\" and try again." % remote)
+ sys.exit(1)
+
+ # Gerrit remote not present, try to add it
+ try:
+ add_remote(hostname, port, project, remote)
+ except Exception:
+ print(sys.exc_info()[2])
+ print("We don't know where your gerrit is. Please manually create ")
+ print("a remote named \"%s\" and try again." % remote)
+ raise
+
+
+def rebase_changes(branch, remote, interactive=True):
+
+ remote_branch = "remotes/%s/%s" % (remote, branch)
+
+ if not update_remote(remote):
+ return False
+
+ if interactive:
+ cmd = "git rebase -i %s" % remote_branch
+ else:
+ cmd = "git rebase %s" % remote_branch
+
+ (status, output) = run_command_status(cmd, GIT_EDITOR='true')
+ if status != 0:
+ print("Errors running %s" % cmd)
+ if interactive:
+ print(output)
+ return False
+ return True
+
+
+def undo_rebase():
+ cmd = "git reset --hard ORIG_HEAD"
+ (status, output) = run_command_status(cmd)
+ if status != 0:
+ print("Errors running %s" % cmd)
+ print(output)
+ return False
+ return True
+
+
+def get_branch_name(target_branch):
+ global _branch_name
+ if _branch_name is not None:
+ return _branch_name
+ _branch_name = None
+ has_color = check_color_support()
+ if has_color:
+ color_never = "--color=never"
+ else:
+ color_never = ""
+ for branch in run_command("git branch %s" % color_never).split("\n"):
+ if branch.startswith('*'):
+ _branch_name = branch.split()[1].strip()
+ if _branch_name == "(no":
+ _branch_name = target_branch
+ return _branch_name
+
+
+def assert_one_change(remote, branch, yes, have_hook):
+ has_color = check_color_support()
+ if has_color:
+ color = git_config_get_value("color", "ui")
+ if color is None:
+ color = "auto"
+ else:
+ color = color.lower()
+ if (color == "" or color == "true"):
+ color = "auto"
+ elif color == "false":
+ color = "never"
+ elif color == "auto":
+ # Python is not a tty, we have to force colors
+ color = "always"
+ use_color = "--color=%s" % color
+ else:
+ use_color = ""
+ cmd = "git log %s --decorate --oneline HEAD --not remotes/%s/%s --" % (
+ use_color, remote, branch)
+ (status, output) = run_command_status(cmd)
+ if status != 0:
+ print("Had trouble running %s" % cmd)
+ print(output)
+ sys.exit(1)
+ output_lines = len(output.split("\n"))
+ if output_lines == 1 and not have_hook:
+ print("Your change was committed before the commit hook was installed")
+ print("Amending the commit to add a gerrit change id")
+ run_command("git commit --amend", GIT_EDITOR='true')
+ elif output_lines == 0:
+ print("No changes between HEAD and %s/%s." % (remote, branch))
+ print("Submitting for review would be pointless.")
+ sys.exit(1)
+ elif output_lines > 1:
+ if not yes:
+ print("You have more than one commit"
+ " that you are about to submit.")
+ print("The outstanding commits are:\n\n%s\n" % output)
+ print("Is this really what you meant to do?")
+ yes_no = do_input("Type 'yes' to confirm: ")
+ if yes_no.lower().strip() != "yes":
+ print("Aborting.")
+ print("Please rebase/squash your changes and try again")
+ sys.exit(1)
+
+
+def use_topic(why, topic):
+ """Inform the user about why a particular topic has been selected."""
+ if VERBOSE:
+ print(why % ('"%s"' % topic,))
+ return topic
+
+
+def get_topic(target_branch):
+
+ branch_name = get_branch_name(target_branch)
+
+ branch_parts = branch_name.split("/")
+ if len(branch_parts) >= 3 and branch_parts[0] == "review":
+ return use_topic("Using change number %s "
+ "for the topic of the change submitted",
+ "/".join(branch_parts[2:]))
+
+ log_output = run_command("git log HEAD^1..HEAD")
+ bug_re = r'\b([Bb]ug|[Ll][Pp])\s*[#:]?\s*(\d+)'
+
+ match = re.search(bug_re, log_output)
+ if match is not None:
+ return use_topic("Using bug number %s "
+ "for the topic of the change submitted",
+ "bug/%s" % match.group(2))
+
+ bp_re = r'\b([Bb]lue[Pp]rint|[Bb][Pp])\s*[#:]?\s*([0-9a-zA-Z-_]+)'
+ match = re.search(bp_re, log_output)
+ if match is not None:
+ return use_topic("Using blueprint number %s "
+ "for the topic of the change submitted",
+ "bp/%s" % match.group(2))
+
+ return use_topic("Using local branch name %s "
+ "for the topic of the change submitted",
+ branch_name)
+
+
+class CannotQueryOpenChangesets(CommandFailed):
+ "Cannot fetch review information from gerrit"
+ EXIT_CODE = 32
+
+
+class CannotParseOpenChangesets(ChangeSetException):
+ "Cannot parse JSON review information from gerrit"
+ EXIT_CODE = 33
+
+
+def list_reviews(remote):
+
+ (hostname, username, port, project_name) = \
+ parse_git_show(remote, "Push")
+
+ if port is not None:
+ port = "-p %s" % port
+ else:
+ port = ""
+ if username is None:
+ userhost = hostname
+ else:
+ userhost = "%s@%s" % (username, hostname)
+
+ review_info = None
+ output = run_command_exc(
+ CannotQueryOpenChangesets,
+ "ssh", "-x", port, userhost,
+ "gerrit", "query",
+ "--current-patch-set --format=JSON project:%s status:open reviewer:self" % project_name)
+
+ review_list = []
+ review_field_width = {}
+ REVIEW_FIELDS = ('number', 'currentPatchSet', 'branch', 'subject')
+ FIELDS = range(0, len(REVIEW_FIELDS))
+ if check_color_support():
+ review_field_color = (colors.yellow, colors.yellow, colors.green, "")
+ color_reset = colors.reset
+ else:
+ review_field_color = ("", "", "", "")
+ color_reset = ""
+ review_field_width = [0, 0, 0, 0]
+ review_field_format = ["%*s", "%*s", "%*s", "%*s"]
+ review_field_justify = [+1, +1, +1, -1] # -1 is justify to right
+
+ for line in output.split("\n"):
+ # Warnings from ssh wind up in this output
+ if line[0] != "{":
+ print(line)
+ continue
+ try:
+ review_info = json.loads(line)
+ except Exception:
+ if VERBOSE:
+ print(output)
+ raise(CannotParseOpenChangesets, sys.exc_info()[1])
+
+ if 'type' in review_info:
+ break
+
+ tempPS = review_info['currentPatchSet']
+ appPS = tempPS['approvals']
+ appValue = '-';
+ for appLine in appPS:
+ appBy = appLine['by']
+ appUser = appBy['username']
+ if appUser == username:
+ appValue = appLine['value']
+ review_info['currentPatchSet'] = tempPS['number'] + ' ' + appValue
+
+ review_list.append([review_info[f] for f in REVIEW_FIELDS])
+ for i in FIELDS:
+ review_field_width[i] = max(
+ review_field_width[i],
+ len(review_info[REVIEW_FIELDS[i]])
+ )
+
+ review_field_format = " ".join([
+ review_field_color[i] +
+ review_field_format[i] +
+ color_reset
+ for i in FIELDS])
+
+ review_field_width = [
+ review_field_width[i] * review_field_justify[i]
+ for i in FIELDS]
+ for review_value in review_list:
+ # At this point we have review_field_format
+ # like "%*s %*s %*s" and we need to supply
+ # (width1, value1, width2, value2, ...) tuple to print
+ # It's easy to zip() widths with actual values,
+ # but we need to flatten the resulting
+ # ((width1, value1), (width2, value2), ...) map.
+ formatted_fields = []
+ for (width, value) in zip(review_field_width, review_value):
+ formatted_fields.extend([width, value])
+ print(review_field_format % tuple(formatted_fields))
+ print("Found %d items for review" % review_info['rowCount'])
+
+ return 0
+
+
+class CannotQueryPatchSet(CommandFailed):
+ "Cannot query patchset information"
+ EXIT_CODE = 34
+
+
+class ReviewInformationNotFound(ChangeSetException):
+ "Could not fetch review information for change %s"
+ EXIT_CODE = 35
+
+
+class ReviewNotFound(ChangeSetException):
+ "Gerrit review %s not found"
+ EXIT_CODE = 36
+
+
+class PatchSetGitFetchFailed(CommandFailed):
+ """Cannot fetch patchset contents
+
+Does specified change number belong to this project?
+"""
+ EXIT_CODE = 37
+
+
+class PatchSetNotFound(ChangeSetException):
+ "Review patchset %s not found"
+ EXIT_CODE = 38
+
+
+class CheckoutNewBranchFailed(CommandFailed):
+ "Cannot checkout to new branch"
+ EXIT_CODE = 64
+
+
+class CheckoutExistingBranchFailed(CommandFailed):
+ "Cannot checkout existing branch"
+ EXIT_CODE = 65
+
+
+class ResetHardFailed(CommandFailed):
+ "Failed to hard reset downloaded branch"
+ EXIT_CODE = 66
+
+
+def fetch_review(review, masterbranch, remote):
+
+ (hostname, username, port, project_name) = \
+ parse_git_show(remote, "Push")
+
+ if port is not None:
+ port = "-p %s" % port
+ else:
+ port = ""
+ if username is None:
+ userhost = hostname
+ else:
+ userhost = "%s@%s" % (username, hostname)
+
+ review_arg = review
+ patchset_opt = '--current-patch-set'
+
+ review, patchset_number = parse_review_number(review)
+ if patchset_number is not None:
+ patchset_opt = '--patch-sets'
+
+ review_info = None
+ output = run_command_exc(
+ CannotQueryPatchSet,
+ "ssh", "-x", port, userhost,
+ "gerrit", "query",
+ "--format=JSON %s change:%s" % (patchset_opt, review))
+
+ review_jsons = output.split("\n")
+ found_review = False
+ for review_json in review_jsons:
+ try:
+ review_info = json.loads(review_json)
+ found_review = True
+ except Exception:
+ pass
+ if found_review:
+ break
+ if not found_review:
+ if VERBOSE:
+ print(output)
+ raise ReviewInformationNotFound(review)
+
+ try:
+ if patchset_number is None:
+ refspec = review_info['currentPatchSet']['ref']
+ else:
+ refspec = [ps for ps
+ in review_info['patchSets']
+ if ps['number'] == patchset_number][0]['ref']
+ except IndexError:
+ raise PatchSetNotFound(review_arg)
+ except KeyError:
+ raise ReviewNotFound(review)
+
+ try:
+ topic = review_info['topic']
+ if topic == masterbranch:
+ topic = review
+ except KeyError:
+ topic = review
+ try:
+ author = re.sub('\W+', '_', review_info['owner']['name']).lower()
+ except KeyError:
+ author = 'unknown'
+
+ if patchset_number is None:
+ branch_name = "review/%s/%s" % (author, topic)
+ else:
+ branch_name = "review/%s/%s-patch%s" % (author, topic, patchset_number)
+
+ print("Downloading %s from gerrit" % refspec)
+ run_command_exc(PatchSetGitFetchFailed,
+ "git", "fetch", remote, refspec)
+ return branch_name
+
+
+def checkout_review(branch_name):
+ """Checkout a newly fetched (FETCH_HEAD) change
+ into a branch
+ """
+
+ try:
+ run_command_exc(CheckoutNewBranchFailed,
+ "git", "checkout", "-b",
+ branch_name, "FETCH_HEAD")
+
+ except CheckoutNewBranchFailed as e:
+ if re.search("already exists\.?", e.output):
+ print("Branch already exists - reusing")
+ run_command_exc(CheckoutExistingBranchFailed,
+ "git", "checkout", branch_name)
+ run_command_exc(ResetHardFailed,
+ "git", "reset", "--hard", "FETCH_HEAD")
+ else:
+ raise
+
+ print("Switched to branch \"%s\"" % branch_name)
+
+
+class PatchSetGitCherrypickFailed(CommandFailed):
+ "There was a problem applying changeset contents to the current branch."
+ EXIT_CODE = 69
+
+
+def cherrypick_review(option=None):
+ cmd = ["git", "cherry-pick"]
+ if option:
+ cmd.append(option)
+ cmd.append("FETCH_HEAD")
+ print(run_command_exc(PatchSetGitCherrypickFailed, *cmd))
+
+
+class CheckoutBackExistingBranchFailed(CommandFailed):
+ "Cannot switch back to existing branch"
+ EXIT_CODE = 67
+
+
+class DeleteBranchFailed(CommandFailed):
+ "Failed to delete branch"
+ EXIT_CODE = 68
+
+
+class InvalidPatchsetsToCompare(GitReviewException):
+ def __init__(self, patchsetA, patchsetB):
+ Exception.__init__(
+ self,
+ "Invalid patchsets for comparison specified (old=%s,new=%s)" % (
+ patchsetA,
+ patchsetB))
+ EXIT_CODE = 39
+
+
+def compare_review(review_spec, branch, remote, rebase=False):
+ new_ps = None # none means latest
+
+ if '-' in review_spec:
+ review_spec, new_ps = review_spec.split('-')
+ review, old_ps = parse_review_number(review_spec)
+
+ if old_ps is None or old_ps == new_ps:
+ raise InvalidPatchsetsToCompare(old_ps, new_ps)
+
+ old_review = build_review_number(review, old_ps)
+ new_review = build_review_number(review, new_ps)
+
+ old_branch = fetch_review(old_review, branch, remote)
+ checkout_review(old_branch)
+
+ if rebase:
+ print('Rebasing %s' % old_branch)
+ rebase = rebase_changes(branch, remote, False)
+ if not rebase:
+ print('Skipping rebase because of conflicts')
+ run_command_exc(CommandFailed, 'git', 'rebase', '--abort')
+
+ new_branch = fetch_review(new_review, branch, remote)
+ checkout_review(new_branch)
+
+ if rebase:
+ print('Rebasing also %s' % new_branch)
+ if not rebase_changes(branch, remote, False):
+ print("Rebasing of the new branch failed, "
+ "diff can be messed up (use -R to not rebase at all)!")
+ run_command_exc(CommandFailed, 'git', 'rebase', '--abort')
+
+ subprocess.check_call(['git', 'difftool', old_branch])
+
+
+def finish_branch(target_branch):
+ local_branch = get_branch_name(target_branch)
+ if VERBOSE:
+ print("Switching back to '%s' and deleting '%s'" % (target_branch,
+ local_branch))
+ run_command_exc(CheckoutBackExistingBranchFailed,
+ "git", "checkout", target_branch)
+ print("Switched to branch '%s'" % target_branch)
+
+ run_command_exc(DeleteBranchFailed,
+ "git", "branch", "-D", local_branch)
+ print("Deleted branch '%s'" % local_branch)
+
+
+def convert_bool(one_or_zero):
+ "Return a bool on a one or zero string."
+ return one_or_zero in ["1", "true", "True"]
+
+
+def print_exit_message(status, needs_update):
+
+ if needs_update:
+ print("""
+***********************************************************
+A new version of git-review is available on PyPI. Please
+update your copy with:
+
+ pip install -U git-review
+
+to ensure proper behavior with gerrit. Thanks!
+***********************************************************
+""")
+ sys.exit(status)
+
+
+def main():
+ global _no_color_support
+ usage = "git review [OPTIONS] ... [BRANCH]"
+
+ import argparse
+
+ class DownloadFlag(argparse.Action):
+ """Additional option parsing: store value in 'dest', but
+ at the same time set one of the flag options to True
+ """
+ def __call__(self, parser, namespace, values, option_string=None):
+ setattr(namespace, self.dest, values)
+ setattr(namespace, self.const, True)
+
+ parser = argparse.ArgumentParser(usage=usage, description=COPYRIGHT)
+
+ parser.add_argument("-t", "--topic", dest="topic",
+ help="Topic to submit branch to")
+ parser.add_argument("-D", "--draft", dest="draft", action="store_true",
+ help="Submit review as a draft")
+ parser.add_argument("-c", "--compatible", dest="compatible",
+ action="store_true",
+ help="Push change to refs/for/* for compatibility "
+ "with Gerrit versions < 2.3. Ignored if "
+ "-D/--draft is used.")
+ parser.add_argument("-n", "--dry-run", dest="dry", action="store_true",
+ help="Don't actually submit the branch for review")
+ parser.add_argument("-i", "--new-changeid", dest="regenerate",
+ action="store_true",
+ help="Regenerate Change-id before submitting")
+ parser.add_argument("-r", "--remote", dest="remote",
+ help="git remote to use for gerrit")
+ parser.add_argument("-R", "--no-rebase", dest="rebase",
+ action="store_false",
+ help="Don't rebase changes before submitting.")
+ parser.add_argument("-F", "--force-rebase", dest="force_rebase",
+ action="store_true",
+ help="Force rebase even when not needed.")
+ parser.add_argument("-B", "--no-color", dest="no_color_support",
+ action="store_true",
+ help="No color support.")
+
+
+ fetch = parser.add_mutually_exclusive_group()
+ fetch.set_defaults(download=False, compare=False, cherrypickcommit=False,
+ cherrypickindicate=False, cherrypickonly=False)
+ fetch.add_argument("-d", "--download", dest="changeidentifier",
+ action=DownloadFlag, metavar="CHANGE",
+ const="download",
+ help="Download the contents of an existing gerrit "
+ "review into a branch")
+ fetch.add_argument("-x", "--cherrypick", dest="changeidentifier",
+ action=DownloadFlag, metavar="CHANGE",
+ const="cherrypickcommit",
+ help="Apply the contents of an existing gerrit "
+ "review onto the current branch and commit "
+ "(cherry pick; not recommended in most "
+ "situations)")
+ fetch.add_argument("-X", "--cherrypickindicate", dest="changeidentifier",
+ action=DownloadFlag, metavar="CHANGE",
+ const="cherrypickindicate",
+ help="Apply the contents of an existing gerrit "
+ "review onto the current branch and commit, "
+ "indicating its origin")
+ fetch.add_argument("-N", "--cherrypickonly", dest="changeidentifier",
+ action=DownloadFlag, metavar="CHANGE",
+ const="cherrypickonly",
+ help="Apply the contents of an existing gerrit "
+ "review to the working directory and prepare "
+ "for commit")
+ fetch.add_argument("-m", "--compare", dest="changeidentifier",
+ action=DownloadFlag, metavar="CHANGE,PS[-NEW_PS]",
+ const="compare",
+ help="Download specified and latest (or NEW_PS) "
+ "patchsets of an existing gerrit review into "
+ "a branches, rebase on master "
+ "(skipped on conflicts or when -R is specified) "
+ "and show their differences")
+
+ parser.add_argument("-u", "--update", dest="update", action="store_true",
+ help="Force updates from remote locations")
+ parser.add_argument("-s", "--setup", dest="setup", action="store_true",
+ help="Just run the repo setup commands but don't "
+ "submit anything")
+ parser.add_argument("-f", "--finish", dest="finish", action="store_true",
+ help="Close down this branch and switch back to "
+ "master on successful submission")
+ parser.add_argument("-l", "--list", dest="list", action="store_true",
+ help="List available reviews for the current project")
+ parser.add_argument("-y", "--yes", dest="yes", action="store_true",
+ help="Indicate that you do, in fact, understand if "
+ "you are submitting more than one patch")
+ parser.add_argument("-v", "--verbose", dest="verbose", action="store_true",
+ help="Output more information about what's going on")
+ parser.add_argument("--no-custom-script", dest="custom_script",
+ action="store_false", default=True,
+ help="Do not run custom scripts.")
+ parser.add_argument("--license", dest="license", action="store_true",
+ help="Print the license and exit")
+ parser.add_argument("--version", action="version",
+ version='%s version %s' %
+ (os.path.split(sys.argv[0])[-1], version))
+ parser.add_argument("branch", nargs="?")
+
+ try:
+ (top_dir, git_dir) = git_directories()
+ except GitDirectoriesException:
+ if sys.argv[1:] in ([], ['-h'], ['--help']):
+ parser.print_help()
+ sys.exit(1)
+ raise
+
+# config = get_config(os.path.join(top_dir, ".gitreview"))
+ config = DEFAULTS.copy()
+ cur_proj = run_command("git remote -v")
+ import re
+ m = re.search('(?<=29418\/)(\S+)', cur_proj)
+ config['project'] = m.group(0)
+
+
+ defaultrebase = convert_bool(
+ git_config_get_value("gitreview", "rebase",
+ default=str(config['defaultrebase'])))
+ parser.set_defaults(dry=False,
+ draft=False,
+ rebase=defaultrebase,
+ verbose=False,
+ update=False,
+ setup=False,
+ list=False,
+ yes=False,
+ branch=config['defaultbranch'],
+ remote=config['defaultremote'])
+ options = parser.parse_args()
+
+ if options.license:
+ print(COPYRIGHT)
+ sys.exit(0)
+
+ branch = options.branch
+ global VERBOSE
+ global UPDATE
+ VERBOSE = options.verbose
+ UPDATE = options.update
+ remote = options.remote
+ yes = options.yes
+ status = 0
+
+ needs_update = latest_is_newer()
+ check_remote(branch, remote,
+ config['hostname'], config['port'], config['project'])
+
+ if options.no_color_support:
+ _no_color_support = True
+
+ if options.changeidentifier:
+ if options.compare:
+ compare_review(options.changeidentifier,
+ branch, remote, options.rebase)
+ return
+ local_branch = fetch_review(options.changeidentifier, branch, remote)
+ if options.download:
+ checkout_review(local_branch)
+ else:
+ if options.cherrypickcommit:
+ cherrypick_review()
+ elif options.cherrypickonly:
+ cherrypick_review("-n")
+ if options.cherrypickindicate:
+ cherrypick_review("-x")
+ return
+ elif options.list:
+ list_reviews(remote)
+ return
+
+ if options.custom_script:
+ run_custom_script("pre")
+
+ hook_file = os.path.join(git_dir, "hooks", "commit-msg")
+ have_hook = os.path.exists(hook_file) and os.access(hook_file, os.X_OK)
+
+ if not have_hook:
+ set_hooks_commit_msg(remote, hook_file)
+
+ if options.setup:
+ if options.finish and not options.dry:
+ finish_branch(branch)
+ return
+
+ if options.rebase:
+ if not rebase_changes(branch, remote):
+ print_exit_message(1, needs_update)
+ if not options.force_rebase and not undo_rebase():
+ print_exit_message(1, needs_update)
+ assert_one_change(remote, branch, yes, have_hook)
+
+ ref = "publish"
+
+ if options.draft:
+ ref = "drafts"
+ if options.custom_script:
+ run_custom_script("draft")
+ elif options.compatible:
+ ref = "for"
+
+ cmd = "git push %s HEAD:refs/%s/%s" % (remote, ref, branch)
+ topic = options.topic or get_topic(branch)
+ if topic != branch:
+ cmd += "/%s" % topic
+ if options.regenerate:
+ print("Amending the commit to regenerate the change id\n")
+ regenerate_cmd = "git commit --amend"
+ if options.dry:
+ print("\tGIT_EDITOR=\"sed -i -e '/^Change-Id:/d'\" %s\n" %
+ regenerate_cmd)
+ else:
+ run_command(regenerate_cmd,
+ GIT_EDITOR="sed -i -e "
+ "'/^Change-Id:/d'")
+
+ if options.dry:
+ print("Please use the following command "
+ "to send your commits to review:\n")
+ print("\t%s\n" % cmd)
+ else:
+ (status, output) = run_command_status(cmd)
+ print(output)
+
+ if options.finish and not options.dry and status == 0:
+ finish_branch(branch)
+ return
+
+ if options.custom_script:
+ run_custom_script("post")
+ print_exit_message(status, needs_update)
+
+
+if __name__ == "__main__":
+ try:
+ main()
+ except GitReviewException as e:
+ print(e)
+ sys.exit(e.EXIT_CODE)
projects / dotfiles.git / commitdiff