~ubuntu-branches/debian/jessie/bzr-git/jessie

« back to all changes in this revision

Viewing changes to branch.py

  • Committer: Bazaar Package Importer
  • Author(s): Jelmer Vernooij
  • Date: 2011-06-05 14:24:08 UTC
  • mfrom: (1.1.18 upstream)
  • Revision ID: james.westby@ubuntu.com-20110605142408-a0icybzfem8vltht
Tags: 0.6.0+bzr1270-1
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
288
288
        self._format = GitBranchFormat()
289
289
        self.control_files = lockfiles
290
290
        self.bzrdir = bzrdir
 
291
        self._lock_mode = None
 
292
        self._lock_count = 0
291
293
        super(GitBranch, self).__init__(repository.get_mapping())
292
294
        if tagsdict is not None:
293
295
            self.tags = DictTagDict(self, tagsdict)
338
340
    def lock_write(self, token=None):
339
341
        if token is not None:
340
342
            raise errors.TokenLockingNotSupported(self)
341
 
        self.control_files.lock_write()
 
343
        if self._lock_mode:
 
344
            assert self._lock_mode == 'w'
 
345
            self._lock_count += 1
 
346
        else:
 
347
            self._lock_mode = 'w'
 
348
            self._lock_count = 1
 
349
        self.repository.lock_write()
342
350
        return GitWriteLock(self.unlock)
343
351
 
344
352
    def get_stacked_on_url(self):
355
363
        pass
356
364
 
357
365
    def lock_read(self):
358
 
        self.control_files.lock_read()
 
366
        if self._lock_mode:
 
367
            assert self._lock_mode in ('r', 'w')
 
368
            self._lock_count += 1
 
369
        else:
 
370
            self._lock_mode = 'r'
 
371
            self._lock_count = 1
 
372
        self.repository.lock_read()
359
373
        return GitReadLock(self.unlock)
360
374
 
 
375
    def peek_lock_mode(self):
 
376
        return self._lock_mode
 
377
 
361
378
    def is_locked(self):
362
 
        return self.control_files.is_locked()
 
379
        return (self._lock_mode is not None)
363
380
 
364
381
    def unlock(self):
365
 
        self.control_files.unlock()
 
382
        """See Branch.unlock()."""
 
383
        self._lock_count -= 1
 
384
        if self._lock_count == 0:
 
385
            self._lock_mode = None
 
386
            self._clear_cached_state()
 
387
        self.repository.unlock()
366
388
 
367
389
    def get_physical_lock_status(self):
368
390
        return False
445
467
        except KeyError:
446
468
            return None
447
469
 
448
 
    def set_last_revision_info(self, revno, revid):
449
 
        self.set_last_revision(revid)
 
470
    def _read_last_revision_info(self):
 
471
        last_revid = self.last_revision()
 
472
        graph = self.repository.get_graph()
 
473
        revno = graph.find_distance_to_null(last_revid,
 
474
            [(revision.NULL_REVISION, 0)])
 
475
        return revno, last_revid
 
476
 
 
477
    def set_last_revision_info(self, revno, revision_id):
 
478
        self.set_last_revision(revision_id)
 
479
        self._last_revision_info_cache = revno, revision_id
450
480
 
451
481
    def set_last_revision(self, revid):
 
482
        if not revid or not isinstance(revid, basestring):
 
483
            raise errors.InvalidRevisionId(revision_id=revid, branch=self)
452
484
        if revid == NULL_REVISION:
453
485
            newhead = ZERO_SHA
454
486
        else:
588
620
            return False
589
621
        return True
590
622
 
591
 
    def fetch(self, stop_revision=None, fetch_tags=True):
592
 
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags)
 
623
    def fetch(self, stop_revision=None, fetch_tags=True, limit=None):
 
624
        self.fetch_objects(stop_revision, fetch_tags=fetch_tags, limit=limit)
593
625
 
594
 
    def fetch_objects(self, stop_revision, fetch_tags):
 
626
    def fetch_objects(self, stop_revision, fetch_tags, limit=None):
595
627
        interrepo = self._get_interrepo(self.source, self.target)
596
628
        def determine_wants(heads):
597
629
            if self.source.ref is not None and not self.source.ref in heads:
609
641
                [self._last_revid], include_tags=fetch_tags)
610
642
            return real(heads)
611
643
        pack_hint, head, refs = interrepo.fetch_objects(
612
 
            determine_wants, self.source.mapping)
 
644
            determine_wants, self.source.mapping, limit=limit)
613
645
        if (pack_hint is not None and
614
646
            self.target.repository._format.pack_compresses):
615
647
            self.target.repository.pack(hint=pack_hint)
829
861
        result.new_revid = new_refs[main_ref][1]
830
862
        return result
831
863
 
832
 
    def push(self, overwrite=False, stop_revision=None,
 
864
    def push(self, overwrite=False, stop_revision=None, lossy=False,
833
865
             _override_hook_source_branch=None):
834
866
        result = GitBranchPushResult()
835
867
        result.source_branch = self.source
840
872
            # FIXME: Check for diverged branches
841
873
            refs.update(new_refs)
842
874
            return refs
843
 
        try:
844
 
            old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
845
 
        except NoPushSupport:
846
 
            raise errors.NoRoundtrippingSupport(self.source, self.target)
 
875
        if lossy:
 
876
            result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(
 
877
                update_refs)
 
878
        else:
 
879
            try:
 
880
                old_refs, new_refs = self.interrepo.fetch_refs(update_refs)
 
881
            except NoPushSupport:
 
882
                raise errors.NoRoundtrippingSupport(self.source, self.target)
847
883
        (result.old_revid, old_sha1) = old_refs.get(main_ref, (ZERO_SHA, NULL_REVISION))
848
884
        if result.old_revid is None:
849
885
            result.old_revid = self.target.lookup_foreign_revision_id(old_sha1)
850
886
        result.new_revid = new_refs[main_ref][1]
 
887
        (result.new_original_revno, result.new_original_revid) = stop_revinfo
851
888
        return result
852
889
 
853
890
    def lossy_push(self, stop_revision=None):
854
 
        result = GitBranchPushResult()
855
 
        result.source_branch = self.source
856
 
        result.target_branch = self.target
857
 
        new_refs, main_ref, stop_revinfo = self._get_new_refs(stop_revision)
858
 
        def update_refs(old_refs):
859
 
            refs = dict(old_refs)
860
 
            # FIXME: Check for diverged branches
861
 
            refs.update(new_refs)
862
 
            return refs
863
 
        result.revidmap, old_refs, new_refs = self.interrepo.dfetch_refs(
864
 
            update_refs)
865
 
        result.old_revid = old_refs.get(self.target.ref, (None, NULL_REVISION))[1]
866
 
        result.new_revid = new_refs[main_ref][1]
867
 
        (result.new_original_revno, result.new_original_revid) = stop_revinfo
868
 
        return result
 
891
        # For compatibility with bzr < 2.4
 
892
        return self.push(lossy=True, stop_revision=stop_revision)
869
893
 
870
894
 
871
895
branch.InterBranch.register_optimiser(InterGitLocalGitBranch)