Update git-llvm script to push to GitHub

[tstellar]

Summary

Note: This patch should not be pushed until SVN has become read-only.
It should be the first patch committed directly to GitHub.

This patch updates git-llvm to check for merge commits and then push
changes to GitHub if none are found. All logic related to SVN has been
removed.

I need help testing this to make sure it is robust and that the merge
commit checks can cover every case. To test only the merge checks,
just run git-llvm push --dry-run.

If you want to also test pushing chagnes, change the GIT_ORG and
GIT_REPO variables to one of your personal github repositories.
You will also need to enable the branch protections and the 'rebased'
status check for the branches you are trying to push to.

You need to run the script at least once with an unpushed commits
in order for the 'rebased' status check to appear as an option
to enable in your github projects configuration.

[lenary]

One request:

llvm/utils/git-svn/git-llvm

96

Please may you ensure that this works for the non-monorepo LLVM repositories when it initially goes live?

[thakis]

I'm getting

$ llvm/utils/git-svn/git-llvm push -n
Traceback (most recent call last):
  File "llvm/utils/git-svn/git-llvm", line 39, in <module>
    import github
ImportError: No module named github

now. Are there docs on what I need to do to be able to commit using this script now?

[thakis]

Alternatively I tried pushing via git directly but couldn't get that to work either:

$ git push origin mylocalbranch:master
Enumerating objects: 13, done.
Counting objects: 100% (13/13), done.
Delta compression using up to 24 threads
Compressing objects: 100% (7/7), done.
Writing objects: 100% (7/7), 657 bytes | 657.00 KiB/s, done.
Total 7 (delta 6), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (6/6), completed with 6 local objects.
remote: error: GH006: Protected branch update failed for refs/heads/master.
remote: error: You're not authorized to push to this branch. Visit https://help.github.com/articles/about-protected-branches/ for more information.
To https://github.com/llvm/llvm-project.git
 ! [remote rejected]         gnmergerev -> master (protected branch hook declined)
error: failed to push some refs to 'https://github.com/llvm/llvm-project.git'

[thakis]

Filed https://bugs.llvm.org/show_bug.cgi?id=43761 , let's move this there.

llvm/utils/git-svn/git-llvm

 #!/usr/bin/env python
 #
 # ======- git-llvm - LLVM Git Help Integration ---------*- python -*--========#
 #
 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 # See https://llvm.org/LICENSE.txt for license information.
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 #
 # ==------------------------------------------------------------------------==#
 
 """
 git-llvm integration
 ====================
 
 This file provides integration for git.
+
+The git llvm push sub-command can be used to push changes to GitHub.  It is
+designed to be a thin wrapper around git, and its main purpose is to
+detect and prevent merge commits from being pushed to the main repository.
+
+Usage:
+
+git-llvm push <upstream-branch>
+
+This will push changes from the current HEAD to the branch <upstream-branch>.
+
 """
 
 from __future__ import print_function
 import argparse
 import collections
 import os
 import re
 import shutil
 import subprocess
 import sys
 import time
+import getpass
+import github
 assert sys.version_info >= (2, 7)
 
 try:
     dict.iteritems
 except AttributeError:
     # Python 3
     def iteritems(d):
         return iter(d.items())

 
 SPLIT_REPO_NAMES = {'llvm-' + d: d + '/trunk'
                     for d in ['www', 'zorg', 'test-suite', 'lnt']}
 
 VERBOSE = False
 QUIET = False
 dev_null_fd = None
 
+GIT_ORG = 'tstellar'
+GIT_REPO = 'llvm'
+GIT_URL = 'github.com/{}/{}.git'.format(GIT_ORG, GIT_REPO)
+
 
 def eprint(*args, **kwargs):
     print(*args, file=sys.stderr, **kwargs)
 
 
 def log(*args, **kwargs):
     if QUIET:
         return
def ask_confirm(prompt):
     while True:
         query = read_input('%s (y/N): ' % (prompt))
         if query.lower() not in ['y','n', '']:
            print('Expect y or n!')
            continue
         return query.lower() == 'y'
 
 
-def split_first_path_component(d):
-    # Assuming we have a git path, it'll use slashes even on windows...I hope.
-    if '/' in d:
-        return d.split('/', 1)
-    else:
-        return (d, None)
-
-
 def get_dev_null():
     """Lazily create a /dev/null fd for use in shell()"""
     global dev_null_fd
     if dev_null_fd is None:
         dev_null_fd = open(os.devnull, 'w')
     return dev_null_fd
 
 
 def shell(cmd, strip=True, cwd=None, stdin=None, die_on_failure=True,
-          ignore_errors=False, text=True):
+          ignore_errors=False, text=True, print_raw_stderr=False):
     # Escape args when logging for easy repro.
     quoted_cmd = [quote(arg) for arg in cmd]
     log_verbose('Running in %s: %s' % (cwd, ' '.join(quoted_cmd)))
 
     err_pipe = subprocess.PIPE
     if ignore_errors:
         # Silence errors if requested.
         err_pipe = get_dev_null()
 
     start = time.time()
     p = subprocess.Popen(cmd, cwd=cwd, stdout=subprocess.PIPE, stderr=err_pipe,
                          stdin=subprocess.PIPE,
                          universal_newlines=text)
     stdout, stderr = p.communicate(input=stdin)
     elapsed = time.time() - start
 
     log_verbose('Command took %0.1fs' % elapsed)
 
     if p.returncode == 0 or ignore_errors:
         if stderr and not ignore_errors:
+            if not print_raw_stderr:
                 eprint('`%s` printed to stderr:' % ' '.join(quoted_cmd))
             eprint(stderr.rstrip())
         if strip:
             if text:
                 stdout = stdout.rstrip('\r\n')
             else:
                 stdout = stdout.rstrip(b'\r\n')
         if VERBOSE:
             for l in stdout.splitlines():
def program_exists(cmd):
     if sys.platform == 'win32' and not cmd.endswith('.exe'):
         cmd += '.exe'
     for path in os.environ["PATH"].split(os.pathsep):
         if os.access(os.path.join(path, cmd), os.X_OK):
             return True
     return False
 
 
-def get_default_rev_range():
-    # Get the newest common ancestor between HEAD and our upstream branch.
-    upstream_rev = git('merge-base', 'HEAD', '@{upstream}', ignore_errors=True)
-    if not upstream_rev:
-        eprint("Warning: git-llvm assumes that origin/master is the upstream "
-               "branch but git does not.")
-        eprint("To make this warning go away: git branch -u origin/master")
-        eprint("To avoid this warning when creating branches: "
-               "git checkout -b MyBranchName origin/master")
-        upstream_rev = git('merge-base', 'HEAD', 'origin/master')
-
-    return '%s..' % upstream_rev
-
-
-def get_revs_to_push(rev_range):
-    if not rev_range:
-        rev_range = get_default_rev_range()
-    # Use git show rather than some plumbing command to figure out which revs
-    # are in rev_range because it handles single revs (HEAD^) and ranges
-    # (foo..bar) like we want.
-    return git('show', '--reverse', '--quiet',
-               '--pretty=%h', rev_range).splitlines()
-
-
-def clean_svn(svn_repo):
-    svn(svn_repo, 'revert', '-R', '.')
-
-    # Unfortunately it appears there's no svn equivalent for git clean, so we
-    # have to do it ourselves.
-    for line in svn(svn_repo, 'status', '--no-ignore').split('\n'):
-        if not line.startswith('?'):
-            continue
-        filename = line[1:].strip()
-        filepath = os.path.abspath(os.path.join(svn_repo, filename))
-        abs_svn_repo = os.path.abspath(svn_repo)
-        # Safety check that the directory we are about to delete is
-        # actually within our svn staging dir.
-        if not filepath.startswith(abs_svn_repo):
-            die("Path to clean (%s) is not in svn staging dir (%s)"
-                % (filepath, abs_svn_repo))
+def get_fetch_url():
+    return 'https://{}'.format(GIT_URL)
 
-        if os.path.isdir(filepath):
-            shutil.rmtree(filepath)
-        else:
-            os.remove(filepath)
 
+def get_push_url(user='', token='', ssh=False):
 
-def svn_init(svn_root):
-    if not os.path.exists(svn_root):
-        log('Creating svn staging directory: (%s)' % (svn_root))
-        os.makedirs(svn_root)
-        svn(svn_root, 'checkout', '--depth=empty',
-            'https://llvm.org/svn/llvm-project/', '.')
-        log("svn staging area ready in '%s'" % svn_root)
-    if not os.path.isdir(svn_root):
-        die("Can't initialize svn staging dir (%s)" % svn_root)
-
-
-def fix_eol_style_native(rev, svn_sr_path, files):
-    """Fix line endings before applying patches with Unix endings
-
-    SVN on Windows will check out files with CRLF for files with the
-    svn:eol-style property set to "native". This breaks `git apply`, which
-    typically works with Unix-line ending patches. Work around the problem here
-    by doing a dos2unix up front for files with svn:eol-style set to "native".
-    SVN will not commit a mass line ending re-doing because it detects the line
-    ending format for files with this property.
-    """
-    # Skip files that don't exist in SVN yet.
-    files = [f for f in files if os.path.exists(os.path.join(svn_sr_path, f))]
-    # Use ignore_errors because 'svn propget' prints errors if the file doesn't
-    # have the named property. There doesn't seem to be a way to suppress that.
-    eol_props = svn(svn_sr_path, 'propget', 'svn:eol-style', *files,
-                    ignore_errors=True)
-    crlf_files = []
-    if len(files) == 1:
-        # No need to split propget output on ' - ' when we have one file.
-        if eol_props.strip() in ['native', 'CRLF']:
-            crlf_files = files
-    else:
-        for eol_prop in eol_props.split('\n'):
-            # Remove spare CR.
-            eol_prop = eol_prop.strip('\r')
-            if not eol_prop:
-                continue
-            prop_parts = eol_prop.rsplit(' - ', 1)
-            if len(prop_parts) != 2:
-                eprint("unable to parse svn propget line:")
-                eprint(eol_prop)
-                continue
-            (f, eol_style) = prop_parts
-            if eol_style == 'native':
-                crlf_files.append(f)
-    if crlf_files:
-        # Reformat all files with native SVN line endings to Unix format. SVN
-        # knows files with native line endings are text files. It will commit
-        # just the diff, and not a mass line ending change.
-        shell(['dos2unix'] + crlf_files, ignore_errors=True, cwd=svn_sr_path)
-
-
-def split_subrepo(f, git_to_svn_mapping):
-    # Given a path, splits it into (subproject, rest-of-path). If the path is
-    # not in a subproject, returns ('', full-path).
+    if GIT_ORG == 'llvm' or "github.com/llvm" in GIT_URL:
+        die("Do not push to the official repository yet!!")
 
-    subproject, remainder = split_first_path_component(f)
+    if ssh:
+        return 'ssh://{}'.format(GIT_URL)
 
-    if subproject in git_to_svn_mapping:
-        return subproject, remainder
-    else:
-        return '', f
+    return 'https://{}@{}'.format(token, GIT_URL)
 
 
-def get_all_parent_dirs(name):
-    parts = []
-    head, tail = os.path.split(name)
-    while head:
-        parts.append(head)
-        head, tail = os.path.split(head)
-    return parts
-
-
-def svn_push_one_rev(svn_repo, rev, git_to_svn_mapping, dry_run):
-    def split_status(x):
-        x = x.split('\t')
-        return x[1], x[0]
-    files_status = [split_status(x) for x in
-                    git('diff-tree', '--no-commit-id', '--name-status',
-                        '--no-renames', '-r', rev).split('\n')]
-    if not files_status:
-        raise RuntimeError('Empty diff for rev %s?' % rev)
-
-    # Split files by subrepo
-    subrepo_files = collections.defaultdict(list)
-    for f, st in files_status:
-        subrepo, remainder = split_subrepo(f, git_to_svn_mapping)
-        subrepo_files[subrepo].append((remainder, st))
-
-    status = svn(svn_repo, 'status', '--no-ignore')
-    if status:
-        die("Can't push git rev %s because status in svn staging dir (%s) is "
-            "not empty:\n%s" % (rev, svn_repo, status))
-
-    svn_dirs_to_update = set()
-    for sr, files_status in iteritems(subrepo_files):
-        svn_sr_path = git_to_svn_mapping[sr]
-        for f, _ in files_status:
-            svn_dirs_to_update.add(
-                os.path.dirname(os.path.join(svn_sr_path, f)))
-
-    # We also need to svn update any parent directories which are not yet
-    # present
-    parent_dirs = set()
-    for dir in svn_dirs_to_update:
-        parent_dirs.update(get_all_parent_dirs(dir))
-    parent_dirs = set(dir for dir in parent_dirs
-                      if not os.path.exists(os.path.join(svn_repo, dir)))
-    svn_dirs_to_update.update(parent_dirs)
-
-    # Sort by length to ensure that the parent directories are passed to svn
-    # before child directories.
-    sorted_dirs_to_update = sorted(svn_dirs_to_update, key=len)
-
-    # SVN update only in the affected directories.
-    svn(svn_repo, 'update', '--depth=files', *sorted_dirs_to_update)
-
-    for sr, files_status in iteritems(subrepo_files):
-        svn_sr_path = os.path.join(svn_repo, git_to_svn_mapping[sr])
-        if os.name == 'nt':
-            fix_eol_style_native(rev, svn_sr_path,
-                                 [f for f, _ in files_status])
-
-        # We use text=False (and pass '--binary') so that we can get an exact
-        # diff that can be passed as-is to 'git apply' without any line ending,
-        # encoding, or other mangling.
-        diff = git('show', '--binary', rev, '--',
-                   *(os.path.join(sr, f) for f, _ in files_status),
-                   strip=False, text=False)
-        # git is the only thing that can handle its own patches...
-        if sr == '':
-            prefix_strip = '-p1'
-        else:
-            prefix_strip = '-p2'
-        try:
-            shell(['git', 'apply', prefix_strip, '-'], cwd=svn_sr_path,
-                  stdin=diff, die_on_failure=False, text=False)
-        except RuntimeError as e:
-            eprint("Patch doesn't apply: maybe you should try `git pull -r` "
-                   "first?")
-            sys.exit(2)
+def get_revs_to_push(branch):
+    # Fetch the latest upstream to determine which commits will be pushed.
+    git('fetch', get_fetch_url(), branch)
 
-        # Handle removed files and directories. We need to be careful not to
-        # remove directories just because they _look_ empty in the svn tree, as
-        # we might be missing sibling directories in the working copy. So, only
-        # remove parent directories if they're empty on both the git and svn
-        # sides.
-        maybe_dirs_to_remove = set()
-        for f, st in files_status:
-            if st == 'D':
-                maybe_dirs_to_remove.update(get_all_parent_dirs(f))
-                svn(svn_sr_path, 'remove', f)
-            elif not (st == 'A' or st == 'M' or st == 'T'):
-                # Add is handled below, and nothing needs to be done for Modify.
-                # (FIXME: Type-change between symlink and file might need some
-                # special handling, but let's ignore that for now.)
-                die("Unexpected git status for %r: %r" % (f, st))
-
-        maybe_dirs_to_remove = sorted(maybe_dirs_to_remove, key=len)
-        for f in maybe_dirs_to_remove:
-            if(not os.path.exists(os.path.join(svn_sr_path, f)) and
-               git('ls-tree', '-d', rev, os.path.join(sr, f)) == ''):
-                svn(svn_sr_path, 'remove', f)
-
-    status_lines = svn(svn_repo, 'status', '--no-ignore').split('\n')
-
-    for l in status_lines:
-        f = l[1:].strip()
-        if l.startswith('?') or l.startswith('I'):
-            svn(svn_repo, 'add', '--no-ignore', f)
-
-    # Now we're ready to commit.
-    commit_msg = git('show', '--pretty=%B', '--quiet', rev)
-    if not dry_run:
-        commit_args = ['commit', '-m', commit_msg]
-        if '--force-interactive' in svn(svn_repo, 'commit', '--help'):
-            commit_args.append('--force-interactive')
-        log(svn(svn_repo, *commit_args))
-        log('Committed %s to svn.' % rev)
-    else:
-        log("Would have committed %s to svn, if this weren't a dry run." % rev)
+    commits = git('rev-list', '--ancestry-path', 'FETCH_HEAD..HEAD').splitlines()
+    # Reverse the order so we commit the oldest commit first
+    commits.reverse()
+    return commits
 
 
-def cmd_push(args):
-    '''Push changes back to SVN: this is extracted from Justin Lebar's script
-    available here: https://github.com/jlebar/llvm-repo-tools/
+def git_push_one_rev(rev, dry_run, branch, github_ctx, github_token):
+    # Check if this a merge commit by counting the number of parent commits.
+    # More than 1 parent commmit means this is a merge.
+    num_parents = len(git('show', '--no-patch', '--format="%P"', rev).split())
 
-    Note: a current limitation is that git does not track file rename, so they
-    will show up in SVN as delete+add.
-    '''
-    # Get the git root
-    git_root = git('rev-parse', '--show-toplevel')
-    if not os.path.isdir(git_root):
-        die("Can't find git root dir")
-
-    # Push from the root of the git repo
-    os.chdir(git_root)
-
-    # Get the remote URL, and check if it's one of the standalone repos.
-    git_remote_url = git('ls-remote', '--get-url', 'origin')
-    git_remote_url = git_remote_url.rstrip('.git').rstrip('/')
-    git_remote_repo_name = git_remote_url.rsplit('/', 1)[-1]
-    split_repo_path = SPLIT_REPO_NAMES.get(git_remote_repo_name)
-    if split_repo_path:
-        git_to_svn_mapping = {'': split_repo_path}
-    else:
-        # Default to the monorepo mapping
-        git_to_svn_mapping = LLVM_MONOREPO_SVN_MAPPING
+    if num_parents > 1:
+        raise Exception("Merge commit detected, cannot push ", rev)
+
+    if num_parents != 1:
+        raise Exception("Error detecting number of parents for ", rev)
+
+    if dry_run:
+        print("[DryRun] Would push", rev)
+        return
 
-    # We need a staging area for SVN, let's hide it in the .git directory.
-    dot_git_dir = git('rev-parse', '--git-common-dir')
-    # Not all versions of git support --git-common-dir and just print the
-    # unknown command back. If this happens, fall back to --git-dir
-    if dot_git_dir == '--git-common-dir':
-        dot_git_dir = git('rev-parse', '--git-dir')
+    # First push: If status checks are enabled this will be rejected, but having
+    # the push rejected will allow us to set the status checks on the commits.  The
+    # only other way to do this would be to first push to a temp branch, but that is
+    # more complicated as we would have to cleanup branches when done.
+    git('push', get_push_url(token = github_token), '{}:{}'.format(rev, branch), ignore_errors=True)
 
-    svn_root = os.path.join(dot_git_dir, 'llvm-upstream-svn')
-    svn_init(svn_root)
+    # Set the status check:
+    status = github_ctx.get_repo('{}/{}'.format(GIT_ORG, GIT_REPO)).get_commit(rev).create_status('success', context='rebased')
 
-    rev_range = args.rev_range
+    # Second push to actually push the commit
+    git('push', get_push_url(token = github_token), '{}:{}'.format(rev, branch), print_raw_stderr=True)
+
+
+def cmd_push(args):
+    '''Push changes to git:'''
     dry_run = args.dry_run
-    revs = get_revs_to_push(rev_range)
 
-    if not args.force and not revs:
-        die('Nothing to push: No revs in range %s.' % rev_range)
+    revs = get_revs_to_push(args.branch)
 
-    log('%sPushing %d %s commit%s:\n%s' %
+    if not revs:
+        die('Nothing to push')
+
+    log('%sPushing %d commit%s:\n%s' %
         ('[DryRun] ' if dry_run else '', len(revs),
-         'split-repo (%s)' % split_repo_path
-         if split_repo_path else 'monorepo',
          's' if len(revs) != 1 else '',
          '\n'.join('  ' + git('show', '--oneline', '--quiet', c)
                    for c in revs)))
 
     # Ask confirmation if multiple commits are about to be pushed
     if not args.force and len(revs) > 1:
         if not ask_confirm("Are you sure you want to create %d commits?" % len(revs)):
             die("Aborting")
 
+    # FIXME: I'm really trying to avoid prompting twice for the password, the only
+    # way I can see to do that is require an authentication token instead of a
+    # password, because you can embedded authentication tokens into the URL.
+    github_token = getpass.getpass("Auth token for https://github.com':")
+    g = github.Github(github_token)
     for r in revs:
-        clean_svn(svn_root)
-        svn_push_one_rev(svn_root, r, git_to_svn_mapping, dry_run)
-
-
-def lookup_llvm_svn_id(git_commit_hash):
-    # Use --format=%b to get the raw commit message, without any extra
-    # whitespace.
-    commit_msg = git('log', '-1', '--format=%b', git_commit_hash,
-                     ignore_errors=True)
-    if len(commit_msg) == 0:
-        die("Can't find git commit " + git_commit_hash)
-    # If a commit has multiple "llvm-svn:" lines (e.g. if the commit is
-    # reverting/quoting a previous commit), choose the last one, which should
-    # be the authoritative one.
-    svn_match_iter = re.finditer('^llvm-svn: (\d{5,7})$', commit_msg,
-                                 re.MULTILINE)
-    svn_match = None
-    for m in svn_match_iter:
-        svn_match = m.group(1)
-    if svn_match:
-        return int(svn_match)
-    die("Can't find svn revision in git commit " + git_commit_hash)
-
-
-def cmd_svn_lookup(args):
-    '''Find the SVN revision id for a given git commit hash.
-
-    This is identified by 'llvm-svn: NNNNNN' in the git commit message.'''
-    # Get the git root
-    git_root = git('rev-parse', '--show-toplevel')
-    if not os.path.isdir(git_root):
-        die("Can't find git root dir")
-
-    # Run commands from the root
-    os.chdir(git_root)
-
-    log('r' + str(lookup_llvm_svn_id(args.git_commit_hash)))
-
-
-def git_hash_by_svn_rev(svn_rev):
-    '''Find the git hash for a given svn revision.
-
-    This check is paranoid: 'llvm-svn: NNNNNN' could exist on its own line
-    somewhere else in the commit message. Look in the full log message to see
-    if it's actually on the last line.
-
-    Since this check is expensive (we're searching every single commit), limit
-    to the past 10k commits (about 5 months).
-    '''
-    possible_hashes = git(
-        'log', '--format=%H', '--grep', '^llvm-svn: %d$' % svn_rev,
-        'HEAD~10000...HEAD').split('\n')
-    matching_hashes = [h for h in possible_hashes
-                       if lookup_llvm_svn_id(h) == svn_rev]
-    if len(matching_hashes) > 1:
-        die("svn revision r%d has ambiguous commits: %s" % (
-            svn_rev, ', '.join(matching_hashes)))
-    elif len(matching_hashes) < 1:
-        die("svn revision r%d matches no commits" % svn_rev)
-    return matching_hashes[0]
-
-
-def cmd_revert(args):
-    '''Revert a commit by either SVN id (rNNNNNN) or git hash. This also
-    populates the git commit message with both the SVN revision and git hash of
-    the change being reverted.'''
-
-    # Get the git root
-    git_root = git('rev-parse', '--show-toplevel')
-    if not os.path.isdir(git_root):
-        die("Can't find git root dir")
-
-    # Run commands from the root
-    os.chdir(git_root)
-
-    # Check for a client branch first.
-    open_files = git('status', '-uno', '-s', '--porcelain')
-    if len(open_files) > 0:
-        die("Found open files. Please stash and then revert.\n" + open_files)
-
-    # If the revision looks like rNNNNNN (or with a callsign, e.g. rLLDNNNNNN),
-    # use that. Otherwise, look for it in the git commit.
-    svn_match = re.match('^r[A-Z]*(\d{5,7})$', args.revision)
-    if svn_match:
-        # If the revision looks like rNNNNNN, use that as the svn revision, and
-        # grep through git commits to find which one corresponds to that svn
-        # revision.
-        svn_rev = int(svn_match.group(1))
-        git_hash = git_hash_by_svn_rev(svn_rev)
-    else:
-        # Otherwise, this looks like a git hash, so we just need to grab the
-        # svn revision from the end of the commit message.  Get the actual git
-        # hash in case the revision is something like "HEAD~1"
-        git_hash = git('rev-parse', '--verify', args.revision + '^{commit}')
-        svn_rev = lookup_llvm_svn_id(git_hash)
-
-    msg = git('log', '-1', '--format=%s', git_hash)
-
-    log_verbose('Ready to revert r%d (%s): "%s"' % (svn_rev, git_hash, msg))
-
-    revert_args = ['revert', '--no-commit', git_hash]
-    # TODO: Running --edit doesn't seem to work, with errors that stdin is not
-    # a tty.
-    commit_args = [
-        'commit', '-m', 'Revert ' + msg,
-        '-m', 'This reverts r%d (git commit %s)' % (svn_rev, git_hash)]
-    if args.dry_run:
-        log("Would have run the following commands, if this weren't a"
-            "dry run:\n"
-            '1) git %s\n2) git %s' % (
-                ' '.join(quote(arg) for arg in revert_args),
-                ' '.join(quote(arg) for arg in commit_args)))
-        return
-
-    git(*revert_args)
-    commit_log = git(*commit_args)
-
-    log('Created revert of r%d: %s' % (svn_rev, commit_log))
-    log("Run 'git llvm push -n' to inspect your changes and "
-        "run 'git llvm push' when ready")
+        git_push_one_rev(r, dry_run, args.branch, g, github_token)
 
 
 if __name__ == '__main__':
-    if not program_exists('svn'):
-        die('error: git-llvm needs svn command, but svn is not installed.')
+    if not program_exists('git'):
+        die('error: git-llvm needs git command, but git is not installed.')
 
     argv = sys.argv[1:]
     p = argparse.ArgumentParser(
         prog='git llvm', formatter_class=argparse.RawDescriptionHelpFormatter,
         description=__doc__)
     subcommands = p.add_subparsers(title='subcommands',
                                    description='valid subcommands',
                                    help='additional help')
parser_push.add_argument(
         'repo, so probably will not work well if you try to commit more '
         'than one rev.')
     parser_push.add_argument(
         '-f',
         '--force',
         action='store_true',
         help='Do not ask for confirmation when pushing multiple commits.')
     parser_push.add_argument(
-        'rev_range',
-        metavar='GIT_REVS',
+        'branch',
+        metavar='GIT_BRANCH',
         type=str,
         nargs='?',
-        help="revs to push (default: everything not in the branch's "
-        'upstream, or not in origin/master if the branch lacks '
-        'an explicit upstream)')
+        help="branch to push (default: everything not in the branch's "
+        'upstream)')
     parser_push.set_defaults(func=cmd_push)
 
-    parser_revert = subcommands.add_parser(
-        'revert', description=cmd_revert.__doc__,
-        help='Revert a commit locally.')
-    parser_revert.add_argument(
-        'revision',
-        help='Revision to revert. Can either be an SVN revision number '
-        "(rNNNNNN) or a git commit hash (anything that doesn't look "
-        'like an SVN revision number).')
-    parser_revert.add_argument(
-        '-n',
-        '--dry-run',
-        dest='dry_run',
-        action='store_true',
-        help='Do everything other than perform a revert. Prints the git '
-        'revert command it would have run.')
-    parser_revert.set_defaults(func=cmd_revert)
-
-    parser_svn_lookup = subcommands.add_parser(
-        'svn-lookup', description=cmd_svn_lookup.__doc__,
-        help='Find the llvm-svn revision for a given commit.')
-    parser_svn_lookup.add_argument(
-        'git_commit_hash',
-        help='git_commit_hash for which we will look up the svn revision id.')
-    parser_svn_lookup.set_defaults(func=cmd_svn_lookup)
-
     args = p.parse_args(argv)
     VERBOSE = args.verbose
     QUIET = args.quiet
 
     # Python3 workaround, for when not arguments are provided.
     # See https://bugs.python.org/issue16308
     try:
         func = args.func
     except AttributeError:
         # No arguments or subcommands were given.
         parser.print_help()
         parser.exit()
 
     # Dispatch to the right subcommand
     args.func(args)