mirror of
https://github.com/mnauw/git-remote-hg.git
synced 2025-11-02 17:45:48 +01:00
957 lines
36 KiB
Python
Executable File
957 lines
36 KiB
Python
Executable File
#!/usr/bin/env python2
|
|
#
|
|
# Copyright (c) 2016 Mark Nauwelaerts
|
|
#
|
|
|
|
from mercurial import hg, ui, commands, util
|
|
from mercurial import context, subrepo
|
|
|
|
import re
|
|
import sys
|
|
import os
|
|
import subprocess
|
|
import argparse
|
|
import textwrap
|
|
import logging
|
|
|
|
# thanks go to git-remote-helper for some helper functions
|
|
|
|
def die(msg, *args):
|
|
sys.stderr.write('ERROR: %s\n' % (msg % args))
|
|
sys.exit(1)
|
|
|
|
def warn(msg, *args):
|
|
sys.stderr.write('WARNING: %s\n' % (msg % args))
|
|
|
|
def info(msg, *args):
|
|
logger.info(msg, *args)
|
|
|
|
def debug(msg, *args):
|
|
logger.debug(msg, *args)
|
|
|
|
def log(msg, *args):
|
|
logger.log(logging.LOG, msg, *args)
|
|
|
|
class GitHgRepo:
|
|
|
|
def __init__(self, topdir=None, gitdir=None):
|
|
if gitdir != None:
|
|
self.gitdir = gitdir
|
|
self.topdir = os.path.join(gitdir, '..') # will have to do
|
|
else:
|
|
self.topdir = None
|
|
if not topdir:
|
|
topdir = self.run_cmd(['rev-parse', '--show-cdup']).strip()
|
|
if not topdir:
|
|
if not os.path.exists('.git'):
|
|
# now we lost where we are
|
|
raise Exception('failed to determine topdir')
|
|
topdir = '.'
|
|
self.topdir = topdir
|
|
self.gitdir = self.run_cmd(['rev-parse', '--git-dir']).strip()
|
|
if not self.gitdir:
|
|
raise Exception('failed to determine gitdir')
|
|
# the above was run in topdir
|
|
if not os.path.isabs(self.gitdir):
|
|
self.gitdir = os.path.join(self.topdir, self.gitdir)
|
|
self.hg_repos = {}
|
|
|
|
def identity(self):
|
|
return '[%s|%s]' % (os.getcwd(), self.topdir)
|
|
|
|
# run a git cmd in repo dir, captures stdout and stderr by default
|
|
# override in kwargs if otherwise desired
|
|
def run_cmd(self, args, check=False, **kwargs):
|
|
cmd = ['git'] + args
|
|
popen_options = { 'cwd': self.topdir,
|
|
'stdout': subprocess.PIPE, 'stderr': subprocess.PIPE }
|
|
popen_options.update(kwargs)
|
|
log('%s running cmd %s with options %s', self.identity(),
|
|
cmd, popen_options)
|
|
process = subprocess.Popen(cmd, **popen_options)
|
|
output = process.communicate()[0]
|
|
if check and process.returncode != 0:
|
|
die('command failed: %s', ' '.join(cmd))
|
|
return output
|
|
|
|
def get_config(self, config, getall=False):
|
|
get = { True : '--get-all', False: '--get' }
|
|
cmd = ['git', 'config', get[getall] , config]
|
|
return self.run_cmd(['config', get[getall] , config], stderr=None)
|
|
|
|
def get_config_bool(self, config, default=False):
|
|
value = self.get_config(config).rstrip('\n')
|
|
if value == "true":
|
|
return True
|
|
elif value == "false":
|
|
return False
|
|
else:
|
|
return default
|
|
|
|
def get_hg_repo_url(self, remote):
|
|
url = self.get_config('remote.%s.url' % (remote))
|
|
if url and url[0:4] == 'hg::':
|
|
url = url[4:].strip()
|
|
else:
|
|
url = None
|
|
return url
|
|
|
|
def get_hg_rev(self, commit):
|
|
hgrev = self.run_cmd(['notes', '--ref', 'refs/notes/hg', 'show', commit])
|
|
return hgrev
|
|
|
|
def rev_parse(self, ref):
|
|
args = [ref] if not isinstance(ref, list) else ref
|
|
args[0:0] = ['rev-parse', '--verify', '-q']
|
|
return self.run_cmd(args).strip()
|
|
|
|
def update_ref(self, ref, value):
|
|
self.run_cmd(['update-ref', '-m', 'update by helper', ref, value])
|
|
# let's check it happened
|
|
return git_rev_parse(ref) == git_rev_parse(value)
|
|
|
|
def cat_file(self, ref):
|
|
return self.run_cmd(['cat-file', '-p', ref])
|
|
|
|
def get_git_commit(self, rev):
|
|
mydir = os.path.dirname(__file__)
|
|
import imp
|
|
remotehg = imp.load_source('remotehg', os.path.join(mydir, 'git-remote-hg'))
|
|
for r in self.get_hg_repos():
|
|
try:
|
|
hgpath = os.path.join(self.gitdir, 'hg', r)
|
|
m = remotehg.Marks(os.path.join(hgpath, 'marks-hg'), None)
|
|
mark = m.from_rev(rev)
|
|
m = GitMarks(os.path.join(hgpath, 'marks-git'))
|
|
return m.to_rev(mark)
|
|
except:
|
|
pass
|
|
|
|
# returns dict: (alias: local hg repo dir)
|
|
def get_hg_repos(self):
|
|
# minor caching
|
|
if self.hg_repos:
|
|
return self.hg_repos
|
|
|
|
# check any local hg repo to see if rev is in there
|
|
shared_path = os.path.join(self.gitdir, 'hg')
|
|
hg_path = os.path.join(shared_path, '.hg')
|
|
if os.path.exists(shared_path):
|
|
repos = os.listdir(shared_path)
|
|
for r in repos:
|
|
# skip the shared repo
|
|
if r == '.hg':
|
|
continue
|
|
local_path = os.path.join(shared_path, r, 'clone')
|
|
local_hg = os.path.join(local_path, '.hg')
|
|
if not os.path.exists(local_hg):
|
|
# could be a local repo without proxy, fetch url
|
|
local_path = self.get_hg_repo_url(r)
|
|
if not local_path:
|
|
warn('failed to find local hg for remote %s', r)
|
|
continue
|
|
else:
|
|
# make sure the shared path is always up-to-date
|
|
util.writefile(os.path.join(local_hg, 'sharedpath'), hg_path)
|
|
self.hg_repos[r] = os.path.join(local_path)
|
|
|
|
log('%s determined hg_repos %s', self.identity(), self.hg_repos)
|
|
return self.hg_repos
|
|
|
|
# returns hg repo object
|
|
def get_hg_repo(self, r):
|
|
repos = self.get_hg_repos()
|
|
if r in repos:
|
|
local_path = repos[r]
|
|
hushui = ui.ui()
|
|
hushui.setconfig('ui', 'interactive', 'off')
|
|
hushui.fout = open(os.devnull, 'w')
|
|
return hg.repository(hushui, local_path)
|
|
|
|
def find_hg_repo(self, rev):
|
|
repos = self.get_hg_repos()
|
|
for r in repos:
|
|
srepo = self.get_hg_repo(r)
|
|
# if this one had it, we are done
|
|
if srepo and rev in srepo and srepo[rev]:
|
|
return srepo
|
|
|
|
def rev_describe(self, rev):
|
|
result = self.run_cmd(['describe', rev]) or \
|
|
self.run_cmd(['describe', '--tags', rev]) or \
|
|
self.run_cmd(['describe', '--contains', rev]) or \
|
|
self.run_cmd(['describe', '--all', '--always', rev])
|
|
return result.strip()
|
|
|
|
class dictmemctx(context.memctx):
|
|
|
|
def __init__(self, repo, files):
|
|
p1, p2, data = repo[None], '0' * 40, ''
|
|
context.memctx.__init__(self, repo, (p1, p2),
|
|
data, files.keys(), self.getfilectx)
|
|
self.files = files
|
|
|
|
def __contains__(self, item):
|
|
return item in self.files
|
|
|
|
def getfilectx(self, repo, memctx, path):
|
|
is_exec = is_link = rename = False
|
|
if check_version(3, 1):
|
|
return context.memfilectx(repo, path, self.files[path],
|
|
is_link, is_exec, rename)
|
|
else:
|
|
return context.memfilectx(path, self.files[path],
|
|
is_link, is_exec, rename)
|
|
|
|
def read(self, relpath, rev=None):
|
|
rev = rev if rev else ':0'
|
|
obj = '%s:%s' % (rev, relpath)
|
|
# might complain bitterly to stderr if no subrepos so let's not show that
|
|
return self.run_cmd(['show', obj])
|
|
|
|
# see also subrepo.state
|
|
def state(self, remote='origin', rev=None):
|
|
"""return a state dict, mapping subrepo paths configured in .hgsub
|
|
to tuple: (source from .hgsub, revision from .hgsubstate, kind
|
|
(key in types dict))
|
|
"""
|
|
|
|
# obtain relevant files' content from specified revision
|
|
files = { }
|
|
for f in ('.hgsub', '.hgsubstate'):
|
|
files[f] = self.read(f)
|
|
log('state files for %s in revision %s:\n%s', remote, rev, files)
|
|
|
|
# wrap in a context and delegate to subrepo
|
|
# (rather than duplicating the admittedly simple parsing here)
|
|
repo = self.get_hg_repo(remote)
|
|
if not repo:
|
|
die('no hg repo for alias %s' % remote)
|
|
ctx = self.dictmemctx(repo, files)
|
|
state = subrepo.state(ctx, ui.ui())
|
|
log('obtained state %s', state)
|
|
|
|
# now filter on type and resolve relative urls
|
|
import posixpath
|
|
resolved = {}
|
|
for s in state:
|
|
src, rev, kind = state[s]
|
|
if not kind in ('hg', 'git'):
|
|
warn('skipping unsupported subrepo type %s' % kind)
|
|
continue
|
|
if not util.url(src).isabs():
|
|
parent = self.get_hg_repo_url(remote)
|
|
if not parent:
|
|
die('could not determine repo url of %s' % remote)
|
|
parent = util.url(parent)
|
|
parent.path = posixpath.join(parent.path or '', src)
|
|
parent.path = posixpath.normpath(parent.path)
|
|
src = str(parent)
|
|
# translate to git view url
|
|
if kind == 'hg':
|
|
src = 'hg::' + src
|
|
resolved[s] = (src.strip(), rev or '', kind)
|
|
log('resolved state %s', resolved)
|
|
return resolved
|
|
|
|
|
|
class SubCommand:
|
|
|
|
def __init__(self, subcmdname, githgrepo):
|
|
self.subcommand = subcmdname
|
|
self.githgrepo = githgrepo
|
|
self.argparser = self.argumentparser()
|
|
|
|
def argumentparser(self):
|
|
return argparse.ArgumentParser()
|
|
|
|
def get_remote(self, args):
|
|
if len(args):
|
|
return (args[0], args[1:])
|
|
else:
|
|
self.usage('missing argument: <remote-alias>')
|
|
|
|
def get_remote_url_hg(self, remote):
|
|
url = self.githgrepo.get_hg_repo_url(remote)
|
|
if not url:
|
|
self.usage('%s is not a remote hg repository' % (remote))
|
|
return url
|
|
|
|
def execute(self, args):
|
|
(self.options, self.args) = self.argparser.parse_known_args(args)
|
|
self.do(self.options, self.args)
|
|
|
|
def usage(self, msg):
|
|
if msg:
|
|
self.argparser.error(msg)
|
|
else:
|
|
self.argparser.print_usage(sys.stderr)
|
|
sys.exit(2)
|
|
|
|
def do(self, options, args):
|
|
pass
|
|
|
|
|
|
class HgRevCommand(SubCommand):
|
|
|
|
def argumentparser(self):
|
|
usage = '%%(prog)s %s [options] <commit-ish>' % (self.subcommand)
|
|
p = argparse.ArgumentParser(usage=usage)
|
|
p.epilog = textwrap.dedent("""\
|
|
Determines the hg revision corresponding to <commit-ish>.
|
|
""")
|
|
return p
|
|
|
|
def do(self, options, args):
|
|
if len(args):
|
|
hgrev = self.githgrepo.get_hg_rev(args[0])
|
|
if hgrev:
|
|
print hgrev
|
|
|
|
|
|
class GitMarks:
|
|
|
|
def __init__(self, path):
|
|
self.path = path
|
|
self.clear()
|
|
self.load()
|
|
|
|
def clear(self):
|
|
self.marks = {}
|
|
self.rev_marks = {}
|
|
|
|
def load(self):
|
|
if not os.path.exists(self.path):
|
|
return
|
|
|
|
for l in file(self.path):
|
|
m, c = l.strip().split(' ', 2)
|
|
m = int(m[1:])
|
|
self.marks[c] = m
|
|
self.rev_marks[m] = c
|
|
|
|
def store(self):
|
|
marks = self.rev_marks.keys()
|
|
marks.sort()
|
|
with open(self.path, 'w') as f:
|
|
for m in marks:
|
|
f.write(':%d %s\n' % (m, self.rev_marks[m]))
|
|
|
|
def from_rev(self, rev):
|
|
return self.marks[rev]
|
|
|
|
def to_rev(self, mark):
|
|
return str(self.rev_marks[mark])
|
|
|
|
|
|
class GitRevCommand(SubCommand):
|
|
|
|
def argumentparser(self):
|
|
usage = '%%(prog)s %s [options] <revision>' % (self.subcommand)
|
|
p = argparse.ArgumentParser(usage=usage)
|
|
p.epilog = textwrap.dedent("""\
|
|
Determines the git commit id corresponding to hg <revision>.
|
|
""")
|
|
return p
|
|
|
|
def do(self, options, args):
|
|
if len(args):
|
|
rev = args[0]
|
|
gitcommit = self.githgrepo.get_git_commit(rev)
|
|
if gitcommit:
|
|
print gitcommit
|
|
|
|
|
|
class MarksCommand(SubCommand):
|
|
|
|
def argumentparser(self):
|
|
usage = '%%(prog)s %s [options] <remote>...' % (self.subcommand)
|
|
p = argparse.ArgumentParser(usage=usage, \
|
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
p.add_argument('-n', '--dry-run', action='store_true',
|
|
help='do not actually update any metadata files')
|
|
p.add_argument('--keep', metavar='REVID',
|
|
help='only retain ancestors of REVID (including) in \
|
|
hg tracking metadata, akin to hg\'s strip')
|
|
p.epilog = textwrap.dedent("""\
|
|
Performs checks on <remote>'s marks files and ensures these are consistent
|
|
(never affecting or touching any git repository objects or history).
|
|
The marks files are considered consistent if they "join"
|
|
on the :mark number (with no dangling hg or git commit id on either side).
|
|
|
|
While fetching from an hg remote usually results in a sane state, there
|
|
are some cases where that might not suffice (or not even succeed in the first
|
|
place). Also, fetching will only ever add tracked metadata marks, whereas
|
|
sometimes forgetting about some state might be required for consistent state
|
|
recovery (e.g. a strip performed on a remote Mercurial repo). Executing this
|
|
command should allow a subsequent fetch to succeed and restore a sane state
|
|
quickly. In particular, making good use of --keep following a strip allows
|
|
a subsequent fetch to recover quickly without extensive history processing.
|
|
|
|
Furthermore, since git-fast-import (used during fetch) also dumps
|
|
non-commit SHA-1 in the marks file, the latter can become pretty large.
|
|
It will reduce in size by either performing a push (git-fast-export only
|
|
dumps commit objects to marks file) or by running this helper command.
|
|
""")
|
|
return p
|
|
|
|
def do(self, options, args):
|
|
mydir = os.path.dirname(__file__)
|
|
import imp
|
|
remotehg = imp.load_source('remotehg', os.path.join(mydir, 'git-remote-hg'))
|
|
|
|
hg_repos = self.githgrepo.get_hg_repos()
|
|
if not args:
|
|
self.usage('no remote specified')
|
|
for remote in args:
|
|
if not remote in hg_repos:
|
|
self.usage('%s is not a valid hg remote' % (remote))
|
|
hgpath = os.path.join(self.githgrepo.gitdir, 'hg', remote)
|
|
hgm = remotehg.Marks(os.path.join(hgpath, 'marks-hg'), None)
|
|
gm = GitMarks(os.path.join(hgpath, 'marks-git'))
|
|
repo = hg.repository(ui.ui(), hg_repos[remote])
|
|
ctx = ctxrev = None
|
|
if options.keep != None:
|
|
strip = options.keep
|
|
if strip in repo and repo[strip]:
|
|
ctx = repo[strip]
|
|
ctxrev = ctx.rev()
|
|
if not ctxrev >= 0:
|
|
self.usage('revision %s not found in repository %s' % (strip, repo.root))
|
|
# reduce down to marks that are common to both
|
|
common_marks = set(hgm.rev_marks.keys()).intersection(gm.rev_marks.keys())
|
|
hg_rev_marks = {}
|
|
git_rev_marks = {}
|
|
for m in common_marks:
|
|
rev = hgm.rev_marks[m]
|
|
# also check if still around in repo
|
|
if rev in repo and \
|
|
not (ctxrev != None and repo[rev].rev() > ctxrev):
|
|
hg_rev_marks[m] = hgm.rev_marks[m]
|
|
git_rev_marks[m] = gm.rev_marks[m]
|
|
# common marks will not not include any refs/notes/hg
|
|
# let's not discard those casually, though they are not vital
|
|
revlist = subprocess.Popen(['git', 'rev-list', 'refs/notes/hg'], stdout=subprocess.PIPE)
|
|
for l in revlist.stdout.readlines():
|
|
c = l.strip()
|
|
m = gm.marks.get(c, 0)
|
|
if m:
|
|
git_rev_marks[m] = c
|
|
# also save last-note mark
|
|
if hgm.last_note:
|
|
git_rev_marks[hgm.last_note] = gm.rev_marks[hgm.last_note]
|
|
# some status report
|
|
if len(hgm.rev_marks) != len(hg_rev_marks):
|
|
print "Trimmed hg marks from #%d down to #%d" % (len(hgm.rev_marks), len(hg_rev_marks))
|
|
if len(gm.rev_marks) != len(git_rev_marks):
|
|
print "Trimmed git marks from #%d down to #%d" % (len(gm.rev_marks), len(git_rev_marks))
|
|
# make hg tips as consistent as possible
|
|
for b in hgm.tips:
|
|
tip = hgm.tips[b]
|
|
if tip not in repo or not repo[tip]:
|
|
if not ctx:
|
|
print "Could not determine safe value for tip of %s (rev %s)" % (b, tip)
|
|
print "Please use --strip to provide fallback value."
|
|
return
|
|
else:
|
|
# basically only the revision number is used by a fetch
|
|
tip = ctx.hex()
|
|
else:
|
|
hgrevs = set(hg_rev_marks.values())
|
|
while True:
|
|
if tip in hgrevs:
|
|
break
|
|
parent = repo[tip].parents()[0].hex()
|
|
if parent == tip:
|
|
break
|
|
tip = parent
|
|
if hgm.tips[b] != tip:
|
|
hgm.tips[b] = tip
|
|
print "Updated tip of %s to %s" % (b, tip)
|
|
# now update and store
|
|
if not options.dry_run:
|
|
# hg marks
|
|
hgm.rev_marks = hg_rev_marks
|
|
hgm.marks = {}
|
|
for mark, rev in hg_rev_marks.iteritems():
|
|
hgm.marks[rev] = mark
|
|
hgm.store()
|
|
# git marks
|
|
gm.rev_marks = git_rev_marks
|
|
gm.marks = {}
|
|
for mark, rev in git_rev_marks.iteritems():
|
|
gm.marks[rev] = mark
|
|
gm.store()
|
|
|
|
|
|
class SubRepoCommand(SubCommand):
|
|
|
|
def writestate(repo, state):
|
|
"""rewrite .hgsubstate in (outer) repo with these subrepo states"""
|
|
lines = ['%s %s\n' % (state[s][1], s) for s in sorted(state)
|
|
if state[s][1] != nullstate[1]]
|
|
repo.wwrite('.hgsubstate', ''.join(lines), '')
|
|
|
|
def argumentparser(self):
|
|
#usage = '%%(prog)s %s [options] <remote>...' % (self.subcommand)
|
|
# argparse.ArgumentParser(parents=[common])
|
|
# top-level
|
|
p = argparse.ArgumentParser(
|
|
formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
p.add_argument('--quiet', '-q', action='store_true')
|
|
p.add_argument('--recursive', '-r', action='store_true',
|
|
help='recursive execution in each submodule')
|
|
p.add_argument('--remote', metavar='ALIAS', default='origin',
|
|
help='remote alias to use as base for relative url')
|
|
p.epilog = textwrap.dedent("""\
|
|
A group of (sub-)subcommands that aid in handling Mercurial subrepos
|
|
as managed by .hgsub and .hgsubstate. The commands are (where applicable)
|
|
loosely modeled after the corresponding and similar git-submodule command,
|
|
though otherwise there is no relation whatsoever with the git-submodule system.
|
|
Each command supports recursive execution into subrepos of subrepos,
|
|
and the considered (top-level) repos can be restricted by a list of subrepo
|
|
paths as arguments. For most commands, the state files are examined
|
|
in the parent repo's index.
|
|
|
|
Though depending on your workflow, the \'update\' command will likely
|
|
suffice, along with possibly an occasional \'upstate\'.
|
|
""")
|
|
# subparsers
|
|
sub = p.add_subparsers()
|
|
# common
|
|
common = argparse.ArgumentParser(add_help=False)
|
|
common.add_argument('paths', nargs=argparse.REMAINDER)
|
|
# update
|
|
p_update = sub.add_parser('update', parents=[common],
|
|
help='update subrepos to state as specified in parent repo')
|
|
p_update.set_defaults(func=self.cmd_update)
|
|
p_update.add_argument('--rebase', action='store_true',
|
|
help='rebase the subrepo current branch onto recorded superproject commit')
|
|
p_update.add_argument('--merge', action='store_true',
|
|
help='merge recorded superproject commit into the current branch of subrepo')
|
|
p_update.add_argument('--force', action='store_true',
|
|
help='throw away local changes when switching to a different commit')
|
|
p_update.epilog = textwrap.dedent("""\
|
|
Brings all subrepos in the state as specified by the parent repo.
|
|
If not yet present in the subpath, the subrepo is cloned from the URL
|
|
specified by the parent repo (resolving relative path wrt a parent repo URL).
|
|
If already present, and target state revision is ancestor of current HEAD,
|
|
no update is done. Otherwise, a checkout to the required revision is done
|
|
(optionally forcibly so). Alternatively, a rebase or merge is performed if
|
|
so requested by the corresponding option.
|
|
""")
|
|
# foreach
|
|
p_foreach = sub.add_parser('foreach',
|
|
help='evaluate shell command in each checked out subrepo')
|
|
p_foreach.set_defaults(func=self.cmd_foreach)
|
|
p_foreach.add_argument('command', help='shell command')
|
|
p_foreach.epilog = textwrap.dedent("""\
|
|
The command is executed in the subrepo directory and has access to
|
|
the variables $path, $toplevel, $sha1, $rev and $kind.
|
|
$path is the subrepo directory relative to the parent project.
|
|
$toplevel is the absolute path to the top-level of the parent project.
|
|
$rev is the state revision info as set in .hgsubstate whereas
|
|
$sha1 is the git commit corresponding to it (which may be identical
|
|
if subrepo is a git repo). $kind is the type of subrepo, e.g. git or hg.
|
|
Unless given --quiet, the (recursively collected) submodule path is printed
|
|
before evaluating the command. A non-zero return from the command in
|
|
any submodule causes the processing to terminate.
|
|
""")
|
|
# add state
|
|
p_upstate = sub.add_parser('upstate', parents=[common],
|
|
help='update .hgsubstate to current HEAD of subrepo')
|
|
p_upstate.set_defaults(func=self.cmd_upstate)
|
|
p_upstate.epilog = textwrap.dedent("""\
|
|
Rather than dealing with the index the .hgsubstate file is simply and only
|
|
edited to reflect the current HEAD of (all or selected) subrepos
|
|
(and any adding to index and committing is left to user's discretion).
|
|
""")
|
|
# status
|
|
p_status = sub.add_parser('status', parents=[common],
|
|
help='show the status of the subrepos')
|
|
p_status.add_argument('--cached', action='store_true',
|
|
help='show index .hgsubstate revision if != subrepo HEAD')
|
|
p_status.set_defaults(func=self.cmd_status)
|
|
p_status.epilog = textwrap.dedent("""\
|
|
This will print the SHA-1 of the currently checked out commit for each
|
|
subrepo, along with the subrepo path and the output of git describe for
|
|
the SHA-1. Each SHA-1 will be prefixed with - if the submodule is not
|
|
yet set up (i.e. cloned) and + if the currently checked out submodule commit
|
|
does not match the SHA-1 found in the parent repo index state.
|
|
""")
|
|
# sync
|
|
p_sync = sub.add_parser('sync', parents=[common],
|
|
help='synchronize subrepo\'s remote URL configuration with parent configuration')
|
|
p_sync.set_defaults(func=self.cmd_sync)
|
|
p_sync.epilog = textwrap.dedent("""\
|
|
The subrepo's .git/config URL configuration is set to the value specified in
|
|
the parent's .hgstate (with relative path suitable resolved wrt parent project).
|
|
""")
|
|
return p
|
|
|
|
def git_hg_repo_try(self, path):
|
|
try:
|
|
return GitHgRepo(topdir=path)
|
|
except:
|
|
return None
|
|
|
|
def run_cmd(self, options, repo, *args, **kwargs):
|
|
# no output if quiet, otherwise show output by default
|
|
# unless the caller specified something explicitly
|
|
if hasattr(options, 'quiet') and options.quiet:
|
|
kwargs['stdout'] = os.devnull
|
|
elif 'stdout' not in kwargs:
|
|
kwargs['stdout'] = None
|
|
# show errors unless caller decide some way
|
|
if 'stderr' not in kwargs:
|
|
kwargs['stderr'] = None
|
|
repo.run_cmd(*args, **kwargs)
|
|
|
|
class subcontext(dict):
|
|
__getattr__= dict.__getitem__
|
|
__setattr__= dict.__setitem__
|
|
__delattr__= dict.__delitem__
|
|
def __init__(self, repo):
|
|
# recursion level
|
|
self.level = 0
|
|
# super repo object
|
|
self.repo = repo
|
|
# sub repo object (if any)
|
|
self.subrepo = None
|
|
# (recursively) collected path of subrepo
|
|
self.subpath = None
|
|
# relative path of subrepo wrt super repo
|
|
self.relpath = None
|
|
|
|
def do(self, options, args):
|
|
if args:
|
|
# all arguments are registered, so should not have leftover
|
|
# could be that main arguments were given to subcommands
|
|
warn('unparsed arguments: %s' % ' '.join(args))
|
|
log('running subcmd options %s, args %s', options, args)
|
|
# establish initial operation ctx
|
|
ctx = self.subcontext(self.githgrepo)
|
|
self.do_operation(options, args, ctx)
|
|
|
|
def do_operation(self, options, args, ctx):
|
|
log('running %s with options %s in context %s', \
|
|
options.func, options, ctx)
|
|
subrepos = ctx.repo.state(options.remote)
|
|
paths = subrepos.keys()
|
|
selabspaths = None
|
|
if ctx.level == 0 and hasattr(options, 'paths') and options.paths:
|
|
selabspaths = [ os.path.abspath(p) for p in options.paths ]
|
|
log('level %s selected paths %s', ctx.level, selabspaths)
|
|
for p in paths:
|
|
# prep context
|
|
ctx.relpath = p
|
|
ctx.subpath = os.path.join(ctx.repo.topdir, p)
|
|
# check if selected
|
|
abspath = os.path.abspath(ctx.subpath)
|
|
if selabspaths != None and abspath not in selabspaths:
|
|
log('skipping subrepo abspath %s' % abspath)
|
|
continue
|
|
ctx.subrepo = self.git_hg_repo_try(ctx.subpath)
|
|
ctx.state = subrepos[p]
|
|
# perform operation
|
|
log('exec for context %s', ctx)
|
|
options.func(options, args, ctx)
|
|
if not ctx.subrepo:
|
|
ctx.subrepo = self.git_hg_repo_try(ctx.subpath)
|
|
# prep recursion (only into git-hg subrepos)
|
|
if ctx.subrepo and options.recursive and ctx.state[2] == 'hg':
|
|
newctx = self.subcontext(ctx.subrepo)
|
|
newctx.level = ctx.level + 1
|
|
self.do_operation(options, args, newctx)
|
|
|
|
def get_git_commit(self, ctx):
|
|
src, rev, kind = ctx.state
|
|
if kind == 'hg':
|
|
gitcommit = ctx.subrepo.get_git_commit(rev)
|
|
if not gitcommit:
|
|
die('could not determine git commit for %s; a fetch may update notes' % rev)
|
|
else:
|
|
gitcommit = rev
|
|
return gitcommit
|
|
|
|
def cmd_upstate(self, options, args, ctx):
|
|
if not ctx.subrepo:
|
|
return
|
|
src, orig, kind = ctx.state
|
|
gitcommit = ctx.subrepo.rev_parse('HEAD')
|
|
if not gitcommit:
|
|
die('could not determine current HEAD state in %s' % ctx.subrepo.topdir)
|
|
rev = gitcommit
|
|
if kind == 'hg':
|
|
rev = ctx.subrepo.get_hg_rev(gitcommit)
|
|
if not rev:
|
|
die('could not determine hg changeset for commit %s' % gitcommit)
|
|
else:
|
|
rev = gitcommit
|
|
# obtain state from index
|
|
state_path = os.path.join(ctx.repo.topdir, '.hgsubstate')
|
|
# should have this, since we have subrepo (state) in the first place ...
|
|
if not os.path.exists(state_path):
|
|
die('no .hgsubstate found in repo %s' % ctx.repo.topdir)
|
|
if orig != rev:
|
|
short = ctx.subrepo.rev_parse(['--short', gitcommit])
|
|
print "Updating %s to %s [git %s]" % (ctx.subpath, rev, short)
|
|
# replace and update index
|
|
with open(state_path, 'r') as f:
|
|
state = f.read()
|
|
state = re.sub('.{40} %s' % (ctx.relpath), '%s %s' % (rev, ctx.relpath), state)
|
|
with open(state_path, 'wb') as f:
|
|
f.write(state)
|
|
|
|
def cmd_foreach(self, options, args, ctx):
|
|
if not ctx.subrepo:
|
|
return
|
|
if not options.quiet:
|
|
print 'Entering %s' % ctx.subpath
|
|
sys.stdout.flush()
|
|
newenv = os.environ.copy()
|
|
newenv['path'] = ctx.relpath
|
|
newenv['sha1'] = self.get_git_commit(ctx)
|
|
newenv['toplevel'] = os.path.abspath(ctx.repo.topdir)
|
|
newenv['rev'] = ctx.state[1]
|
|
newenv['kind'] = ctx.state[2]
|
|
proc = subprocess.Popen(options.command, shell=True, cwd=ctx.subpath, env=newenv)
|
|
proc.wait()
|
|
if proc.returncode != 0:
|
|
die('stopping at %s; script returned non-zero status' % ctx.subpath)
|
|
|
|
def cmd_update(self, options, args, ctx):
|
|
if not ctx.subrepo:
|
|
src, _, _ = ctx.state
|
|
self.run_cmd(options, ctx.repo, ['clone', src, ctx.subpath], cwd=None)
|
|
ctx.subrepo = self.git_hg_repo_try(ctx.subpath)
|
|
if not ctx.subrepo:
|
|
die('subrepo %s setup clone failed', ctx.subpath)
|
|
# force (detached) checkout of target commit following clone
|
|
cmd = [ 'checkout', '-q' ]
|
|
else:
|
|
self.run_cmd(options, ctx.subrepo, ['fetch', 'origin'], check=True)
|
|
cmd = []
|
|
# check if subrepo is up-to-date,
|
|
# i.e. if target commit is ancestor of HEAD
|
|
# (output never to be shown)
|
|
gitcommit = self.get_git_commit(ctx)
|
|
newrev = ctx.subrepo.run_cmd(['rev-list', gitcommit, '^HEAD']).strip()
|
|
if newrev and not cmd:
|
|
if options.force:
|
|
self.run_cmd(options, ctx.subrepo, ['reset', '--hard', 'HEAD'],
|
|
check=True)
|
|
if options.rebase:
|
|
cmd = [ 'rebase' ]
|
|
elif options.merge:
|
|
cmd = [ 'merge' ]
|
|
else:
|
|
# we know about the detached consequences ... keep it a bit quiet
|
|
cmd = [ 'checkout', '-q' ]
|
|
if cmd:
|
|
cmd.append(gitcommit)
|
|
self.run_cmd(options, ctx.subrepo, cmd, check=True)
|
|
|
|
def cmd_status(self, options, args, ctx):
|
|
if not ctx.subrepo:
|
|
state = '-'
|
|
revname = ''
|
|
_, gitcommit, kind = ctx.state
|
|
if kind != 'git':
|
|
gitcommit += '[hg] '
|
|
else:
|
|
gitcommit = self.get_git_commit(ctx)
|
|
head = ctx.subrepo.rev_parse('HEAD')
|
|
if head == gitcommit:
|
|
state = ' '
|
|
else:
|
|
state = '+'
|
|
# option determines what to print
|
|
if not options.cached:
|
|
gitcommit = head
|
|
revname = ctx.subrepo.rev_describe(gitcommit)
|
|
if revname:
|
|
revname = ' (%s)' % revname
|
|
print "%s%s %s%s" % (state, gitcommit, ctx.subpath, revname)
|
|
|
|
def cmd_sync(self, options, args, ctx):
|
|
if not ctx.subrepo:
|
|
return
|
|
src, _, _ = ctx.state
|
|
self.run_cmd(options, ctx.subrepo, \
|
|
['config', 'remote.%s.url' % (options.remote), src])
|
|
|
|
|
|
class RepoCommand(SubCommand):
|
|
|
|
def argumentparser(self):
|
|
usage = '%%(prog)s %s [options] <remote>...' % (self.subcommand)
|
|
p = argparse.ArgumentParser(usage=usage)
|
|
p.epilog = textwrap.dedent("""\
|
|
Determines the local hg repository of <remote>.
|
|
This can either be a separate and independent local hg repository
|
|
or a local proxy repo (within the .git directory).
|
|
""")
|
|
return p
|
|
|
|
def do(self, options, args):
|
|
(remote, args) = self.get_remote(args)
|
|
repos = self.githgrepo.get_hg_repos()
|
|
if remote in repos:
|
|
print repos[remote].rstrip('/')
|
|
|
|
|
|
class HgCommand(SubCommand):
|
|
|
|
def argumentparser(self):
|
|
usage = '%%(prog)s %s <hg-command>...' % (self.subcommand)
|
|
p = argparse.ArgumentParser(usage=usage)
|
|
hgdir = self.githgrepo.get_hg_repos()[self.subcommand]
|
|
p.epilog = textwrap.dedent("""\
|
|
Executes <hg-command> on the backing repository of %s (%s)
|
|
(by supplying it with the standard -R option).
|
|
""" % (self.subcommand, hgdir))
|
|
return p
|
|
|
|
def do(self, options, args):
|
|
# subcommand name is already a known valid alias of hg repo
|
|
remote = self.subcommand
|
|
repos = self.githgrepo.get_hg_repos()
|
|
if len(args) and remote in repos:
|
|
if args[0].find('hg') < 0:
|
|
args.insert(0, 'hg')
|
|
args[1:1] = ['-R', repos[remote]]
|
|
p = subprocess.Popen(args, stdout=None)
|
|
p.wait()
|
|
else:
|
|
if len(args):
|
|
self.usage('invalid repo: %s' % remote)
|
|
else:
|
|
self.usage('missing command')
|
|
|
|
|
|
class HelpCommand(SubCommand):
|
|
|
|
def do(self, options, args):
|
|
if len(args):
|
|
cmd = args[0]
|
|
if cmd in subcommands:
|
|
p = subcommands[cmd].argumentparser()
|
|
p.print_help(sys.stderr)
|
|
return
|
|
do_usage()
|
|
|
|
|
|
def get_subcommands():
|
|
commands = {
|
|
'hg-rev': HgRevCommand,
|
|
'git-rev': GitRevCommand,
|
|
'repo': RepoCommand,
|
|
'marks': MarksCommand,
|
|
'sub': SubRepoCommand,
|
|
'help' : HelpCommand
|
|
}
|
|
# add remote named subcommands
|
|
repos = githgrepo.get_hg_repos()
|
|
for r in repos:
|
|
if not r in commands:
|
|
commands[r] = HgCommand
|
|
# now turn into instances
|
|
for c in commands:
|
|
commands[c] = commands[c](c, githgrepo)
|
|
return commands
|
|
|
|
|
|
def do_usage():
|
|
usage = textwrap.dedent("""
|
|
git-hg-helper subcommands:
|
|
|
|
hg-rev \t show hg revision corresponding to a git revision
|
|
git-rev \t find git revision corresponding to a hg revision
|
|
marks \t perform maintenance on repo tracking marks
|
|
sub \t manage subrepos
|
|
repo \t show local hg repo backing a remote
|
|
|
|
If the subcommand is the name of a remote hg repo, then any remaining arguments
|
|
are considered a "hg command", e.g. hg heads, or thg, and it is then executed
|
|
with -R set appropriately to the local hg repo backing the specified remote.
|
|
Do note, however, that the local proxy repos are not maintained as exact mirrors
|
|
of their respective remote, and also use shared storage. As such, depending
|
|
on the command, the result may not be exactly as could otherwise be expected
|
|
(e.g. might involve more heads, etc).
|
|
|
|
Available hg remotes:
|
|
""")
|
|
for r in githgrepo.get_hg_repos():
|
|
usage += '\t%s\n' % (r)
|
|
usage += '\n'
|
|
sys.stderr.write(usage)
|
|
sys.stderr.flush()
|
|
sys.exit(2)
|
|
|
|
def init_git(gitdir=None):
|
|
global githgrepo
|
|
|
|
try:
|
|
githgrepo = GitHgRepo(gitdir=gitdir)
|
|
except Exception, e:
|
|
die(str(e))
|
|
|
|
def init_logger():
|
|
global logger
|
|
|
|
# setup logging
|
|
logging.LOG = 5
|
|
logging.addLevelName(logging.LOG, 'LOG')
|
|
envlevel = os.environ.get('GIT_HG_HELPER_DEBUG', 'WARN')
|
|
loglevel = logging.getLevelName(envlevel)
|
|
logging.basicConfig(level=loglevel, \
|
|
format='%(asctime)-15s %(levelname)s %(message)s')
|
|
logger = logging.getLogger()
|
|
|
|
def init_version():
|
|
global hg_version
|
|
|
|
try:
|
|
version, _, extra = util.version().partition('+')
|
|
version = list(int(e) for e in version.split('.'))
|
|
if extra:
|
|
version[1] += 1
|
|
hg_version = tuple(version)
|
|
except:
|
|
hg_version = None
|
|
|
|
def check_version(*check):
|
|
if not hg_version:
|
|
return True
|
|
return hg_version >= check
|
|
|
|
def main(argv):
|
|
global subcommands
|
|
|
|
# init repo dir
|
|
# we will take over dir management ...
|
|
init_git(os.environ.pop('GIT_DIR', None))
|
|
|
|
# as an alias, cwd is top dir, change again to original directory
|
|
reldir = os.environ.get('GIT_PREFIX')
|
|
if reldir:
|
|
os.chdir(reldir)
|
|
|
|
subcommands = get_subcommands()
|
|
|
|
cmd = ''
|
|
if len(argv) > 1:
|
|
cmd = argv[1]
|
|
argv = argv[2:]
|
|
if cmd in subcommands:
|
|
c = subcommands[cmd]
|
|
c.execute(argv)
|
|
else:
|
|
do_usage()
|
|
|
|
init_logger()
|
|
init_version()
|
|
if __name__ == '__main__':
|
|
sys.exit(main(sys.argv))
|