3 # Copyright (c) 2012 Felipe Contreras
6 # Inspired by Rocco Rutte's hg-fast-export
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/
12 # For remote repositories a local clone is stored in
13 # "$GIT_DIR/hg/origin/clone/.hg/".
15 from mercurial
import hg
, ui
, bookmarks
, context
, encoding
, node
, error
, extensions
, discovery
, util
25 import urlparse
, hashlib
29 # If you want to see Mercurial revisions as Git commit notes:
30 # git config core.notesRef refs/notes/hg
32 # If you are not in hg-git-compat mode and want to disable the tracking of
34 # git config --global remote-hg.track-branches false
36 # If you want the equivalent of hg's clone/pull--insecure option:
37 # git config --global remote-hg.insecure true
39 # If you want to switch to hg-git compatibility mode:
40 # git config --global remote-hg.hg-git-compat true
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.
49 # Only hg bookmarks are exported as git branches.
50 # Commits are modified to preserve hg information and allow bidirectionality.
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+)')
62 sys
.stderr
.write('ERROR: %s\n' % (msg
% args
))
66 sys
.stderr
.write('WARNING: %s\n' % (msg
% args
))
69 return 'l' in flags
and '120000' or 'x' in flags
and '100755' or '100644'
72 return '%+03d%02d' % (-tz
/ 3600, -tz
% 3600 / 60)
75 m
= { '100755': 'x', '120000': 'l' }
76 return m
.get(mode
, '')
85 return ref
.replace('___', ' ')
88 return ref
.replace(' ', '___')
90 def check_version(*check
):
93 return hg_version
>= check
95 def get_config(config
):
96 cmd
= ['git', 'config', '--get', config
]
97 process
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
)
98 output
, _
= process
.communicate()
101 def get_config_bool(config
, default
=False):
102 value
= get_config(config
).rstrip('\n')
105 elif value
== "false":
112 def __init__(self
, path
, repo
):
118 if self
.version
< VERSION
:
119 if self
.version
== 1:
123 if self
.version
< VERSION
:
125 self
.version
= VERSION
136 if not os
.path
.exists(self
.path
):
139 tmp
= json
.load(open(self
.path
))
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)
147 for rev
, mark
in self
.marks
.iteritems():
148 self
.rev_marks
[mark
] = rev
150 def upgrade_one(self
):
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())
159 return { 'tips': self
.tips
, 'marks': self
.marks
, 'last-mark' : self
.last_mark
, 'version' : self
.version
, 'last-note' : self
.last_note
}
162 json
.dump(self
.dict(), open(self
.path
, 'w'))
165 return str(self
.dict())
167 def from_rev(self
, rev
):
168 return self
.marks
[rev
]
170 def to_rev(self
, mark
):
171 return str(self
.rev_marks
[mark
])
175 return self
.last_mark
177 def get_mark(self
, rev
):
179 self
.marks
[rev
] = self
.last_mark
180 return self
.last_mark
182 def new_mark(self
, rev
, mark
):
183 self
.marks
[rev
] = mark
184 self
.rev_marks
[mark
] = rev
185 self
.last_mark
= mark
187 def is_marked(self
, rev
):
188 return rev
in self
.marks
190 def get_tip(self
, branch
):
191 return str(self
.tips
[branch
])
193 def set_tip(self
, branch
, tip
):
194 self
.tips
[branch
] = tip
198 def __init__(self
, repo
):
200 self
.line
= self
.get_line()
203 return sys
.stdin
.readline().strip()
205 def __getitem__(self
, i
):
206 return self
.line
.split()[i
]
208 def check(self
, word
):
209 return self
.line
.startswith(word
)
211 def each_block(self
, separator
):
212 while self
.line
!= separator
:
214 self
.line
= self
.get_line()
217 return self
.each_block('')
220 self
.line
= self
.get_line()
221 if self
.line
== 'done':
225 i
= self
.line
.index(':') + 1
226 return int(self
.line
[i
:])
229 if not self
.check('data'):
231 i
= self
.line
.index(' ') + 1
232 size
= int(self
.line
[i
:])
233 return sys
.stdin
.read(size
)
235 def get_author(self
):
237 m
= RAW_AUTHOR_RE
.match(self
.line
)
240 _
, name
, email
, date
, tz
= m
.groups()
241 if name
and 'ext:' in name
:
242 m
= re
.match('^(.+?) ext:\((.+)\)$', name
)
245 ex
= urllib
.unquote(m
.group(2))
247 if email
!= bad_mail
:
249 user
= '%s <%s>' % (name
, email
)
251 user
= '<%s>' % (email
)
259 tz
= ((tz
/ 100) * 3600) + ((tz
% 100) * 60)
260 return (user
, int(date
), -tz
)
262 def fix_file_path(path
):
263 path
= os
.path
.normpath(path
)
264 if not os
.path
.isabs(path
):
266 return os
.path
.relpath(path
, '/')
268 def export_files(files
):
271 fid
= node
.hex(f
.filenode())
274 mark
= filenodes
[fid
]
276 mark
= marks
.next_mark()
277 filenodes
[fid
] = mark
281 print "mark :%u" % mark
282 print "data %d" % len(d
)
285 path
= fix_file_path(f
.path())
286 final
.append((gitmode(f
.flags()), mark
, path
))
290 def get_filechanges(repo
, ctx
, parent
):
295 # load earliest manifest first for caching reasons
296 prev
= parent
.manifest().copy()
301 if (cur
.flags(fn
) != prev
.flags(fn
) or cur
[fn
] != prev
[fn
]):
306 removed |
= set(prev
.keys())
308 return added | modified
, removed
310 def fixup_user_git(user
):
312 user
= user
.replace('"', '')
313 m
= AUTHOR_RE
.match(user
)
316 mail
= m
.group(2).strip()
318 m
= EMAIL_RE
.match(user
)
322 m
= NAME_RE
.match(user
)
324 name
= m
.group(1).strip()
327 def fixup_user_hg(user
):
329 # stole this from hg-git
330 return re
.sub('[<>\n]', '?', name
.lstrip('< ').rstrip('> '))
332 m
= AUTHOR_HG_RE
.match(user
)
334 name
= sanitize(m
.group(1))
335 mail
= sanitize(m
.group(2))
338 name
+= ' ext:(' + urllib
.quote(ex
) + ')'
340 name
= sanitize(user
)
348 def fixup_user(user
):
350 name
, mail
= fixup_user_git(user
)
352 name
, mail
= fixup_user_hg(user
)
359 return '%s <%s>' % (name
, mail
)
361 def updatebookmarks(repo
, peer
):
362 remotemarks
= peer
.listkeys('bookmarks')
363 localmarks
= repo
._bookmarks
368 for k
, v
in remotemarks
.iteritems():
369 localmarks
[k
] = hgbin(v
)
371 if hasattr(localmarks
, 'write'):
374 bookmarks
.write(repo
)
376 def get_repo(url
, alias
):
380 myui
.setconfig('ui', 'interactive', 'off')
381 myui
.fout
= sys
.stderr
383 if get_config_bool('remote-hg.insecure'):
384 myui
.setconfig('web', 'cacerts', '')
386 extensions
.loadall(myui
)
388 if hg
.islocal(url
) and not os
.environ
.get('GIT_REMOTE_HG_TEST_REMOTE'):
389 repo
= hg
.repository(myui
, url
)
390 if not os
.path
.exists(dirname
):
393 shared_path
= os
.path
.join(gitdir
, 'hg')
395 # check and upgrade old organization
396 hg_path
= os
.path
.join(shared_path
, '.hg')
397 if os
.path
.exists(shared_path
) and not os
.path
.exists(hg_path
):
398 repos
= os
.listdir(shared_path
)
400 local_hg
= os
.path
.join(shared_path
, x
, 'clone', '.hg')
401 if not os
.path
.exists(local_hg
):
403 if not os
.path
.exists(hg_path
):
404 shutil
.move(local_hg
, hg_path
)
405 shutil
.rmtree(os
.path
.join(shared_path
, x
, 'clone'))
407 # setup shared repo (if not there)
409 hg
.peer(myui
, {}, shared_path
, create
=True)
410 except error
.RepoError
:
413 if not os
.path
.exists(dirname
):
416 local_path
= os
.path
.join(dirname
, 'clone')
417 if not os
.path
.exists(local_path
):
418 hg
.share(myui
, shared_path
, local_path
, update
=False)
420 # make sure the shared path is always up-to-date
421 util
.writefile(os
.path
.join(local_path
, '.hg', 'sharedpath'), hg_path
)
423 repo
= hg
.repository(myui
, local_path
)
425 peer
= hg
.peer(myui
, {}, url
)
427 die('Repository error')
428 repo
.pull(peer
, heads
=None, force
=True)
430 updatebookmarks(repo
, peer
)
434 def rev_to_mark(rev
):
435 return marks
.from_rev(rev
.hex())
437 def mark_to_rev(mark
):
438 return marks
.to_rev(mark
)
440 def export_ref(repo
, name
, kind
, head
):
441 ename
= '%s/%s' % (kind
, name
)
443 tip
= marks
.get_tip(ename
)
444 tip
= repo
[tip
].rev()
448 revs
= xrange(tip
, head
.rev() + 1)
456 if marks
.is_marked(c
.hex()):
459 (manifest
, user
, (time
, tz
), files
, desc
, extra
) = repo
.changelog
.read(node
)
460 rev_branch
= extra
['branch']
462 author
= "%s %d %s" % (fixup_user(user
), time
, gittz(tz
))
463 if 'committer' in extra
:
464 user
, time
, tz
= extra
['committer'].rsplit(' ', 2)
465 committer
= "%s %s %s" % (user
, time
, gittz(int(tz
)))
469 parents
= [repo
[p
] for p
in repo
.changelog
.parentrevs(rev
) if p
>= 0]
471 if len(parents
) == 0:
472 modified
= c
.manifest().keys()
475 modified
, removed
= get_filechanges(repo
, c
, parents
[0])
482 if rev_branch
!= 'default':
483 extra_msg
+= 'branch : %s\n' % rev_branch
487 if f
not in c
.manifest():
489 rename
= c
.filectx(f
).renamed()
491 renames
.append((rename
[0], f
))
494 extra_msg
+= "rename : %s => %s\n" % e
496 for key
, value
in extra
.iteritems():
497 if key
in ('author', 'committer', 'encoding', 'message', 'branch', 'hg-git'):
500 extra_msg
+= "extra : %s : %s\n" % (key
, urllib
.quote(value
))
503 desc
+= '\n--HG--\n' + extra_msg
505 if len(parents
) == 0 and rev
:
506 print 'reset %s/%s' % (prefix
, ename
)
508 modified_final
= export_files(c
.filectx(f
) for f
in modified
)
510 print "commit %s/%s" % (prefix
, ename
)
511 print "mark :%d" % (marks
.get_mark(c
.hex()))
512 print "author %s" % (author
)
513 print "committer %s" % (committer
)
514 print "data %d" % (len(desc
))
518 print "from :%s" % (rev_to_mark(parents
[0]))
520 print "merge :%s" % (rev_to_mark(parents
[1]))
523 print "D %s" % (fix_file_path(f
))
524 for f
in modified_final
:
525 print "M %s :%u %s" % f
528 progress
= (rev
- tip
)
529 if (progress
% 100 == 0):
530 print "progress revision %d '%s' (%d/%d)" % (rev
, name
, progress
, total
)
532 # make sure the ref is updated
533 print "reset %s/%s" % (prefix
, ename
)
534 print "from :%u" % rev_to_mark(head
)
537 pending_revs
= set(revs
) - notes
539 note_mark
= marks
.next_mark()
540 ref
= "refs/notes/hg"
542 print "commit %s" % ref
543 print "mark :%d" % (note_mark
)
544 print "committer remote-hg <> %d %s" % (ptime
.time(), gittz(ptime
.timezone
))
545 desc
= "Notes for %s\n" % (name
)
546 print "data %d" % (len(desc
))
549 print "from :%u" % marks
.last_note
551 for rev
in pending_revs
:
554 print "N inline :%u" % rev_to_mark(c
)
556 print "data %d" % (len(msg
))
560 marks
.last_note
= note_mark
562 marks
.set_tip(ename
, head
.hex())
564 def export_tag(repo
, tag
):
565 export_ref(repo
, tag
, 'tags', repo
[hgref(tag
)])
567 def export_bookmark(repo
, bmark
):
568 head
= bmarks
[hgref(bmark
)]
569 export_ref(repo
, bmark
, 'bookmarks', head
)
571 def export_branch(repo
, branch
):
572 tip
= get_branch_tip(repo
, branch
)
574 export_ref(repo
, branch
, 'branches', head
)
576 def export_head(repo
):
577 export_ref(repo
, g_head
[0], 'bookmarks', g_head
[1])
579 def do_capabilities(parser
):
582 print "refspec refs/heads/branches/*:%s/branches/*" % prefix
583 print "refspec refs/heads/*:%s/bookmarks/*" % prefix
584 print "refspec refs/tags/*:%s/tags/*" % prefix
586 path
= os
.path
.join(dirname
, 'marks-git')
588 if os
.path
.exists(path
):
589 print "*import-marks %s" % path
590 print "*export-marks %s" % path
595 def branch_tip(branch
):
596 return branches
[branch
][-1]
598 def get_branch_tip(repo
, branch
):
599 heads
= branches
.get(hgref(branch
), None)
603 # verify there's only one head
605 warn("Branch '%s' has more than one head, consider merging" % branch
)
606 return branch_tip(hgref(branch
))
610 def list_head(repo
, cur
):
611 global g_head
, fake_bmark
613 if 'default' not in branches
:
617 node
= repo
[branch_tip('default')]
618 head
= 'master' if not 'master' in bmarks
else 'default'
623 print "@refs/heads/%s HEAD" % head
624 g_head
= (head
, node
)
628 for bmark
, node
in bookmarks
.listbookmarks(repo
).iteritems():
629 bmarks
[bmark
] = repo
[node
]
631 cur
= repo
.dirstate
.branch()
632 orig
= peer
if peer
else repo
634 for branch
, heads
in orig
.branchmap().iteritems():
636 heads
= [h
for h
in heads
if 'close' not in repo
.changelog
.read(h
)[5]]
638 branches
[branch
] = heads
643 for branch
in branches
:
644 print "? refs/heads/branches/%s" % gitref(branch
)
647 if bmarks
[bmark
].hex() == '0000000000000000000000000000000000000000':
648 warn("Ignoring invalid bookmark '%s'", bmark
)
650 print "? refs/heads/%s" % gitref(bmark
)
652 for tag
, node
in repo
.tagslist():
655 print "? refs/tags/%s" % gitref(tag
)
659 def do_import(parser
):
662 path
= os
.path
.join(dirname
, 'marks-git')
665 if os
.path
.exists(path
):
666 print "feature import-marks=%s" % path
667 print "feature export-marks=%s" % path
668 print "feature force"
671 tmp
= encoding
.encoding
672 encoding
.encoding
= 'utf-8'
674 # lets get all the import lines
675 while parser
.check('import'):
680 elif ref
.startswith('refs/heads/branches/'):
681 branch
= ref
[len('refs/heads/branches/'):]
682 export_branch(repo
, branch
)
683 elif ref
.startswith('refs/heads/'):
684 bmark
= ref
[len('refs/heads/'):]
685 export_bookmark(repo
, bmark
)
686 elif ref
.startswith('refs/tags/'):
687 tag
= ref
[len('refs/tags/'):]
688 export_tag(repo
, tag
)
692 encoding
.encoding
= tmp
696 def parse_blob(parser
):
698 mark
= parser
.get_mark()
700 data
= parser
.get_data()
701 blob_marks
[mark
] = data
704 def get_merge_files(repo
, p1
, p2
, files
):
705 for e
in repo
[p1
].files():
707 if e
not in repo
[p1
].manifest():
709 f
= { 'ctx' : repo
[p1
][e
] }
712 def c_style_unescape(string
):
713 if string
[0] == string
[-1] == '"':
714 return string
.decode('string-escape')[1:-1]
717 def parse_commit(parser
):
718 from_mark
= merge_mark
= None
723 commit_mark
= parser
.get_mark()
725 author
= parser
.get_author()
727 committer
= parser
.get_author()
729 data
= parser
.get_data()
731 if parser
.check('from'):
732 from_mark
= parser
.get_mark()
734 if parser
.check('merge'):
735 merge_mark
= parser
.get_mark()
737 if parser
.check('merge'):
738 die('octopus merges are not supported yet')
740 # fast-export adds an extra newline
747 if parser
.check('M'):
748 t
, m
, mark_ref
, path
= line
.split(' ', 3)
749 mark
= int(mark_ref
[1:])
750 f
= { 'mode' : hgmode(m
), 'data' : blob_marks
[mark
] }
751 elif parser
.check('D'):
752 t
, path
= line
.split(' ', 1)
753 f
= { 'deleted' : True }
755 die('Unknown file command: %s' % line
)
756 path
= c_style_unescape(path
)
759 # only export the commits if we are on an internal proxy repo
760 if dry_run
and not peer
:
761 parsed_refs
[ref
] = None
764 def getfilectx(repo
, memctx
, f
):
770 is_exec
= of
['mode'] == 'x'
771 is_link
= of
['mode'] == 'l'
772 rename
= of
.get('rename', None)
773 return context
.memfilectx(f
, of
['data'],
774 is_link
, is_exec
, rename
)
778 user
, date
, tz
= author
781 if committer
!= author
:
782 extra
['committer'] = "%s %u %u" % committer
785 p1
= mark_to_rev(from_mark
)
790 p2
= mark_to_rev(merge_mark
)
795 # If files changed from any of the parents, hg wants to know, but in git if
796 # nothing changed from the first parent, nothing changed.
799 get_merge_files(repo
, p1
, p2
, files
)
801 # Check if the ref is supposed to be a named branch
802 if ref
.startswith('refs/heads/branches/'):
803 branch
= ref
[len('refs/heads/branches/'):]
804 extra
['branch'] = hgref(branch
)
807 i
= data
.find('\n--HG--\n')
809 tmp
= data
[i
+ len('\n--HG--\n'):].strip()
810 for k
, v
in [e
.split(' : ', 1) for e
in tmp
.split('\n')]:
812 old
, new
= v
.split(' => ', 1)
813 files
[new
]['rename'] = old
817 ek
, ev
= v
.split(' : ', 1)
818 extra
[ek
] = urllib
.unquote(ev
)
821 ctx
= context
.memctx(repo
, (p1
, p2
), data
,
822 files
.keys(), getfilectx
,
823 user
, (date
, tz
), extra
)
825 tmp
= encoding
.encoding
826 encoding
.encoding
= 'utf-8'
828 node
= hghex(repo
.commitctx(ctx
))
830 encoding
.encoding
= tmp
832 parsed_refs
[ref
] = node
833 marks
.new_mark(node
, commit_mark
)
835 def parse_reset(parser
):
839 if parser
.check('commit'):
842 if not parser
.check('from'):
844 from_mark
= parser
.get_mark()
848 rev
= mark_to_rev(from_mark
)
851 parsed_refs
[ref
] = rev
853 def parse_tag(parser
):
856 from_mark
= parser
.get_mark()
858 tagger
= parser
.get_author()
860 data
= parser
.get_data()
863 parsed_tags
[name
] = (tagger
, data
)
865 def write_tag(repo
, tag
, node
, msg
, author
):
866 branch
= repo
[node
].branch()
867 tip
= branch_tip(branch
)
870 def getfilectx(repo
, memctx
, f
):
872 fctx
= tip
.filectx(f
)
874 except error
.ManifestLookupError
:
876 content
= data
+ "%s %s\n" % (node
, tag
)
877 return context
.memfilectx(f
, content
, False, False, None)
882 user
, date
, tz
= author
885 cmd
= ['git', 'var', 'GIT_COMMITTER_IDENT']
886 process
= subprocess
.Popen(cmd
, stdout
=subprocess
.PIPE
)
887 output
, _
= process
.communicate()
888 m
= re
.match('^.* <.*>', output
)
892 user
= repo
.ui
.username()
895 ctx
= context
.memctx(repo
, (p1
, p2
), msg
,
896 ['.hgtags'], getfilectx
,
897 user
, date_tz
, {'branch' : branch
})
899 tmp
= encoding
.encoding
900 encoding
.encoding
= 'utf-8'
902 tagnode
= repo
.commitctx(ctx
)
904 encoding
.encoding
= tmp
906 return (tagnode
, branch
)
908 def checkheads_bmark(repo
, ref
, ctx
):
909 bmark
= ref
[len('refs/heads/'):]
910 if not bmark
in bmarks
:
914 ctx_old
= bmarks
[bmark
]
916 if not repo
.changelog
.descendant(ctx_old
.rev(), ctx_new
.rev()):
918 print "ok %s forced update" % ref
920 print "error %s non-fast forward" % ref
925 def checkheads(repo
, remote
, p_revs
):
927 remotemap
= remote
.branchmap()
935 for node
, ref
in p_revs
.iteritems():
937 branch
= ctx
.branch()
938 if not branch
in remotemap
:
941 if not ref
.startswith('refs/heads/branches'):
942 if ref
.startswith('refs/heads/'):
943 if not checkheads_bmark(repo
, ref
, ctx
):
946 # only check branches
948 new
.setdefault(branch
, []).append(ctx
.rev())
950 for branch
, heads
in new
.iteritems():
951 old
= [repo
.changelog
.rev(x
) for x
in remotemap
[branch
]]
953 if check_version(2, 3):
954 ancestors
= repo
.changelog
.ancestors([rev
], stoprev
=min(old
))
956 ancestors
= repo
.changelog
.ancestors(rev
)
967 node
= repo
.changelog
.node(rev
)
970 print "ok %s forced update" % ref
972 print "error %s non-fast forward" % ref
977 def push_unsafe(repo
, remote
, parsed_refs
, p_revs
):
981 fci
= discovery
.findcommonincoming
982 commoninc
= fci(repo
, remote
, force
=force
)
983 common
, _
, remoteheads
= commoninc
985 if not checkheads(repo
, remote
, p_revs
):
988 cg
= repo
.getbundle('push', heads
=list(p_revs
), common
=common
)
990 unbundle
= remote
.capable('unbundle')
993 remoteheads
= ['force']
994 return remote
.unbundle(cg
, remoteheads
, 'push')
996 return remote
.addchangegroup(cg
, 'push', repo
.url())
998 def push(repo
, remote
, parsed_refs
, p_revs
):
999 if hasattr(remote
, 'canpush') and not remote
.canpush():
1000 print "error cannot push"
1007 unbundle
= remote
.capable('unbundle')
1009 lock
= remote
.lock()
1011 ret
= push_unsafe(repo
, remote
, parsed_refs
, p_revs
)
1013 if lock
is not None:
1018 def check_tip(ref
, kind
, name
, heads
):
1020 ename
= '%s/%s' % (kind
, name
)
1021 tip
= marks
.get_tip(ename
)
1027 def do_export(parser
):
1033 for line
in parser
.each_block('done'):
1034 if parser
.check('blob'):
1036 elif parser
.check('commit'):
1037 parse_commit(parser
)
1038 elif parser
.check('reset'):
1040 elif parser
.check('tag'):
1042 elif parser
.check('feature'):
1045 die('unhandled export command: %s' % line
)
1049 for ref
, node
in parsed_refs
.iteritems():
1050 bnode
= hgbin(node
) if node
else None
1051 if ref
.startswith('refs/heads/branches'):
1052 branch
= ref
[len('refs/heads/branches/'):]
1053 if branch
in branches
and bnode
in branches
[branch
]:
1058 remotemap
= peer
.branchmap()
1059 if remotemap
and branch
in remotemap
:
1060 heads
= [hghex(e
) for e
in remotemap
[branch
]]
1061 if not check_tip(ref
, 'branches', branch
, heads
):
1062 print "error %s fetch first" % ref
1068 elif ref
.startswith('refs/heads/'):
1069 bmark
= ref
[len('refs/heads/'):]
1071 old
= bmarks
[bmark
].hex() if bmark
in bmarks
else ''
1077 if bmark
!= fake_bmark
and \
1078 not (bmark
== 'master' and bmark
not in parser
.repo
._bookmarks
):
1079 p_bmarks
.append((ref
, bmark
, old
, new
))
1082 remote_old
= peer
.listkeys('bookmarks').get(bmark
)
1084 if not check_tip(ref
, 'bookmarks', bmark
, remote_old
):
1085 print "error %s fetch first" % ref
1090 elif ref
.startswith('refs/tags/'):
1094 tag
= ref
[len('refs/tags/'):]
1096 author
, msg
= parsed_tags
.get(tag
, (None, None))
1099 msg
= 'Added tag %s for changeset %s' % (tag
, node
[:12])
1100 tagnode
, branch
= write_tag(parser
.repo
, tag
, node
, msg
, author
)
1101 p_revs
[tagnode
] = 'refs/heads/branches/' + gitref(branch
)
1103 fp
= parser
.repo
.opener('localtags', 'a')
1104 fp
.write('%s %s\n' % (node
, tag
))
1109 # transport-helper/fast-export bugs
1117 if peer
and not force_push
:
1118 checkheads(parser
.repo
, peer
, p_revs
)
1123 if not push(parser
.repo
, peer
, parsed_refs
, p_revs
):
1124 # do not update bookmarks
1128 # update remote bookmarks
1129 remote_bmarks
= peer
.listkeys('bookmarks')
1130 for ref
, bmark
, old
, new
in p_bmarks
:
1132 old
= remote_bmarks
.get(bmark
, '')
1133 if not peer
.pushkey('bookmarks', bmark
, old
, new
):
1134 print "error %s" % ref
1136 # update local bookmarks
1137 for ref
, bmark
, old
, new
in p_bmarks
:
1138 if not bookmarks
.pushbookmark(parser
.repo
, bmark
, old
, new
):
1139 print "error %s" % ref
1143 def do_option(parser
):
1144 global dry_run
, force_push
1145 _
, key
, value
= parser
.line
.split(' ')
1146 if key
== 'dry-run':
1147 dry_run
= (value
== 'true')
1149 elif key
== 'force':
1150 force_push
= (value
== 'true')
1155 def fix_path(alias
, repo
, orig_url
):
1156 url
= urlparse
.urlparse(orig_url
, 'file')
1157 if url
.scheme
!= 'file' or os
.path
.isabs(os
.path
.expanduser(url
.path
)):
1159 abs_url
= urlparse
.urljoin("%s/" % os
.getcwd(), orig_url
)
1160 cmd
= ['git', 'config', 'remote.%s.url' % alias
, "hg::%s" % abs_url
]
1161 subprocess
.call(cmd
)
1164 global prefix
, gitdir
, dirname
, branches
, bmarks
1165 global marks
, blob_marks
, parsed_refs
1166 global peer
, mode
, bad_mail
, bad_name
1167 global track_branches
, force_push
, is_tmp
1170 global fake_bmark
, hg_version
1176 gitdir
= os
.environ
.get('GIT_DIR', None)
1179 die('Not enough arguments.')
1182 die('GIT_DIR not set')
1188 hg_git_compat
= get_config_bool('remote-hg.hg-git-compat')
1189 track_branches
= get_config_bool('remote-hg.track-branches', True)
1194 bad_mail
= 'none@none'
1198 bad_mail
= 'unknown'
1199 bad_name
= 'Unknown'
1201 if alias
[4:] == url
:
1203 alias
= hashlib
.sha1(alias
).hexdigest()
1205 dirname
= os
.path
.join(gitdir
, 'hg', alias
)
1214 hg_version
= tuple(int(e
) for e
in util
.version().split('.'))
1220 repo
= get_repo(url
, alias
)
1221 prefix
= 'refs/hg/%s' % alias
1224 fix_path(alias
, peer
or repo
, url
)
1226 marks_path
= os
.path
.join(dirname
, 'marks-hg')
1227 marks
= Marks(marks_path
, repo
)
1229 if sys
.platform
== 'win32':
1231 msvcrt
.setmode(sys
.stdout
.fileno(), os
.O_BINARY
)
1233 parser
= Parser(repo
)
1235 if parser
.check('capabilities'):
1236 do_capabilities(parser
)
1237 elif parser
.check('list'):
1239 elif parser
.check('import'):
1241 elif parser
.check('export'):
1243 elif parser
.check('option'):
1246 die('unhandled command: %s' % line
)
1255 shutil
.rmtree(dirname
)
1257 atexit
.register(bye
)
1258 sys
.exit(main(sys
.argv
))