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, encoding, node, error, extensions, discovery, util
  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, hashlib
  26
  27 #
  28 # If you are not in hg-git-compat mode and want to disable the tracking of
  29 # named branches:
  30 # git config --global remote-hg.track-branches false
  31 #
  32 # If you don't want to force pushes (and thus risk creating new remote heads):
  33 # git config --global remote-hg.force-push false
  34 #
  35 # If you want the equivalent of hg's clone/pull--insecure option:
  36 # git config --global remote-hg.insecure true
  37 #
  38 # If you want to switch to hg-git compatibility mode:
  39 # git config --global remote-hg.hg-git-compat 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 EMAIL_RE = re.compile('^([^<>]+[^ \\\t<>])?\\b(?:[ \\t<>]*?)\\b([^ \\t<>]+@[^ \\t<>]+)')
  55 AUTHOR_HG_RE = re.compile('^(.*?) ?<(.*?)(?:>(.+)?)?$')
  56 RAW_AUTHOR_RE = re.compile('^(\w+) (?:(.+)? )?<(.*)> (\d+) ([+-]\d+)')
  57
  58 VERSION = 2
  59
  60 def die(msg, *args):
  61     sys.stderr.write('ERROR: %s\n' % (msg % args))
  62     sys.exit(1)
  63
  64 def warn(msg, *args):
  65     sys.stderr.write('WARNING: %s\n' % (msg % args))
  66
  67 def gitmode(flags):
  68     return 'l' in flags and '120000' or 'x' in flags and '100755' or '100644'
  69
  70 def gittz(tz):
  71     return '%+03d%02d' % (-tz / 3600, -tz % 3600 / 60)
  72
  73 def hgmode(mode):
  74     m = { '100755': 'x', '120000': 'l' }
  75     return m.get(mode, '')
  76
  77 def hghex(n):
  78     return node.hex(n)
  79
  80 def hgbin(n):
  81     return node.bin(n)
  82
  83 def hgref(ref):
  84     return ref.replace('___', ' ')
  85
  86 def gitref(ref):
  87     return ref.replace(' ', '___')
  88
  89 def check_version(*check):
  90     if not hg_version:
  91         return True
  92     return hg_version >= check
  93
  94 def get_config(config):
  95     cmd = ['git', 'config', '--get', config]
  96     process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
  97     output, _ = process.communicate()
  98     return output
  99
 100 def get_config_bool(config, default=False):
 101     value = get_config(config).rstrip('\n')
 102     if value == "true":
 103         return True
 104     elif value == "false":
 105         return False
 106     else:
 107         return default
 108
 109 class Marks:
 110
 111     def __init__(self, path, repo):
 112         self.path = path
 113         self.repo = repo
 114         self.clear()
 115         self.load()
 116
 117         if self.version < VERSION:
 118             if self.version == 1:
 119                 self.upgrade_one()
 120
 121             # upgraded?
 122             if self.version < VERSION:
 123                 self.clear()
 124                 self.version = VERSION
 125
 126     def clear(self):
 127         self.tips = {}
 128         self.marks = {}
 129         self.rev_marks = {}
 130         self.last_mark = 0
 131         self.version = 0
 132
 133     def load(self):
 134         if not os.path.exists(self.path):
 135             return
 136
 137         tmp = json.load(open(self.path))
 138
 139         self.tips = tmp['tips']
 140         self.marks = tmp['marks']
 141         self.last_mark = tmp['last-mark']
 142         self.version = tmp.get('version', 1)
 143
 144         for rev, mark in self.marks.iteritems():
 145             self.rev_marks[mark] = rev
 146
 147     def upgrade_one(self):
 148         def get_id(rev):
 149             return hghex(self.repo.changelog.node(int(rev)))
 150         self.tips = dict((name, get_id(rev)) for name, rev in self.tips.iteritems())
 151         self.marks = dict((get_id(rev), mark) for rev, mark in self.marks.iteritems())
 152         self.rev_marks = dict((mark, get_id(rev)) for mark, rev in self.rev_marks.iteritems())
 153         self.version = 2
 154
 155     def dict(self):
 156         return { 'tips': self.tips, 'marks': self.marks, 'last-mark' : self.last_mark, 'version' : self.version }
 157
 158     def store(self):
 159         json.dump(self.dict(), open(self.path, 'w'))
 160
 161     def __str__(self):
 162         return str(self.dict())
 163
 164     def from_rev(self, rev):
 165         return self.marks[rev]
 166
 167     def to_rev(self, mark):
 168         return self.rev_marks[mark]
 169
 170     def next_mark(self):
 171         self.last_mark += 1
 172         return self.last_mark
 173
 174     def get_mark(self, rev):
 175         self.last_mark += 1
 176         self.marks[rev] = self.last_mark
 177         return self.last_mark
 178
 179     def new_mark(self, rev, mark):
 180         self.marks[rev] = mark
 181         self.rev_marks[mark] = rev
 182         self.last_mark = mark
 183
 184     def is_marked(self, rev):
 185         return rev in self.marks
 186
 187     def get_tip(self, branch):
 188         return self.tips.get(branch, None)
 189
 190     def set_tip(self, branch, tip):
 191         self.tips[branch] = tip
 192
 193 class Parser:
 194
 195     def __init__(self, repo):
 196         self.repo = repo
 197         self.line = self.get_line()
 198
 199     def get_line(self):
 200         return sys.stdin.readline().strip()
 201
 202     def __getitem__(self, i):
 203         return self.line.split()[i]
 204
 205     def check(self, word):
 206         return self.line.startswith(word)
 207
 208     def each_block(self, separator):
 209         while self.line != separator:
 210             yield self.line
 211             self.line = self.get_line()
 212
 213     def __iter__(self):
 214         return self.each_block('')
 215
 216     def next(self):
 217         self.line = self.get_line()
 218         if self.line == 'done':
 219             self.line = None
 220
 221     def get_mark(self):
 222         i = self.line.index(':') + 1
 223         return int(self.line[i:])
 224
 225     def get_data(self):
 226         if not self.check('data'):
 227             return None
 228         i = self.line.index(' ') + 1
 229         size = int(self.line[i:])
 230         return sys.stdin.read(size)
 231
 232     def get_author(self):
 233         global bad_mail
 234
 235         ex = None
 236         m = RAW_AUTHOR_RE.match(self.line)
 237         if not m:
 238             return None
 239         _, name, email, date, tz = m.groups()
 240         if name and 'ext:' in name:
 241             m = re.match('^(.+?) ext:\((.+)\)$', name)
 242             if m:
 243                 name = m.group(1)
 244                 ex = urllib.unquote(m.group(2))
 245
 246         if email != bad_mail:
 247             if name:
 248                 user = '%s <%s>' % (name, email)
 249             else:
 250                 user = '<%s>' % (email)
 251         else:
 252             user = name
 253
 254         if ex:
 255             user += ex
 256
 257         tz = int(tz)
 258         tz = ((tz / 100) * 3600) + ((tz % 100) * 60)
 259         return (user, int(date), -tz)
 260
 261 def fix_file_path(path):
 262     if not os.path.isabs(path):
 263         return path
 264     return os.path.relpath(path, '/')
 265
 266 def export_files(files):
 267     global marks, filenodes
 268
 269     final = []
 270     for f in files:
 271         fid = node.hex(f.filenode())
 272
 273         if fid in filenodes:
 274             mark = filenodes[fid]
 275         else:
 276             mark = marks.next_mark()
 277             filenodes[fid] = mark
 278             d = f.data()
 279
 280             print "blob"
 281             print "mark :%u" % mark
 282             print "data %d" % len(d)
 283             print d
 284
 285         path = fix_file_path(f.path())
 286         final.append((gitmode(f.flags()), mark, path))
 287
 288     return final
 289
 290 def get_filechanges(repo, ctx, parent):
 291     modified = set()
 292     added = set()
 293     removed = set()
 294
 295     # load earliest manifest first for caching reasons
 296     prev = parent.manifest().copy()
 297     cur = ctx.manifest()
 298
 299     for fn in cur:
 300         if fn in prev:
 301             if (cur.flags(fn) != prev.flags(fn) or cur[fn] != prev[fn]):
 302                 modified.add(fn)
 303             del prev[fn]
 304         else:
 305             added.add(fn)
 306     removed |= set(prev.keys())
 307
 308     return added | modified, removed
 309
 310 def fixup_user_git(user):
 311     name = mail = None
 312     user = user.replace('"', '')
 313     m = AUTHOR_RE.match(user)
 314     if m:
 315         name = m.group(1)
 316         mail = m.group(2).strip()
 317     else:
 318         m = EMAIL_RE.match(user)
 319         if m:
 320             name = m.group(1)
 321             mail = m.group(2)
 322         else:
 323             m = NAME_RE.match(user)
 324             if m:
 325                 name = m.group(1).strip()
 326     return (name, mail)
 327
 328 def fixup_user_hg(user):
 329     def sanitize(name):
 330         # stole this from hg-git
 331         return re.sub('[<>\n]', '?', name.lstrip('< ').rstrip('> '))
 332
 333     m = AUTHOR_HG_RE.match(user)
 334     if m:
 335         name = sanitize(m.group(1))
 336         mail = sanitize(m.group(2))
 337         ex = m.group(3)
 338         if ex:
 339             name += ' ext:(' + urllib.quote(ex) + ')'
 340     else:
 341         name = sanitize(user)
 342         if '@' in user:
 343             mail = name
 344         else:
 345             mail = None
 346
 347     return (name, mail)
 348
 349 def fixup_user(user):
 350     global mode, bad_mail
 351
 352     if mode == 'git':
 353         name, mail = fixup_user_git(user)
 354     else:
 355         name, mail = fixup_user_hg(user)
 356
 357     if not name:
 358         name = bad_name
 359     if not mail:
 360         mail = bad_mail
 361
 362     return '%s <%s>' % (name, mail)
 363
 364 def updatebookmarks(repo, peer):
 365     remotemarks = peer.listkeys('bookmarks')
 366     localmarks = repo._bookmarks
 367
 368     if not remotemarks:
 369         return
 370
 371     for k, v in remotemarks.iteritems():
 372         localmarks[k] = hgbin(v)
 373
 374     if hasattr(localmarks, 'write'):
 375         localmarks.write()
 376     else:
 377         bookmarks.write(repo)
 378
 379 def get_repo(url, alias):
 380     global dirname, peer
 381
 382     myui = ui.ui()
 383     myui.setconfig('ui', 'interactive', 'off')
 384     myui.fout = sys.stderr
 385
 386     if get_config_bool('remote-hg.insecure'):
 387         myui.setconfig('web', 'cacerts', '')
 388
 389     extensions.loadall(myui)
 390
 391     if hg.islocal(url) and not os.environ.get('GIT_REMOTE_HG_TEST_REMOTE'):
 392         repo = hg.repository(myui, url)
 393         if not os.path.exists(dirname):
 394             os.makedirs(dirname)
 395     else:
 396         shared_path = os.path.join(gitdir, 'hg')
 397         if not os.path.exists(shared_path):
 398             try:
 399                 hg.clone(myui, {}, url, shared_path, update=False, pull=True)
 400             except:
 401                 die('Repository error')
 402
 403         if not os.path.exists(dirname):
 404             os.makedirs(dirname)
 405
 406         local_path = os.path.join(dirname, 'clone')
 407         if not os.path.exists(local_path):
 408             hg.share(myui, shared_path, local_path, update=False)
 409
 410         repo = hg.repository(myui, local_path)
 411         try:
 412             peer = hg.peer(myui, {}, url)
 413         except:
 414             die('Repository error')
 415         repo.pull(peer, heads=None, force=True)
 416
 417         updatebookmarks(repo, peer)
 418
 419     return repo
 420
 421 def rev_to_mark(rev):
 422     global marks
 423     return marks.from_rev(rev.hex())
 424
 425 def mark_to_rev(mark):
 426     global marks
 427     return marks.to_rev(mark)
 428
 429 def export_ref(repo, name, kind, head):
 430     global prefix, marks, mode
 431
 432     ename = '%s/%s' % (kind, name)
 433     tip = marks.get_tip(ename)
 434     if tip and tip in repo:
 435         tip = repo[tip].rev()
 436     else:
 437         tip = 0
 438
 439     revs = xrange(tip, head.rev() + 1)
 440     total = len(revs)
 441
 442     for rev in revs:
 443
 444         c = repo[rev]
 445         node = c.node()
 446
 447         if marks.is_marked(c.hex()):
 448             continue
 449
 450         (manifest, user, (time, tz), files, desc, extra) = repo.changelog.read(node)
 451         rev_branch = extra['branch']
 452
 453         author = "%s %d %s" % (fixup_user(user), time, gittz(tz))
 454         if 'committer' in extra:
 455             user, time, tz = extra['committer'].rsplit(' ', 2)
 456             committer = "%s %s %s" % (user, time, gittz(int(tz)))
 457         else:
 458             committer = author
 459
 460         parents = [repo[p] for p in repo.changelog.parentrevs(rev) if p >= 0]
 461
 462         if len(parents) == 0:
 463             modified = c.manifest().keys()
 464             removed = []
 465         else:
 466             modified, removed = get_filechanges(repo, c, parents[0])
 467
 468         desc += '\n'
 469
 470         if mode == 'hg':
 471             extra_msg = ''
 472
 473             if rev_branch != 'default':
 474                 extra_msg += 'branch : %s\n' % rev_branch
 475
 476             renames = []
 477             for f in c.files():
 478                 if f not in c.manifest():
 479                     continue
 480                 rename = c.filectx(f).renamed()
 481                 if rename:
 482                     renames.append((rename[0], f))
 483
 484             for e in renames:
 485                 extra_msg += "rename : %s => %s\n" % e
 486
 487             for key, value in extra.iteritems():
 488                 if key in ('author', 'committer', 'encoding', 'message', 'branch', 'hg-git'):
 489                     continue
 490                 else:
 491                     extra_msg += "extra : %s : %s\n" % (key, urllib.quote(value))
 492
 493             if extra_msg:
 494                 desc += '\n--HG--\n' + extra_msg
 495
 496         if len(parents) == 0 and rev:
 497             print 'reset %s/%s' % (prefix, ename)
 498
 499         modified_final = export_files(c.filectx(f) for f in modified)
 500
 501         print "commit %s/%s" % (prefix, ename)
 502         print "mark :%d" % (marks.get_mark(c.hex()))
 503         print "author %s" % (author)
 504         print "committer %s" % (committer)
 505         print "data %d" % (len(desc))
 506         print desc
 507
 508         if len(parents) > 0:
 509             print "from :%s" % (rev_to_mark(parents[0]))
 510             if len(parents) > 1:
 511                 print "merge :%s" % (rev_to_mark(parents[1]))
 512
 513         for f in modified_final:
 514             print "M %s :%u %s" % f
 515         for f in removed:
 516             print "D %s" % (fix_file_path(f))
 517         print
 518
 519         progress = (rev - tip)
 520         if (progress % 100 == 0):
 521             print "progress revision %d '%s' (%d/%d)" % (rev, name, progress, total)
 522
 523     # make sure the ref is updated
 524     print "reset %s/%s" % (prefix, ename)
 525     print "from :%u" % rev_to_mark(head)
 526     print
 527
 528     marks.set_tip(ename, head.hex())
 529
 530 def export_tag(repo, tag):
 531     export_ref(repo, tag, 'tags', repo[hgref(tag)])
 532
 533 def export_bookmark(repo, bmark):
 534     head = bmarks[hgref(bmark)]
 535     export_ref(repo, bmark, 'bookmarks', head)
 536
 537 def export_branch(repo, branch):
 538     tip = get_branch_tip(repo, branch)
 539     head = repo[tip]
 540     export_ref(repo, branch, 'branches', head)
 541
 542 def export_head(repo):
 543     global g_head
 544     export_ref(repo, g_head[0], 'bookmarks', g_head[1])
 545
 546 def do_capabilities(parser):
 547     global prefix, dirname
 548
 549     print "import"
 550     print "export"
 551     print "refspec refs/heads/branches/*:%s/branches/*" % prefix
 552     print "refspec refs/heads/*:%s/bookmarks/*" % prefix
 553     print "refspec refs/tags/*:%s/tags/*" % prefix
 554
 555     path = os.path.join(dirname, 'marks-git')
 556
 557     if os.path.exists(path):
 558         print "*import-marks %s" % path
 559     print "*export-marks %s" % path
 560
 561     print
 562
 563 def branch_tip(branch):
 564     return branches[branch][-1]
 565
 566 def get_branch_tip(repo, branch):
 567     global branches
 568
 569     heads = branches.get(hgref(branch), None)
 570     if not heads:
 571         return None
 572
 573     # verify there's only one head
 574     if (len(heads) > 1):
 575         warn("Branch '%s' has more than one head, consider merging" % branch)
 576         return branch_tip(hgref(branch))
 577
 578     return heads[0]
 579
 580 def list_head(repo, cur):
 581     global g_head, bmarks, fake_bmark
 582
 583     if 'default' not in repo:
 584         # empty repo
 585         return
 586
 587     node = repo['default']
 588     head = 'master' if not 'master' in bmarks else 'default'
 589     fake_bmark = head
 590     bmarks[head] = node
 591
 592     head = gitref(head)
 593     print "@refs/heads/%s HEAD" % head
 594     g_head = (head, node)
 595
 596 def do_list(parser):
 597     global branches, bmarks, track_branches
 598
 599     repo = parser.repo
 600     for bmark, node in bookmarks.listbookmarks(repo).iteritems():
 601         bmarks[bmark] = repo[node]
 602
 603     cur = repo.dirstate.branch()
 604
 605     list_head(repo, cur)
 606
 607     if track_branches:
 608         orig = peer if peer else repo
 609
 610         for branch, heads in orig.branchmap().iteritems():
 611             # only open heads
 612             heads = [h for h in heads if 'close' not in repo.changelog.read(h)[5]]
 613             if heads:
 614                 branches[branch] = heads
 615
 616         for branch in branches:
 617             print "? refs/heads/branches/%s" % gitref(branch)
 618
 619     for bmark in bmarks:
 620         print "? refs/heads/%s" % gitref(bmark)
 621
 622     for tag, node in repo.tagslist():
 623         if tag == 'tip':
 624             continue
 625         print "? refs/tags/%s" % gitref(tag)
 626
 627     print
 628
 629 def do_import(parser):
 630     repo = parser.repo
 631
 632     path = os.path.join(dirname, 'marks-git')
 633
 634     print "feature done"
 635     if os.path.exists(path):
 636         print "feature import-marks=%s" % path
 637     print "feature export-marks=%s" % path
 638     print "feature force"
 639     sys.stdout.flush()
 640
 641     tmp = encoding.encoding
 642     encoding.encoding = 'utf-8'
 643
 644     # lets get all the import lines
 645     while parser.check('import'):
 646         ref = parser[1]
 647
 648         if (ref == 'HEAD'):
 649             export_head(repo)
 650         elif ref.startswith('refs/heads/branches/'):
 651             branch = ref[len('refs/heads/branches/'):]
 652             export_branch(repo, branch)
 653         elif ref.startswith('refs/heads/'):
 654             bmark = ref[len('refs/heads/'):]
 655             export_bookmark(repo, bmark)
 656         elif ref.startswith('refs/tags/'):
 657             tag = ref[len('refs/tags/'):]
 658             export_tag(repo, tag)
 659
 660         parser.next()
 661
 662     encoding.encoding = tmp
 663
 664     print 'done'
 665
 666 def parse_blob(parser):
 667     global blob_marks
 668
 669     parser.next()
 670     mark = parser.get_mark()
 671     parser.next()
 672     data = parser.get_data()
 673     blob_marks[mark] = data
 674     parser.next()
 675
 676 def get_merge_files(repo, p1, p2, files):
 677     for e in repo[p1].files():
 678         if e not in files:
 679             if e not in repo[p1].manifest():
 680                 continue
 681             f = { 'ctx' : repo[p1][e] }
 682             files[e] = f
 683
 684 def parse_commit(parser):
 685     global marks, blob_marks, parsed_refs
 686     global mode
 687
 688     from_mark = merge_mark = None
 689
 690     ref = parser[1]
 691     parser.next()
 692
 693     commit_mark = parser.get_mark()
 694     parser.next()
 695     author = parser.get_author()
 696     parser.next()
 697     committer = parser.get_author()
 698     parser.next()
 699     data = parser.get_data()
 700     parser.next()
 701     if parser.check('from'):
 702         from_mark = parser.get_mark()
 703         parser.next()
 704     if parser.check('merge'):
 705         merge_mark = parser.get_mark()
 706         parser.next()
 707         if parser.check('merge'):
 708             die('octopus merges are not supported yet')
 709
 710     # fast-export adds an extra newline
 711     if data[-1] == '\n':
 712         data = data[:-1]
 713
 714     files = {}
 715
 716     for line in parser:
 717         if parser.check('M'):
 718             t, m, mark_ref, path = line.split(' ', 3)
 719             mark = int(mark_ref[1:])
 720             f = { 'mode' : hgmode(m), 'data' : blob_marks[mark] }
 721         elif parser.check('D'):
 722             t, path = line.split(' ', 1)
 723             f = { 'deleted' : True }
 724         else:
 725             die('Unknown file command: %s' % line)
 726         files[path] = f
 727
 728     def getfilectx(repo, memctx, f):
 729         of = files[f]
 730         if 'deleted' in of:
 731             raise IOError
 732         if 'ctx' in of:
 733             return of['ctx']
 734         is_exec = of['mode'] == 'x'
 735         is_link = of['mode'] == 'l'
 736         rename = of.get('rename', None)
 737         return context.memfilectx(f, of['data'],
 738                 is_link, is_exec, rename)
 739
 740     repo = parser.repo
 741
 742     user, date, tz = author
 743     extra = {}
 744
 745     if committer != author:
 746         extra['committer'] = "%s %u %u" % committer
 747
 748     if from_mark:
 749         p1 = mark_to_rev(from_mark)
 750     else:
 751         p1 = '0' * 40
 752
 753     if merge_mark:
 754         p2 = mark_to_rev(merge_mark)
 755     else:
 756         p2 = '0' * 40
 757
 758     #
 759     # If files changed from any of the parents, hg wants to know, but in git if
 760     # nothing changed from the first parent, nothing changed.
 761     #
 762     if merge_mark:
 763         get_merge_files(repo, p1, p2, files)
 764
 765     # Check if the ref is supposed to be a named branch
 766     if ref.startswith('refs/heads/branches/'):
 767         branch = ref[len('refs/heads/branches/'):]
 768         extra['branch'] = hgref(branch)
 769
 770     if mode == 'hg':
 771         i = data.find('\n--HG--\n')
 772         if i >= 0:
 773             tmp = data[i + len('\n--HG--\n'):].strip()
 774             for k, v in [e.split(' : ', 1) for e in tmp.split('\n')]:
 775                 if k == 'rename':
 776                     old, new = v.split(' => ', 1)
 777                     files[new]['rename'] = old
 778                 elif k == 'branch':
 779                     extra[k] = v
 780                 elif k == 'extra':
 781                     ek, ev = v.split(' : ', 1)
 782                     extra[ek] = urllib.unquote(ev)
 783             data = data[:i]
 784
 785     ctx = context.memctx(repo, (p1, p2), data,
 786             files.keys(), getfilectx,
 787             user, (date, tz), extra)
 788
 789     tmp = encoding.encoding
 790     encoding.encoding = 'utf-8'
 791
 792     node = hghex(repo.commitctx(ctx))
 793
 794     encoding.encoding = tmp
 795
 796     parsed_refs[ref] = node
 797     marks.new_mark(node, commit_mark)
 798
 799 def parse_reset(parser):
 800     global parsed_refs
 801
 802     ref = parser[1]
 803     parser.next()
 804     # ugh
 805     if parser.check('commit'):
 806         parse_commit(parser)
 807         return
 808     if not parser.check('from'):
 809         return
 810     from_mark = parser.get_mark()
 811     parser.next()
 812
 813     rev = mark_to_rev(from_mark)
 814     parsed_refs[ref] = rev
 815
 816 def parse_tag(parser):
 817     name = parser[1]
 818     parser.next()
 819     from_mark = parser.get_mark()
 820     parser.next()
 821     tagger = parser.get_author()
 822     parser.next()
 823     data = parser.get_data()
 824     parser.next()
 825
 826     parsed_tags[name] = (tagger, data)
 827
 828 def write_tag(repo, tag, node, msg, author):
 829     branch = repo[node].branch()
 830     tip = branch_tip(branch)
 831     tip = repo[tip]
 832
 833     def getfilectx(repo, memctx, f):
 834         try:
 835             fctx = tip.filectx(f)
 836             data = fctx.data()
 837         except error.ManifestLookupError:
 838             data = ""
 839         content = data + "%s %s\n" % (node, tag)
 840         return context.memfilectx(f, content, False, False, None)
 841
 842     p1 = tip.hex()
 843     p2 = '0' * 40
 844     if not author:
 845         author = (None, 0, 0)
 846     user, date, tz = author
 847
 848     ctx = context.memctx(repo, (p1, p2), msg,
 849             ['.hgtags'], getfilectx,
 850             user, (date, tz), {'branch' : branch})
 851
 852     tmp = encoding.encoding
 853     encoding.encoding = 'utf-8'
 854
 855     tagnode = repo.commitctx(ctx)
 856
 857     encoding.encoding = tmp
 858
 859     return (tagnode, branch)
 860
 861 def checkheads_bmark(repo, ref, ctx):
 862     if force_push:
 863         return True
 864
 865     bmark = ref[len('refs/heads/'):]
 866     if not bmark in bmarks:
 867         # new bmark
 868         return True
 869
 870     ctx_old = bmarks[bmark]
 871     ctx_new = ctx
 872     if not repo.changelog.descendant(ctx_old.rev(), ctx_new.rev()):
 873         print "error %s non-fast forward" % ref
 874         return False
 875
 876     return True
 877
 878 def checkheads(repo, remote, p_revs):
 879
 880     remotemap = remote.branchmap()
 881     if not remotemap:
 882         # empty repo
 883         return True
 884
 885     new = {}
 886     ret = True
 887
 888     for node, ref in p_revs.iteritems():
 889         ctx = repo[node]
 890         branch = ctx.branch()
 891         if not branch in remotemap:
 892             # new branch
 893             continue
 894         if not ref.startswith('refs/heads/branches'):
 895             if ref.startswith('refs/heads/'):
 896                 if not checkheads_bmark(repo, ref, ctx):
 897                     ret = False
 898
 899             # only check branches
 900             continue
 901         new.setdefault(branch, []).append(ctx.rev())
 902
 903     for branch, heads in new.iteritems():
 904         old = [repo.changelog.rev(x) for x in remotemap[branch]]
 905         for rev in heads:
 906             if check_version(2, 3):
 907                 ancestors = repo.changelog.ancestors([rev], stoprev=min(old))
 908             else:
 909                 ancestors = repo.changelog.ancestors(rev)
 910             found = False
 911
 912             for x in old:
 913                 if x in ancestors:
 914                     found = True
 915                     break
 916
 917             if found:
 918                 continue
 919
 920             node = repo.changelog.node(rev)
 921             print "error %s non-fast forward" % p_revs[node]
 922             ret = False
 923
 924     return ret
 925
 926 def push_unsafe(repo, remote, parsed_refs, p_revs):
 927
 928     force = force_push
 929
 930     fci = discovery.findcommonincoming
 931     commoninc = fci(repo, remote, force=force)
 932     common, _, remoteheads = commoninc
 933
 934     if not force and not checkheads(repo, remote, p_revs):
 935         return None
 936
 937     cg = repo.getbundle('push', heads=list(p_revs), common=common)
 938
 939     unbundle = remote.capable('unbundle')
 940     if unbundle:
 941         if force:
 942             remoteheads = ['force']
 943         return remote.unbundle(cg, remoteheads, 'push')
 944     else:
 945         return remote.addchangegroup(cg, 'push', repo.url())
 946
 947 def push(repo, remote, parsed_refs, p_revs):
 948     if hasattr(remote, 'canpush') and not remote.canpush():
 949         print "error cannot push"
 950
 951     if not p_revs:
 952         # nothing to push
 953         return
 954
 955     lock = None
 956     unbundle = remote.capable('unbundle')
 957     if not unbundle:
 958         lock = remote.lock()
 959     try:
 960         ret = push_unsafe(repo, remote, parsed_refs, p_revs)
 961     finally:
 962         if lock is not None:
 963             lock.release()
 964
 965     return ret
 966
 967 def do_export(parser):
 968     global parsed_refs, bmarks, peer
 969
 970     p_bmarks = []
 971     p_revs = {}
 972
 973     parser.next()
 974
 975     for line in parser.each_block('done'):
 976         if parser.check('blob'):
 977             parse_blob(parser)
 978         elif parser.check('commit'):
 979             parse_commit(parser)
 980         elif parser.check('reset'):
 981             parse_reset(parser)
 982         elif parser.check('tag'):
 983             parse_tag(parser)
 984         elif parser.check('feature'):
 985             pass
 986         else:
 987             die('unhandled export command: %s' % line)
 988
 989     for ref, node in parsed_refs.iteritems():
 990         bnode = hgbin(node)
 991         if ref.startswith('refs/heads/branches'):
 992             branch = ref[len('refs/heads/branches/'):]
 993             if branch in branches and bnode in branches[branch]:
 994                 # up to date
 995                 continue
 996             p_revs[bnode] = ref
 997             print "ok %s" % ref
 998         elif ref.startswith('refs/heads/'):
 999             bmark = ref[len('refs/heads/'):]
1000             new = node
1001             old = bmarks[bmark].hex() if bmark in bmarks else ''
1002
1003             if old == new:
1004                 continue
1005
1006             print "ok %s" % ref
1007             if bmark != fake_bmark and \
1008                     not (bmark == 'master' and bmark not in parser.repo._bookmarks):
1009                 p_bmarks.append((ref, bmark, old, new))
1010
1011             p_revs[bnode] = ref
1012         elif ref.startswith('refs/tags/'):
1013             tag = ref[len('refs/tags/'):]
1014             tag = hgref(tag)
1015             author, msg = parsed_tags.get(tag, (None, None))
1016             if mode == 'git':
1017                 if not msg:
1018                     msg = 'Added tag %s for changeset %s' % (tag, node[:12]);
1019                 tagnode, branch = write_tag(parser.repo, tag, node, msg, author)
1020                 p_revs[tagnode] = 'refs/heads/branches/' + gitref(branch)
1021             else:
1022                 fp = parser.repo.opener('localtags', 'a')
1023                 fp.write('%s %s\n' % (node, tag))
1024                 fp.close()
1025             p_revs[bnode] = ref
1026             print "ok %s" % ref
1027         else:
1028             # transport-helper/fast-export bugs
1029             continue
1030
1031     if peer:
1032         if not push(parser.repo, peer, parsed_refs, p_revs):
1033             # do not update bookmarks
1034             print
1035             return
1036
1037         # update remote bookmarks
1038         remote_bmarks = peer.listkeys('bookmarks')
1039         for ref, bmark, old, new in p_bmarks:
1040             if force_push:
1041                 old = remote_bmarks.get(bmark, '')
1042             if not peer.pushkey('bookmarks', bmark, old, new):
1043                 print "error %s" % ref
1044     else:
1045         # update local bookmarks
1046         for ref, bmark, old, new in p_bmarks:
1047             if not bookmarks.pushbookmark(parser.repo, bmark, old, new):
1048                 print "error %s" % ref
1049
1050     print
1051
1052 def fix_path(alias, repo, orig_url):
1053     url = urlparse.urlparse(orig_url, 'file')
1054     if url.scheme != 'file' or os.path.isabs(url.path):
1055         return
1056     abs_url = urlparse.urljoin("%s/" % os.getcwd(), orig_url)
1057     cmd = ['git', 'config', 'remote.%s.url' % alias, "hg::%s" % abs_url]
1058     subprocess.call(cmd)
1059
1060 def main(args):
1061     global prefix, gitdir, dirname, branches, bmarks
1062     global marks, blob_marks, parsed_refs
1063     global peer, mode, bad_mail, bad_name
1064     global track_branches, force_push, is_tmp
1065     global parsed_tags
1066     global filenodes
1067     global fake_bmark, hg_version
1068
1069     alias = args[1]
1070     url = args[2]
1071     peer = None
1072
1073     hg_git_compat = get_config_bool('remote-hg.hg-git-compat')
1074     track_branches = get_config_bool('remote-hg.track-branches', True)
1075     force_push = get_config_bool('remote-hg.force-push')
1076
1077     if hg_git_compat:
1078         mode = 'hg'
1079         bad_mail = 'none@none'
1080         bad_name = ''
1081     else:
1082         mode = 'git'
1083         bad_mail = 'unknown'
1084         bad_name = 'Unknown'
1085
1086     if alias[4:] == url:
1087         is_tmp = True
1088         alias = hashlib.sha1(alias).hexdigest()
1089     else:
1090         is_tmp = False
1091
1092     gitdir = os.environ['GIT_DIR']
1093     dirname = os.path.join(gitdir, 'hg', alias)
1094     branches = {}
1095     bmarks = {}
1096     blob_marks = {}
1097     parsed_refs = {}
1098     marks = None
1099     parsed_tags = {}
1100     filenodes = {}
1101     fake_bmark = None
1102     try:
1103         hg_version = tuple(int(e) for e in util.version().split('.'))
1104     except:
1105         hg_version = None
1106
1107     repo = get_repo(url, alias)
1108     prefix = 'refs/hg/%s' % alias
1109
1110     if not is_tmp:
1111         fix_path(alias, peer or repo, url)
1112
1113     marks_path = os.path.join(dirname, 'marks-hg')
1114     marks = Marks(marks_path, repo)
1115
1116     if sys.platform == 'win32':
1117         import msvcrt
1118         msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
1119
1120     parser = Parser(repo)
1121     for line in parser:
1122         if parser.check('capabilities'):
1123             do_capabilities(parser)
1124         elif parser.check('list'):
1125             do_list(parser)
1126         elif parser.check('import'):
1127             do_import(parser)
1128         elif parser.check('export'):
1129             do_export(parser)
1130         else:
1131             die('unhandled command: %s' % line)
1132         sys.stdout.flush()
1133
1134 def bye():
1135     if not marks:
1136         return
1137     if not is_tmp:
1138         marks.store()
1139     else:
1140         shutil.rmtree(dirname)
1141
1142 atexit.register(bye)
1143 sys.exit(main(sys.argv))