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