contrib/remote-helpers/git-remote-bzr

   1 #!/usr/bin/env python
   2 #
   3 # Copyright (c) 2012 Felipe Contreras
   4 #
   5
   6 #
   7 # Just copy to your ~/bin, or anywhere in your $PATH.
   8 # Then you can clone with:
   9 # % git clone bzr::/path/to/bzr/repo/or/url
  10 #
  11 # For example:
  12 # % git clone bzr::$HOME/myrepo
  13 # or
  14 # % git clone bzr::lp:myrepo
  15 #
  16 # If you want to specify which branches you want track (per repo):
  17 # git config remote-bzr.branches 'trunk, devel, test'
  18 #
  19
  20 import sys
  21
  22 import bzrlib
  23 if hasattr(bzrlib, "initialize"):
  24     bzrlib.initialize()
  25
  26 import bzrlib.plugin
  27 bzrlib.plugin.load_plugins()
  28
  29 import bzrlib.generate_ids
  30 import bzrlib.transport
  31 import bzrlib.errors
  32 import bzrlib.ui
  33 import bzrlib.urlutils
  34
  35 import sys
  36 import os
  37 import json
  38 import re
  39 import StringIO
  40 import atexit, shutil, hashlib, urlparse, subprocess
  41
  42 NAME_RE = re.compile('^([^<>]+)')
  43 AUTHOR_RE = re.compile('^([^<>]+?)? ?<([^<>]*)>$')
  44 EMAIL_RE = re.compile('^([^<>]+[^ \\\t<>])?\\b(?:[ \\t<>]*?)\\b([^ \\t<>]+@[^ \\t<>]+)')
  45 RAW_AUTHOR_RE = re.compile('^(\w+) (.+)? <(.*)> (\d+) ([+-]\d+)')
  46
  47 def die(msg, *args):
  48     sys.stderr.write('ERROR: %s\n' % (msg % args))
  49     sys.exit(1)
  50
  51 def warn(msg, *args):
  52     sys.stderr.write('WARNING: %s\n' % (msg % args))
  53
  54 def gittz(tz):
  55     return '%+03d%02d' % (tz / 3600, tz % 3600 / 60)
  56
  57 def get_config(config):
  58     cmd = ['git', 'config', '--get', config]
  59     process = subprocess.Popen(cmd, stdout=subprocess.PIPE)
  60     output, _ = process.communicate()
  61     return output
  62
  63 class Marks:
  64
  65     def __init__(self, path):
  66         self.path = path
  67         self.tips = {}
  68         self.marks = {}
  69         self.rev_marks = {}
  70         self.last_mark = 0
  71         self.load()
  72
  73     def load(self):
  74         if not os.path.exists(self.path):
  75             return
  76
  77         tmp = json.load(open(self.path))
  78         self.tips = tmp['tips']
  79         self.marks = tmp['marks']
  80         self.last_mark = tmp['last-mark']
  81
  82         for rev, mark in self.marks.iteritems():
  83             self.rev_marks[mark] = rev
  84
  85     def dict(self):
  86         return { 'tips': self.tips, 'marks': self.marks, 'last-mark' : self.last_mark }
  87
  88     def store(self):
  89         json.dump(self.dict(), open(self.path, 'w'))
  90
  91     def __str__(self):
  92         return str(self.dict())
  93
  94     def from_rev(self, rev):
  95         return self.marks[rev]
  96
  97     def to_rev(self, mark):
  98         return str(self.rev_marks[mark])
  99
 100     def next_mark(self):
 101         self.last_mark += 1
 102         return self.last_mark
 103
 104     def get_mark(self, rev):
 105         self.last_mark += 1
 106         self.marks[rev] = self.last_mark
 107         return self.last_mark
 108
 109     def is_marked(self, rev):
 110         return rev in self.marks
 111
 112     def new_mark(self, rev, mark):
 113         self.marks[rev] = mark
 114         self.rev_marks[mark] = rev
 115         self.last_mark = mark
 116
 117     def get_tip(self, branch):
 118         return self.tips.get(branch, None)
 119
 120     def set_tip(self, branch, tip):
 121         self.tips[branch] = tip
 122
 123 class Parser:
 124
 125     def __init__(self, repo):
 126         self.repo = repo
 127         self.line = self.get_line()
 128
 129     def get_line(self):
 130         return sys.stdin.readline().strip()
 131
 132     def __getitem__(self, i):
 133         return self.line.split()[i]
 134
 135     def check(self, word):
 136         return self.line.startswith(word)
 137
 138     def each_block(self, separator):
 139         while self.line != separator:
 140             yield self.line
 141             self.line = self.get_line()
 142
 143     def __iter__(self):
 144         return self.each_block('')
 145
 146     def next(self):
 147         self.line = self.get_line()
 148         if self.line == 'done':
 149             self.line = None
 150
 151     def get_mark(self):
 152         i = self.line.index(':') + 1
 153         return int(self.line[i:])
 154
 155     def get_data(self):
 156         if not self.check('data'):
 157             return None
 158         i = self.line.index(' ') + 1
 159         size = int(self.line[i:])
 160         return sys.stdin.read(size)
 161
 162     def get_author(self):
 163         m = RAW_AUTHOR_RE.match(self.line)
 164         if not m:
 165             return None
 166         _, name, email, date, tz = m.groups()
 167         committer = '%s <%s>' % (name, email)
 168         tz = int(tz)
 169         tz = ((tz / 100) * 3600) + ((tz % 100) * 60)
 170         return (committer, int(date), tz)
 171
 172 def rev_to_mark(rev):
 173     global marks
 174     return marks.from_rev(rev)
 175
 176 def mark_to_rev(mark):
 177     global marks
 178     return marks.to_rev(mark)
 179
 180 def fixup_user(user):
 181     name = mail = None
 182     user = user.replace('"', '')
 183     m = AUTHOR_RE.match(user)
 184     if m:
 185         name = m.group(1)
 186         mail = m.group(2).strip()
 187     else:
 188         m = EMAIL_RE.match(user)
 189         if m:
 190             name = m.group(1)
 191             mail = m.group(2)
 192         else:
 193             m = NAME_RE.match(user)
 194             if m:
 195                 name = m.group(1).strip()
 196
 197     if not name:
 198         name = 'unknown'
 199     if not mail:
 200         mail = 'Unknown'
 201
 202     return '%s <%s>' % (name, mail)
 203
 204 def get_filechanges(cur, prev):
 205     modified = {}
 206     removed = {}
 207
 208     changes = cur.changes_from(prev)
 209
 210     def u(s):
 211         return s.encode('utf-8')
 212
 213     for path, fid, kind in changes.added:
 214         modified[u(path)] = fid
 215     for path, fid, kind in changes.removed:
 216         removed[u(path)] = None
 217     for path, fid, kind, mod, _ in changes.modified:
 218         modified[u(path)] = fid
 219     for oldpath, newpath, fid, kind, mod, _ in changes.renamed:
 220         removed[u(oldpath)] = None
 221         if kind == 'directory':
 222             lst = cur.list_files(from_dir=newpath, recursive=True)
 223             for path, file_class, kind, fid, entry in lst:
 224                 if kind != 'directory':
 225                     modified[u(newpath + '/' + path)] = fid
 226         else:
 227             modified[u(newpath)] = fid
 228
 229     return modified, removed
 230
 231 def export_files(tree, files):
 232     global marks, filenodes
 233
 234     final = []
 235     for path, fid in files.iteritems():
 236         kind = tree.kind(fid)
 237
 238         h = tree.get_file_sha1(fid)
 239
 240         if kind == 'symlink':
 241             d = tree.get_symlink_target(fid)
 242             mode = '120000'
 243         elif kind == 'file':
 244
 245             if tree.is_executable(fid):
 246                 mode = '100755'
 247             else:
 248                 mode = '100644'
 249
 250             # is the blob already exported?
 251             if h in filenodes:
 252                 mark = filenodes[h]
 253                 final.append((mode, mark, path))
 254                 continue
 255
 256             d = tree.get_file_text(fid)
 257         elif kind == 'directory':
 258             continue
 259         else:
 260             die("Unhandled kind '%s' for path '%s'" % (kind, path))
 261
 262         mark = marks.next_mark()
 263         filenodes[h] = mark
 264
 265         print "blob"
 266         print "mark :%u" % mark
 267         print "data %d" % len(d)
 268         print d
 269
 270         final.append((mode, mark, path))
 271
 272     return final
 273
 274 def export_branch(repo, name):
 275     global prefix
 276
 277     ref = '%s/heads/%s' % (prefix, name)
 278     tip = marks.get_tip(name)
 279
 280     branch = bzrlib.branch.Branch.open(branches[name])
 281     repo = branch.repository
 282
 283     branch.lock_read()
 284     revs = branch.iter_merge_sorted_revisions(None, tip, 'exclude', 'forward')
 285     tip_revno = branch.revision_id_to_revno(tip)
 286     last_revno, _ = branch.last_revision_info()
 287     total = last_revno - tip_revno
 288
 289     for revid, _, seq, _ in revs:
 290
 291         if marks.is_marked(revid):
 292             continue
 293
 294         rev = repo.get_revision(revid)
 295         revno = seq[0]
 296
 297         parents = rev.parent_ids
 298         time = rev.timestamp
 299         tz = rev.timezone
 300         committer = rev.committer.encode('utf-8')
 301         committer = "%s %u %s" % (fixup_user(committer), time, gittz(tz))
 302         authors = rev.get_apparent_authors()
 303         if authors:
 304             author = authors[0].encode('utf-8')
 305             author = "%s %u %s" % (fixup_user(author), time, gittz(tz))
 306         else:
 307             author = committer
 308         msg = rev.message.encode('utf-8')
 309
 310         msg += '\n'
 311
 312         if len(parents) == 0:
 313             parent = bzrlib.revision.NULL_REVISION
 314         else:
 315             parent = parents[0]
 316
 317         cur_tree = repo.revision_tree(revid)
 318         prev = repo.revision_tree(parent)
 319         modified, removed = get_filechanges(cur_tree, prev)
 320
 321         modified_final = export_files(cur_tree, modified)
 322
 323         if len(parents) == 0:
 324             print 'reset %s' % ref
 325
 326         print "commit %s" % ref
 327         print "mark :%d" % (marks.get_mark(revid))
 328         print "author %s" % (author)
 329         print "committer %s" % (committer)
 330         print "data %d" % (len(msg))
 331         print msg
 332
 333         for i, p in enumerate(parents):
 334             try:
 335                 m = rev_to_mark(p)
 336             except KeyError:
 337                 # ghost?
 338                 continue
 339             if i == 0:
 340                 print "from :%s" % m
 341             else:
 342                 print "merge :%s" % m
 343
 344         for f in removed:
 345             print "D %s" % (f,)
 346         for f in modified_final:
 347             print "M %s :%u %s" % f
 348         print
 349
 350         if len(seq) > 1:
 351             # let's skip branch revisions from the progress report
 352             continue
 353
 354         progress = (revno - tip_revno)
 355         if (progress % 100 == 0):
 356             print "progress revision %d '%s' (%d/%d)" % (revno, name, progress, total)
 357
 358     branch.unlock()
 359
 360     revid = branch.last_revision()
 361
 362     # make sure the ref is updated
 363     print "reset %s" % ref
 364     print "from :%u" % rev_to_mark(revid)
 365     print
 366
 367     marks.set_tip(name, revid)
 368
 369 def export_tag(repo, name):
 370     global tags, prefix
 371
 372     ref = '%s/tags/%s' % (prefix, name)
 373     print "reset %s" % ref
 374     print "from :%u" % rev_to_mark(tags[name])
 375     print
 376
 377 def do_import(parser):
 378     global dirname
 379
 380     repo = parser.repo
 381     path = os.path.join(dirname, 'marks-git')
 382
 383     print "feature done"
 384     if os.path.exists(path):
 385         print "feature import-marks=%s" % path
 386     print "feature export-marks=%s" % path
 387     print "feature force"
 388     sys.stdout.flush()
 389
 390     while parser.check('import'):
 391         ref = parser[1]
 392         if ref.startswith('refs/heads/'):
 393             name = ref[len('refs/heads/'):]
 394             export_branch(repo, name)
 395         if ref.startswith('refs/tags/'):
 396             name = ref[len('refs/tags/'):]
 397             export_tag(repo, name)
 398         parser.next()
 399
 400     print 'done'
 401
 402     sys.stdout.flush()
 403
 404 def parse_blob(parser):
 405     global blob_marks
 406
 407     parser.next()
 408     mark = parser.get_mark()
 409     parser.next()
 410     data = parser.get_data()
 411     blob_marks[mark] = data
 412     parser.next()
 413
 414 class CustomTree():
 415
 416     def __init__(self, branch, revid, parents, files):
 417         global files_cache
 418
 419         self.updates = {}
 420         self.branch = branch
 421
 422         def copy_tree(revid):
 423             files = files_cache[revid] = {}
 424             branch.lock_read()
 425             tree = branch.repository.revision_tree(revid)
 426             try:
 427                 for path, entry in tree.iter_entries_by_dir():
 428                     files[path] = [entry.file_id, None]
 429             finally:
 430                 branch.unlock()
 431             return files
 432
 433         if len(parents) == 0:
 434             self.base_id = bzrlib.revision.NULL_REVISION
 435             self.base_files = {}
 436         else:
 437             self.base_id = parents[0]
 438             self.base_files = files_cache.get(self.base_id, None)
 439             if not self.base_files:
 440                 self.base_files = copy_tree(self.base_id)
 441
 442         self.files = files_cache[revid] = self.base_files.copy()
 443         self.rev_files = {}
 444
 445         for path, data in self.files.iteritems():
 446             fid, mark = data
 447             self.rev_files[fid] = [path, mark]
 448
 449         for path, f in files.iteritems():
 450             fid, mark = self.files.get(path, [None, None])
 451             if not fid:
 452                 fid = bzrlib.generate_ids.gen_file_id(path)
 453             f['path'] = path
 454             self.rev_files[fid] = [path, mark]
 455             self.updates[fid] = f
 456
 457     def last_revision(self):
 458         return self.base_id
 459
 460     def iter_changes(self):
 461         changes = []
 462
 463         def get_parent(dirname, basename):
 464             parent_fid, mark = self.base_files.get(dirname, [None, None])
 465             if parent_fid:
 466                 return parent_fid
 467             parent_fid, mark = self.files.get(dirname, [None, None])
 468             if parent_fid:
 469                 return parent_fid
 470             if basename == '':
 471                 return None
 472             fid = bzrlib.generate_ids.gen_file_id(path)
 473             add_entry(fid, dirname, 'directory')
 474             return fid
 475
 476         def add_entry(fid, path, kind, mode = None):
 477             dirname, basename = os.path.split(path)
 478             parent_fid = get_parent(dirname, basename)
 479
 480             executable = False
 481             if mode == '100755':
 482                 executable = True
 483             elif mode == '120000':
 484                 kind = 'symlink'
 485
 486             change = (fid,
 487                     (None, path),
 488                     True,
 489                     (False, True),
 490                     (None, parent_fid),
 491                     (None, basename),
 492                     (None, kind),
 493                     (None, executable))
 494             self.files[path] = [change[0], None]
 495             changes.append(change)
 496
 497         def update_entry(fid, path, kind, mode = None):
 498             dirname, basename = os.path.split(path)
 499             parent_fid = get_parent(dirname, basename)
 500
 501             executable = False
 502             if mode == '100755':
 503                 executable = True
 504             elif mode == '120000':
 505                 kind = 'symlink'
 506
 507             change = (fid,
 508                     (path, path),
 509                     True,
 510                     (True, True),
 511                     (None, parent_fid),
 512                     (None, basename),
 513                     (None, kind),
 514                     (None, executable))
 515             self.files[path] = [change[0], None]
 516             changes.append(change)
 517
 518         def remove_entry(fid, path, kind):
 519             dirname, basename = os.path.split(path)
 520             parent_fid = get_parent(dirname, basename)
 521             change = (fid,
 522                     (path, None),
 523                     True,
 524                     (True, False),
 525                     (parent_fid, None),
 526                     (None, None),
 527                     (None, None),
 528                     (None, None))
 529             del self.files[path]
 530             changes.append(change)
 531
 532         for fid, f in self.updates.iteritems():
 533             path = f['path']
 534
 535             if 'deleted' in f:
 536                 remove_entry(fid, path, 'file')
 537                 continue
 538
 539             if path in self.base_files:
 540                 update_entry(fid, path, 'file', f['mode'])
 541             else:
 542                 add_entry(fid, path, 'file', f['mode'])
 543
 544             self.files[path][1] = f['mark']
 545             self.rev_files[fid][1] = f['mark']
 546
 547         return changes
 548
 549     def get_content(self, file_id):
 550         path, mark = self.rev_files[file_id]
 551         if mark:
 552             return blob_marks[mark]
 553
 554         # last resort
 555         tree = self.branch.repository.revision_tree(self.base_id)
 556         return tree.get_file_text(file_id)
 557
 558     def get_file_with_stat(self, file_id, path=None):
 559         content = self.get_content(file_id)
 560         return (StringIO.StringIO(content), None)
 561
 562     def get_symlink_target(self, file_id):
 563         return self.get_content(file_id)
 564
 565     def id2path(self, file_id):
 566         path, mark = self.rev_files[file_id]
 567         return path
 568
 569 def c_style_unescape(string):
 570     if string[0] == string[-1] == '"':
 571         return string.decode('string-escape')[1:-1]
 572     return string
 573
 574 def parse_commit(parser):
 575     global marks, blob_marks, parsed_refs
 576     global mode
 577
 578     parents = []
 579
 580     ref = parser[1]
 581     parser.next()
 582
 583     if ref.startswith('refs/heads/'):
 584         name = ref[len('refs/heads/'):]
 585         branch = bzrlib.branch.Branch.open(branches[name])
 586     else:
 587         die('unknown ref')
 588
 589     commit_mark = parser.get_mark()
 590     parser.next()
 591     author = parser.get_author()
 592     parser.next()
 593     committer = parser.get_author()
 594     parser.next()
 595     data = parser.get_data()
 596     parser.next()
 597     if parser.check('from'):
 598         parents.append(parser.get_mark())
 599         parser.next()
 600     while parser.check('merge'):
 601         parents.append(parser.get_mark())
 602         parser.next()
 603
 604     # fast-export adds an extra newline
 605     if data[-1] == '\n':
 606         data = data[:-1]
 607
 608     files = {}
 609
 610     for line in parser:
 611         if parser.check('M'):
 612             t, m, mark_ref, path = line.split(' ', 3)
 613             mark = int(mark_ref[1:])
 614             f = { 'mode' : m, 'mark' : mark }
 615         elif parser.check('D'):
 616             t, path = line.split(' ')
 617             f = { 'deleted' : True }
 618         else:
 619             die('Unknown file command: %s' % line)
 620         path = c_style_unescape(path).decode('utf-8')
 621         files[path] = f
 622
 623     committer, date, tz = committer
 624     parents = [mark_to_rev(p) for p in parents]
 625     revid = bzrlib.generate_ids.gen_revision_id(committer, date)
 626     props = {}
 627     props['branch-nick'] = branch.nick
 628
 629     mtree = CustomTree(branch, revid, parents, files)
 630     changes = mtree.iter_changes()
 631
 632     branch.lock_write()
 633     try:
 634         builder = branch.get_commit_builder(parents, None, date, tz, committer, props, revid)
 635         try:
 636             list(builder.record_iter_changes(mtree, mtree.last_revision(), changes))
 637             builder.finish_inventory()
 638             builder.commit(data.decode('utf-8', 'replace'))
 639         except Exception, e:
 640             builder.abort()
 641             raise
 642     finally:
 643         branch.unlock()
 644
 645     parsed_refs[ref] = revid
 646     marks.new_mark(revid, commit_mark)
 647
 648 def parse_reset(parser):
 649     global parsed_refs
 650
 651     ref = parser[1]
 652     parser.next()
 653
 654     # ugh
 655     if parser.check('commit'):
 656         parse_commit(parser)
 657         return
 658     if not parser.check('from'):
 659         return
 660     from_mark = parser.get_mark()
 661     parser.next()
 662
 663     parsed_refs[ref] = mark_to_rev(from_mark)
 664
 665 def do_export(parser):
 666     global parsed_refs, dirname
 667
 668     parser.next()
 669
 670     for line in parser.each_block('done'):
 671         if parser.check('blob'):
 672             parse_blob(parser)
 673         elif parser.check('commit'):
 674             parse_commit(parser)
 675         elif parser.check('reset'):
 676             parse_reset(parser)
 677         elif parser.check('tag'):
 678             pass
 679         elif parser.check('feature'):
 680             pass
 681         else:
 682             die('unhandled export command: %s' % line)
 683
 684     for ref, revid in parsed_refs.iteritems():
 685         if ref.startswith('refs/heads/'):
 686             name = ref[len('refs/heads/'):]
 687             branch = bzrlib.branch.Branch.open(branches[name])
 688             branch.generate_revision_history(revid, marks.get_tip(name))
 689
 690             if name in peers:
 691                 peer = bzrlib.branch.Branch.open(peers[name])
 692                 try:
 693                     peer.bzrdir.push_branch(branch, revision_id=revid)
 694                 except bzrlib.errors.DivergedBranches:
 695                     print "error %s non-fast forward" % ref
 696                     continue
 697
 698             try:
 699                 wt = branch.bzrdir.open_workingtree()
 700                 wt.update()
 701             except bzrlib.errors.NoWorkingTree:
 702                 pass
 703         elif ref.startswith('refs/tags/'):
 704             # TODO: implement tag push
 705             print "error %s pushing tags not supported" % ref
 706             continue
 707         else:
 708             # transport-helper/fast-export bugs
 709             continue
 710
 711         print "ok %s" % ref
 712
 713     print
 714
 715 def do_capabilities(parser):
 716     global dirname
 717
 718     print "import"
 719     print "export"
 720     print "refspec refs/heads/*:%s/heads/*" % prefix
 721     print "refspec refs/tags/*:%s/tags/*" % prefix
 722
 723     path = os.path.join(dirname, 'marks-git')
 724
 725     if os.path.exists(path):
 726         print "*import-marks %s" % path
 727     print "*export-marks %s" % path
 728
 729     print
 730
 731 def ref_is_valid(name):
 732     return not True in [c in name for c in '~^: \\']
 733
 734 def do_list(parser):
 735     global tags
 736
 737     master_branch = None
 738
 739     for name in branches:
 740         if not master_branch:
 741             master_branch = name
 742         print "? refs/heads/%s" % name
 743
 744     branch = bzrlib.branch.Branch.open(branches[master_branch])
 745     branch.lock_read()
 746     for tag, revid in branch.tags.get_tag_dict().items():
 747         try:
 748             branch.revision_id_to_dotted_revno(revid)
 749         except bzrlib.errors.NoSuchRevision:
 750             continue
 751         if not ref_is_valid(tag):
 752             continue
 753         print "? refs/tags/%s" % tag
 754         tags[tag] = revid
 755     branch.unlock()
 756
 757     print "@refs/heads/%s HEAD" % master_branch
 758     print
 759
 760 def get_remote_branch(origin, remote_branch, name):
 761     global dirname, peers
 762
 763     branch_path = os.path.join(dirname, 'clone', name)
 764     if os.path.exists(branch_path):
 765         # pull
 766         d = bzrlib.bzrdir.BzrDir.open(branch_path)
 767         branch = d.open_branch()
 768         try:
 769             branch.pull(remote_branch, [], None, False)
 770         except bzrlib.errors.DivergedBranches:
 771             # use remote branch for now
 772             return remote_branch
 773     else:
 774         # clone
 775         d = origin.sprout(branch_path, None,
 776                 hardlink=True, create_tree_if_local=False,
 777                 force_new_repo=False,
 778                 source_branch=remote_branch)
 779         branch = d.open_branch()
 780
 781     return branch
 782
 783 def find_branches(repo, wanted):
 784     transport = repo.user_transport
 785
 786     for fn in transport.iter_files_recursive():
 787         if not fn.endswith('.bzr/branch-format'):
 788             continue
 789
 790         name = subdir = fn[:-len('/.bzr/branch-format')]
 791         name = name if name != '' else 'master'
 792         name = name.replace('/', '+')
 793
 794         if wanted and not name in wanted:
 795             continue
 796
 797         try:
 798             cur = transport.clone(subdir)
 799             branch = bzrlib.branch.Branch.open_from_transport(cur)
 800         except bzrlib.errors.NotBranchError:
 801             continue
 802         else:
 803             yield name, branch
 804
 805 def get_repo(url, alias):
 806     global dirname, peer, branches
 807
 808     normal_url = bzrlib.urlutils.normalize_url(url)
 809     origin = bzrlib.bzrdir.BzrDir.open(url)
 810     is_local = isinstance(origin.transport, bzrlib.transport.local.LocalTransport)
 811
 812     shared_path = os.path.join(gitdir, 'bzr')
 813     try:
 814         shared_dir = bzrlib.bzrdir.BzrDir.open(shared_path)
 815     except bzrlib.errors.NotBranchError:
 816         shared_dir = bzrlib.bzrdir.BzrDir.create(shared_path)
 817     try:
 818         shared_repo = shared_dir.open_repository()
 819     except bzrlib.errors.NoRepositoryPresent:
 820         shared_repo = shared_dir.create_repository(shared=True)
 821
 822     if not is_local:
 823         clone_path = os.path.join(dirname, 'clone')
 824         if not os.path.exists(clone_path):
 825             os.mkdir(clone_path)
 826
 827     try:
 828         repo = origin.open_repository()
 829     except bzrlib.errors.NoRepositoryPresent:
 830         # branch
 831
 832         name = 'master'
 833         remote_branch = origin.open_branch()
 834
 835         if not is_local:
 836             peers[name] = remote_branch.base
 837             branch = get_remote_branch(origin, remote_branch, name)
 838         else:
 839             branch = remote_branch
 840
 841         branches[name] = branch.base
 842
 843         return branch.repository
 844     else:
 845         # repository
 846
 847         wanted = get_config('remote-bzr.branches').rstrip().split(', ')
 848         # stupid python
 849         wanted = [e for e in wanted if e]
 850
 851         for name, remote_branch in find_branches(repo, wanted):
 852
 853             if not is_local:
 854                 peers[name] = remote_branch.base
 855                 branch = get_remote_branch(origin, remote_branch, name)
 856             else:
 857                 branch = remote_branch
 858
 859             branches[name] = branch.base
 860
 861         return repo
 862
 863 def fix_path(alias, orig_url):
 864     url = urlparse.urlparse(orig_url, 'file')
 865     if url.scheme != 'file' or os.path.isabs(url.path):
 866         return
 867     abs_url = urlparse.urljoin("%s/" % os.getcwd(), orig_url)
 868     cmd = ['git', 'config', 'remote.%s.url' % alias, "bzr::%s" % abs_url]
 869     subprocess.call(cmd)
 870
 871 def main(args):
 872     global marks, prefix, gitdir, dirname
 873     global tags, filenodes
 874     global blob_marks
 875     global parsed_refs
 876     global files_cache
 877     global is_tmp
 878     global branches, peers
 879
 880     alias = args[1]
 881     url = args[2]
 882
 883     tags = {}
 884     filenodes = {}
 885     blob_marks = {}
 886     parsed_refs = {}
 887     files_cache = {}
 888     marks = None
 889     branches = {}
 890     peers = {}
 891
 892     if alias[5:] == url:
 893         is_tmp = True
 894         alias = hashlib.sha1(alias).hexdigest()
 895     else:
 896         is_tmp = False
 897
 898     prefix = 'refs/bzr/%s' % alias
 899     gitdir = os.environ['GIT_DIR']
 900     dirname = os.path.join(gitdir, 'bzr', alias)
 901
 902     if not is_tmp:
 903         fix_path(alias, url)
 904
 905     if not os.path.exists(dirname):
 906         os.makedirs(dirname)
 907
 908     bzrlib.ui.ui_factory.be_quiet(True)
 909
 910     repo = get_repo(url, alias)
 911
 912     marks_path = os.path.join(dirname, 'marks-int')
 913     marks = Marks(marks_path)
 914
 915     parser = Parser(repo)
 916     for line in parser:
 917         if parser.check('capabilities'):
 918             do_capabilities(parser)
 919         elif parser.check('list'):
 920             do_list(parser)
 921         elif parser.check('import'):
 922             do_import(parser)
 923         elif parser.check('export'):
 924             do_export(parser)
 925         else:
 926             die('unhandled command: %s' % line)
 927         sys.stdout.flush()
 928
 929 def bye():
 930     if not marks:
 931         return
 932     if not is_tmp:
 933         marks.store()
 934     else:
 935         shutil.rmtree(dirname)
 936
 937 atexit.register(bye)
 938 sys.exit(main(sys.argv))