45629e022f472cc4d13314c0715f323ab75490e4
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
12from mercurial import hg, ui, bookmarks, context
13
14import re
15import sys
16import os
17import json
18
19NAME_RE = re.compile('^([^<>]+)')
20AUTHOR_RE = re.compile('^([^<>]+?)? ?<([^<>]+)>$')
21RAW_AUTHOR_RE = re.compile('^(\w+) (?:(.+)? )?<(.+)> (\d+) ([+-]\d+)')
22
23def die(msg, *args):
24 sys.stderr.write('ERROR: %s\n' % (msg % args))
25 sys.exit(1)
26
27def warn(msg, *args):
28 sys.stderr.write('WARNING: %s\n' % (msg % args))
29
30def gitmode(flags):
31 return 'l' in flags and '120000' or 'x' in flags and '100755' or '100644'
32
33def gittz(tz):
34 return '%+03d%02d' % (-tz / 3600, -tz % 3600 / 60)
35
36def hgmode(mode):
37 m = { '0100755': 'x', '0120000': 'l' }
38 return m.get(mode, '')
39
40class Marks:
41
42 def __init__(self, path):
43 self.path = path
44 self.tips = {}
45 self.marks = {}
46 self.rev_marks = {}
47 self.last_mark = 0
48
49 self.load()
50
51 def load(self):
52 if not os.path.exists(self.path):
53 return
54
55 tmp = json.load(open(self.path))
56
57 self.tips = tmp['tips']
58 self.marks = tmp['marks']
59 self.last_mark = tmp['last-mark']
60
61 for rev, mark in self.marks.iteritems():
62 self.rev_marks[mark] = int(rev)
63
64 def dict(self):
65 return { 'tips': self.tips, 'marks': self.marks, 'last-mark' : self.last_mark }
66
67 def store(self):
68 json.dump(self.dict(), open(self.path, 'w'))
69
70 def __str__(self):
71 return str(self.dict())
72
73 def from_rev(self, rev):
74 return self.marks[str(rev)]
75
76 def to_rev(self, mark):
77 return self.rev_marks[mark]
78
79 def get_mark(self, rev):
80 self.last_mark += 1
81 self.marks[str(rev)] = self.last_mark
82 return self.last_mark
83
84 def new_mark(self, rev, mark):
85 self.marks[str(rev)] = mark
86 self.rev_marks[mark] = rev
87 self.last_mark = mark
88
89 def is_marked(self, rev):
90 return self.marks.has_key(str(rev))
91
92 def get_tip(self, branch):
93 return self.tips.get(branch, 0)
94
95 def set_tip(self, branch, tip):
96 self.tips[branch] = tip
97
98class Parser:
99
100 def __init__(self, repo):
101 self.repo = repo
102 self.line = self.get_line()
103
104 def get_line(self):
105 return sys.stdin.readline().strip()
106
107 def __getitem__(self, i):
108 return self.line.split()[i]
109
110 def check(self, word):
111 return self.line.startswith(word)
112
113 def each_block(self, separator):
114 while self.line != separator:
115 yield self.line
116 self.line = self.get_line()
117
118 def __iter__(self):
119 return self.each_block('')
120
121 def next(self):
122 self.line = self.get_line()
123 if self.line == 'done':
124 self.line = None
125
126 def get_mark(self):
127 i = self.line.index(':') + 1
128 return int(self.line[i:])
129
130 def get_data(self):
131 if not self.check('data'):
132 return None
133 i = self.line.index(' ') + 1
134 size = int(self.line[i:])
135 return sys.stdin.read(size)
136
137 def get_author(self):
138 m = RAW_AUTHOR_RE.match(self.line)
139 if not m:
140 return None
141 _, name, email, date, tz = m.groups()
142
143 if email != 'unknown':
144 if name:
145 user = '%s <%s>' % (name, email)
146 else:
147 user = '<%s>' % (email)
148 else:
149 user = name
150
151 tz = int(tz)
152 tz = ((tz / 100) * 3600) + ((tz % 100) * 60)
153 return (user, int(date), -tz)
154
155def export_file(fc):
156 d = fc.data()
157 print "M %s inline %s" % (gitmode(fc.flags()), fc.path())
158 print "data %d" % len(d)
159 print d
160
161def get_filechanges(repo, ctx, parent):
162 modified = set()
163 added = set()
164 removed = set()
165
166 cur = ctx.manifest()
167 prev = repo[parent].manifest().copy()
168
169 for fn in cur:
170 if fn in prev:
171 if (cur.flags(fn) != prev.flags(fn) or cur[fn] != prev[fn]):
172 modified.add(fn)
173 del prev[fn]
174 else:
175 added.add(fn)
176 removed |= set(prev.keys())
177
178 return added | modified, removed
179
180def fixup_user(user):
181 user = user.replace('"', '')
182 name = mail = None
183 m = AUTHOR_RE.match(user)
184 if m:
185 name = m.group(1)
186 mail = m.group(2).strip()
187 else:
188 m = NAME_RE.match(user)
189 if m:
190 name = m.group(1).strip()
191
192 if not name:
193 name = 'Unknown'
194 if not mail:
195 mail = 'unknown'
196
197 return '%s <%s>' % (name, mail)
198
199def get_repo(url, alias):
200 global dirname, peer
201
202 myui = ui.ui()
203 myui.setconfig('ui', 'interactive', 'off')
204
205 if hg.islocal(url):
206 repo = hg.repository(myui, url)
207 else:
208 local_path = os.path.join(dirname, 'clone')
209 if not os.path.exists(local_path):
210 peer, dstpeer = hg.clone(myui, {}, url, local_path, update=False, pull=True)
211 repo = dstpeer.local()
212 else:
213 repo = hg.repository(myui, local_path)
214 peer = hg.peer(myui, {}, url)
215 repo.pull(peer, heads=None, force=True)
216
217 return repo
218
219def rev_to_mark(rev):
220 global marks
221 return marks.from_rev(rev)
222
223def mark_to_rev(mark):
224 global marks
225 return marks.to_rev(mark)
226
227def export_ref(repo, name, kind, head):
228 global prefix, marks
229
230 ename = '%s/%s' % (kind, name)
231 tip = marks.get_tip(ename)
232
233 # mercurial takes too much time checking this
234 if tip and tip == head.rev():
235 # nothing to do
236 return
237 revs = repo.revs('%u:%u' % (tip, head))
238 count = 0
239
240 revs = [rev for rev in revs if not marks.is_marked(rev)]
241
242 for rev in revs:
243
244 c = repo[rev]
245 (manifest, user, (time, tz), files, desc, extra) = repo.changelog.read(c.node())
246 rev_branch = extra['branch']
247
248 author = "%s %d %s" % (fixup_user(user), time, gittz(tz))
249 if 'committer' in extra:
250 user, time, tz = extra['committer'].rsplit(' ', 2)
251 committer = "%s %s %s" % (user, time, gittz(int(tz)))
252 else:
253 committer = author
254
255 parents = [p for p in repo.changelog.parentrevs(rev) if p >= 0]
256
257 if len(parents) == 0:
258 modified = c.manifest().keys()
259 removed = []
260 else:
261 modified, removed = get_filechanges(repo, c, parents[0])
262
263 if len(parents) == 0 and rev:
264 print 'reset %s/%s' % (prefix, ename)
265
266 print "commit %s/%s" % (prefix, ename)
267 print "mark :%d" % (marks.get_mark(rev))
268 print "author %s" % (author)
269 print "committer %s" % (committer)
270 print "data %d" % (len(desc))
271 print desc
272
273 if len(parents) > 0:
274 print "from :%s" % (rev_to_mark(parents[0]))
275 if len(parents) > 1:
276 print "merge :%s" % (rev_to_mark(parents[1]))
277
278 for f in modified:
279 export_file(c.filectx(f))
280 for f in removed:
281 print "D %s" % (f)
282 print
283
284 count += 1
285 if (count % 100 == 0):
286 print "progress revision %d '%s' (%d/%d)" % (rev, name, count, len(revs))
287 print "#############################################################"
288
289 # make sure the ref is updated
290 print "reset %s/%s" % (prefix, ename)
291 print "from :%u" % rev_to_mark(rev)
292 print
293
294 marks.set_tip(ename, rev)
295
296def export_tag(repo, tag):
297 export_ref(repo, tag, 'tags', repo[tag])
298
299def export_bookmark(repo, bmark):
300 head = bmarks[bmark]
301 export_ref(repo, bmark, 'bookmarks', head)
302
303def export_branch(repo, branch):
304 tip = get_branch_tip(repo, branch)
305 head = repo[tip]
306 export_ref(repo, branch, 'branches', head)
307
308def export_head(repo):
309 global g_head
310 export_ref(repo, g_head[0], 'bookmarks', g_head[1])
311
312def do_capabilities(parser):
313 global prefix, dirname
314
315 print "import"
316 print "export"
317 print "refspec refs/heads/branches/*:%s/branches/*" % prefix
318 print "refspec refs/heads/*:%s/bookmarks/*" % prefix
319 print "refspec refs/tags/*:%s/tags/*" % prefix
320
321 path = os.path.join(dirname, 'marks-git')
322
323 if os.path.exists(path):
324 print "*import-marks %s" % path
325 print "*export-marks %s" % path
326
327 print
328
329def get_branch_tip(repo, branch):
330 global branches
331
332 heads = branches.get(branch, None)
333 if not heads:
334 return None
335
336 # verify there's only one head
337 if (len(heads) > 1):
338 warn("Branch '%s' has more than one head, consider merging" % branch)
339 # older versions of mercurial don't have this
340 if hasattr(repo, "branchtip"):
341 return repo.branchtip(branch)
342
343 return heads[0]
344
345def list_head(repo, cur):
346 global g_head
347
348 head = bookmarks.readcurrent(repo)
349 if not head:
350 return
351 node = repo[head]
352 print "@refs/heads/%s HEAD" % head
353 g_head = (head, node)
354
355def do_list(parser):
356 global branches, bmarks
357
358 repo = parser.repo
359 for branch in repo.branchmap():
360 heads = repo.branchheads(branch)
361 if len(heads):
362 branches[branch] = heads
363
364 for bmark, node in bookmarks.listbookmarks(repo).iteritems():
365 bmarks[bmark] = repo[node]
366
367 cur = repo.dirstate.branch()
368
369 list_head(repo, cur)
370 for branch in branches:
371 print "? refs/heads/branches/%s" % branch
372 for bmark in bmarks:
373 print "? refs/heads/%s" % bmark
374
375 for tag, node in repo.tagslist():
376 if tag == 'tip':
377 continue
378 print "? refs/tags/%s" % tag
379
380 print
381
382def do_import(parser):
383 repo = parser.repo
384
385 path = os.path.join(dirname, 'marks-git')
386
387 print "feature done"
388 if os.path.exists(path):
389 print "feature import-marks=%s" % path
390 print "feature export-marks=%s" % path
391 sys.stdout.flush()
392
393 # lets get all the import lines
394 while parser.check('import'):
395 ref = parser[1]
396
397 if (ref == 'HEAD'):
398 export_head(repo)
399 elif ref.startswith('refs/heads/branches/'):
400 branch = ref[len('refs/heads/branches/'):]
401 export_branch(repo, branch)
402 elif ref.startswith('refs/heads/'):
403 bmark = ref[len('refs/heads/'):]
404 export_bookmark(repo, bmark)
405 elif ref.startswith('refs/tags/'):
406 tag = ref[len('refs/tags/'):]
407 export_tag(repo, tag)
408
409 parser.next()
410
411 print 'done'
412
413def parse_blob(parser):
414 global blob_marks
415
416 parser.next()
417 mark = parser.get_mark()
418 parser.next()
419 data = parser.get_data()
420 blob_marks[mark] = data
421 parser.next()
422 return
423
424def parse_commit(parser):
425 global marks, blob_marks, bmarks, parsed_refs
426
427 from_mark = merge_mark = None
428
429 ref = parser[1]
430 parser.next()
431
432 commit_mark = parser.get_mark()
433 parser.next()
434 author = parser.get_author()
435 parser.next()
436 committer = parser.get_author()
437 parser.next()
438 data = parser.get_data()
439 parser.next()
440 if parser.check('from'):
441 from_mark = parser.get_mark()
442 parser.next()
443 if parser.check('merge'):
444 merge_mark = parser.get_mark()
445 parser.next()
446 if parser.check('merge'):
447 die('octopus merges are not supported yet')
448
449 files = {}
450
451 for line in parser:
452 if parser.check('M'):
453 t, m, mark_ref, path = line.split(' ')
454 mark = int(mark_ref[1:])
455 f = { 'mode' : hgmode(m), 'data' : blob_marks[mark] }
456 elif parser.check('D'):
457 t, path = line.split(' ')
458 f = { 'deleted' : True }
459 else:
460 die('Unknown file command: %s' % line)
461 files[path] = f
462
463 def getfilectx(repo, memctx, f):
464 of = files[f]
465 if 'deleted' in of:
466 raise IOError
467 is_exec = of['mode'] == 'x'
468 is_link = of['mode'] == 'l'
469 return context.memfilectx(f, of['data'], is_link, is_exec, None)
470
471 repo = parser.repo
472
473 user, date, tz = author
474 extra = {}
475
476 if committer != author:
477 extra['committer'] = "%s %u %u" % committer
478
479 if from_mark:
480 p1 = repo.changelog.node(mark_to_rev(from_mark))
481 else:
482 p1 = '\0' * 20
483
484 if merge_mark:
485 p2 = repo.changelog.node(mark_to_rev(merge_mark))
486 else:
487 p2 = '\0' * 20
488
489 ctx = context.memctx(repo, (p1, p2), data,
490 files.keys(), getfilectx,
491 user, (date, tz), extra)
492
493 node = repo.commitctx(ctx)
494
495 rev = repo[node].rev()
496
497 parsed_refs[ref] = node
498
499 marks.new_mark(rev, commit_mark)
500
501def parse_reset(parser):
502 ref = parser[1]
503 parser.next()
504 # ugh
505 if parser.check('commit'):
506 parse_commit(parser)
507 return
508 if not parser.check('from'):
509 return
510 from_mark = parser.get_mark()
511 parser.next()
512
513 node = parser.repo.changelog.node(mark_to_rev(from_mark))
514 parsed_refs[ref] = node
515
516def parse_tag(parser):
517 name = parser[1]
518 parser.next()
519 from_mark = parser.get_mark()
520 parser.next()
521 tagger = parser.get_author()
522 parser.next()
523 data = parser.get_data()
524 parser.next()
525
526 # nothing to do
527
528def do_export(parser):
529 global parsed_refs, bmarks, peer
530
531 parser.next()
532
533 for line in parser.each_block('done'):
534 if parser.check('blob'):
535 parse_blob(parser)
536 elif parser.check('commit'):
537 parse_commit(parser)
538 elif parser.check('reset'):
539 parse_reset(parser)
540 elif parser.check('tag'):
541 parse_tag(parser)
542 elif parser.check('feature'):
543 pass
544 else:
545 die('unhandled export command: %s' % line)
546
547 for ref, node in parsed_refs.iteritems():
548 if ref.startswith('refs/heads/branches'):
549 pass
550 elif ref.startswith('refs/heads/'):
551 bmark = ref[len('refs/heads/'):]
552 if bmark in bmarks:
553 old = bmarks[bmark].hex()
554 else:
555 old = ''
556 if not bookmarks.pushbookmark(parser.repo, bmark, old, node):
557 continue
558 elif ref.startswith('refs/tags/'):
559 tag = ref[len('refs/tags/'):]
560 parser.repo.tag([tag], node, None, True, None, {})
561 print "ok %s" % ref
562
563 print
564
565 if peer:
566 parser.repo.push(peer, force=False)
567
568def main(args):
569 global prefix, dirname, branches, bmarks
570 global marks, blob_marks, parsed_refs
571 global peer
572
573 alias = args[1]
574 url = args[2]
575 peer = None
576
577 gitdir = os.environ['GIT_DIR']
578 dirname = os.path.join(gitdir, 'hg', alias)
579 branches = {}
580 bmarks = {}
581 blob_marks = {}
582 parsed_refs = {}
583
584 repo = get_repo(url, alias)
585 prefix = 'refs/hg/%s' % alias
586
587 if not os.path.exists(dirname):
588 os.makedirs(dirname)
589
590 marks_path = os.path.join(dirname, 'marks-hg')
591 marks = Marks(marks_path)
592
593 parser = Parser(repo)
594 for line in parser:
595 if parser.check('capabilities'):
596 do_capabilities(parser)
597 elif parser.check('list'):
598 do_list(parser)
599 elif parser.check('import'):
600 do_import(parser)
601 elif parser.check('export'):
602 do_export(parser)
603 else:
604 die('unhandled command: %s' % line)
605 sys.stdout.flush()
606
607 marks.store()
608
609sys.exit(main(sys.argv))