contrib/remote-helpers/git-remote-hg

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2012 Felipe Contreras
   4 #
   5
   6 # Inspired by Rocco Rutte's hg-fast-export
   7
   8 # Just copy to your ~/bin, or anywhere in your $PATH.
   9 # Then you can clone with:
  10 # git clone hg::/path/to/mercurial/repo/
  11 #
  12 # For remote repositories a local clone is stored in
  13 # "$GIT_DIR/hg/origin/clone/.hg/".
  14
  15 from mercurial import hg, ui, bookmarks, context, util, encoding, node, error
  16
  17 import re
  18 import sys
  19 import os
  20 import json
  21 import shutil
  22 import subprocess
  23 import urllib
  24 import atexit
  25 import urlparse
  26
  27 #
  28 # If you want to switch to hg-git compatibility mode:
  29 # git config --global remote-hg.hg-git-compat true
  30 #
  31 # If you are not in hg-git-compat mode and want to disable the tracking of
  32 # named branches:
  33 # git config --global remote-hg.track-branches false
  34 #
  35 # If you don't want to force pushes (and thus risk creating new remote heads):
  36 # git config --global remote-hg.force-push false
  37 #
  38 # If you want the equivalent of hg's clone/pull--insecure option:
  39 # git config remote-hg.insecure true
  40 #
  41 # git:
  42 # Sensible defaults for git.
  43 # hg bookmarks are exported as git branches, hg branches are prefixed
  44 # with 'branches/', HEAD is a special case.
  45 #
  46 # hg:
  47 # Emulate hg-git.
  48 # Only hg bookmarks are exported as git branches.
  49 # Commits are modified to preserve hg information and allow bidirectionality.
  50 #
  51
  52 NAME_RE = re.compile('^([^<>]+)')
  53 AUTHOR_RE = re.compile('^([^<>]+?)? ?<([^<>]*)>$')
  54 AUTHOR_HG_RE = re.compile('^(.*?) ?<(.*?)(?:>(.+)?)?$')
  55 RAW_AUTHOR_RE = re.compile('^(\w+) (?:(.+)? )?<(.*)> (\d+) ([+-]\d+)')
  56
  57 def die(msg, *args):
  58     sys.stderr.write('ERROR: %s\n' % (msg % args))
  59     sys.exit(1)
  60
  61 def warn(msg, *args):
  62     sys.stderr.write('WARNING: %s\n' % (msg % args))
  63
  64 def gitmode(flags):
  65     return 'l' in flags and '120000' or 'x' in flags and '100755' or '100644'
  66
  67 def gittz(tz):
  68     return '%+03d%02d' % (-tz / 3600, -tz % 3600 / 60)
  69
  70 def hgmode(mode):
  71     m = { '100755': 'x', '120000': 'l' }
  72     return m.get(mode, '')
  73
  74 def hghex(node):
  75     return hg.node.hex(node)
  76
  77 def get_config(config):
  78     cmd = ['git', 'config', '--get', config]
  79     process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
  80     output, _ = process.communicate()
  81     return output
  82
  83 class Marks:
  84
  85     def __init__(self, path):
  86         self.path = path
  87         self.tips = {}
  88         self.marks = {}
  89         self.rev_marks = {}
  90         self.last_mark = 0
  91
  92         self.load()
  93
  94     def load(self):
  95         if not os.path.exists(self.path):
  96             return
  97
  98         tmp = json.load(open(self.path))
  99
 100         self.tips = tmp['tips']
 101         self.marks = tmp['marks']
 102         self.last_mark = tmp['last-mark']
 103
 104         for rev, mark in self.marks.iteritems():
 105             self.rev_marks[mark] = int(rev)
 106
 107     def dict(self):
 108         return { 'tips': self.tips, 'marks': self.marks, 'last-mark' : self.last_mark }
 109
 110     def store(self):
 111         json.dump(self.dict(), open(self.path, 'w'))
 112
 113     def __str__(self):
 114         return str(self.dict())
 115
 116     def from_rev(self, rev):
 117         return self.marks[str(rev)]
 118
 119     def to_rev(self, mark):
 120         return self.rev_marks[mark]
 121
 122     def get_mark(self, rev):
 123         self.last_mark += 1
 124         self.marks[str(rev)] = self.last_mark
 125         return self.last_mark
 126
 127     def new_mark(self, rev, mark):
 128         self.marks[str(rev)] = mark
 129         self.rev_marks[mark] = rev
 130         self.last_mark = mark
 131
 132     def is_marked(self, rev):
 133         return str(rev) in self.marks
 134
 135     def get_tip(self, branch):
 136         return self.tips.get(branch, 0)
 137
 138     def set_tip(self, branch, tip):
 139         self.tips[branch] = tip
 140
 141 class Parser:
 142
 143     def __init__(self, repo):
 144         self.repo = repo
 145         self.line = self.get_line()
 146
 147     def get_line(self):
 148         return sys.stdin.readline().strip()
 149
 150     def __getitem__(self, i):
 151         return self.line.split()[i]
 152
 153     def check(self, word):
 154         return self.line.startswith(word)
 155
 156     def each_block(self, separator):
 157         while self.line != separator:
 158             yield self.line
 159             self.line = self.get_line()
 160
 161     def __iter__(self):
 162         return self.each_block('')
 163
 164     def next(self):
 165         self.line = self.get_line()
 166         if self.line == 'done':
 167             self.line = None
 168
 169     def get_mark(self):
 170         i = self.line.index(':') + 1
 171         return int(self.line[i:])
 172
 173     def get_data(self):
 174         if not self.check('data'):
 175             return None
 176         i = self.line.index(' ') + 1
 177         size = int(self.line[i:])
 178         return sys.stdin.read(size)
 179
 180     def get_author(self):
 181         global bad_mail
 182
 183         ex = None
 184         m = RAW_AUTHOR_RE.match(self.line)
 185         if not m:
 186             return None
 187         _, name, email, date, tz = m.groups()
 188         if name and 'ext:' in name:
 189             m = re.match('^(.+?) ext:\((.+)\)$', name)
 190             if m:
 191                 name = m.group(1)
 192                 ex = urllib.unquote(m.group(2))
 193
 194         if email != bad_mail:
 195             if name:
 196                 user = '%s <%s>' % (name, email)
 197             else:
 198                 user = '<%s>' % (email)
 199         else:
 200             user = name
 201
 202         if ex:
 203             user += ex
 204
 205         tz = int(tz)
 206         tz = ((tz / 100) * 3600) + ((tz % 100) * 60)
 207         return (user, int(date), -tz)
 208
 209 def fix_file_path(path):
 210     if not os.path.isabs(path):
 211         return path
 212     return os.path.relpath(path, '/')
 213
 214 def export_file(fc):
 215     d = fc.data()
 216     path = fix_file_path(fc.path())
 217     print "M %s inline %s" % (gitmode(fc.flags()), path)
 218     print "data %d" % len(d)
 219     print d
 220
 221 def get_filechanges(repo, ctx, parent):
 222     modified = set()
 223     added = set()
 224     removed = set()
 225
 226     cur = ctx.manifest()
 227     prev = repo[parent].manifest().copy()
 228
 229     for fn in cur:
 230         if fn in prev:
 231             if (cur.flags(fn) != prev.flags(fn) or cur[fn] != prev[fn]):
 232                 modified.add(fn)
 233             del prev[fn]
 234         else:
 235             added.add(fn)
 236     removed |= set(prev.keys())
 237
 238     return added | modified, removed
 239
 240 def fixup_user_git(user):
 241     name = mail = None
 242     user = user.replace('"', '')
 243     m = AUTHOR_RE.match(user)
 244     if m:
 245         name = m.group(1)
 246         mail = m.group(2).strip()
 247     else:
 248         m = NAME_RE.match(user)
 249         if m:
 250             name = m.group(1).strip()
 251     return (name, mail)
 252
 253 def fixup_user_hg(user):
 254     def sanitize(name):
 255         # stole this from hg-git
 256         return re.sub('[<>\n]', '?', name.lstrip('< ').rstrip('> '))
 257
 258     m = AUTHOR_HG_RE.match(user)
 259     if m:
 260         name = sanitize(m.group(1))
 261         mail = sanitize(m.group(2))
 262         ex = m.group(3)
 263         if ex:
 264             name += ' ext:(' + urllib.quote(ex) + ')'
 265     else:
 266         name = sanitize(user)
 267         if '@' in user:
 268             mail = name
 269         else:
 270             mail = None
 271
 272     return (name, mail)
 273
 274 def fixup_user(user):
 275     global mode, bad_mail
 276
 277     if mode == 'git':
 278         name, mail = fixup_user_git(user)
 279     else:
 280         name, mail = fixup_user_hg(user)
 281
 282     if not name:
 283         name = bad_name
 284     if not mail:
 285         mail = bad_mail
 286
 287     return '%s <%s>' % (name, mail)
 288
 289 def get_repo(url, alias):
 290     global dirname, peer
 291
 292     myui = ui.ui()
 293     myui.setconfig('ui', 'interactive', 'off')
 294     myui.fout = sys.stderr
 295
 296     try:
 297         if get_config('remote-hg.insecure') == 'true\n':
 298             myui.setconfig('web', 'cacerts', '')
 299     except subprocess.CalledProcessError:
 300         pass
 301
 302     if hg.islocal(url):
 303         repo = hg.repository(myui, url)
 304     else:
 305         local_path = os.path.join(dirname, 'clone')
 306         if not os.path.exists(local_path):
 307             try:
 308                 peer, dstpeer = hg.clone(myui, {}, url, local_path, update=True, pull=True)
 309             except:
 310                 die('Repository error')
 311             repo = dstpeer.local()
 312         else:
 313             repo = hg.repository(myui, local_path)
 314             try:
 315                 peer = hg.peer(myui, {}, url)
 316             except:
 317                 die('Repository error')
 318             repo.pull(peer, heads=None, force=True)
 319
 320     return repo
 321
 322 def rev_to_mark(rev):
 323     global marks
 324     return marks.from_rev(rev)
 325
 326 def mark_to_rev(mark):
 327     global marks
 328     return marks.to_rev(mark)
 329
 330 def export_ref(repo, name, kind, head):
 331     global prefix, marks, mode
 332
 333     ename = '%s/%s' % (kind, name)
 334     tip = marks.get_tip(ename)
 335
 336     # mercurial takes too much time checking this
 337     if tip and tip == head.rev():
 338         # nothing to do
 339         return
 340     revs = xrange(tip, head.rev() + 1)
 341     count = 0
 342
 343     revs = [rev for rev in revs if not marks.is_marked(rev)]
 344
 345     for rev in revs:
 346
 347         c = repo[rev]
 348         (manifest, user, (time, tz), files, desc, extra) = repo.changelog.read(c.node())
 349         rev_branch = extra['branch']
 350
 351         author = "%s %d %s" % (fixup_user(user), time, gittz(tz))
 352         if 'committer' in extra:
 353             user, time, tz = extra['committer'].rsplit(' ', 2)
 354             committer = "%s %s %s" % (user, time, gittz(int(tz)))
 355         else:
 356             committer = author
 357
 358         parents = [p for p in repo.changelog.parentrevs(rev) if p >= 0]
 359
 360         if len(parents) == 0:
 361             modified = c.manifest().keys()
 362             removed = []
 363         else:
 364             modified, removed = get_filechanges(repo, c, parents[0])
 365
 366         desc += '\n'
 367
 368         if mode == 'hg':
 369             extra_msg = ''
 370
 371             if rev_branch != 'default':
 372                 extra_msg += 'branch : %s\n' % rev_branch
 373
 374             renames = []
 375             for f in c.files():
 376                 if f not in c.manifest():
 377                     continue
 378                 rename = c.filectx(f).renamed()
 379                 if rename:
 380                     renames.append((rename[0], f))
 381
 382             for e in renames:
 383                 extra_msg += "rename : %s => %s\n" % e
 384
 385             for key, value in extra.iteritems():
 386                 if key in ('author', 'committer', 'encoding', 'message', 'branch', 'hg-git'):
 387                     continue
 388                 else:
 389                     extra_msg += "extra : %s : %s\n" % (key, urllib.quote(value))
 390
 391             if extra_msg:
 392                 desc += '\n--HG--\n' + extra_msg
 393
 394         if len(parents) == 0 and rev:
 395             print 'reset %s/%s' % (prefix, ename)
 396
 397         print "commit %s/%s" % (prefix, ename)
 398         print "mark :%d" % (marks.get_mark(rev))
 399         print "author %s" % (author)
 400         print "committer %s" % (committer)
 401         print "data %d" % (len(desc))
 402         print desc
 403
 404         if len(parents) > 0:
 405             print "from :%s" % (rev_to_mark(parents[0]))
 406             if len(parents) > 1:
 407                 print "merge :%s" % (rev_to_mark(parents[1]))
 408
 409         for f in modified:
 410             export_file(c.filectx(f))
 411         for f in removed:
 412             print "D %s" % (fix_file_path(f))
 413         print
 414
 415         count += 1
 416         if (count % 100 == 0):
 417             print "progress revision %d '%s' (%d/%d)" % (rev, name, count, len(revs))
 418             print "#############################################################"
 419
 420     # make sure the ref is updated
 421     print "reset %s/%s" % (prefix, ename)
 422     print "from :%u" % rev_to_mark(rev)
 423     print
 424
 425     marks.set_tip(ename, rev)
 426
 427 def export_tag(repo, tag):
 428     export_ref(repo, tag, 'tags', repo[tag])
 429
 430 def export_bookmark(repo, bmark):
 431     head = bmarks[bmark]
 432     export_ref(repo, bmark, 'bookmarks', head)
 433
 434 def export_branch(repo, branch):
 435     tip = get_branch_tip(repo, branch)
 436     head = repo[tip]
 437     export_ref(repo, branch, 'branches', head)
 438
 439 def export_head(repo):
 440     global g_head
 441     export_ref(repo, g_head[0], 'bookmarks', g_head[1])
 442
 443 def do_capabilities(parser):
 444     global prefix, dirname
 445
 446     print "import"
 447     print "export"
 448     print "refspec refs/heads/branches/*:%s/branches/*" % prefix
 449     print "refspec refs/heads/*:%s/bookmarks/*" % prefix
 450     print "refspec refs/tags/*:%s/tags/*" % prefix
 451
 452     path = os.path.join(dirname, 'marks-git')
 453
 454     if os.path.exists(path):
 455         print "*import-marks %s" % path
 456     print "*export-marks %s" % path
 457
 458     print
 459
 460 def branch_tip(repo, branch):
 461     # older versions of mercurial don't have this
 462     if hasattr(repo, 'branchtip'):
 463         return repo.branchtip(branch)
 464     else:
 465         return repo.branchtags()[branch]
 466
 467 def get_branch_tip(repo, branch):
 468     global branches
 469
 470     heads = branches.get(branch, None)
 471     if not heads:
 472         return None
 473
 474     # verify there's only one head
 475     if (len(heads) > 1):
 476         warn("Branch '%s' has more than one head, consider merging" % branch)
 477         return branch_tip(repo, branch)
 478
 479     return heads[0]
 480
 481 def list_head(repo, cur):
 482     global g_head, bmarks
 483
 484     head = bookmarks.readcurrent(repo)
 485     if head:
 486         node = repo[head]
 487     else:
 488         # fake bookmark from current branch
 489         head = cur
 490         node = repo['.']
 491         if not node:
 492             node = repo['tip']
 493         if not node:
 494             return
 495         if head == 'default':
 496             head = 'master'
 497         bmarks[head] = node
 498
 499     print "@refs/heads/%s HEAD" % head
 500     g_head = (head, node)
 501
 502 def do_list(parser):
 503     global branches, bmarks, mode, track_branches
 504
 505     repo = parser.repo
 506     for bmark, node in bookmarks.listbookmarks(repo).iteritems():
 507         bmarks[bmark] = repo[node]
 508
 509     cur = repo.dirstate.branch()
 510
 511     list_head(repo, cur)
 512
 513     if track_branches:
 514         for branch in repo.branchmap():
 515             heads = repo.branchheads(branch)
 516             if len(heads):
 517                 branches[branch] = heads
 518
 519         for branch in branches:
 520             print "? refs/heads/branches/%s" % branch
 521
 522     for bmark in bmarks:
 523         print "? refs/heads/%s" % bmark
 524
 525     for tag, node in repo.tagslist():
 526         if tag == 'tip':
 527             continue
 528         print "? refs/tags/%s" % tag
 529
 530     print
 531
 532 def do_import(parser):
 533     repo = parser.repo
 534
 535     path = os.path.join(dirname, 'marks-git')
 536
 537     print "feature done"
 538     if os.path.exists(path):
 539         print "feature import-marks=%s" % path
 540     print "feature export-marks=%s" % path
 541     sys.stdout.flush()
 542
 543     tmp = encoding.encoding
 544     encoding.encoding = 'utf-8'
 545
 546     # lets get all the import lines
 547     while parser.check('import'):
 548         ref = parser[1]
 549
 550         if (ref == 'HEAD'):
 551             export_head(repo)
 552         elif ref.startswith('refs/heads/branches/'):
 553             branch = ref[len('refs/heads/branches/'):]
 554             export_branch(repo, branch)
 555         elif ref.startswith('refs/heads/'):
 556             bmark = ref[len('refs/heads/'):]
 557             export_bookmark(repo, bmark)
 558         elif ref.startswith('refs/tags/'):
 559             tag = ref[len('refs/tags/'):]
 560             export_tag(repo, tag)
 561
 562         parser.next()
 563
 564     encoding.encoding = tmp
 565
 566     print 'done'
 567
 568 def parse_blob(parser):
 569     global blob_marks
 570
 571     parser.next()
 572     mark = parser.get_mark()
 573     parser.next()
 574     data = parser.get_data()
 575     blob_marks[mark] = data
 576     parser.next()
 577
 578 def get_merge_files(repo, p1, p2, files):
 579     for e in repo[p1].files():
 580         if e not in files:
 581             if e not in repo[p1].manifest():
 582                 continue
 583             f = { 'ctx' : repo[p1][e] }
 584             files[e] = f
 585
 586 def parse_commit(parser):
 587     global marks, blob_marks, parsed_refs
 588     global mode
 589
 590     from_mark = merge_mark = None
 591
 592     ref = parser[1]
 593     parser.next()
 594
 595     commit_mark = parser.get_mark()
 596     parser.next()
 597     author = parser.get_author()
 598     parser.next()
 599     committer = parser.get_author()
 600     parser.next()
 601     data = parser.get_data()
 602     parser.next()
 603     if parser.check('from'):
 604         from_mark = parser.get_mark()
 605         parser.next()
 606     if parser.check('merge'):
 607         merge_mark = parser.get_mark()
 608         parser.next()
 609         if parser.check('merge'):
 610             die('octopus merges are not supported yet')
 611
 612     files = {}
 613
 614     for line in parser:
 615         if parser.check('M'):
 616             t, m, mark_ref, path = line.split(' ', 3)
 617             mark = int(mark_ref[1:])
 618             f = { 'mode' : hgmode(m), 'data' : blob_marks[mark] }
 619         elif parser.check('D'):
 620             t, path = line.split(' ', 1)
 621             f = { 'deleted' : True }
 622         else:
 623             die('Unknown file command: %s' % line)
 624         files[path] = f
 625
 626     def getfilectx(repo, memctx, f):
 627         of = files[f]
 628         if 'deleted' in of:
 629             raise IOError
 630         if 'ctx' in of:
 631             return of['ctx']
 632         is_exec = of['mode'] == 'x'
 633         is_link = of['mode'] == 'l'
 634         rename = of.get('rename', None)
 635         return context.memfilectx(f, of['data'],
 636                 is_link, is_exec, rename)
 637
 638     repo = parser.repo
 639
 640     user, date, tz = author
 641     extra = {}
 642
 643     if committer != author:
 644         extra['committer'] = "%s %u %u" % committer
 645
 646     if from_mark:
 647         p1 = repo.changelog.node(mark_to_rev(from_mark))
 648     else:
 649         p1 = '\0' * 20
 650
 651     if merge_mark:
 652         p2 = repo.changelog.node(mark_to_rev(merge_mark))
 653     else:
 654         p2 = '\0' * 20
 655
 656     #
 657     # If files changed from any of the parents, hg wants to know, but in git if
 658     # nothing changed from the first parent, nothing changed.
 659     #
 660     if merge_mark:
 661         get_merge_files(repo, p1, p2, files)
 662
 663     # Check if the ref is supposed to be a named branch
 664     if ref.startswith('refs/heads/branches/'):
 665         extra['branch'] = ref[len('refs/heads/branches/'):]
 666
 667     if mode == 'hg':
 668         i = data.find('\n--HG--\n')
 669         if i >= 0:
 670             tmp = data[i + len('\n--HG--\n'):].strip()
 671             for k, v in [e.split(' : ', 1) for e in tmp.split('\n')]:
 672                 if k == 'rename':
 673                     old, new = v.split(' => ', 1)
 674                     files[new]['rename'] = old
 675                 elif k == 'branch':
 676                     extra[k] = v
 677                 elif k == 'extra':
 678                     ek, ev = v.split(' : ', 1)
 679                     extra[ek] = urllib.unquote(ev)
 680             data = data[:i]
 681
 682     ctx = context.memctx(repo, (p1, p2), data,
 683             files.keys(), getfilectx,
 684             user, (date, tz), extra)
 685
 686     tmp = encoding.encoding
 687     encoding.encoding = 'utf-8'
 688
 689     node = repo.commitctx(ctx)
 690
 691     encoding.encoding = tmp
 692
 693     rev = repo[node].rev()
 694
 695     parsed_refs[ref] = node
 696     marks.new_mark(rev, commit_mark)
 697
 698 def parse_reset(parser):
 699     global parsed_refs
 700
 701     ref = parser[1]
 702     parser.next()
 703     # ugh
 704     if parser.check('commit'):
 705         parse_commit(parser)
 706         return
 707     if not parser.check('from'):
 708         return
 709     from_mark = parser.get_mark()
 710     parser.next()
 711
 712     node = parser.repo.changelog.node(mark_to_rev(from_mark))
 713     parsed_refs[ref] = node
 714
 715 def parse_tag(parser):
 716     name = parser[1]
 717     parser.next()
 718     from_mark = parser.get_mark()
 719     parser.next()
 720     tagger = parser.get_author()
 721     parser.next()
 722     data = parser.get_data()
 723     parser.next()
 724
 725     parsed_tags[name] = (tagger, data)
 726
 727 def do_export(parser):
 728     global parsed_refs, bmarks, peer
 729
 730     p_bmarks = []
 731
 732     parser.next()
 733
 734     for line in parser.each_block('done'):
 735         if parser.check('blob'):
 736             parse_blob(parser)
 737         elif parser.check('commit'):
 738             parse_commit(parser)
 739         elif parser.check('reset'):
 740             parse_reset(parser)
 741         elif parser.check('tag'):
 742             parse_tag(parser)
 743         elif parser.check('feature'):
 744             pass
 745         else:
 746             die('unhandled export command: %s' % line)
 747
 748     for ref, node in parsed_refs.iteritems():
 749         if ref.startswith('refs/heads/branches'):
 750             branch = ref[len('refs/heads/branches/'):]
 751             if branch in branches and node in branches[branch]:
 752                 # up to date
 753                 continue
 754             print "ok %s" % ref
 755         elif ref.startswith('refs/heads/'):
 756             bmark = ref[len('refs/heads/'):]
 757             p_bmarks.append((bmark, node))
 758             continue
 759         elif ref.startswith('refs/tags/'):
 760             tag = ref[len('refs/tags/'):]
 761             author, msg = parsed_tags.get(tag, (None, None))
 762             if mode == 'git':
 763                 if not msg:
 764                     msg = 'Added tag %s for changeset %s' % (tag, hghex(node[:6]));
 765                 parser.repo.tag([tag], node, msg, False, author[0], {})
 766             else:
 767                 parser.repo.tag([tag], node, None, True, None, {})
 768             print "ok %s" % ref
 769         else:
 770             # transport-helper/fast-export bugs
 771             continue
 772
 773     if peer:
 774         parser.repo.push(peer, force=force_push)
 775
 776     # handle bookmarks
 777     for bmark, node in p_bmarks:
 778         ref = 'refs/heads/' + bmark
 779         new = hghex(node)
 780
 781         if bmark in bmarks:
 782             old = bmarks[bmark].hex()
 783         else:
 784             old = ''
 785
 786         if bmark == 'master' and 'master' not in parser.repo._bookmarks:
 787             # fake bookmark
 788             pass
 789         elif bookmarks.pushbookmark(parser.repo, bmark, old, new):
 790             # updated locally
 791             pass
 792         else:
 793             print "error %s" % ref
 794             continue
 795
 796         if peer:
 797             rb = peer.listkeys('bookmarks')
 798             old = rb.get(bmark, '')
 799             if not peer.pushkey('bookmarks', bmark, old, new):
 800                 print "error %s" % ref
 801                 continue
 802
 803         print "ok %s" % ref
 804
 805     print
 806
 807 def fix_path(alias, repo, orig_url):
 808     url = urlparse.urlparse(orig_url, 'file')
 809     if url.scheme != 'file' or os.path.isabs(url.path):
 810         return
 811     abs_url = urlparse.urljoin("%s/" % os.getcwd(), orig_url)
 812     cmd = ['git', 'config', 'remote.%s.url' % alias, "hg::%s" % abs_url]
 813     subprocess.call(cmd)
 814
 815 def main(args):
 816     global prefix, dirname, branches, bmarks
 817     global marks, blob_marks, parsed_refs
 818     global peer, mode, bad_mail, bad_name
 819     global track_branches, force_push, is_tmp
 820     global parsed_tags
 821
 822     alias = args[1]
 823     url = args[2]
 824     peer = None
 825
 826     hg_git_compat = False
 827     track_branches = True
 828     force_push = True
 829
 830     try:
 831         if get_config('remote-hg.hg-git-compat') == 'true\n':
 832             hg_git_compat = True
 833             track_branches = False
 834         if get_config('remote-hg.track-branches') == 'false\n':
 835             track_branches = False
 836         if get_config('remote-hg.force-push') == 'false\n':
 837             force_push = False
 838     except subprocess.CalledProcessError:
 839         pass
 840
 841     if hg_git_compat:
 842         mode = 'hg'
 843         bad_mail = 'none@none'
 844         bad_name = ''
 845     else:
 846         mode = 'git'
 847         bad_mail = 'unknown'
 848         bad_name = 'Unknown'
 849
 850     if alias[4:] == url:
 851         is_tmp = True
 852         alias = util.sha1(alias).hexdigest()
 853     else:
 854         is_tmp = False
 855
 856     gitdir = os.environ['GIT_DIR']
 857     dirname = os.path.join(gitdir, 'hg', alias)
 858     branches = {}
 859     bmarks = {}
 860     blob_marks = {}
 861     parsed_refs = {}
 862     marks = None
 863     parsed_tags = {}
 864
 865     repo = get_repo(url, alias)
 866     prefix = 'refs/hg/%s' % alias
 867
 868     if not is_tmp:
 869         fix_path(alias, peer or repo, url)
 870
 871     if not os.path.exists(dirname):
 872         os.makedirs(dirname)
 873
 874     marks_path = os.path.join(dirname, 'marks-hg')
 875     marks = Marks(marks_path)
 876
 877     parser = Parser(repo)
 878     for line in parser:
 879         if parser.check('capabilities'):
 880             do_capabilities(parser)
 881         elif parser.check('list'):
 882             do_list(parser)
 883         elif parser.check('import'):
 884             do_import(parser)
 885         elif parser.check('export'):
 886             do_export(parser)
 887         else:
 888             die('unhandled command: %s' % line)
 889         sys.stdout.flush()
 890
 891 def bye():
 892     if not marks:
 893         return
 894     if not is_tmp:
 895         marks.store()
 896     else:
 897         shutil.rmtree(dirname)
 898
 899 atexit.register(bye)
 900 sys.exit(main(sys.argv))