~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Jelmer Vernooij
  • Date: 2009-04-03 21:50:40 UTC
  • mto: This revision was merged to the branch mainline in revision 4253.
  • Revision ID: jelmer@samba.org-20090403215040-lz70cjc4i8bfg9xd
Review from Aaron: 
- move generic serializer tests to bzrlib.tests.test_serializer.
- fix some formatting
- add NEWS item

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
18
 
from cStringIO import StringIO
19
18
import sys
20
19
 
21
20
from bzrlib.lazy_import import lazy_import
31
30
        lockable_files,
32
31
        repository,
33
32
        revision as _mod_revision,
34
 
        rio,
35
33
        symbol_versioning,
36
34
        transport,
37
35
        tsort,
46
44
    )
47
45
""")
48
46
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
 
47
from bzrlib.decorators import needs_read_lock, needs_write_lock
50
48
from bzrlib.hooks import HookPoint, Hooks
51
49
from bzrlib.inter import InterObject
52
 
from bzrlib.lock import _RelockDebugMixin
53
50
from bzrlib import registry
54
51
from bzrlib.symbol_versioning import (
55
52
    deprecated_in,
63
60
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
61
 
65
62
 
66
 
class Branch(bzrdir.ControlComponent):
 
63
# TODO: Maybe include checks for common corruption of newlines, etc?
 
64
 
 
65
# TODO: Some operations like log might retrieve the same revisions
 
66
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
67
# cache in memory to make this faster.  In general anything can be
 
68
# cached in memory between lock and unlock operations. .. nb thats
 
69
# what the transaction identity map provides
 
70
 
 
71
 
 
72
######################################################################
 
73
# branch objects
 
74
 
 
75
class Branch(object):
67
76
    """Branch holding a history of revisions.
68
77
 
69
 
    :ivar base:
70
 
        Base directory/url of the branch; using control_url and
71
 
        control_transport is more standardized.
 
78
    base
 
79
        Base directory/url of the branch.
72
80
 
73
81
    hooks: An instance of BranchHooks.
74
82
    """
76
84
    # - RBC 20060112
77
85
    base = None
78
86
 
79
 
    @property
80
 
    def control_transport(self):
81
 
        return self._transport
82
 
 
83
 
    @property
84
 
    def user_transport(self):
85
 
        return self.bzrdir.user_transport
86
 
 
87
87
    def __init__(self, *ignored, **ignored_too):
88
88
        self.tags = self._format.make_tags(self)
89
89
        self._revision_history_cache = None
90
90
        self._revision_id_to_revno_cache = None
91
91
        self._partial_revision_id_to_revno_cache = {}
92
 
        self._partial_revision_history_cache = []
93
92
        self._last_revision_info_cache = None
94
93
        self._merge_sorted_revisions_cache = None
95
94
        self._open_hook()
102
101
 
103
102
    def _activate_fallback_location(self, url):
104
103
        """Activate the branch/repository from url as a fallback repository."""
105
 
        repo = self._get_fallback_repository(url)
106
 
        if repo.has_same_location(self.repository):
107
 
            raise errors.UnstackableLocationError(self.user_url, url)
108
 
        self.repository.add_fallback_repository(repo)
 
104
        self.repository.add_fallback_repository(
 
105
            self._get_fallback_repository(url))
109
106
 
110
107
    def break_lock(self):
111
108
        """Break a lock if one is present from another instance.
126
123
            raise errors.UnstackableRepositoryFormat(self.repository._format,
127
124
                self.repository.base)
128
125
 
129
 
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
130
 
        """Extend the partial history to include a given index
131
 
 
132
 
        If a stop_index is supplied, stop when that index has been reached.
133
 
        If a stop_revision is supplied, stop when that revision is
134
 
        encountered.  Otherwise, stop when the beginning of history is
135
 
        reached.
136
 
 
137
 
        :param stop_index: The index which should be present.  When it is
138
 
            present, history extension will stop.
139
 
        :param stop_revision: The revision id which should be present.  When
140
 
            it is encountered, history extension will stop.
141
 
        """
142
 
        if len(self._partial_revision_history_cache) == 0:
143
 
            self._partial_revision_history_cache = [self.last_revision()]
144
 
        repository._iter_for_revno(
145
 
            self.repository, self._partial_revision_history_cache,
146
 
            stop_index=stop_index, stop_revision=stop_revision)
147
 
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
148
 
            self._partial_revision_history_cache.pop()
149
 
 
150
 
    def _get_check_refs(self):
151
 
        """Get the references needed for check().
152
 
 
153
 
        See bzrlib.check.
154
 
        """
155
 
        revid = self.last_revision()
156
 
        return [('revision-existence', revid), ('lefthand-distance', revid)]
157
 
 
158
126
    @staticmethod
159
127
    def open(base, _unsupported=False, possible_transports=None):
160
128
        """Open the branch rooted at base.
164
132
        """
165
133
        control = bzrdir.BzrDir.open(base, _unsupported,
166
134
                                     possible_transports=possible_transports)
167
 
        return control.open_branch(unsupported=_unsupported)
 
135
        return control.open_branch(_unsupported)
168
136
 
169
137
    @staticmethod
170
 
    def open_from_transport(transport, name=None, _unsupported=False):
 
138
    def open_from_transport(transport, _unsupported=False):
171
139
        """Open the branch rooted at transport"""
172
140
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
173
 
        return control.open_branch(name=name, unsupported=_unsupported)
 
141
        return control.open_branch(_unsupported)
174
142
 
175
143
    @staticmethod
176
144
    def open_containing(url, possible_transports=None):
214
182
    def _get_fallback_repository(self, url):
215
183
        """Get the repository we fallback to at url."""
216
184
        url = urlutils.join(self.base, url)
217
 
        a_branch = Branch.open(url,
 
185
        a_bzrdir = bzrdir.BzrDir.open(url,
218
186
            possible_transports=[self.bzrdir.root_transport])
219
 
        return a_branch.repository
 
187
        return a_bzrdir.open_branch().repository
220
188
 
221
189
    def _get_tags_bytes(self):
222
190
        """Get the bytes of a serialised tags dict.
283
251
        new_history.reverse()
284
252
        return new_history
285
253
 
286
 
    def lock_write(self, token=None):
287
 
        """Lock the branch for write operations.
288
 
 
289
 
        :param token: A token to permit reacquiring a previously held and
290
 
            preserved lock.
291
 
        :return: A BranchWriteLockResult.
292
 
        """
 
254
    def lock_write(self):
293
255
        raise NotImplementedError(self.lock_write)
294
256
 
295
257
    def lock_read(self):
296
 
        """Lock the branch for read operations.
297
 
 
298
 
        :return: An object with an unlock method which will release the lock
299
 
            obtained.
300
 
        """
301
258
        raise NotImplementedError(self.lock_read)
302
259
 
303
260
    def unlock(self):
428
385
            * 'include' - the stop revision is the last item in the result
429
386
            * 'with-merges' - include the stop revision and all of its
430
387
              merged revisions in the result
431
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
432
 
              that are in both ancestries
433
388
        :param direction: either 'reverse' or 'forward':
434
389
            * reverse means return the start_revision_id first, i.e.
435
390
              start at the most recent revision and go backwards in history
457
412
        # start_revision_id.
458
413
        if self._merge_sorted_revisions_cache is None:
459
414
            last_revision = self.last_revision()
460
 
            known_graph = self.repository.get_known_graph_ancestry(
461
 
                [last_revision])
462
 
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
463
 
                last_revision)
 
415
            graph = self.repository.get_graph()
 
416
            parent_map = dict(((key, value) for key, value in
 
417
                     graph.iter_ancestry([last_revision]) if value is not None))
 
418
            revision_graph = repository._strip_NULL_ghosts(parent_map)
 
419
            revs = tsort.merge_sort(revision_graph, last_revision, None,
 
420
                generate_revno=True)
 
421
            # Drop the sequence # before caching
 
422
            self._merge_sorted_revisions_cache = [r[1:] for r in revs]
 
423
 
464
424
        filtered = self._filter_merge_sorted_revisions(
465
425
            self._merge_sorted_revisions_cache, start_revision_id,
466
426
            stop_revision_id, stop_rule)
467
 
        # Make sure we don't return revisions that are not part of the
468
 
        # start_revision_id ancestry.
469
 
        filtered = self._filter_start_non_ancestors(filtered)
470
427
        if direction == 'reverse':
471
428
            return filtered
472
429
        if direction == 'forward':
479
436
        """Iterate over an inclusive range of sorted revisions."""
480
437
        rev_iter = iter(merge_sorted_revisions)
481
438
        if start_revision_id is not None:
482
 
            for node in rev_iter:
483
 
                rev_id = node.key[-1]
 
439
            for rev_id, depth, revno, end_of_merge in rev_iter:
484
440
                if rev_id != start_revision_id:
485
441
                    continue
486
442
                else:
487
443
                    # The decision to include the start or not
488
444
                    # depends on the stop_rule if a stop is provided
489
 
                    # so pop this node back into the iterator
490
 
                    rev_iter = chain(iter([node]), rev_iter)
 
445
                    rev_iter = chain(
 
446
                        iter([(rev_id, depth, revno, end_of_merge)]),
 
447
                        rev_iter)
491
448
                    break
492
449
        if stop_revision_id is None:
493
 
            # Yield everything
494
 
            for node in rev_iter:
495
 
                rev_id = node.key[-1]
496
 
                yield (rev_id, node.merge_depth, node.revno,
497
 
                       node.end_of_merge)
 
450
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
451
                yield rev_id, depth, revno, end_of_merge
498
452
        elif stop_rule == 'exclude':
499
 
            for node in rev_iter:
500
 
                rev_id = node.key[-1]
 
453
            for rev_id, depth, revno, end_of_merge in rev_iter:
501
454
                if rev_id == stop_revision_id:
502
455
                    return
503
 
                yield (rev_id, node.merge_depth, node.revno,
504
 
                       node.end_of_merge)
 
456
                yield rev_id, depth, revno, end_of_merge
505
457
        elif stop_rule == 'include':
506
 
            for node in rev_iter:
507
 
                rev_id = node.key[-1]
508
 
                yield (rev_id, node.merge_depth, node.revno,
509
 
                       node.end_of_merge)
 
458
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
459
                yield rev_id, depth, revno, end_of_merge
510
460
                if rev_id == stop_revision_id:
511
461
                    return
512
 
        elif stop_rule == 'with-merges-without-common-ancestry':
513
 
            # We want to exclude all revisions that are already part of the
514
 
            # stop_revision_id ancestry.
515
 
            graph = self.repository.get_graph()
516
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
517
 
                                                    [stop_revision_id])
518
 
            for node in rev_iter:
519
 
                rev_id = node.key[-1]
520
 
                if rev_id not in ancestors:
521
 
                    continue
522
 
                yield (rev_id, node.merge_depth, node.revno,
523
 
                       node.end_of_merge)
524
462
        elif stop_rule == 'with-merges':
525
463
            stop_rev = self.repository.get_revision(stop_revision_id)
526
464
            if stop_rev.parent_ids:
527
465
                left_parent = stop_rev.parent_ids[0]
528
466
            else:
529
467
                left_parent = _mod_revision.NULL_REVISION
530
 
            # left_parent is the actual revision we want to stop logging at,
531
 
            # since we want to show the merged revisions after the stop_rev too
532
 
            reached_stop_revision_id = False
533
 
            revision_id_whitelist = []
534
 
            for node in rev_iter:
535
 
                rev_id = node.key[-1]
 
468
            for rev_id, depth, revno, end_of_merge in rev_iter:
536
469
                if rev_id == left_parent:
537
 
                    # reached the left parent after the stop_revision
538
470
                    return
539
 
                if (not reached_stop_revision_id or
540
 
                        rev_id in revision_id_whitelist):
541
 
                    yield (rev_id, node.merge_depth, node.revno,
542
 
                       node.end_of_merge)
543
 
                    if reached_stop_revision_id or rev_id == stop_revision_id:
544
 
                        # only do the merged revs of rev_id from now on
545
 
                        rev = self.repository.get_revision(rev_id)
546
 
                        if rev.parent_ids:
547
 
                            reached_stop_revision_id = True
548
 
                            revision_id_whitelist.extend(rev.parent_ids)
 
471
                yield rev_id, depth, revno, end_of_merge
549
472
        else:
550
473
            raise ValueError('invalid stop_rule %r' % stop_rule)
551
474
 
552
 
    def _filter_start_non_ancestors(self, rev_iter):
553
 
        # If we started from a dotted revno, we want to consider it as a tip
554
 
        # and don't want to yield revisions that are not part of its
555
 
        # ancestry. Given the order guaranteed by the merge sort, we will see
556
 
        # uninteresting descendants of the first parent of our tip before the
557
 
        # tip itself.
558
 
        first = rev_iter.next()
559
 
        (rev_id, merge_depth, revno, end_of_merge) = first
560
 
        yield first
561
 
        if not merge_depth:
562
 
            # We start at a mainline revision so by definition, all others
563
 
            # revisions in rev_iter are ancestors
564
 
            for node in rev_iter:
565
 
                yield node
566
 
 
567
 
        clean = False
568
 
        whitelist = set()
569
 
        pmap = self.repository.get_parent_map([rev_id])
570
 
        parents = pmap.get(rev_id, [])
571
 
        if parents:
572
 
            whitelist.update(parents)
573
 
        else:
574
 
            # If there is no parents, there is nothing of interest left
575
 
 
576
 
            # FIXME: It's hard to test this scenario here as this code is never
577
 
            # called in that case. -- vila 20100322
578
 
            return
579
 
 
580
 
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
581
 
            if not clean:
582
 
                if rev_id in whitelist:
583
 
                    pmap = self.repository.get_parent_map([rev_id])
584
 
                    parents = pmap.get(rev_id, [])
585
 
                    whitelist.remove(rev_id)
586
 
                    whitelist.update(parents)
587
 
                    if merge_depth == 0:
588
 
                        # We've reached the mainline, there is nothing left to
589
 
                        # filter
590
 
                        clean = True
591
 
                else:
592
 
                    # A revision that is not part of the ancestry of our
593
 
                    # starting revision.
594
 
                    continue
595
 
            yield (rev_id, merge_depth, revno, end_of_merge)
596
 
 
597
475
    def leave_lock_in_place(self):
598
476
        """Tell this branch object not to release the physical lock when this
599
477
        object is unlocked.
616
494
        :param other: The branch to bind to
617
495
        :type other: Branch
618
496
        """
619
 
        raise errors.UpgradeRequired(self.user_url)
620
 
 
621
 
    def set_append_revisions_only(self, enabled):
622
 
        if not self._format.supports_set_append_revisions_only():
623
 
            raise errors.UpgradeRequired(self.user_url)
624
 
        if enabled:
625
 
            value = 'True'
626
 
        else:
627
 
            value = 'False'
628
 
        self.get_config().set_user_option('append_revisions_only', value,
629
 
            warn_masked=True)
630
 
 
631
 
    def set_reference_info(self, file_id, tree_path, branch_location):
632
 
        """Set the branch location to use for a tree reference."""
633
 
        raise errors.UnsupportedOperation(self.set_reference_info, self)
634
 
 
635
 
    def get_reference_info(self, file_id):
636
 
        """Get the tree_path and branch_location for a tree reference."""
637
 
        raise errors.UnsupportedOperation(self.get_reference_info, self)
 
497
        raise errors.UpgradeRequired(self.base)
638
498
 
639
499
    @needs_write_lock
640
500
    def fetch(self, from_branch, last_revision=None, pb=None):
674
534
    def get_old_bound_location(self):
675
535
        """Return the URL of the branch we used to be bound to
676
536
        """
677
 
        raise errors.UpgradeRequired(self.user_url)
 
537
        raise errors.UpgradeRequired(self.base)
678
538
 
679
539
    def get_commit_builder(self, parents, config=None, timestamp=None,
680
540
                           timezone=None, committer=None, revprops=None,
730
590
    def set_revision_history(self, rev_history):
731
591
        raise NotImplementedError(self.set_revision_history)
732
592
 
733
 
    @needs_write_lock
734
 
    def set_parent(self, url):
735
 
        """See Branch.set_parent."""
736
 
        # TODO: Maybe delete old location files?
737
 
        # URLs should never be unicode, even on the local fs,
738
 
        # FIXUP this and get_parent in a future branch format bump:
739
 
        # read and rewrite the file. RBC 20060125
740
 
        if url is not None:
741
 
            if isinstance(url, unicode):
742
 
                try:
743
 
                    url = url.encode('ascii')
744
 
                except UnicodeEncodeError:
745
 
                    raise errors.InvalidURL(url,
746
 
                        "Urls must be 7-bit ascii, "
747
 
                        "use bzrlib.urlutils.escape")
748
 
            url = urlutils.relative_url(self.base, url)
749
 
        self._set_parent_location(url)
750
 
 
751
 
    @needs_write_lock
752
593
    def set_stacked_on_url(self, url):
753
594
        """Set the URL this branch is stacked against.
754
595
 
758
599
            stacking.
759
600
        """
760
601
        if not self._format.supports_stacking():
761
 
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
762
 
        # XXX: Changing from one fallback repository to another does not check
763
 
        # that all the data you need is present in the new fallback.
764
 
        # Possibly it should.
 
602
            raise errors.UnstackableBranchFormat(self._format, self.base)
765
603
        self._check_stackable_repo()
766
604
        if not url:
767
605
            try:
769
607
            except (errors.NotStacked, errors.UnstackableBranchFormat,
770
608
                errors.UnstackableRepositoryFormat):
771
609
                return
772
 
            self._unstack()
 
610
            url = ''
 
611
            # repositories don't offer an interface to remove fallback
 
612
            # repositories today; take the conceptually simpler option and just
 
613
            # reopen it.
 
614
            self.repository = self.bzrdir.find_repository()
 
615
            # for every revision reference the branch has, ensure it is pulled
 
616
            # in.
 
617
            source_repository = self._get_fallback_repository(old_url)
 
618
            for revision_id in chain([self.last_revision()],
 
619
                self.tags.get_reverse_tag_dict()):
 
620
                self.repository.fetch(source_repository, revision_id,
 
621
                    find_ghosts=True)
773
622
        else:
774
623
            self._activate_fallback_location(url)
775
624
        # write this out after the repository is stacked to avoid setting a
776
625
        # stacked config that doesn't work.
777
626
        self._set_config_location('stacked_on_location', url)
778
627
 
779
 
    def _unstack(self):
780
 
        """Change a branch to be unstacked, copying data as needed.
781
 
        
782
 
        Don't call this directly, use set_stacked_on_url(None).
783
 
        """
784
 
        pb = ui.ui_factory.nested_progress_bar()
785
 
        try:
786
 
            pb.update("Unstacking")
787
 
            # The basic approach here is to fetch the tip of the branch,
788
 
            # including all available ghosts, from the existing stacked
789
 
            # repository into a new repository object without the fallbacks. 
790
 
            #
791
 
            # XXX: See <https://launchpad.net/bugs/397286> - this may not be
792
 
            # correct for CHKMap repostiories
793
 
            old_repository = self.repository
794
 
            if len(old_repository._fallback_repositories) != 1:
795
 
                raise AssertionError("can't cope with fallback repositories "
796
 
                    "of %r" % (self.repository,))
797
 
            # unlock it, including unlocking the fallback
798
 
            old_repository.unlock()
799
 
            old_repository.lock_read()
800
 
            try:
801
 
                # Repositories don't offer an interface to remove fallback
802
 
                # repositories today; take the conceptually simpler option and just
803
 
                # reopen it.  We reopen it starting from the URL so that we
804
 
                # get a separate connection for RemoteRepositories and can
805
 
                # stream from one of them to the other.  This does mean doing
806
 
                # separate SSH connection setup, but unstacking is not a
807
 
                # common operation so it's tolerable.
808
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
809
 
                new_repository = new_bzrdir.find_repository()
810
 
                self.repository = new_repository
811
 
                if self.repository._fallback_repositories:
812
 
                    raise AssertionError("didn't expect %r to have "
813
 
                        "fallback_repositories"
814
 
                        % (self.repository,))
815
 
                # this is not paired with an unlock because it's just restoring
816
 
                # the previous state; the lock's released when set_stacked_on_url
817
 
                # returns
818
 
                self.repository.lock_write()
819
 
                # XXX: If you unstack a branch while it has a working tree
820
 
                # with a pending merge, the pending-merged revisions will no
821
 
                # longer be present.  You can (probably) revert and remerge.
822
 
                #
823
 
                # XXX: This only fetches up to the tip of the repository; it
824
 
                # doesn't bring across any tags.  That's fairly consistent
825
 
                # with how branch works, but perhaps not ideal.
826
 
                self.repository.fetch(old_repository,
827
 
                    revision_id=self.last_revision(),
828
 
                    find_ghosts=True)
829
 
            finally:
830
 
                old_repository.unlock()
831
 
        finally:
832
 
            pb.finished()
833
628
 
834
629
    def _set_tags_bytes(self, bytes):
835
630
        """Mirror method for _get_tags_bytes.
871
666
        self._revision_id_to_revno_cache = None
872
667
        self._last_revision_info_cache = None
873
668
        self._merge_sorted_revisions_cache = None
874
 
        self._partial_revision_history_cache = []
875
 
        self._partial_revision_id_to_revno_cache = {}
876
669
 
877
670
    def _gen_revision_history(self):
878
671
        """Return sequence of revision hashes on to this branch.
915
708
 
916
709
    def unbind(self):
917
710
        """Older format branches cannot bind or unbind."""
918
 
        raise errors.UpgradeRequired(self.user_url)
 
711
        raise errors.UpgradeRequired(self.base)
 
712
 
 
713
    def set_append_revisions_only(self, enabled):
 
714
        """Older format branches are never restricted to append-only"""
 
715
        raise errors.UpgradeRequired(self.base)
919
716
 
920
717
    def last_revision(self):
921
718
        """Return last revision id, or NULL_REVISION."""
1002
799
        except ValueError:
1003
800
            raise errors.NoSuchRevision(self, revision_id)
1004
801
 
1005
 
    @needs_read_lock
1006
802
    def get_rev_id(self, revno, history=None):
1007
803
        """Find the revision id of the specified revno."""
1008
804
        if revno == 0:
1009
805
            return _mod_revision.NULL_REVISION
1010
 
        last_revno, last_revid = self.last_revision_info()
1011
 
        if revno == last_revno:
1012
 
            return last_revid
1013
 
        if revno <= 0 or revno > last_revno:
 
806
        if history is None:
 
807
            history = self.revision_history()
 
808
        if revno <= 0 or revno > len(history):
1014
809
            raise errors.NoSuchRevision(self, revno)
1015
 
        distance_from_last = last_revno - revno
1016
 
        if len(self._partial_revision_history_cache) <= distance_from_last:
1017
 
            self._extend_partial_history(distance_from_last)
1018
 
        return self._partial_revision_history_cache[distance_from_last]
 
810
        return history[revno - 1]
1019
811
 
1020
 
    @needs_write_lock
1021
812
    def pull(self, source, overwrite=False, stop_revision=None,
1022
 
             possible_transports=None, *args, **kwargs):
 
813
             possible_transports=None, _override_hook_target=None):
1023
814
        """Mirror source into this branch.
1024
815
 
1025
816
        This branch is considered to be 'local', having low latency.
1026
817
 
1027
818
        :returns: PullResult instance
1028
819
        """
1029
 
        return InterBranch.get(source, self).pull(overwrite=overwrite,
1030
 
            stop_revision=stop_revision,
1031
 
            possible_transports=possible_transports, *args, **kwargs)
 
820
        raise NotImplementedError(self.pull)
1032
821
 
1033
 
    def push(self, target, overwrite=False, stop_revision=None, *args,
1034
 
        **kwargs):
 
822
    def push(self, target, overwrite=False, stop_revision=None):
1035
823
        """Mirror this branch into target.
1036
824
 
1037
825
        This branch is considered to be 'local', having low latency.
1038
826
        """
1039
 
        return InterBranch.get(self, target).push(overwrite, stop_revision,
1040
 
            *args, **kwargs)
1041
 
 
1042
 
    def lossy_push(self, target, stop_revision=None):
1043
 
        """Push deltas into another branch.
1044
 
 
1045
 
        :note: This does not, like push, retain the revision ids from 
1046
 
            the source branch and will, rather than adding bzr-specific 
1047
 
            metadata, push only those semantics of the revision that can be 
1048
 
            natively represented by this branch' VCS.
1049
 
 
1050
 
        :param target: Target branch
1051
 
        :param stop_revision: Revision to push, defaults to last revision.
1052
 
        :return: BranchPushResult with an extra member revidmap: 
1053
 
            A dictionary mapping revision ids from the target branch 
1054
 
            to new revision ids in the target branch, for each 
1055
 
            revision that was pushed.
1056
 
        """
1057
 
        inter = InterBranch.get(self, target)
1058
 
        lossy_push = getattr(inter, "lossy_push", None)
1059
 
        if lossy_push is None:
1060
 
            raise errors.LossyPushToSameVCS(self, target)
1061
 
        return lossy_push(stop_revision)
 
827
        raise NotImplementedError(self.push)
1062
828
 
1063
829
    def basis_tree(self):
1064
830
        """Return `Tree` object for last revision."""
1081
847
        try:
1082
848
            return urlutils.join(self.base[:-1], parent)
1083
849
        except errors.InvalidURLJoin, e:
1084
 
            raise errors.InaccessibleParent(parent, self.user_url)
 
850
            raise errors.InaccessibleParent(parent, self.base)
1085
851
 
1086
852
    def _get_parent_location(self):
1087
853
        raise NotImplementedError(self._get_parent_location)
1104
870
            location = None
1105
871
        return location
1106
872
 
1107
 
    def get_child_submit_format(self):
1108
 
        """Return the preferred format of submissions to this branch."""
1109
 
        return self.get_config().get_user_option("child_submit_format")
1110
 
 
1111
873
    def get_submit_branch(self):
1112
874
        """Return the submit location of the branch.
1113
875
 
1130
892
    def get_public_branch(self):
1131
893
        """Return the public location of the branch.
1132
894
 
1133
 
        This is used by merge directives.
 
895
        This is is used by merge directives.
1134
896
        """
1135
897
        return self._get_config_location('public_branch')
1136
898
 
1172
934
        params = ChangeBranchTipParams(
1173
935
            self, old_revno, new_revno, old_revid, new_revid)
1174
936
        for hook in hooks:
1175
 
            hook(params)
 
937
            try:
 
938
                hook(params)
 
939
            except errors.TipChangeRejected:
 
940
                raise
 
941
            except Exception:
 
942
                exc_info = sys.exc_info()
 
943
                hook_name = Branch.hooks.get_hook_name(hook)
 
944
                raise errors.HookFailed(
 
945
                    'pre_change_branch_tip', hook_name, exc_info)
 
946
 
 
947
    def set_parent(self, url):
 
948
        raise NotImplementedError(self.set_parent)
1176
949
 
1177
950
    @needs_write_lock
1178
951
    def update(self):
1209
982
                     be truncated to end with revision_id.
1210
983
        """
1211
984
        result = to_bzrdir.create_branch()
1212
 
        result.lock_write()
1213
 
        try:
1214
 
            if repository_policy is not None:
1215
 
                repository_policy.configure_branch(result)
1216
 
            self.copy_content_into(result, revision_id=revision_id)
1217
 
        finally:
1218
 
            result.unlock()
1219
 
        return result
 
985
        if repository_policy is not None:
 
986
            repository_policy.configure_branch(result)
 
987
        self.copy_content_into(result, revision_id=revision_id)
 
988
        return  result
1220
989
 
1221
990
    @needs_read_lock
1222
991
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
1227
996
        revision_id: if not None, the revision history in the new branch will
1228
997
                     be truncated to end with revision_id.
1229
998
        """
1230
 
        if (repository_policy is not None and
1231
 
            repository_policy.requires_stacking()):
1232
 
            to_bzrdir._format.require_stacking(_skip_repo=True)
1233
999
        result = to_bzrdir.create_branch()
1234
 
        result.lock_write()
1235
 
        try:
1236
 
            if repository_policy is not None:
1237
 
                repository_policy.configure_branch(result)
1238
 
            self.copy_content_into(result, revision_id=revision_id)
1239
 
            result.set_parent(self.bzrdir.root_transport.base)
1240
 
        finally:
1241
 
            result.unlock()
 
1000
        if repository_policy is not None:
 
1001
            repository_policy.configure_branch(result)
 
1002
        self.copy_content_into(result, revision_id=revision_id)
 
1003
        result.set_parent(self.bzrdir.root_transport.base)
1242
1004
        return result
1243
1005
 
1244
1006
    def _synchronize_history(self, destination, revision_id):
1256
1018
        source_revno, source_revision_id = self.last_revision_info()
1257
1019
        if revision_id is None:
1258
1020
            revno, revision_id = source_revno, source_revision_id
 
1021
        elif source_revision_id == revision_id:
 
1022
            # we know the revno without needing to walk all of history
 
1023
            revno = source_revno
1259
1024
        else:
1260
 
            graph = self.repository.get_graph()
1261
 
            try:
1262
 
                revno = graph.find_distance_to_null(revision_id, 
1263
 
                    [(source_revision_id, source_revno)])
1264
 
            except errors.GhostRevisionsHaveNoRevno:
1265
 
                # Default to 1, if we can't find anything else
1266
 
                revno = 1
 
1025
            # To figure out the revno for a random revision, we need to build
 
1026
            # the revision history, and count its length.
 
1027
            # We don't care about the order, just how long it is.
 
1028
            # Alternatively, we could start at the current location, and count
 
1029
            # backwards. But there is no guarantee that we will find it since
 
1030
            # it may be a merged revision.
 
1031
            revno = len(list(self.repository.iter_reverse_revision_history(
 
1032
                                                                revision_id)))
1267
1033
        destination.set_last_revision_info(revno, revision_id)
1268
1034
 
1269
1035
    @needs_read_lock
1273
1039
        revision_id: if not None, the revision history in the new branch will
1274
1040
                     be truncated to end with revision_id.
1275
1041
        """
1276
 
        self.update_references(destination)
1277
1042
        self._synchronize_history(destination, revision_id)
1278
1043
        try:
1279
1044
            parent = self.get_parent()
1285
1050
        if self._push_should_merge_tags():
1286
1051
            self.tags.merge_to(destination.tags)
1287
1052
 
1288
 
    def update_references(self, target):
1289
 
        if not getattr(self._format, 'supports_reference_locations', False):
1290
 
            return
1291
 
        reference_dict = self._get_all_reference_info()
1292
 
        if len(reference_dict) == 0:
1293
 
            return
1294
 
        old_base = self.base
1295
 
        new_base = target.base
1296
 
        target_reference_dict = target._get_all_reference_info()
1297
 
        for file_id, (tree_path, branch_location) in (
1298
 
            reference_dict.items()):
1299
 
            branch_location = urlutils.rebase_url(branch_location,
1300
 
                                                  old_base, new_base)
1301
 
            target_reference_dict.setdefault(
1302
 
                file_id, (tree_path, branch_location))
1303
 
        target._set_all_reference_info(target_reference_dict)
1304
 
 
1305
1053
    @needs_read_lock
1306
 
    def check(self, refs):
 
1054
    def check(self):
1307
1055
        """Check consistency of the branch.
1308
1056
 
1309
1057
        In particular this checks that revisions given in the revision-history
1312
1060
 
1313
1061
        Callers will typically also want to check the repository.
1314
1062
 
1315
 
        :param refs: Calculated refs for this branch as specified by
1316
 
            branch._get_check_refs()
1317
1063
        :return: A BranchCheckResult.
1318
1064
        """
1319
 
        result = BranchCheckResult(self)
 
1065
        mainline_parent_id = None
1320
1066
        last_revno, last_revision_id = self.last_revision_info()
1321
 
        actual_revno = refs[('lefthand-distance', last_revision_id)]
1322
 
        if actual_revno != last_revno:
1323
 
            result.errors.append(errors.BzrCheckError(
1324
 
                'revno does not match len(mainline) %s != %s' % (
1325
 
                last_revno, actual_revno)))
1326
 
        # TODO: We should probably also check that self.revision_history
1327
 
        # matches the repository for older branch formats.
1328
 
        # If looking for the code that cross-checks repository parents against
1329
 
        # the iter_reverse_revision_history output, that is now a repository
1330
 
        # specific check.
1331
 
        return result
 
1067
        real_rev_history = list(self.repository.iter_reverse_revision_history(
 
1068
                                last_revision_id))
 
1069
        real_rev_history.reverse()
 
1070
        if len(real_rev_history) != last_revno:
 
1071
            raise errors.BzrCheckError('revno does not match len(mainline)'
 
1072
                ' %s != %s' % (last_revno, len(real_rev_history)))
 
1073
        # TODO: We should probably also check that real_rev_history actually
 
1074
        #       matches self.revision_history()
 
1075
        for revision_id in real_rev_history:
 
1076
            try:
 
1077
                revision = self.repository.get_revision(revision_id)
 
1078
            except errors.NoSuchRevision, e:
 
1079
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
1080
                            % revision_id)
 
1081
            # In general the first entry on the revision history has no parents.
 
1082
            # But it's not illegal for it to have parents listed; this can happen
 
1083
            # in imports from Arch when the parents weren't reachable.
 
1084
            if mainline_parent_id is not None:
 
1085
                if mainline_parent_id not in revision.parent_ids:
 
1086
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
1087
                                        "parents of {%s}"
 
1088
                                        % (mainline_parent_id, revision_id))
 
1089
            mainline_parent_id = revision_id
 
1090
        return BranchCheckResult(self)
1332
1091
 
1333
1092
    def _get_checkout_format(self):
1334
1093
        """Return the most suitable metadir for a checkout of this branch.
1344
1103
        return format
1345
1104
 
1346
1105
    def create_clone_on_transport(self, to_transport, revision_id=None,
1347
 
        stacked_on=None, create_prefix=False, use_existing_dir=False):
 
1106
        stacked_on=None):
1348
1107
        """Create a clone of this branch and its bzrdir.
1349
1108
 
1350
1109
        :param to_transport: The transport to clone onto.
1351
1110
        :param revision_id: The revision id to use as tip in the new branch.
1352
1111
            If None the tip is obtained from this branch.
1353
1112
        :param stacked_on: An optional URL to stack the clone on.
1354
 
        :param create_prefix: Create any missing directories leading up to
1355
 
            to_transport.
1356
 
        :param use_existing_dir: Use an existing directory if one exists.
1357
1113
        """
1358
1114
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1359
1115
        # clone call. Or something. 20090224 RBC/spiv.
1360
 
        if revision_id is None:
1361
 
            revision_id = self.last_revision()
1362
1116
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1363
 
            revision_id=revision_id, stacked_on=stacked_on,
1364
 
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
 
1117
            revision_id=revision_id, stacked_on=stacked_on)
1365
1118
        return dir_to.open_branch()
1366
1119
 
1367
1120
    def create_checkout(self, to_location, revision_id=None,
1386
1139
        if lightweight:
1387
1140
            format = self._get_checkout_format()
1388
1141
            checkout = format.initialize_on_transport(t)
1389
 
            from_branch = BranchReferenceFormat().initialize(checkout, 
1390
 
                target_branch=self)
 
1142
            from_branch = BranchReferenceFormat().initialize(checkout, self)
1391
1143
        else:
1392
1144
            format = self._get_checkout_format()
1393
1145
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1422
1174
        reconciler.reconcile()
1423
1175
        return reconciler
1424
1176
 
1425
 
    def reference_parent(self, file_id, path, possible_transports=None):
 
1177
    def reference_parent(self, file_id, path):
1426
1178
        """Return the parent branch for a tree-reference file_id
1427
1179
        :param file_id: The file_id of the tree reference
1428
1180
        :param path: The path of the file_id in the tree
1429
1181
        :return: A branch associated with the file_id
1430
1182
        """
1431
1183
        # FIXME should provide multiple branches, based on config
1432
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1433
 
                           possible_transports=possible_transports)
 
1184
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
1434
1185
 
1435
1186
    def supports_tags(self):
1436
1187
        return self._format.supports_tags()
1437
1188
 
1438
 
    def automatic_tag_name(self, revision_id):
1439
 
        """Try to automatically find the tag name for a revision.
1440
 
 
1441
 
        :param revision_id: Revision id of the revision.
1442
 
        :return: A tag name or None if no tag name could be determined.
1443
 
        """
1444
 
        for hook in Branch.hooks['automatic_tag_name']:
1445
 
            ret = hook(self, revision_id)
1446
 
            if ret is not None:
1447
 
                return ret
1448
 
        return None
1449
 
 
1450
1189
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1451
1190
                                         other_branch):
1452
1191
        """Ensure that revision_b is a descendant of revision_a.
1507
1246
    _formats = {}
1508
1247
    """The known formats."""
1509
1248
 
1510
 
    can_set_append_revisions_only = True
1511
 
 
1512
1249
    def __eq__(self, other):
1513
1250
        return self.__class__ is other.__class__
1514
1251
 
1516
1253
        return not (self == other)
1517
1254
 
1518
1255
    @classmethod
1519
 
    def find_format(klass, a_bzrdir, name=None):
 
1256
    def find_format(klass, a_bzrdir):
1520
1257
        """Return the format for the branch object in a_bzrdir."""
1521
1258
        try:
1522
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
1523
 
            format_string = transport.get_bytes("format")
 
1259
            transport = a_bzrdir.get_branch_transport(None)
 
1260
            format_string = transport.get("format").read()
1524
1261
            return klass._formats[format_string]
1525
1262
        except errors.NoSuchFile:
1526
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
 
1263
            raise errors.NotBranchError(path=transport.base)
1527
1264
        except KeyError:
1528
1265
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1529
1266
 
1565
1302
        """Return the short format description for this format."""
1566
1303
        raise NotImplementedError(self.get_format_description)
1567
1304
 
1568
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1569
 
        hooks = Branch.hooks['post_branch_init']
1570
 
        if not hooks:
1571
 
            return
1572
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1573
 
        for hook in hooks:
1574
 
            hook(params)
1575
 
 
1576
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1577
 
                           lock_type='metadir', set_format=True):
 
1305
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
1306
                           set_format=True):
1578
1307
        """Initialize a branch in a bzrdir, with specified files
1579
1308
 
1580
1309
        :param a_bzrdir: The bzrdir to initialize the branch in
1581
1310
        :param utf8_files: The files to create as a list of
1582
1311
            (filename, content) tuples
1583
 
        :param name: Name of colocated branch to create, if any
1584
1312
        :param set_format: If True, set the format with
1585
1313
            self.get_format_string.  (BzrBranch4 has its format set
1586
1314
            elsewhere)
1587
1315
        :return: a branch in this format
1588
1316
        """
1589
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1590
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
1317
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
1318
        branch_transport = a_bzrdir.get_branch_transport(self)
1591
1319
        lock_map = {
1592
1320
            'metadir': ('lock', lockdir.LockDir),
1593
1321
            'branch4': ('branch-lock', lockable_files.TransportLock),
1596
1324
        control_files = lockable_files.LockableFiles(branch_transport,
1597
1325
            lock_name, lock_class)
1598
1326
        control_files.create_lock()
1599
 
        try:
1600
 
            control_files.lock_write()
1601
 
        except errors.LockContention:
1602
 
            if lock_type != 'branch4':
1603
 
                raise
1604
 
            lock_taken = False
1605
 
        else:
1606
 
            lock_taken = True
 
1327
        control_files.lock_write()
1607
1328
        if set_format:
1608
1329
            utf8_files += [('format', self.get_format_string())]
1609
1330
        try:
1612
1333
                    filename, content,
1613
1334
                    mode=a_bzrdir._get_file_mode())
1614
1335
        finally:
1615
 
            if lock_taken:
1616
 
                control_files.unlock()
1617
 
        branch = self.open(a_bzrdir, name, _found=True)
1618
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1619
 
        return branch
 
1336
            control_files.unlock()
 
1337
        return self.open(a_bzrdir, _found=True)
1620
1338
 
1621
 
    def initialize(self, a_bzrdir, name=None):
1622
 
        """Create a branch of this format in a_bzrdir.
1623
 
        
1624
 
        :param name: Name of the colocated branch to create.
1625
 
        """
 
1339
    def initialize(self, a_bzrdir):
 
1340
        """Create a branch of this format in a_bzrdir."""
1626
1341
        raise NotImplementedError(self.initialize)
1627
1342
 
1628
1343
    def is_supported(self):
1658
1373
        """
1659
1374
        raise NotImplementedError(self.network_name)
1660
1375
 
1661
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1376
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
1662
1377
        """Return the branch object for a_bzrdir
1663
1378
 
1664
1379
        :param a_bzrdir: A BzrDir that contains a branch.
1665
 
        :param name: Name of colocated branch to open
1666
1380
        :param _found: a private parameter, do not use it. It is used to
1667
1381
            indicate if format probing has already be done.
1668
1382
        :param ignore_fallbacks: when set, no fallback branches will be opened
1682
1396
    def set_default_format(klass, format):
1683
1397
        klass._default_format = format
1684
1398
 
1685
 
    def supports_set_append_revisions_only(self):
1686
 
        """True if this format supports set_append_revisions_only."""
1687
 
        return False
1688
 
 
1689
1399
    def supports_stacking(self):
1690
1400
        """True if this format records a stacked-on branch."""
1691
1401
        return False
1753
1463
            "post_uncommit is called with (local, master, old_revno, "
1754
1464
            "old_revid, new_revno, new_revid) where local is the local branch "
1755
1465
            "or None, master is the target branch, and an empty branch "
1756
 
            "receives new_revno of 0, new_revid of None.", (0, 15), None))
 
1466
            "recieves new_revno of 0, new_revid of None.", (0, 15), None))
1757
1467
        self.create_hook(HookPoint('pre_change_branch_tip',
1758
1468
            "Called in bzr client and server before a change to the tip of a "
1759
1469
            "branch is made. pre_change_branch_tip is called with a "
1776
1486
            "multiple hooks installed for transform_fallback_location, "
1777
1487
            "all are called with the url returned from the previous hook."
1778
1488
            "The order is however undefined.", (1, 9), None))
1779
 
        self.create_hook(HookPoint('automatic_tag_name',
1780
 
            "Called to determine an automatic tag name for a revision."
1781
 
            "automatic_tag_name is called with (branch, revision_id) and "
1782
 
            "should return a tag name or None if no tag name could be "
1783
 
            "determined. The first non-None tag name returned will be used.",
1784
 
            (2, 2), None))
1785
 
        self.create_hook(HookPoint('post_branch_init',
1786
 
            "Called after new branch initialization completes. "
1787
 
            "post_branch_init is called with a "
1788
 
            "bzrlib.branch.BranchInitHookParams. "
1789
 
            "Note that init, branch and checkout (both heavyweight and "
1790
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1791
 
        self.create_hook(HookPoint('post_switch',
1792
 
            "Called after a checkout switches branch. "
1793
 
            "post_switch is called with a "
1794
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1795
 
 
1796
1489
 
1797
1490
 
1798
1491
# install the default hooks into the Branch class.
1837
1530
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1838
1531
 
1839
1532
 
1840
 
class BranchInitHookParams(object):
1841
 
    """Object holding parameters passed to *_branch_init hooks.
1842
 
 
1843
 
    There are 4 fields that hooks may wish to access:
1844
 
 
1845
 
    :ivar format: the branch format
1846
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1847
 
    :ivar name: name of colocated branch, if any (or None)
1848
 
    :ivar branch: the branch created
1849
 
 
1850
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1851
 
    the checkout, hence they are different from the corresponding fields in
1852
 
    branch, which refer to the original branch.
1853
 
    """
1854
 
 
1855
 
    def __init__(self, format, a_bzrdir, name, branch):
1856
 
        """Create a group of BranchInitHook parameters.
1857
 
 
1858
 
        :param format: the branch format
1859
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
1860
 
            initialized
1861
 
        :param name: name of colocated branch, if any (or None)
1862
 
        :param branch: the branch created
1863
 
 
1864
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1865
 
        to the checkout, hence they are different from the corresponding fields
1866
 
        in branch, which refer to the original branch.
1867
 
        """
1868
 
        self.format = format
1869
 
        self.bzrdir = a_bzrdir
1870
 
        self.name = name
1871
 
        self.branch = branch
1872
 
 
1873
 
    def __eq__(self, other):
1874
 
        return self.__dict__ == other.__dict__
1875
 
 
1876
 
    def __repr__(self):
1877
 
        if self.branch:
1878
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1879
 
        else:
1880
 
            return "<%s of format:%s bzrdir:%s>" % (
1881
 
                self.__class__.__name__, self.branch,
1882
 
                self.format, self.bzrdir)
1883
 
 
1884
 
 
1885
 
class SwitchHookParams(object):
1886
 
    """Object holding parameters passed to *_switch hooks.
1887
 
 
1888
 
    There are 4 fields that hooks may wish to access:
1889
 
 
1890
 
    :ivar control_dir: BzrDir of the checkout to change
1891
 
    :ivar to_branch: branch that the checkout is to reference
1892
 
    :ivar force: skip the check for local commits in a heavy checkout
1893
 
    :ivar revision_id: revision ID to switch to (or None)
1894
 
    """
1895
 
 
1896
 
    def __init__(self, control_dir, to_branch, force, revision_id):
1897
 
        """Create a group of SwitchHook parameters.
1898
 
 
1899
 
        :param control_dir: BzrDir of the checkout to change
1900
 
        :param to_branch: branch that the checkout is to reference
1901
 
        :param force: skip the check for local commits in a heavy checkout
1902
 
        :param revision_id: revision ID to switch to (or None)
1903
 
        """
1904
 
        self.control_dir = control_dir
1905
 
        self.to_branch = to_branch
1906
 
        self.force = force
1907
 
        self.revision_id = revision_id
1908
 
 
1909
 
    def __eq__(self, other):
1910
 
        return self.__dict__ == other.__dict__
1911
 
 
1912
 
    def __repr__(self):
1913
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1914
 
            self.control_dir, self.to_branch,
1915
 
            self.revision_id)
1916
 
 
1917
 
 
1918
1533
class BzrBranchFormat4(BranchFormat):
1919
1534
    """Bzr branch format 4.
1920
1535
 
1927
1542
        """See BranchFormat.get_format_description()."""
1928
1543
        return "Branch format 4"
1929
1544
 
1930
 
    def initialize(self, a_bzrdir, name=None):
 
1545
    def initialize(self, a_bzrdir):
1931
1546
        """Create a branch of this format in a_bzrdir."""
1932
1547
        utf8_files = [('revision-history', ''),
1933
1548
                      ('branch-name', ''),
1934
1549
                      ]
1935
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
 
1550
        return self._initialize_helper(a_bzrdir, utf8_files,
1936
1551
                                       lock_type='branch4', set_format=False)
1937
1552
 
1938
1553
    def __init__(self):
1943
1558
        """The network name for this format is the control dirs disk label."""
1944
1559
        return self._matchingbzrdir.get_format_string()
1945
1560
 
1946
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1561
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
1947
1562
        """See BranchFormat.open()."""
1948
1563
        if not _found:
1949
1564
            # we are being called directly and must probe.
1951
1566
        return BzrBranch(_format=self,
1952
1567
                         _control_files=a_bzrdir._control_files,
1953
1568
                         a_bzrdir=a_bzrdir,
1954
 
                         name=name,
1955
1569
                         _repository=a_bzrdir.open_repository())
1956
1570
 
1957
1571
    def __str__(self):
1972
1586
        """
1973
1587
        return self.get_format_string()
1974
1588
 
1975
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1589
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
1976
1590
        """See BranchFormat.open()."""
1977
1591
        if not _found:
1978
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
1592
            format = BranchFormat.find_format(a_bzrdir)
1979
1593
            if format.__class__ != self.__class__:
1980
1594
                raise AssertionError("wrong format %r found for %r" %
1981
1595
                    (format, self))
1982
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
1983
1596
        try:
 
1597
            transport = a_bzrdir.get_branch_transport(None)
1984
1598
            control_files = lockable_files.LockableFiles(transport, 'lock',
1985
1599
                                                         lockdir.LockDir)
1986
1600
            return self._branch_class()(_format=self,
1987
1601
                              _control_files=control_files,
1988
 
                              name=name,
1989
1602
                              a_bzrdir=a_bzrdir,
1990
1603
                              _repository=a_bzrdir.find_repository(),
1991
1604
                              ignore_fallbacks=ignore_fallbacks)
1992
1605
        except errors.NoSuchFile:
1993
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
 
1606
            raise errors.NotBranchError(path=transport.base)
1994
1607
 
1995
1608
    def __init__(self):
1996
1609
        super(BranchFormatMetadir, self).__init__()
2025
1638
        """See BranchFormat.get_format_description()."""
2026
1639
        return "Branch format 5"
2027
1640
 
2028
 
    def initialize(self, a_bzrdir, name=None):
 
1641
    def initialize(self, a_bzrdir):
2029
1642
        """Create a branch of this format in a_bzrdir."""
2030
1643
        utf8_files = [('revision-history', ''),
2031
1644
                      ('branch-name', ''),
2032
1645
                      ]
2033
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
1646
        return self._initialize_helper(a_bzrdir, utf8_files)
2034
1647
 
2035
1648
    def supports_tags(self):
2036
1649
        return False
2058
1671
        """See BranchFormat.get_format_description()."""
2059
1672
        return "Branch format 6"
2060
1673
 
2061
 
    def initialize(self, a_bzrdir, name=None):
2062
 
        """Create a branch of this format in a_bzrdir."""
2063
 
        utf8_files = [('last-revision', '0 null:\n'),
2064
 
                      ('branch.conf', ''),
2065
 
                      ('tags', ''),
2066
 
                      ]
2067
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2068
 
 
2069
 
    def make_tags(self, branch):
2070
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2071
 
        return BasicTags(branch)
2072
 
 
2073
 
    def supports_set_append_revisions_only(self):
2074
 
        return True
2075
 
 
2076
 
 
2077
 
class BzrBranchFormat8(BranchFormatMetadir):
2078
 
    """Metadir format supporting storing locations of subtree branches."""
2079
 
 
2080
 
    def _branch_class(self):
2081
 
        return BzrBranch8
2082
 
 
2083
 
    def get_format_string(self):
2084
 
        """See BranchFormat.get_format_string()."""
2085
 
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
2086
 
 
2087
 
    def get_format_description(self):
2088
 
        """See BranchFormat.get_format_description()."""
2089
 
        return "Branch format 8"
2090
 
 
2091
 
    def initialize(self, a_bzrdir, name=None):
2092
 
        """Create a branch of this format in a_bzrdir."""
2093
 
        utf8_files = [('last-revision', '0 null:\n'),
2094
 
                      ('branch.conf', ''),
2095
 
                      ('tags', ''),
2096
 
                      ('references', '')
2097
 
                      ]
2098
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2099
 
 
2100
 
    def __init__(self):
2101
 
        super(BzrBranchFormat8, self).__init__()
2102
 
        self._matchingbzrdir.repository_format = \
2103
 
            RepositoryFormatKnitPack5RichRoot()
2104
 
 
2105
 
    def make_tags(self, branch):
2106
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2107
 
        return BasicTags(branch)
2108
 
 
2109
 
    def supports_set_append_revisions_only(self):
2110
 
        return True
2111
 
 
2112
 
    def supports_stacking(self):
2113
 
        return True
2114
 
 
2115
 
    supports_reference_locations = True
2116
 
 
2117
 
 
2118
 
class BzrBranchFormat7(BzrBranchFormat8):
 
1674
    def initialize(self, a_bzrdir):
 
1675
        """Create a branch of this format in a_bzrdir."""
 
1676
        utf8_files = [('last-revision', '0 null:\n'),
 
1677
                      ('branch.conf', ''),
 
1678
                      ('tags', ''),
 
1679
                      ]
 
1680
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1681
 
 
1682
    def make_tags(self, branch):
 
1683
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
1684
        return BasicTags(branch)
 
1685
 
 
1686
 
 
1687
 
 
1688
class BzrBranchFormat7(BranchFormatMetadir):
2119
1689
    """Branch format with last-revision, tags, and a stacked location pointer.
2120
1690
 
2121
1691
    The stacked location pointer is passed down to the repository and requires
2124
1694
    This format was introduced in bzr 1.6.
2125
1695
    """
2126
1696
 
2127
 
    def initialize(self, a_bzrdir, name=None):
2128
 
        """Create a branch of this format in a_bzrdir."""
2129
 
        utf8_files = [('last-revision', '0 null:\n'),
2130
 
                      ('branch.conf', ''),
2131
 
                      ('tags', ''),
2132
 
                      ]
2133
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2134
 
 
2135
1697
    def _branch_class(self):
2136
1698
        return BzrBranch7
2137
1699
 
2143
1705
        """See BranchFormat.get_format_description()."""
2144
1706
        return "Branch format 7"
2145
1707
 
2146
 
    def supports_set_append_revisions_only(self):
 
1708
    def initialize(self, a_bzrdir):
 
1709
        """Create a branch of this format in a_bzrdir."""
 
1710
        utf8_files = [('last-revision', '0 null:\n'),
 
1711
                      ('branch.conf', ''),
 
1712
                      ('tags', ''),
 
1713
                      ]
 
1714
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1715
 
 
1716
    def __init__(self):
 
1717
        super(BzrBranchFormat7, self).__init__()
 
1718
        self._matchingbzrdir.repository_format = \
 
1719
            RepositoryFormatKnitPack5RichRoot()
 
1720
 
 
1721
    def make_tags(self, branch):
 
1722
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
1723
        return BasicTags(branch)
 
1724
 
 
1725
    def supports_stacking(self):
2147
1726
        return True
2148
1727
 
2149
 
    supports_reference_locations = False
2150
 
 
2151
1728
 
2152
1729
class BranchReferenceFormat(BranchFormat):
2153
1730
    """Bzr branch reference format.
2171
1748
    def get_reference(self, a_bzrdir):
2172
1749
        """See BranchFormat.get_reference()."""
2173
1750
        transport = a_bzrdir.get_branch_transport(None)
2174
 
        return transport.get_bytes('location')
 
1751
        return transport.get('location').read()
2175
1752
 
2176
1753
    def set_reference(self, a_bzrdir, to_branch):
2177
1754
        """See BranchFormat.set_reference()."""
2178
1755
        transport = a_bzrdir.get_branch_transport(None)
2179
1756
        location = transport.put_bytes('location', to_branch.base)
2180
1757
 
2181
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
 
1758
    def initialize(self, a_bzrdir, target_branch=None):
2182
1759
        """Create a branch of this format in a_bzrdir."""
2183
1760
        if target_branch is None:
2184
1761
            # this format does not implement branch itself, thus the implicit
2185
1762
            # creation contract must see it as uninitializable
2186
1763
            raise errors.UninitializableFormat(self)
2187
 
        mutter('creating branch reference in %s', a_bzrdir.user_url)
2188
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
1764
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1765
        branch_transport = a_bzrdir.get_branch_transport(self)
2189
1766
        branch_transport.put_bytes('location',
2190
 
            target_branch.bzrdir.user_url)
 
1767
            target_branch.bzrdir.root_transport.base)
2191
1768
        branch_transport.put_bytes('format', self.get_format_string())
2192
 
        branch = self.open(
2193
 
            a_bzrdir, name, _found=True,
 
1769
        return self.open(
 
1770
            a_bzrdir, _found=True,
2194
1771
            possible_transports=[target_branch.bzrdir.root_transport])
2195
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2196
 
        return branch
2197
1772
 
2198
1773
    def __init__(self):
2199
1774
        super(BranchReferenceFormat, self).__init__()
2205
1780
        def clone(to_bzrdir, revision_id=None,
2206
1781
            repository_policy=None):
2207
1782
            """See Branch.clone()."""
2208
 
            return format.initialize(to_bzrdir, target_branch=a_branch)
 
1783
            return format.initialize(to_bzrdir, a_branch)
2209
1784
            # cannot obey revision_id limits when cloning a reference ...
2210
1785
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2211
1786
            # emit some sort of warning/error to the caller ?!
2212
1787
        return clone
2213
1788
 
2214
 
    def open(self, a_bzrdir, name=None, _found=False, location=None,
 
1789
    def open(self, a_bzrdir, _found=False, location=None,
2215
1790
             possible_transports=None, ignore_fallbacks=False):
2216
1791
        """Return the branch that the branch reference in a_bzrdir points at.
2217
1792
 
2218
1793
        :param a_bzrdir: A BzrDir that contains a branch.
2219
 
        :param name: Name of colocated branch to open, if any
2220
1794
        :param _found: a private parameter, do not use it. It is used to
2221
1795
            indicate if format probing has already be done.
2222
1796
        :param ignore_fallbacks: when set, no fallback branches will be opened
2227
1801
        :param possible_transports: An optional reusable transports list.
2228
1802
        """
2229
1803
        if not _found:
2230
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
1804
            format = BranchFormat.find_format(a_bzrdir)
2231
1805
            if format.__class__ != self.__class__:
2232
1806
                raise AssertionError("wrong format %r found for %r" %
2233
1807
                    (format, self))
2235
1809
            location = self.get_reference(a_bzrdir)
2236
1810
        real_bzrdir = bzrdir.BzrDir.open(
2237
1811
            location, possible_transports=possible_transports)
2238
 
        result = real_bzrdir.open_branch(name=name, 
2239
 
            ignore_fallbacks=ignore_fallbacks)
 
1812
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2240
1813
        # this changes the behaviour of result.clone to create a new reference
2241
1814
        # rather than a copy of the content of the branch.
2242
1815
        # I did not use a proxy object because that needs much more extensive
2263
1836
__format5 = BzrBranchFormat5()
2264
1837
__format6 = BzrBranchFormat6()
2265
1838
__format7 = BzrBranchFormat7()
2266
 
__format8 = BzrBranchFormat8()
2267
1839
BranchFormat.register_format(__format5)
2268
1840
BranchFormat.register_format(BranchReferenceFormat())
2269
1841
BranchFormat.register_format(__format6)
2270
1842
BranchFormat.register_format(__format7)
2271
 
BranchFormat.register_format(__format8)
2272
 
BranchFormat.set_default_format(__format7)
 
1843
BranchFormat.set_default_format(__format6)
2273
1844
_legacy_formats = [BzrBranchFormat4(),
2274
1845
    ]
2275
1846
network_format_registry.register(
2276
1847
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2277
1848
 
2278
1849
 
2279
 
class BranchWriteLockResult(object):
2280
 
    """The result of write locking a branch.
2281
 
 
2282
 
    :ivar branch_token: The token obtained from the underlying branch lock, or
2283
 
        None.
2284
 
    :ivar unlock: A callable which will unlock the lock.
2285
 
    """
2286
 
 
2287
 
    def __init__(self, unlock, branch_token):
2288
 
        self.branch_token = branch_token
2289
 
        self.unlock = unlock
2290
 
 
2291
 
    def __str__(self):
2292
 
        return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
2293
 
            self.unlock)
2294
 
 
2295
 
 
2296
 
class BzrBranch(Branch, _RelockDebugMixin):
 
1850
class BzrBranch(Branch):
2297
1851
    """A branch stored in the actual filesystem.
2298
1852
 
2299
1853
    Note that it's "local" in the context of the filesystem; it doesn't
2305
1859
    :ivar repository: Repository for this branch.
2306
1860
    :ivar base: The url of the base directory for this branch; the one
2307
1861
        containing the .bzr directory.
2308
 
    :ivar name: Optional colocated branch name as it exists in the control
2309
 
        directory.
2310
1862
    """
2311
1863
 
2312
1864
    def __init__(self, _format=None,
2313
 
                 _control_files=None, a_bzrdir=None, name=None,
2314
 
                 _repository=None, ignore_fallbacks=False):
 
1865
                 _control_files=None, a_bzrdir=None, _repository=None,
 
1866
                 ignore_fallbacks=False):
2315
1867
        """Create new branch object at a particular location."""
2316
1868
        if a_bzrdir is None:
2317
1869
            raise ValueError('a_bzrdir must be supplied')
2318
1870
        else:
2319
1871
            self.bzrdir = a_bzrdir
2320
1872
        self._base = self.bzrdir.transport.clone('..').base
2321
 
        self.name = name
2322
1873
        # XXX: We should be able to just do
2323
1874
        #   self.base = self.bzrdir.root_transport.base
2324
1875
        # but this does not quite work yet -- mbp 20080522
2331
1882
        Branch.__init__(self)
2332
1883
 
2333
1884
    def __str__(self):
2334
 
        if self.name is None:
2335
 
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
2336
 
        else:
2337
 
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2338
 
                self.name)
 
1885
        return '%s(%r)' % (self.__class__.__name__, self.base)
2339
1886
 
2340
1887
    __repr__ = __str__
2341
1888
 
2352
1899
        return self.control_files.is_locked()
2353
1900
 
2354
1901
    def lock_write(self, token=None):
2355
 
        """Lock the branch for write operations.
2356
 
 
2357
 
        :param token: A token to permit reacquiring a previously held and
2358
 
            preserved lock.
2359
 
        :return: A BranchWriteLockResult.
2360
 
        """
2361
 
        if not self.is_locked():
2362
 
            self._note_lock('w')
2363
 
        # All-in-one needs to always unlock/lock.
2364
 
        repo_control = getattr(self.repository, 'control_files', None)
2365
 
        if self.control_files == repo_control or not self.is_locked():
2366
 
            self.repository._warn_if_deprecated(self)
2367
 
            self.repository.lock_write()
2368
 
            took_lock = True
2369
 
        else:
2370
 
            took_lock = False
 
1902
        repo_token = self.repository.lock_write()
2371
1903
        try:
2372
 
            return BranchWriteLockResult(self.unlock,
2373
 
                self.control_files.lock_write(token=token))
 
1904
            token = self.control_files.lock_write(token=token)
2374
1905
        except:
2375
 
            if took_lock:
2376
 
                self.repository.unlock()
 
1906
            self.repository.unlock()
2377
1907
            raise
 
1908
        return token
2378
1909
 
2379
1910
    def lock_read(self):
2380
 
        """Lock the branch for read operations.
2381
 
 
2382
 
        :return: An object with an unlock method which will release the lock
2383
 
            obtained.
2384
 
        """
2385
 
        if not self.is_locked():
2386
 
            self._note_lock('r')
2387
 
        # All-in-one needs to always unlock/lock.
2388
 
        repo_control = getattr(self.repository, 'control_files', None)
2389
 
        if self.control_files == repo_control or not self.is_locked():
2390
 
            self.repository._warn_if_deprecated(self)
2391
 
            self.repository.lock_read()
2392
 
            took_lock = True
2393
 
        else:
2394
 
            took_lock = False
 
1911
        self.repository.lock_read()
2395
1912
        try:
2396
1913
            self.control_files.lock_read()
2397
 
            return self
2398
1914
        except:
2399
 
            if took_lock:
2400
 
                self.repository.unlock()
 
1915
            self.repository.unlock()
2401
1916
            raise
2402
1917
 
2403
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2404
1918
    def unlock(self):
 
1919
        # TODO: test for failed two phase locks. This is known broken.
2405
1920
        try:
2406
1921
            self.control_files.unlock()
2407
1922
        finally:
2408
 
            # All-in-one needs to always unlock/lock.
2409
 
            repo_control = getattr(self.repository, 'control_files', None)
2410
 
            if (self.control_files == repo_control or
2411
 
                not self.control_files.is_locked()):
2412
 
                self.repository.unlock()
2413
 
            if not self.control_files.is_locked():
2414
 
                # we just released the lock
2415
 
                self._clear_cached_state()
 
1923
            self.repository.unlock()
 
1924
        if not self.control_files.is_locked():
 
1925
            # we just released the lock
 
1926
            self._clear_cached_state()
2416
1927
 
2417
1928
    def peek_lock_mode(self):
2418
1929
        if self.control_files._lock_count == 0:
2537
2048
        """See Branch.basis_tree."""
2538
2049
        return self.repository.revision_tree(self.last_revision())
2539
2050
 
 
2051
    @needs_write_lock
 
2052
    def pull(self, source, overwrite=False, stop_revision=None,
 
2053
             _hook_master=None, run_hooks=True, possible_transports=None,
 
2054
             _override_hook_target=None):
 
2055
        """See Branch.pull.
 
2056
 
 
2057
        :param _hook_master: Private parameter - set the branch to
 
2058
            be supplied as the master to pull hooks.
 
2059
        :param run_hooks: Private parameter - if false, this branch
 
2060
            is being called because it's the master of the primary branch,
 
2061
            so it should not run its hooks.
 
2062
        :param _override_hook_target: Private parameter - set the branch to be
 
2063
            supplied as the target_branch to pull hooks.
 
2064
        """
 
2065
        result = PullResult()
 
2066
        result.source_branch = source
 
2067
        if _override_hook_target is None:
 
2068
            result.target_branch = self
 
2069
        else:
 
2070
            result.target_branch = _override_hook_target
 
2071
        source.lock_read()
 
2072
        try:
 
2073
            # We assume that during 'pull' the local repository is closer than
 
2074
            # the remote one.
 
2075
            graph = self.repository.get_graph(source.repository)
 
2076
            result.old_revno, result.old_revid = self.last_revision_info()
 
2077
            self.update_revisions(source, stop_revision, overwrite=overwrite,
 
2078
                                  graph=graph)
 
2079
            result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
 
2080
            result.new_revno, result.new_revid = self.last_revision_info()
 
2081
            if _hook_master:
 
2082
                result.master_branch = _hook_master
 
2083
                result.local_branch = result.target_branch
 
2084
            else:
 
2085
                result.master_branch = result.target_branch
 
2086
                result.local_branch = None
 
2087
            if run_hooks:
 
2088
                for hook in Branch.hooks['post_pull']:
 
2089
                    hook(result)
 
2090
        finally:
 
2091
            source.unlock()
 
2092
        return result
 
2093
 
2540
2094
    def _get_parent_location(self):
2541
2095
        _locs = ['parent', 'pull', 'x-pull']
2542
2096
        for l in _locs:
2546
2100
                pass
2547
2101
        return None
2548
2102
 
 
2103
    @needs_read_lock
 
2104
    def push(self, target, overwrite=False, stop_revision=None,
 
2105
             _override_hook_source_branch=None):
 
2106
        """See Branch.push.
 
2107
 
 
2108
        This is the basic concrete implementation of push()
 
2109
 
 
2110
        :param _override_hook_source_branch: If specified, run
 
2111
        the hooks passing this Branch as the source, rather than self.
 
2112
        This is for use of RemoteBranch, where push is delegated to the
 
2113
        underlying vfs-based Branch.
 
2114
        """
 
2115
        # TODO: Public option to disable running hooks - should be trivial but
 
2116
        # needs tests.
 
2117
        return _run_with_write_locked_target(
 
2118
            target, self._push_with_bound_branches, target, overwrite,
 
2119
            stop_revision,
 
2120
            _override_hook_source_branch=_override_hook_source_branch)
 
2121
 
 
2122
    def _push_with_bound_branches(self, target, overwrite,
 
2123
            stop_revision,
 
2124
            _override_hook_source_branch=None):
 
2125
        """Push from self into target, and into target's master if any.
 
2126
 
 
2127
        This is on the base BzrBranch class even though it doesn't support
 
2128
        bound branches because the *target* might be bound.
 
2129
        """
 
2130
        def _run_hooks():
 
2131
            if _override_hook_source_branch:
 
2132
                result.source_branch = _override_hook_source_branch
 
2133
            for hook in Branch.hooks['post_push']:
 
2134
                hook(result)
 
2135
 
 
2136
        bound_location = target.get_bound_location()
 
2137
        if bound_location and target.base != bound_location:
 
2138
            # there is a master branch.
 
2139
            #
 
2140
            # XXX: Why the second check?  Is it even supported for a branch to
 
2141
            # be bound to itself? -- mbp 20070507
 
2142
            master_branch = target.get_master_branch()
 
2143
            master_branch.lock_write()
 
2144
            try:
 
2145
                # push into the master from this branch.
 
2146
                self._basic_push(master_branch, overwrite, stop_revision)
 
2147
                # and push into the target branch from this. Note that we push from
 
2148
                # this branch again, because its considered the highest bandwidth
 
2149
                # repository.
 
2150
                result = self._basic_push(target, overwrite, stop_revision)
 
2151
                result.master_branch = master_branch
 
2152
                result.local_branch = target
 
2153
                _run_hooks()
 
2154
                return result
 
2155
            finally:
 
2156
                master_branch.unlock()
 
2157
        else:
 
2158
            # no master branch
 
2159
            result = self._basic_push(target, overwrite, stop_revision)
 
2160
            # TODO: Why set master_branch and local_branch if there's no
 
2161
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
2162
            # 20070504
 
2163
            result.master_branch = target
 
2164
            result.local_branch = None
 
2165
            _run_hooks()
 
2166
            return result
 
2167
 
2549
2168
    def _basic_push(self, target, overwrite, stop_revision):
2550
2169
        """Basic implementation of push without bound branches or hooks.
2551
2170
 
2552
 
        Must be called with source read locked and target write locked.
 
2171
        Must be called with self read locked and target write locked.
2553
2172
        """
2554
2173
        result = BranchPushResult()
2555
2174
        result.source_branch = self
2556
2175
        result.target_branch = target
2557
2176
        result.old_revno, result.old_revid = target.last_revision_info()
2558
 
        self.update_references(target)
2559
2177
        if result.old_revid != self.last_revision():
2560
2178
            # We assume that during 'push' this repository is closer than
2561
2179
            # the target.
2562
2180
            graph = self.repository.get_graph(target.repository)
2563
 
            target.update_revisions(self, stop_revision,
2564
 
                overwrite=overwrite, graph=graph)
 
2181
            target.update_revisions(self, stop_revision, overwrite=overwrite,
 
2182
                                    graph=graph)
2565
2183
        if self._push_should_merge_tags():
2566
 
            result.tag_conflicts = self.tags.merge_to(target.tags,
2567
 
                overwrite)
 
2184
            result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
2568
2185
        result.new_revno, result.new_revid = target.last_revision_info()
2569
2186
        return result
2570
2187
 
2571
2188
    def get_stacked_on_url(self):
2572
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
2189
        raise errors.UnstackableBranchFormat(self._format, self.base)
2573
2190
 
2574
2191
    def set_push_location(self, location):
2575
2192
        """See Branch.set_push_location."""
2577
2194
            'push_location', location,
2578
2195
            store=_mod_config.STORE_LOCATION_NORECURSE)
2579
2196
 
 
2197
    @needs_write_lock
 
2198
    def set_parent(self, url):
 
2199
        """See Branch.set_parent."""
 
2200
        # TODO: Maybe delete old location files?
 
2201
        # URLs should never be unicode, even on the local fs,
 
2202
        # FIXUP this and get_parent in a future branch format bump:
 
2203
        # read and rewrite the file. RBC 20060125
 
2204
        if url is not None:
 
2205
            if isinstance(url, unicode):
 
2206
                try:
 
2207
                    url = url.encode('ascii')
 
2208
                except UnicodeEncodeError:
 
2209
                    raise errors.InvalidURL(url,
 
2210
                        "Urls must be 7-bit ascii, "
 
2211
                        "use bzrlib.urlutils.escape")
 
2212
            url = urlutils.relative_url(self.base, url)
 
2213
        self._set_parent_location(url)
 
2214
 
2580
2215
    def _set_parent_location(self, url):
2581
2216
        if url is None:
2582
2217
            self._transport.delete('parent')
2591
2226
    It has support for a master_branch which is the data for bound branches.
2592
2227
    """
2593
2228
 
 
2229
    @needs_write_lock
 
2230
    def pull(self, source, overwrite=False, stop_revision=None,
 
2231
             run_hooks=True, possible_transports=None,
 
2232
             _override_hook_target=None):
 
2233
        """Pull from source into self, updating my master if any.
 
2234
 
 
2235
        :param run_hooks: Private parameter - if false, this branch
 
2236
            is being called because it's the master of the primary branch,
 
2237
            so it should not run its hooks.
 
2238
        """
 
2239
        bound_location = self.get_bound_location()
 
2240
        master_branch = None
 
2241
        if bound_location and source.base != bound_location:
 
2242
            # not pulling from master, so we need to update master.
 
2243
            master_branch = self.get_master_branch(possible_transports)
 
2244
            master_branch.lock_write()
 
2245
        try:
 
2246
            if master_branch:
 
2247
                # pull from source into master.
 
2248
                master_branch.pull(source, overwrite, stop_revision,
 
2249
                    run_hooks=False)
 
2250
            return super(BzrBranch5, self).pull(source, overwrite,
 
2251
                stop_revision, _hook_master=master_branch,
 
2252
                run_hooks=run_hooks,
 
2253
                _override_hook_target=_override_hook_target)
 
2254
        finally:
 
2255
            if master_branch:
 
2256
                master_branch.unlock()
 
2257
 
2594
2258
    def get_bound_location(self):
2595
2259
        try:
2596
2260
            return self._transport.get_bytes('bound')[:-1]
2683
2347
        return None
2684
2348
 
2685
2349
 
2686
 
class BzrBranch8(BzrBranch5):
2687
 
    """A branch that stores tree-reference locations."""
 
2350
class BzrBranch7(BzrBranch5):
 
2351
    """A branch with support for a fallback repository."""
2688
2352
 
2689
2353
    def _open_hook(self):
2690
2354
        if self._ignore_fallbacks:
2706
2370
 
2707
2371
    def __init__(self, *args, **kwargs):
2708
2372
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2709
 
        super(BzrBranch8, self).__init__(*args, **kwargs)
 
2373
        super(BzrBranch7, self).__init__(*args, **kwargs)
2710
2374
        self._last_revision_info_cache = None
2711
 
        self._reference_info = None
 
2375
        self._partial_revision_history_cache = []
2712
2376
 
2713
2377
    def _clear_cached_state(self):
2714
 
        super(BzrBranch8, self)._clear_cached_state()
 
2378
        super(BzrBranch7, self)._clear_cached_state()
2715
2379
        self._last_revision_info_cache = None
2716
 
        self._reference_info = None
 
2380
        self._partial_revision_history_cache = []
2717
2381
 
2718
2382
    def _last_revision_info(self):
2719
2383
        revision_string = self._transport.get_bytes('last-revision')
2765
2429
        if _mod_revision.is_null(last_revision):
2766
2430
            return
2767
2431
        if last_revision not in self._lefthand_history(revision_id):
2768
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
 
2432
            raise errors.AppendRevisionsOnlyViolation(self.base)
2769
2433
 
2770
2434
    def _gen_revision_history(self):
2771
2435
        """Generate the revision history from last revision
2774
2438
        self._extend_partial_history(stop_index=last_revno-1)
2775
2439
        return list(reversed(self._partial_revision_history_cache))
2776
2440
 
 
2441
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
 
2442
        """Extend the partial history to include a given index
 
2443
 
 
2444
        If a stop_index is supplied, stop when that index has been reached.
 
2445
        If a stop_revision is supplied, stop when that revision is
 
2446
        encountered.  Otherwise, stop when the beginning of history is
 
2447
        reached.
 
2448
 
 
2449
        :param stop_index: The index which should be present.  When it is
 
2450
            present, history extension will stop.
 
2451
        :param revision_id: The revision id which should be present.  When
 
2452
            it is encountered, history extension will stop.
 
2453
        """
 
2454
        repo = self.repository
 
2455
        if len(self._partial_revision_history_cache) == 0:
 
2456
            iterator = repo.iter_reverse_revision_history(self.last_revision())
 
2457
        else:
 
2458
            start_revision = self._partial_revision_history_cache[-1]
 
2459
            iterator = repo.iter_reverse_revision_history(start_revision)
 
2460
            #skip the last revision in the list
 
2461
            next_revision = iterator.next()
 
2462
        for revision_id in iterator:
 
2463
            self._partial_revision_history_cache.append(revision_id)
 
2464
            if (stop_index is not None and
 
2465
                len(self._partial_revision_history_cache) > stop_index):
 
2466
                break
 
2467
            if revision_id == stop_revision:
 
2468
                break
 
2469
 
2777
2470
    def _write_revision_history(self, history):
2778
2471
        """Factored out of set_revision_history.
2779
2472
 
2800
2493
        """Set the parent branch"""
2801
2494
        return self._get_config_location('parent_location')
2802
2495
 
2803
 
    @needs_write_lock
2804
 
    def _set_all_reference_info(self, info_dict):
2805
 
        """Replace all reference info stored in a branch.
2806
 
 
2807
 
        :param info_dict: A dict of {file_id: (tree_path, branch_location)}
2808
 
        """
2809
 
        s = StringIO()
2810
 
        writer = rio.RioWriter(s)
2811
 
        for key, (tree_path, branch_location) in info_dict.iteritems():
2812
 
            stanza = rio.Stanza(file_id=key, tree_path=tree_path,
2813
 
                                branch_location=branch_location)
2814
 
            writer.write_stanza(stanza)
2815
 
        self._transport.put_bytes('references', s.getvalue())
2816
 
        self._reference_info = info_dict
2817
 
 
2818
 
    @needs_read_lock
2819
 
    def _get_all_reference_info(self):
2820
 
        """Return all the reference info stored in a branch.
2821
 
 
2822
 
        :return: A dict of {file_id: (tree_path, branch_location)}
2823
 
        """
2824
 
        if self._reference_info is not None:
2825
 
            return self._reference_info
2826
 
        rio_file = self._transport.get('references')
2827
 
        try:
2828
 
            stanzas = rio.read_stanzas(rio_file)
2829
 
            info_dict = dict((s['file_id'], (s['tree_path'],
2830
 
                             s['branch_location'])) for s in stanzas)
2831
 
        finally:
2832
 
            rio_file.close()
2833
 
        self._reference_info = info_dict
2834
 
        return info_dict
2835
 
 
2836
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2837
 
        """Set the branch location to use for a tree reference.
2838
 
 
2839
 
        :param file_id: The file-id of the tree reference.
2840
 
        :param tree_path: The path of the tree reference in the tree.
2841
 
        :param branch_location: The location of the branch to retrieve tree
2842
 
            references from.
2843
 
        """
2844
 
        info_dict = self._get_all_reference_info()
2845
 
        info_dict[file_id] = (tree_path, branch_location)
2846
 
        if None in (tree_path, branch_location):
2847
 
            if tree_path is not None:
2848
 
                raise ValueError('tree_path must be None when branch_location'
2849
 
                                 ' is None.')
2850
 
            if branch_location is not None:
2851
 
                raise ValueError('branch_location must be None when tree_path'
2852
 
                                 ' is None.')
2853
 
            del info_dict[file_id]
2854
 
        self._set_all_reference_info(info_dict)
2855
 
 
2856
 
    def get_reference_info(self, file_id):
2857
 
        """Get the tree_path and branch_location for a tree reference.
2858
 
 
2859
 
        :return: a tuple of (tree_path, branch_location)
2860
 
        """
2861
 
        return self._get_all_reference_info().get(file_id, (None, None))
2862
 
 
2863
 
    def reference_parent(self, file_id, path, possible_transports=None):
2864
 
        """Return the parent branch for a tree-reference file_id.
2865
 
 
2866
 
        :param file_id: The file_id of the tree reference
2867
 
        :param path: The path of the file_id in the tree
2868
 
        :return: A branch associated with the file_id
2869
 
        """
2870
 
        branch_location = self.get_reference_info(file_id)[1]
2871
 
        if branch_location is None:
2872
 
            return Branch.reference_parent(self, file_id, path,
2873
 
                                           possible_transports)
2874
 
        branch_location = urlutils.join(self.user_url, branch_location)
2875
 
        return Branch.open(branch_location,
2876
 
                           possible_transports=possible_transports)
2877
 
 
2878
2496
    def set_push_location(self, location):
2879
2497
        """See Branch.set_push_location."""
2880
2498
        self._set_config_location('push_location', location)
2922
2540
            raise errors.NotStacked(self)
2923
2541
        return stacked_url
2924
2542
 
 
2543
    def set_append_revisions_only(self, enabled):
 
2544
        if enabled:
 
2545
            value = 'True'
 
2546
        else:
 
2547
            value = 'False'
 
2548
        self.get_config().set_user_option('append_revisions_only', value,
 
2549
            warn_masked=True)
 
2550
 
2925
2551
    def _get_append_revisions_only(self):
2926
 
        return self.get_config(
2927
 
            ).get_user_option_as_bool('append_revisions_only')
 
2552
        value = self.get_config().get_user_option('append_revisions_only')
 
2553
        return value == 'True'
2928
2554
 
2929
2555
    @needs_write_lock
2930
2556
    def generate_revision_history(self, revision_id, last_rev=None,
2970
2596
        return self.revno() - index
2971
2597
 
2972
2598
 
2973
 
class BzrBranch7(BzrBranch8):
2974
 
    """A branch with support for a fallback repository."""
2975
 
 
2976
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2977
 
        Branch.set_reference_info(self, file_id, tree_path, branch_location)
2978
 
 
2979
 
    def get_reference_info(self, file_id):
2980
 
        Branch.get_reference_info(self, file_id)
2981
 
 
2982
 
    def reference_parent(self, file_id, path, possible_transports=None):
2983
 
        return Branch.reference_parent(self, file_id, path,
2984
 
                                       possible_transports)
2985
 
 
2986
 
 
2987
2599
class BzrBranch6(BzrBranch7):
2988
2600
    """See BzrBranchFormat6 for the capabilities of this branch.
2989
2601
 
2992
2604
    """
2993
2605
 
2994
2606
    def get_stacked_on_url(self):
2995
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
2607
        raise errors.UnstackableBranchFormat(self._format, self.base)
2996
2608
 
2997
2609
 
2998
2610
######################################################################
3077
2689
 
3078
2690
    def __init__(self, branch):
3079
2691
        self.branch = branch
3080
 
        self.errors = []
3081
2692
 
3082
2693
    def report_results(self, verbose):
3083
2694
        """Report the check results via trace.note.
3085
2696
        :param verbose: Requests more detailed display of what was checked,
3086
2697
            if any.
3087
2698
        """
3088
 
        note('checked branch %s format %s', self.branch.user_url,
3089
 
            self.branch._format)
3090
 
        for error in self.errors:
3091
 
            note('found error:%s', error)
 
2699
        note('checked branch %s format %s',
 
2700
             self.branch.base,
 
2701
             self.branch._format)
3092
2702
 
3093
2703
 
3094
2704
class Converter5to6(object):
3132
2742
        branch._transport.put_bytes('format', format.get_format_string())
3133
2743
 
3134
2744
 
3135
 
class Converter7to8(object):
3136
 
    """Perform an in-place upgrade of format 6 to format 7"""
3137
 
 
3138
 
    def convert(self, branch):
3139
 
        format = BzrBranchFormat8()
3140
 
        branch._transport.put_bytes('references', '')
3141
 
        # update target format
3142
 
        branch._transport.put_bytes('format', format.get_format_string())
3143
 
 
3144
2745
 
3145
2746
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3146
2747
    """Run ``callable(*args, **kwargs)``, write-locking target for the
3189
2790
    @staticmethod
3190
2791
    def _get_branch_formats_to_test():
3191
2792
        """Return a tuple with the Branch formats to use when testing."""
3192
 
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
3193
 
 
3194
 
    def pull(self, overwrite=False, stop_revision=None,
3195
 
             possible_transports=None, local=False):
3196
 
        """Mirror source into target branch.
3197
 
 
3198
 
        The target branch is considered to be 'local', having low latency.
3199
 
 
3200
 
        :returns: PullResult instance
3201
 
        """
3202
 
        raise NotImplementedError(self.pull)
 
2793
        raise NotImplementedError(self._get_branch_formats_to_test)
3203
2794
 
3204
2795
    def update_revisions(self, stop_revision=None, overwrite=False,
3205
2796
                         graph=None):
3214
2805
        """
3215
2806
        raise NotImplementedError(self.update_revisions)
3216
2807
 
3217
 
    def push(self, overwrite=False, stop_revision=None,
3218
 
             _override_hook_source_branch=None):
3219
 
        """Mirror the source branch into the target branch.
3220
 
 
3221
 
        The source branch is considered to be 'local', having low latency.
3222
 
        """
3223
 
        raise NotImplementedError(self.push)
3224
 
 
3225
2808
 
3226
2809
class GenericInterBranch(InterBranch):
3227
2810
    """InterBranch implementation that uses public Branch functions.
3274
2857
        finally:
3275
2858
            self.source.unlock()
3276
2859
 
3277
 
    def pull(self, overwrite=False, stop_revision=None,
3278
 
             possible_transports=None, _hook_master=None, run_hooks=True,
3279
 
             _override_hook_target=None, local=False):
3280
 
        """See Branch.pull.
3281
 
 
3282
 
        :param _hook_master: Private parameter - set the branch to
3283
 
            be supplied as the master to pull hooks.
3284
 
        :param run_hooks: Private parameter - if false, this branch
3285
 
            is being called because it's the master of the primary branch,
3286
 
            so it should not run its hooks.
3287
 
        :param _override_hook_target: Private parameter - set the branch to be
3288
 
            supplied as the target_branch to pull hooks.
3289
 
        :param local: Only update the local branch, and not the bound branch.
3290
 
        """
3291
 
        # This type of branch can't be bound.
3292
 
        if local:
3293
 
            raise errors.LocalRequiresBoundBranch()
3294
 
        result = PullResult()
3295
 
        result.source_branch = self.source
3296
 
        if _override_hook_target is None:
3297
 
            result.target_branch = self.target
3298
 
        else:
3299
 
            result.target_branch = _override_hook_target
3300
 
        self.source.lock_read()
3301
 
        try:
3302
 
            # We assume that during 'pull' the target repository is closer than
3303
 
            # the source one.
3304
 
            self.source.update_references(self.target)
3305
 
            graph = self.target.repository.get_graph(self.source.repository)
3306
 
            # TODO: Branch formats should have a flag that indicates 
3307
 
            # that revno's are expensive, and pull() should honor that flag.
3308
 
            # -- JRV20090506
3309
 
            result.old_revno, result.old_revid = \
3310
 
                self.target.last_revision_info()
3311
 
            self.target.update_revisions(self.source, stop_revision,
3312
 
                overwrite=overwrite, graph=graph)
3313
 
            # TODO: The old revid should be specified when merging tags, 
3314
 
            # so a tags implementation that versions tags can only 
3315
 
            # pull in the most recent changes. -- JRV20090506
3316
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3317
 
                overwrite)
3318
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3319
 
            if _hook_master:
3320
 
                result.master_branch = _hook_master
3321
 
                result.local_branch = result.target_branch
3322
 
            else:
3323
 
                result.master_branch = result.target_branch
3324
 
                result.local_branch = None
3325
 
            if run_hooks:
3326
 
                for hook in Branch.hooks['post_pull']:
3327
 
                    hook(result)
3328
 
        finally:
3329
 
            self.source.unlock()
3330
 
        return result
3331
 
 
3332
 
    def push(self, overwrite=False, stop_revision=None,
3333
 
             _override_hook_source_branch=None):
3334
 
        """See InterBranch.push.
3335
 
 
3336
 
        This is the basic concrete implementation of push()
3337
 
 
3338
 
        :param _override_hook_source_branch: If specified, run
3339
 
        the hooks passing this Branch as the source, rather than self.
3340
 
        This is for use of RemoteBranch, where push is delegated to the
3341
 
        underlying vfs-based Branch.
3342
 
        """
3343
 
        # TODO: Public option to disable running hooks - should be trivial but
3344
 
        # needs tests.
3345
 
        self.source.lock_read()
3346
 
        try:
3347
 
            return _run_with_write_locked_target(
3348
 
                self.target, self._push_with_bound_branches, overwrite,
3349
 
                stop_revision,
3350
 
                _override_hook_source_branch=_override_hook_source_branch)
3351
 
        finally:
3352
 
            self.source.unlock()
3353
 
 
3354
 
    def _push_with_bound_branches(self, overwrite, stop_revision,
3355
 
            _override_hook_source_branch=None):
3356
 
        """Push from source into target, and into target's master if any.
3357
 
        """
3358
 
        def _run_hooks():
3359
 
            if _override_hook_source_branch:
3360
 
                result.source_branch = _override_hook_source_branch
3361
 
            for hook in Branch.hooks['post_push']:
3362
 
                hook(result)
3363
 
 
3364
 
        bound_location = self.target.get_bound_location()
3365
 
        if bound_location and self.target.base != bound_location:
3366
 
            # there is a master branch.
3367
 
            #
3368
 
            # XXX: Why the second check?  Is it even supported for a branch to
3369
 
            # be bound to itself? -- mbp 20070507
3370
 
            master_branch = self.target.get_master_branch()
3371
 
            master_branch.lock_write()
3372
 
            try:
3373
 
                # push into the master from the source branch.
3374
 
                self.source._basic_push(master_branch, overwrite, stop_revision)
3375
 
                # and push into the target branch from the source. Note that we
3376
 
                # push from the source branch again, because its considered the
3377
 
                # highest bandwidth repository.
3378
 
                result = self.source._basic_push(self.target, overwrite,
3379
 
                    stop_revision)
3380
 
                result.master_branch = master_branch
3381
 
                result.local_branch = self.target
3382
 
                _run_hooks()
3383
 
                return result
3384
 
            finally:
3385
 
                master_branch.unlock()
3386
 
        else:
3387
 
            # no master branch
3388
 
            result = self.source._basic_push(self.target, overwrite,
3389
 
                stop_revision)
3390
 
            # TODO: Why set master_branch and local_branch if there's no
3391
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
3392
 
            # 20070504
3393
 
            result.master_branch = self.target
3394
 
            result.local_branch = None
3395
 
            _run_hooks()
3396
 
            return result
3397
 
 
3398
2860
    @classmethod
3399
2861
    def is_compatible(self, source, target):
3400
2862
        # GenericBranch uses the public API, so always compatible
3401
2863
        return True
3402
2864
 
3403
2865
 
3404
 
class InterToBranch5(GenericInterBranch):
3405
 
 
3406
 
    @staticmethod
3407
 
    def _get_branch_formats_to_test():
3408
 
        return BranchFormat._default_format, BzrBranchFormat5()
3409
 
 
3410
 
    def pull(self, overwrite=False, stop_revision=None,
3411
 
             possible_transports=None, run_hooks=True,
3412
 
             _override_hook_target=None, local=False):
3413
 
        """Pull from source into self, updating my master if any.
3414
 
 
3415
 
        :param run_hooks: Private parameter - if false, this branch
3416
 
            is being called because it's the master of the primary branch,
3417
 
            so it should not run its hooks.
3418
 
        """
3419
 
        bound_location = self.target.get_bound_location()
3420
 
        if local and not bound_location:
3421
 
            raise errors.LocalRequiresBoundBranch()
3422
 
        master_branch = None
3423
 
        if not local and bound_location and self.source.user_url != bound_location:
3424
 
            # not pulling from master, so we need to update master.
3425
 
            master_branch = self.target.get_master_branch(possible_transports)
3426
 
            master_branch.lock_write()
3427
 
        try:
3428
 
            if master_branch:
3429
 
                # pull from source into master.
3430
 
                master_branch.pull(self.source, overwrite, stop_revision,
3431
 
                    run_hooks=False)
3432
 
            return super(InterToBranch5, self).pull(overwrite,
3433
 
                stop_revision, _hook_master=master_branch,
3434
 
                run_hooks=run_hooks,
3435
 
                _override_hook_target=_override_hook_target)
3436
 
        finally:
3437
 
            if master_branch:
3438
 
                master_branch.unlock()
3439
 
 
3440
 
 
3441
2866
InterBranch.register_optimiser(GenericInterBranch)
3442
 
InterBranch.register_optimiser(InterToBranch5)