← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-07-16 20:52:54 UTC
  • mfrom: (5193.5.9 cleanup)
  • Revision ID: pqm@pqm.ubuntu.com-20100716205254-j0m65wckb90rj54w
(vila) Cleanup some bogus rest constructs in the doc. (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
1
 
# Copyright (C) 2005, 2006, 2007, 2008, 2009 Canonical Ltd
 
1
# Copyright (C) 2005-2010 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
29
29
        errors,
30
30
        lockdir,
31
31
        lockable_files,
 
32
        remote,
32
33
        repository,
33
34
        revision as _mod_revision,
34
35
        rio,
46
47
    )
47
48
""")
48
49
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
50
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
51
from bzrlib.hooks import HookPoint, Hooks
51
52
from bzrlib.inter import InterObject
 
53
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
52
54
from bzrlib import registry
53
55
from bzrlib.symbol_versioning import (
54
56
    deprecated_in,
62
64
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
63
65
 
64
66
 
65
 
# TODO: Maybe include checks for common corruption of newlines, etc?
66
 
 
67
 
# TODO: Some operations like log might retrieve the same revisions
68
 
# repeatedly to calculate deltas.  We could perhaps have a weakref
69
 
# cache in memory to make this faster.  In general anything can be
70
 
# cached in memory between lock and unlock operations. .. nb thats
71
 
# what the transaction identity map provides
72
 
 
73
 
 
74
 
######################################################################
75
 
# branch objects
76
 
 
77
 
class Branch(object):
 
67
class Branch(bzrdir.ControlComponent):
78
68
    """Branch holding a history of revisions.
79
69
 
80
 
    base
81
 
        Base directory/url of the branch.
 
70
    :ivar base:
 
71
        Base directory/url of the branch; using control_url and
 
72
        control_transport is more standardized.
82
73
 
83
74
    hooks: An instance of BranchHooks.
84
75
    """
86
77
    # - RBC 20060112
87
78
    base = None
88
79
 
 
80
    @property
 
81
    def control_transport(self):
 
82
        return self._transport
 
83
 
 
84
    @property
 
85
    def user_transport(self):
 
86
        return self.bzrdir.user_transport
 
87
 
89
88
    def __init__(self, *ignored, **ignored_too):
90
89
        self.tags = self._format.make_tags(self)
91
90
        self._revision_history_cache = None
106
105
        """Activate the branch/repository from url as a fallback repository."""
107
106
        repo = self._get_fallback_repository(url)
108
107
        if repo.has_same_location(self.repository):
109
 
            raise errors.UnstackableLocationError(self.base, url)
 
108
            raise errors.UnstackableLocationError(self.user_url, url)
110
109
        self.repository.add_fallback_repository(repo)
111
110
 
112
111
    def break_lock(self):
166
165
        """
167
166
        control = bzrdir.BzrDir.open(base, _unsupported,
168
167
                                     possible_transports=possible_transports)
169
 
        return control.open_branch(_unsupported)
 
168
        return control.open_branch(unsupported=_unsupported)
170
169
 
171
170
    @staticmethod
172
 
    def open_from_transport(transport, _unsupported=False):
 
171
    def open_from_transport(transport, name=None, _unsupported=False):
173
172
        """Open the branch rooted at transport"""
174
173
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
175
 
        return control.open_branch(_unsupported)
 
174
        return control.open_branch(name=name, unsupported=_unsupported)
176
175
 
177
176
    @staticmethod
178
177
    def open_containing(url, possible_transports=None):
199
198
        return self.supports_tags() and self.tags.get_tag_dict()
200
199
 
201
200
    def get_config(self):
 
201
        """Get a bzrlib.config.BranchConfig for this Branch.
 
202
 
 
203
        This can then be used to get and set configuration options for the
 
204
        branch.
 
205
 
 
206
        :return: A bzrlib.config.BranchConfig.
 
207
        """
202
208
        return BranchConfig(self)
203
209
 
204
210
    def _get_config(self):
216
222
    def _get_fallback_repository(self, url):
217
223
        """Get the repository we fallback to at url."""
218
224
        url = urlutils.join(self.base, url)
219
 
        a_bzrdir = bzrdir.BzrDir.open(url,
 
225
        a_branch = Branch.open(url,
220
226
            possible_transports=[self.bzrdir.root_transport])
221
 
        return a_bzrdir.open_branch().repository
 
227
        return a_branch.repository
222
228
 
223
229
    def _get_tags_bytes(self):
224
230
        """Get the bytes of a serialised tags dict.
285
291
        new_history.reverse()
286
292
        return new_history
287
293
 
288
 
    def lock_write(self):
 
294
    def lock_write(self, token=None):
 
295
        """Lock the branch for write operations.
 
296
 
 
297
        :param token: A token to permit reacquiring a previously held and
 
298
            preserved lock.
 
299
        :return: A BranchWriteLockResult.
 
300
        """
289
301
        raise NotImplementedError(self.lock_write)
290
302
 
291
303
    def lock_read(self):
 
304
        """Lock the branch for read operations.
 
305
 
 
306
        :return: A bzrlib.lock.LogicalLockResult.
 
307
        """
292
308
        raise NotImplementedError(self.lock_read)
293
309
 
294
310
    def unlock(self):
419
435
            * 'include' - the stop revision is the last item in the result
420
436
            * 'with-merges' - include the stop revision and all of its
421
437
              merged revisions in the result
 
438
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
439
              that are in both ancestries
422
440
        :param direction: either 'reverse' or 'forward':
423
441
            * reverse means return the start_revision_id first, i.e.
424
442
              start at the most recent revision and go backwards in history
446
464
        # start_revision_id.
447
465
        if self._merge_sorted_revisions_cache is None:
448
466
            last_revision = self.last_revision()
449
 
            graph = self.repository.get_graph()
450
 
            parent_map = dict(((key, value) for key, value in
451
 
                     graph.iter_ancestry([last_revision]) if value is not None))
452
 
            revision_graph = repository._strip_NULL_ghosts(parent_map)
453
 
            revs = tsort.merge_sort(revision_graph, last_revision, None,
454
 
                generate_revno=True)
455
 
            # Drop the sequence # before caching
456
 
            self._merge_sorted_revisions_cache = [r[1:] for r in revs]
457
 
 
 
467
            known_graph = self.repository.get_known_graph_ancestry(
 
468
                [last_revision])
 
469
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
 
470
                last_revision)
458
471
        filtered = self._filter_merge_sorted_revisions(
459
472
            self._merge_sorted_revisions_cache, start_revision_id,
460
473
            stop_revision_id, stop_rule)
 
474
        # Make sure we don't return revisions that are not part of the
 
475
        # start_revision_id ancestry.
 
476
        filtered = self._filter_start_non_ancestors(filtered)
461
477
        if direction == 'reverse':
462
478
            return filtered
463
479
        if direction == 'forward':
470
486
        """Iterate over an inclusive range of sorted revisions."""
471
487
        rev_iter = iter(merge_sorted_revisions)
472
488
        if start_revision_id is not None:
473
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
489
            for node in rev_iter:
 
490
                rev_id = node.key[-1]
474
491
                if rev_id != start_revision_id:
475
492
                    continue
476
493
                else:
477
494
                    # The decision to include the start or not
478
495
                    # depends on the stop_rule if a stop is provided
479
 
                    rev_iter = chain(
480
 
                        iter([(rev_id, depth, revno, end_of_merge)]),
481
 
                        rev_iter)
 
496
                    # so pop this node back into the iterator
 
497
                    rev_iter = chain(iter([node]), rev_iter)
482
498
                    break
483
499
        if stop_revision_id is None:
484
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
485
 
                yield rev_id, depth, revno, end_of_merge
 
500
            # Yield everything
 
501
            for node in rev_iter:
 
502
                rev_id = node.key[-1]
 
503
                yield (rev_id, node.merge_depth, node.revno,
 
504
                       node.end_of_merge)
486
505
        elif stop_rule == 'exclude':
487
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
506
            for node in rev_iter:
 
507
                rev_id = node.key[-1]
488
508
                if rev_id == stop_revision_id:
489
509
                    return
490
 
                yield rev_id, depth, revno, end_of_merge
 
510
                yield (rev_id, node.merge_depth, node.revno,
 
511
                       node.end_of_merge)
491
512
        elif stop_rule == 'include':
492
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
493
 
                yield rev_id, depth, revno, end_of_merge
 
513
            for node in rev_iter:
 
514
                rev_id = node.key[-1]
 
515
                yield (rev_id, node.merge_depth, node.revno,
 
516
                       node.end_of_merge)
494
517
                if rev_id == stop_revision_id:
495
518
                    return
 
519
        elif stop_rule == 'with-merges-without-common-ancestry':
 
520
            # We want to exclude all revisions that are already part of the
 
521
            # stop_revision_id ancestry.
 
522
            graph = self.repository.get_graph()
 
523
            ancestors = graph.find_unique_ancestors(start_revision_id,
 
524
                                                    [stop_revision_id])
 
525
            for node in rev_iter:
 
526
                rev_id = node.key[-1]
 
527
                if rev_id not in ancestors:
 
528
                    continue
 
529
                yield (rev_id, node.merge_depth, node.revno,
 
530
                       node.end_of_merge)
496
531
        elif stop_rule == 'with-merges':
497
532
            stop_rev = self.repository.get_revision(stop_revision_id)
498
533
            if stop_rev.parent_ids:
499
534
                left_parent = stop_rev.parent_ids[0]
500
535
            else:
501
536
                left_parent = _mod_revision.NULL_REVISION
502
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
537
            # left_parent is the actual revision we want to stop logging at,
 
538
            # since we want to show the merged revisions after the stop_rev too
 
539
            reached_stop_revision_id = False
 
540
            revision_id_whitelist = []
 
541
            for node in rev_iter:
 
542
                rev_id = node.key[-1]
503
543
                if rev_id == left_parent:
 
544
                    # reached the left parent after the stop_revision
504
545
                    return
505
 
                yield rev_id, depth, revno, end_of_merge
 
546
                if (not reached_stop_revision_id or
 
547
                        rev_id in revision_id_whitelist):
 
548
                    yield (rev_id, node.merge_depth, node.revno,
 
549
                       node.end_of_merge)
 
550
                    if reached_stop_revision_id or rev_id == stop_revision_id:
 
551
                        # only do the merged revs of rev_id from now on
 
552
                        rev = self.repository.get_revision(rev_id)
 
553
                        if rev.parent_ids:
 
554
                            reached_stop_revision_id = True
 
555
                            revision_id_whitelist.extend(rev.parent_ids)
506
556
        else:
507
557
            raise ValueError('invalid stop_rule %r' % stop_rule)
508
558
 
 
559
    def _filter_start_non_ancestors(self, rev_iter):
 
560
        # If we started from a dotted revno, we want to consider it as a tip
 
561
        # and don't want to yield revisions that are not part of its
 
562
        # ancestry. Given the order guaranteed by the merge sort, we will see
 
563
        # uninteresting descendants of the first parent of our tip before the
 
564
        # tip itself.
 
565
        first = rev_iter.next()
 
566
        (rev_id, merge_depth, revno, end_of_merge) = first
 
567
        yield first
 
568
        if not merge_depth:
 
569
            # We start at a mainline revision so by definition, all others
 
570
            # revisions in rev_iter are ancestors
 
571
            for node in rev_iter:
 
572
                yield node
 
573
 
 
574
        clean = False
 
575
        whitelist = set()
 
576
        pmap = self.repository.get_parent_map([rev_id])
 
577
        parents = pmap.get(rev_id, [])
 
578
        if parents:
 
579
            whitelist.update(parents)
 
580
        else:
 
581
            # If there is no parents, there is nothing of interest left
 
582
 
 
583
            # FIXME: It's hard to test this scenario here as this code is never
 
584
            # called in that case. -- vila 20100322
 
585
            return
 
586
 
 
587
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
 
588
            if not clean:
 
589
                if rev_id in whitelist:
 
590
                    pmap = self.repository.get_parent_map([rev_id])
 
591
                    parents = pmap.get(rev_id, [])
 
592
                    whitelist.remove(rev_id)
 
593
                    whitelist.update(parents)
 
594
                    if merge_depth == 0:
 
595
                        # We've reached the mainline, there is nothing left to
 
596
                        # filter
 
597
                        clean = True
 
598
                else:
 
599
                    # A revision that is not part of the ancestry of our
 
600
                    # starting revision.
 
601
                    continue
 
602
            yield (rev_id, merge_depth, revno, end_of_merge)
 
603
 
509
604
    def leave_lock_in_place(self):
510
605
        """Tell this branch object not to release the physical lock when this
511
606
        object is unlocked.
528
623
        :param other: The branch to bind to
529
624
        :type other: Branch
530
625
        """
531
 
        raise errors.UpgradeRequired(self.base)
 
626
        raise errors.UpgradeRequired(self.user_url)
532
627
 
533
628
    def set_append_revisions_only(self, enabled):
534
629
        if not self._format.supports_set_append_revisions_only():
535
 
            raise errors.UpgradeRequired(self.base)
 
630
            raise errors.UpgradeRequired(self.user_url)
536
631
        if enabled:
537
632
            value = 'True'
538
633
        else:
586
681
    def get_old_bound_location(self):
587
682
        """Return the URL of the branch we used to be bound to
588
683
        """
589
 
        raise errors.UpgradeRequired(self.base)
 
684
        raise errors.UpgradeRequired(self.user_url)
590
685
 
591
686
    def get_commit_builder(self, parents, config=None, timestamp=None,
592
687
                           timezone=None, committer=None, revprops=None,
670
765
            stacking.
671
766
        """
672
767
        if not self._format.supports_stacking():
673
 
            raise errors.UnstackableBranchFormat(self._format, self.base)
 
768
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
674
769
        # XXX: Changing from one fallback repository to another does not check
675
770
        # that all the data you need is present in the new fallback.
676
771
        # Possibly it should.
706
801
            if len(old_repository._fallback_repositories) != 1:
707
802
                raise AssertionError("can't cope with fallback repositories "
708
803
                    "of %r" % (self.repository,))
709
 
            # unlock it, including unlocking the fallback
 
804
            # Open the new repository object.
 
805
            # Repositories don't offer an interface to remove fallback
 
806
            # repositories today; take the conceptually simpler option and just
 
807
            # reopen it.  We reopen it starting from the URL so that we
 
808
            # get a separate connection for RemoteRepositories and can
 
809
            # stream from one of them to the other.  This does mean doing
 
810
            # separate SSH connection setup, but unstacking is not a
 
811
            # common operation so it's tolerable.
 
812
            new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
813
            new_repository = new_bzrdir.find_repository()
 
814
            if new_repository._fallback_repositories:
 
815
                raise AssertionError("didn't expect %r to have "
 
816
                    "fallback_repositories"
 
817
                    % (self.repository,))
 
818
            # Replace self.repository with the new repository.
 
819
            # Do our best to transfer the lock state (i.e. lock-tokens and
 
820
            # lock count) of self.repository to the new repository.
 
821
            lock_token = old_repository.lock_write().repository_token
 
822
            self.repository = new_repository
 
823
            if isinstance(self, remote.RemoteBranch):
 
824
                # Remote branches can have a second reference to the old
 
825
                # repository that need to be replaced.
 
826
                if self._real_branch is not None:
 
827
                    self._real_branch.repository = new_repository
 
828
            self.repository.lock_write(token=lock_token)
 
829
            if lock_token is not None:
 
830
                old_repository.leave_lock_in_place()
710
831
            old_repository.unlock()
 
832
            if lock_token is not None:
 
833
                # XXX: self.repository.leave_lock_in_place() before this
 
834
                # function will not be preserved.  Fortunately that doesn't
 
835
                # affect the current default format (2a), and would be a
 
836
                # corner-case anyway.
 
837
                #  - Andrew Bennetts, 2010/06/30
 
838
                self.repository.dont_leave_lock_in_place()
 
839
            old_lock_count = 0
 
840
            while True:
 
841
                try:
 
842
                    old_repository.unlock()
 
843
                except errors.LockNotHeld:
 
844
                    break
 
845
                old_lock_count += 1
 
846
            if old_lock_count == 0:
 
847
                raise AssertionError(
 
848
                    'old_repository should have been locked at least once.')
 
849
            for i in range(old_lock_count-1):
 
850
                self.repository.lock_write()
 
851
            # Fetch from the old repository into the new.
711
852
            old_repository.lock_read()
712
853
            try:
713
 
                # Repositories don't offer an interface to remove fallback
714
 
                # repositories today; take the conceptually simpler option and just
715
 
                # reopen it.  We reopen it starting from the URL so that we
716
 
                # get a separate connection for RemoteRepositories and can
717
 
                # stream from one of them to the other.  This does mean doing
718
 
                # separate SSH connection setup, but unstacking is not a
719
 
                # common operation so it's tolerable.
720
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
721
 
                new_repository = new_bzrdir.find_repository()
722
 
                self.repository = new_repository
723
 
                if self.repository._fallback_repositories:
724
 
                    raise AssertionError("didn't expect %r to have "
725
 
                        "fallback_repositories"
726
 
                        % (self.repository,))
727
 
                # this is not paired with an unlock because it's just restoring
728
 
                # the previous state; the lock's released when set_stacked_on_url
729
 
                # returns
730
 
                self.repository.lock_write()
731
854
                # XXX: If you unstack a branch while it has a working tree
732
855
                # with a pending merge, the pending-merged revisions will no
733
856
                # longer be present.  You can (probably) revert and remerge.
827
950
 
828
951
    def unbind(self):
829
952
        """Older format branches cannot bind or unbind."""
830
 
        raise errors.UpgradeRequired(self.base)
 
953
        raise errors.UpgradeRequired(self.user_url)
831
954
 
832
955
    def last_revision(self):
833
956
        """Return last revision id, or NULL_REVISION."""
874
997
                raise errors.NoSuchRevision(self, stop_revision)
875
998
        return other_history[self_len:stop_revision]
876
999
 
877
 
    @needs_write_lock
878
1000
    def update_revisions(self, other, stop_revision=None, overwrite=False,
879
1001
                         graph=None):
880
1002
        """Pull in new perfect-fit revisions.
929
1051
            self._extend_partial_history(distance_from_last)
930
1052
        return self._partial_revision_history_cache[distance_from_last]
931
1053
 
932
 
    @needs_write_lock
933
1054
    def pull(self, source, overwrite=False, stop_revision=None,
934
1055
             possible_transports=None, *args, **kwargs):
935
1056
        """Mirror source into this branch.
993
1114
        try:
994
1115
            return urlutils.join(self.base[:-1], parent)
995
1116
        except errors.InvalidURLJoin, e:
996
 
            raise errors.InaccessibleParent(parent, self.base)
 
1117
            raise errors.InaccessibleParent(parent, self.user_url)
997
1118
 
998
1119
    def _get_parent_location(self):
999
1120
        raise NotImplementedError(self._get_parent_location)
1084
1205
        params = ChangeBranchTipParams(
1085
1206
            self, old_revno, new_revno, old_revid, new_revid)
1086
1207
        for hook in hooks:
1087
 
            try:
1088
 
                hook(params)
1089
 
            except errors.TipChangeRejected:
1090
 
                raise
1091
 
            except Exception:
1092
 
                exc_info = sys.exc_info()
1093
 
                hook_name = Branch.hooks.get_hook_name(hook)
1094
 
                raise errors.HookFailed(
1095
 
                    'pre_change_branch_tip', hook_name, exc_info)
 
1208
            hook(params)
1096
1209
 
1097
1210
    @needs_write_lock
1098
1211
    def update(self):
1147
1260
        revision_id: if not None, the revision history in the new branch will
1148
1261
                     be truncated to end with revision_id.
1149
1262
        """
 
1263
        if (repository_policy is not None and
 
1264
            repository_policy.requires_stacking()):
 
1265
            to_bzrdir._format.require_stacking(_skip_repo=True)
1150
1266
        result = to_bzrdir.create_branch()
1151
1267
        result.lock_write()
1152
1268
        try:
1183
1299
                revno = 1
1184
1300
        destination.set_last_revision_info(revno, revision_id)
1185
1301
 
1186
 
    @needs_read_lock
1187
1302
    def copy_content_into(self, destination, revision_id=None):
1188
1303
        """Copy the content of self into destination.
1189
1304
 
1190
1305
        revision_id: if not None, the revision history in the new branch will
1191
1306
                     be truncated to end with revision_id.
1192
1307
        """
1193
 
        self.update_references(destination)
1194
 
        self._synchronize_history(destination, revision_id)
1195
 
        try:
1196
 
            parent = self.get_parent()
1197
 
        except errors.InaccessibleParent, e:
1198
 
            mutter('parent was not accessible to copy: %s', e)
1199
 
        else:
1200
 
            if parent:
1201
 
                destination.set_parent(parent)
1202
 
        if self._push_should_merge_tags():
1203
 
            self.tags.merge_to(destination.tags)
 
1308
        return InterBranch.get(self, destination).copy_content_into(
 
1309
            revision_id=revision_id)
1204
1310
 
1205
1311
    def update_references(self, target):
1206
1312
        if not getattr(self._format, 'supports_reference_locations', False):
1274
1380
        """
1275
1381
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1276
1382
        # clone call. Or something. 20090224 RBC/spiv.
 
1383
        # XXX: Should this perhaps clone colocated branches as well, 
 
1384
        # rather than just the default branch? 20100319 JRV
1277
1385
        if revision_id is None:
1278
1386
            revision_id = self.last_revision()
1279
 
        try:
1280
 
            dir_to = self.bzrdir.clone_on_transport(to_transport,
1281
 
                revision_id=revision_id, stacked_on=stacked_on,
1282
 
                create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1283
 
        except errors.FileExists:
1284
 
            if not use_existing_dir:
1285
 
                raise
1286
 
        except errors.NoSuchFile:
1287
 
            if not create_prefix:
1288
 
                raise
 
1387
        dir_to = self.bzrdir.clone_on_transport(to_transport,
 
1388
            revision_id=revision_id, stacked_on=stacked_on,
 
1389
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1289
1390
        return dir_to.open_branch()
1290
1391
 
1291
1392
    def create_checkout(self, to_location, revision_id=None,
1310
1411
        if lightweight:
1311
1412
            format = self._get_checkout_format()
1312
1413
            checkout = format.initialize_on_transport(t)
1313
 
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
1414
            from_branch = BranchReferenceFormat().initialize(checkout, 
 
1415
                target_branch=self)
1314
1416
        else:
1315
1417
            format = self._get_checkout_format()
1316
1418
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1358
1460
    def supports_tags(self):
1359
1461
        return self._format.supports_tags()
1360
1462
 
 
1463
    def automatic_tag_name(self, revision_id):
 
1464
        """Try to automatically find the tag name for a revision.
 
1465
 
 
1466
        :param revision_id: Revision id of the revision.
 
1467
        :return: A tag name or None if no tag name could be determined.
 
1468
        """
 
1469
        for hook in Branch.hooks['automatic_tag_name']:
 
1470
            ret = hook(self, revision_id)
 
1471
            if ret is not None:
 
1472
                return ret
 
1473
        return None
 
1474
 
1361
1475
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1362
1476
                                         other_branch):
1363
1477
        """Ensure that revision_b is a descendant of revision_a.
1427
1541
        return not (self == other)
1428
1542
 
1429
1543
    @classmethod
1430
 
    def find_format(klass, a_bzrdir):
 
1544
    def find_format(klass, a_bzrdir, name=None):
1431
1545
        """Return the format for the branch object in a_bzrdir."""
1432
1546
        try:
1433
 
            transport = a_bzrdir.get_branch_transport(None)
1434
 
            format_string = transport.get("format").read()
1435
 
            return klass._formats[format_string]
 
1547
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
1548
            format_string = transport.get_bytes("format")
 
1549
            format = klass._formats[format_string]
 
1550
            if isinstance(format, MetaDirBranchFormatFactory):
 
1551
                return format()
 
1552
            return format
1436
1553
        except errors.NoSuchFile:
1437
 
            raise errors.NotBranchError(path=transport.base)
 
1554
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1438
1555
        except KeyError:
1439
1556
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1440
1557
 
1443
1560
        """Return the current default format."""
1444
1561
        return klass._default_format
1445
1562
 
1446
 
    def get_reference(self, a_bzrdir):
 
1563
    @classmethod
 
1564
    def get_formats(klass):
 
1565
        """Get all the known formats.
 
1566
 
 
1567
        Warning: This triggers a load of all lazy registered formats: do not
 
1568
        use except when that is desireed.
 
1569
        """
 
1570
        result = []
 
1571
        for fmt in klass._formats.values():
 
1572
            if isinstance(fmt, MetaDirBranchFormatFactory):
 
1573
                fmt = fmt()
 
1574
            result.append(fmt)
 
1575
        return result
 
1576
 
 
1577
    def get_reference(self, a_bzrdir, name=None):
1447
1578
        """Get the target reference of the branch in a_bzrdir.
1448
1579
 
1449
1580
        format probing must have been completed before calling
1451
1582
        in a_bzrdir is correct.
1452
1583
 
1453
1584
        :param a_bzrdir: The bzrdir to get the branch data from.
 
1585
        :param name: Name of the colocated branch to fetch
1454
1586
        :return: None if the branch is not a reference branch.
1455
1587
        """
1456
1588
        return None
1457
1589
 
1458
1590
    @classmethod
1459
 
    def set_reference(self, a_bzrdir, to_branch):
 
1591
    def set_reference(self, a_bzrdir, name, to_branch):
1460
1592
        """Set the target reference of the branch in a_bzrdir.
1461
1593
 
1462
1594
        format probing must have been completed before calling
1464
1596
        in a_bzrdir is correct.
1465
1597
 
1466
1598
        :param a_bzrdir: The bzrdir to set the branch reference for.
 
1599
        :param name: Name of colocated branch to set, None for default
1467
1600
        :param to_branch: branch that the checkout is to reference
1468
1601
        """
1469
1602
        raise NotImplementedError(self.set_reference)
1476
1609
        """Return the short format description for this format."""
1477
1610
        raise NotImplementedError(self.get_format_description)
1478
1611
 
1479
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1480
 
                           set_format=True):
 
1612
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
 
1613
        hooks = Branch.hooks['post_branch_init']
 
1614
        if not hooks:
 
1615
            return
 
1616
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
 
1617
        for hook in hooks:
 
1618
            hook(params)
 
1619
 
 
1620
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
 
1621
                           lock_type='metadir', set_format=True):
1481
1622
        """Initialize a branch in a bzrdir, with specified files
1482
1623
 
1483
1624
        :param a_bzrdir: The bzrdir to initialize the branch in
1484
1625
        :param utf8_files: The files to create as a list of
1485
1626
            (filename, content) tuples
 
1627
        :param name: Name of colocated branch to create, if any
1486
1628
        :param set_format: If True, set the format with
1487
1629
            self.get_format_string.  (BzrBranch4 has its format set
1488
1630
            elsewhere)
1489
1631
        :return: a branch in this format
1490
1632
        """
1491
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1492
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1633
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
 
1634
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1493
1635
        lock_map = {
1494
1636
            'metadir': ('lock', lockdir.LockDir),
1495
1637
            'branch4': ('branch-lock', lockable_files.TransportLock),
1516
1658
        finally:
1517
1659
            if lock_taken:
1518
1660
                control_files.unlock()
1519
 
        return self.open(a_bzrdir, _found=True)
 
1661
        branch = self.open(a_bzrdir, name, _found=True)
 
1662
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
1663
        return branch
1520
1664
 
1521
 
    def initialize(self, a_bzrdir):
1522
 
        """Create a branch of this format in a_bzrdir."""
 
1665
    def initialize(self, a_bzrdir, name=None):
 
1666
        """Create a branch of this format in a_bzrdir.
 
1667
        
 
1668
        :param name: Name of the colocated branch to create.
 
1669
        """
1523
1670
        raise NotImplementedError(self.initialize)
1524
1671
 
1525
1672
    def is_supported(self):
1555
1702
        """
1556
1703
        raise NotImplementedError(self.network_name)
1557
1704
 
1558
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1705
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1559
1706
        """Return the branch object for a_bzrdir
1560
1707
 
1561
1708
        :param a_bzrdir: A BzrDir that contains a branch.
 
1709
        :param name: Name of colocated branch to open
1562
1710
        :param _found: a private parameter, do not use it. It is used to
1563
1711
            indicate if format probing has already be done.
1564
1712
        :param ignore_fallbacks: when set, no fallback branches will be opened
1568
1716
 
1569
1717
    @classmethod
1570
1718
    def register_format(klass, format):
1571
 
        """Register a metadir format."""
 
1719
        """Register a metadir format.
 
1720
        
 
1721
        See MetaDirBranchFormatFactory for the ability to register a format
 
1722
        without loading the code the format needs until it is actually used.
 
1723
        """
1572
1724
        klass._formats[format.get_format_string()] = format
1573
1725
        # Metadir formats have a network name of their format string, and get
1574
 
        # registered as class factories.
1575
 
        network_format_registry.register(format.get_format_string(), format.__class__)
 
1726
        # registered as factories.
 
1727
        if isinstance(format, MetaDirBranchFormatFactory):
 
1728
            network_format_registry.register(format.get_format_string(), format)
 
1729
        else:
 
1730
            network_format_registry.register(format.get_format_string(),
 
1731
                format.__class__)
1576
1732
 
1577
1733
    @classmethod
1578
1734
    def set_default_format(klass, format):
1598
1754
        return False  # by default
1599
1755
 
1600
1756
 
 
1757
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
 
1758
    """A factory for a BranchFormat object, permitting simple lazy registration.
 
1759
    
 
1760
    While none of the built in BranchFormats are lazy registered yet,
 
1761
    bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
 
1762
    use it, and the bzr-loom plugin uses it as well (see
 
1763
    bzrlib.plugins.loom.formats).
 
1764
    """
 
1765
 
 
1766
    def __init__(self, format_string, module_name, member_name):
 
1767
        """Create a MetaDirBranchFormatFactory.
 
1768
 
 
1769
        :param format_string: The format string the format has.
 
1770
        :param module_name: Module to load the format class from.
 
1771
        :param member_name: Attribute name within the module for the format class.
 
1772
        """
 
1773
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
 
1774
        self._format_string = format_string
 
1775
        
 
1776
    def get_format_string(self):
 
1777
        """See BranchFormat.get_format_string."""
 
1778
        return self._format_string
 
1779
 
 
1780
    def __call__(self):
 
1781
        """Used for network_format_registry support."""
 
1782
        return self.get_obj()()
 
1783
 
 
1784
 
1601
1785
class BranchHooks(Hooks):
1602
1786
    """A dictionary mapping hook name to a list of callables for branch hooks.
1603
1787
 
1672
1856
            "multiple hooks installed for transform_fallback_location, "
1673
1857
            "all are called with the url returned from the previous hook."
1674
1858
            "The order is however undefined.", (1, 9), None))
 
1859
        self.create_hook(HookPoint('automatic_tag_name',
 
1860
            "Called to determine an automatic tag name for a revision."
 
1861
            "automatic_tag_name is called with (branch, revision_id) and "
 
1862
            "should return a tag name or None if no tag name could be "
 
1863
            "determined. The first non-None tag name returned will be used.",
 
1864
            (2, 2), None))
 
1865
        self.create_hook(HookPoint('post_branch_init',
 
1866
            "Called after new branch initialization completes. "
 
1867
            "post_branch_init is called with a "
 
1868
            "bzrlib.branch.BranchInitHookParams. "
 
1869
            "Note that init, branch and checkout (both heavyweight and "
 
1870
            "lightweight) will all trigger this hook.", (2, 2), None))
 
1871
        self.create_hook(HookPoint('post_switch',
 
1872
            "Called after a checkout switches branch. "
 
1873
            "post_switch is called with a "
 
1874
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
 
1875
 
1675
1876
 
1676
1877
 
1677
1878
# install the default hooks into the Branch class.
1716
1917
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1717
1918
 
1718
1919
 
 
1920
class BranchInitHookParams(object):
 
1921
    """Object holding parameters passed to *_branch_init hooks.
 
1922
 
 
1923
    There are 4 fields that hooks may wish to access:
 
1924
 
 
1925
    :ivar format: the branch format
 
1926
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
 
1927
    :ivar name: name of colocated branch, if any (or None)
 
1928
    :ivar branch: the branch created
 
1929
 
 
1930
    Note that for lightweight checkouts, the bzrdir and format fields refer to
 
1931
    the checkout, hence they are different from the corresponding fields in
 
1932
    branch, which refer to the original branch.
 
1933
    """
 
1934
 
 
1935
    def __init__(self, format, a_bzrdir, name, branch):
 
1936
        """Create a group of BranchInitHook parameters.
 
1937
 
 
1938
        :param format: the branch format
 
1939
        :param a_bzrdir: the BzrDir where the branch will be/has been
 
1940
            initialized
 
1941
        :param name: name of colocated branch, if any (or None)
 
1942
        :param branch: the branch created
 
1943
 
 
1944
        Note that for lightweight checkouts, the bzrdir and format fields refer
 
1945
        to the checkout, hence they are different from the corresponding fields
 
1946
        in branch, which refer to the original branch.
 
1947
        """
 
1948
        self.format = format
 
1949
        self.bzrdir = a_bzrdir
 
1950
        self.name = name
 
1951
        self.branch = branch
 
1952
 
 
1953
    def __eq__(self, other):
 
1954
        return self.__dict__ == other.__dict__
 
1955
 
 
1956
    def __repr__(self):
 
1957
        if self.branch:
 
1958
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
 
1959
        else:
 
1960
            return "<%s of format:%s bzrdir:%s>" % (
 
1961
                self.__class__.__name__, self.branch,
 
1962
                self.format, self.bzrdir)
 
1963
 
 
1964
 
 
1965
class SwitchHookParams(object):
 
1966
    """Object holding parameters passed to *_switch hooks.
 
1967
 
 
1968
    There are 4 fields that hooks may wish to access:
 
1969
 
 
1970
    :ivar control_dir: BzrDir of the checkout to change
 
1971
    :ivar to_branch: branch that the checkout is to reference
 
1972
    :ivar force: skip the check for local commits in a heavy checkout
 
1973
    :ivar revision_id: revision ID to switch to (or None)
 
1974
    """
 
1975
 
 
1976
    def __init__(self, control_dir, to_branch, force, revision_id):
 
1977
        """Create a group of SwitchHook parameters.
 
1978
 
 
1979
        :param control_dir: BzrDir of the checkout to change
 
1980
        :param to_branch: branch that the checkout is to reference
 
1981
        :param force: skip the check for local commits in a heavy checkout
 
1982
        :param revision_id: revision ID to switch to (or None)
 
1983
        """
 
1984
        self.control_dir = control_dir
 
1985
        self.to_branch = to_branch
 
1986
        self.force = force
 
1987
        self.revision_id = revision_id
 
1988
 
 
1989
    def __eq__(self, other):
 
1990
        return self.__dict__ == other.__dict__
 
1991
 
 
1992
    def __repr__(self):
 
1993
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
 
1994
            self.control_dir, self.to_branch,
 
1995
            self.revision_id)
 
1996
 
 
1997
 
1719
1998
class BzrBranchFormat4(BranchFormat):
1720
1999
    """Bzr branch format 4.
1721
2000
 
1728
2007
        """See BranchFormat.get_format_description()."""
1729
2008
        return "Branch format 4"
1730
2009
 
1731
 
    def initialize(self, a_bzrdir):
 
2010
    def initialize(self, a_bzrdir, name=None):
1732
2011
        """Create a branch of this format in a_bzrdir."""
1733
2012
        utf8_files = [('revision-history', ''),
1734
2013
                      ('branch-name', ''),
1735
2014
                      ]
1736
 
        return self._initialize_helper(a_bzrdir, utf8_files,
 
2015
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1737
2016
                                       lock_type='branch4', set_format=False)
1738
2017
 
1739
2018
    def __init__(self):
1744
2023
        """The network name for this format is the control dirs disk label."""
1745
2024
        return self._matchingbzrdir.get_format_string()
1746
2025
 
1747
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
2026
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1748
2027
        """See BranchFormat.open()."""
1749
2028
        if not _found:
1750
2029
            # we are being called directly and must probe.
1752
2031
        return BzrBranch(_format=self,
1753
2032
                         _control_files=a_bzrdir._control_files,
1754
2033
                         a_bzrdir=a_bzrdir,
 
2034
                         name=name,
1755
2035
                         _repository=a_bzrdir.open_repository())
1756
2036
 
1757
2037
    def __str__(self):
1772
2052
        """
1773
2053
        return self.get_format_string()
1774
2054
 
1775
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
2055
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1776
2056
        """See BranchFormat.open()."""
1777
2057
        if not _found:
1778
 
            format = BranchFormat.find_format(a_bzrdir)
 
2058
            format = BranchFormat.find_format(a_bzrdir, name=name)
1779
2059
            if format.__class__ != self.__class__:
1780
2060
                raise AssertionError("wrong format %r found for %r" %
1781
2061
                    (format, self))
 
2062
        transport = a_bzrdir.get_branch_transport(None, name=name)
1782
2063
        try:
1783
 
            transport = a_bzrdir.get_branch_transport(None)
1784
2064
            control_files = lockable_files.LockableFiles(transport, 'lock',
1785
2065
                                                         lockdir.LockDir)
1786
2066
            return self._branch_class()(_format=self,
1787
2067
                              _control_files=control_files,
 
2068
                              name=name,
1788
2069
                              a_bzrdir=a_bzrdir,
1789
2070
                              _repository=a_bzrdir.find_repository(),
1790
2071
                              ignore_fallbacks=ignore_fallbacks)
1791
2072
        except errors.NoSuchFile:
1792
 
            raise errors.NotBranchError(path=transport.base)
 
2073
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1793
2074
 
1794
2075
    def __init__(self):
1795
2076
        super(BranchFormatMetadir, self).__init__()
1824
2105
        """See BranchFormat.get_format_description()."""
1825
2106
        return "Branch format 5"
1826
2107
 
1827
 
    def initialize(self, a_bzrdir):
 
2108
    def initialize(self, a_bzrdir, name=None):
1828
2109
        """Create a branch of this format in a_bzrdir."""
1829
2110
        utf8_files = [('revision-history', ''),
1830
2111
                      ('branch-name', ''),
1831
2112
                      ]
1832
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2113
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1833
2114
 
1834
2115
    def supports_tags(self):
1835
2116
        return False
1857
2138
        """See BranchFormat.get_format_description()."""
1858
2139
        return "Branch format 6"
1859
2140
 
1860
 
    def initialize(self, a_bzrdir):
 
2141
    def initialize(self, a_bzrdir, name=None):
1861
2142
        """Create a branch of this format in a_bzrdir."""
1862
2143
        utf8_files = [('last-revision', '0 null:\n'),
1863
2144
                      ('branch.conf', ''),
1864
2145
                      ('tags', ''),
1865
2146
                      ]
1866
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2147
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1867
2148
 
1868
2149
    def make_tags(self, branch):
1869
2150
        """See bzrlib.branch.BranchFormat.make_tags()."""
1887
2168
        """See BranchFormat.get_format_description()."""
1888
2169
        return "Branch format 8"
1889
2170
 
1890
 
    def initialize(self, a_bzrdir):
 
2171
    def initialize(self, a_bzrdir, name=None):
1891
2172
        """Create a branch of this format in a_bzrdir."""
1892
2173
        utf8_files = [('last-revision', '0 null:\n'),
1893
2174
                      ('branch.conf', ''),
1894
2175
                      ('tags', ''),
1895
2176
                      ('references', '')
1896
2177
                      ]
1897
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2178
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1898
2179
 
1899
2180
    def __init__(self):
1900
2181
        super(BzrBranchFormat8, self).__init__()
1923
2204
    This format was introduced in bzr 1.6.
1924
2205
    """
1925
2206
 
1926
 
    def initialize(self, a_bzrdir):
 
2207
    def initialize(self, a_bzrdir, name=None):
1927
2208
        """Create a branch of this format in a_bzrdir."""
1928
2209
        utf8_files = [('last-revision', '0 null:\n'),
1929
2210
                      ('branch.conf', ''),
1930
2211
                      ('tags', ''),
1931
2212
                      ]
1932
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2213
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1933
2214
 
1934
2215
    def _branch_class(self):
1935
2216
        return BzrBranch7
1967
2248
        """See BranchFormat.get_format_description()."""
1968
2249
        return "Checkout reference format 1"
1969
2250
 
1970
 
    def get_reference(self, a_bzrdir):
 
2251
    def get_reference(self, a_bzrdir, name=None):
1971
2252
        """See BranchFormat.get_reference()."""
1972
 
        transport = a_bzrdir.get_branch_transport(None)
1973
 
        return transport.get('location').read()
 
2253
        transport = a_bzrdir.get_branch_transport(None, name=name)
 
2254
        return transport.get_bytes('location')
1974
2255
 
1975
 
    def set_reference(self, a_bzrdir, to_branch):
 
2256
    def set_reference(self, a_bzrdir, name, to_branch):
1976
2257
        """See BranchFormat.set_reference()."""
1977
 
        transport = a_bzrdir.get_branch_transport(None)
 
2258
        transport = a_bzrdir.get_branch_transport(None, name=name)
1978
2259
        location = transport.put_bytes('location', to_branch.base)
1979
2260
 
1980
 
    def initialize(self, a_bzrdir, target_branch=None):
 
2261
    def initialize(self, a_bzrdir, name=None, target_branch=None):
1981
2262
        """Create a branch of this format in a_bzrdir."""
1982
2263
        if target_branch is None:
1983
2264
            # this format does not implement branch itself, thus the implicit
1984
2265
            # creation contract must see it as uninitializable
1985
2266
            raise errors.UninitializableFormat(self)
1986
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1987
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
2267
        mutter('creating branch reference in %s', a_bzrdir.user_url)
 
2268
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1988
2269
        branch_transport.put_bytes('location',
1989
 
            target_branch.bzrdir.root_transport.base)
 
2270
            target_branch.bzrdir.user_url)
1990
2271
        branch_transport.put_bytes('format', self.get_format_string())
1991
 
        return self.open(
1992
 
            a_bzrdir, _found=True,
 
2272
        branch = self.open(
 
2273
            a_bzrdir, name, _found=True,
1993
2274
            possible_transports=[target_branch.bzrdir.root_transport])
 
2275
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2276
        return branch
1994
2277
 
1995
2278
    def __init__(self):
1996
2279
        super(BranchReferenceFormat, self).__init__()
2002
2285
        def clone(to_bzrdir, revision_id=None,
2003
2286
            repository_policy=None):
2004
2287
            """See Branch.clone()."""
2005
 
            return format.initialize(to_bzrdir, a_branch)
 
2288
            return format.initialize(to_bzrdir, target_branch=a_branch)
2006
2289
            # cannot obey revision_id limits when cloning a reference ...
2007
2290
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2008
2291
            # emit some sort of warning/error to the caller ?!
2009
2292
        return clone
2010
2293
 
2011
 
    def open(self, a_bzrdir, _found=False, location=None,
 
2294
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2012
2295
             possible_transports=None, ignore_fallbacks=False):
2013
2296
        """Return the branch that the branch reference in a_bzrdir points at.
2014
2297
 
2015
2298
        :param a_bzrdir: A BzrDir that contains a branch.
 
2299
        :param name: Name of colocated branch to open, if any
2016
2300
        :param _found: a private parameter, do not use it. It is used to
2017
2301
            indicate if format probing has already be done.
2018
2302
        :param ignore_fallbacks: when set, no fallback branches will be opened
2023
2307
        :param possible_transports: An optional reusable transports list.
2024
2308
        """
2025
2309
        if not _found:
2026
 
            format = BranchFormat.find_format(a_bzrdir)
 
2310
            format = BranchFormat.find_format(a_bzrdir, name=name)
2027
2311
            if format.__class__ != self.__class__:
2028
2312
                raise AssertionError("wrong format %r found for %r" %
2029
2313
                    (format, self))
2030
2314
        if location is None:
2031
 
            location = self.get_reference(a_bzrdir)
 
2315
            location = self.get_reference(a_bzrdir, name)
2032
2316
        real_bzrdir = bzrdir.BzrDir.open(
2033
2317
            location, possible_transports=possible_transports)
2034
 
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2318
        result = real_bzrdir.open_branch(name=name, 
 
2319
            ignore_fallbacks=ignore_fallbacks)
2035
2320
        # this changes the behaviour of result.clone to create a new reference
2036
2321
        # rather than a copy of the content of the branch.
2037
2322
        # I did not use a proxy object because that needs much more extensive
2064
2349
BranchFormat.register_format(__format6)
2065
2350
BranchFormat.register_format(__format7)
2066
2351
BranchFormat.register_format(__format8)
2067
 
BranchFormat.set_default_format(__format6)
 
2352
BranchFormat.set_default_format(__format7)
2068
2353
_legacy_formats = [BzrBranchFormat4(),
2069
2354
    ]
2070
2355
network_format_registry.register(
2071
2356
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2072
2357
 
2073
2358
 
2074
 
class BzrBranch(Branch):
 
2359
class BranchWriteLockResult(LogicalLockResult):
 
2360
    """The result of write locking a branch.
 
2361
 
 
2362
    :ivar branch_token: The token obtained from the underlying branch lock, or
 
2363
        None.
 
2364
    :ivar unlock: A callable which will unlock the lock.
 
2365
    """
 
2366
 
 
2367
    def __init__(self, unlock, branch_token):
 
2368
        LogicalLockResult.__init__(self, unlock)
 
2369
        self.branch_token = branch_token
 
2370
 
 
2371
    def __repr__(self):
 
2372
        return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
 
2373
            self.unlock)
 
2374
 
 
2375
 
 
2376
class BzrBranch(Branch, _RelockDebugMixin):
2075
2377
    """A branch stored in the actual filesystem.
2076
2378
 
2077
2379
    Note that it's "local" in the context of the filesystem; it doesn't
2083
2385
    :ivar repository: Repository for this branch.
2084
2386
    :ivar base: The url of the base directory for this branch; the one
2085
2387
        containing the .bzr directory.
 
2388
    :ivar name: Optional colocated branch name as it exists in the control
 
2389
        directory.
2086
2390
    """
2087
2391
 
2088
2392
    def __init__(self, _format=None,
2089
 
                 _control_files=None, a_bzrdir=None, _repository=None,
2090
 
                 ignore_fallbacks=False):
 
2393
                 _control_files=None, a_bzrdir=None, name=None,
 
2394
                 _repository=None, ignore_fallbacks=False):
2091
2395
        """Create new branch object at a particular location."""
2092
2396
        if a_bzrdir is None:
2093
2397
            raise ValueError('a_bzrdir must be supplied')
2094
2398
        else:
2095
2399
            self.bzrdir = a_bzrdir
2096
2400
        self._base = self.bzrdir.transport.clone('..').base
 
2401
        self.name = name
2097
2402
        # XXX: We should be able to just do
2098
2403
        #   self.base = self.bzrdir.root_transport.base
2099
2404
        # but this does not quite work yet -- mbp 20080522
2106
2411
        Branch.__init__(self)
2107
2412
 
2108
2413
    def __str__(self):
2109
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
2414
        if self.name is None:
 
2415
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
 
2416
        else:
 
2417
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
 
2418
                self.name)
2110
2419
 
2111
2420
    __repr__ = __str__
2112
2421
 
2123
2432
        return self.control_files.is_locked()
2124
2433
 
2125
2434
    def lock_write(self, token=None):
 
2435
        """Lock the branch for write operations.
 
2436
 
 
2437
        :param token: A token to permit reacquiring a previously held and
 
2438
            preserved lock.
 
2439
        :return: A BranchWriteLockResult.
 
2440
        """
 
2441
        if not self.is_locked():
 
2442
            self._note_lock('w')
2126
2443
        # All-in-one needs to always unlock/lock.
2127
2444
        repo_control = getattr(self.repository, 'control_files', None)
2128
2445
        if self.control_files == repo_control or not self.is_locked():
 
2446
            self.repository._warn_if_deprecated(self)
2129
2447
            self.repository.lock_write()
2130
2448
            took_lock = True
2131
2449
        else:
2132
2450
            took_lock = False
2133
2451
        try:
2134
 
            return self.control_files.lock_write(token=token)
 
2452
            return BranchWriteLockResult(self.unlock,
 
2453
                self.control_files.lock_write(token=token))
2135
2454
        except:
2136
2455
            if took_lock:
2137
2456
                self.repository.unlock()
2138
2457
            raise
2139
2458
 
2140
2459
    def lock_read(self):
 
2460
        """Lock the branch for read operations.
 
2461
 
 
2462
        :return: A bzrlib.lock.LogicalLockResult.
 
2463
        """
 
2464
        if not self.is_locked():
 
2465
            self._note_lock('r')
2141
2466
        # All-in-one needs to always unlock/lock.
2142
2467
        repo_control = getattr(self.repository, 'control_files', None)
2143
2468
        if self.control_files == repo_control or not self.is_locked():
 
2469
            self.repository._warn_if_deprecated(self)
2144
2470
            self.repository.lock_read()
2145
2471
            took_lock = True
2146
2472
        else:
2147
2473
            took_lock = False
2148
2474
        try:
2149
2475
            self.control_files.lock_read()
 
2476
            return LogicalLockResult(self.unlock)
2150
2477
        except:
2151
2478
            if took_lock:
2152
2479
                self.repository.unlock()
2153
2480
            raise
2154
2481
 
 
2482
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2155
2483
    def unlock(self):
2156
2484
        try:
2157
2485
            self.control_files.unlock()
2320
2648
        return result
2321
2649
 
2322
2650
    def get_stacked_on_url(self):
2323
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2651
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2324
2652
 
2325
2653
    def set_push_location(self, location):
2326
2654
        """See Branch.set_push_location."""
2516
2844
        if _mod_revision.is_null(last_revision):
2517
2845
            return
2518
2846
        if last_revision not in self._lefthand_history(revision_id):
2519
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2847
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2520
2848
 
2521
2849
    def _gen_revision_history(self):
2522
2850
        """Generate the revision history from last revision
2622
2950
        if branch_location is None:
2623
2951
            return Branch.reference_parent(self, file_id, path,
2624
2952
                                           possible_transports)
2625
 
        branch_location = urlutils.join(self.base, branch_location)
 
2953
        branch_location = urlutils.join(self.user_url, branch_location)
2626
2954
        return Branch.open(branch_location,
2627
2955
                           possible_transports=possible_transports)
2628
2956
 
2674
3002
        return stacked_url
2675
3003
 
2676
3004
    def _get_append_revisions_only(self):
2677
 
        value = self.get_config().get_user_option('append_revisions_only')
2678
 
        return value == 'True'
 
3005
        return self.get_config(
 
3006
            ).get_user_option_as_bool('append_revisions_only')
2679
3007
 
2680
3008
    @needs_write_lock
2681
3009
    def generate_revision_history(self, revision_id, last_rev=None,
2743
3071
    """
2744
3072
 
2745
3073
    def get_stacked_on_url(self):
2746
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
3074
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2747
3075
 
2748
3076
 
2749
3077
######################################################################
2836
3164
        :param verbose: Requests more detailed display of what was checked,
2837
3165
            if any.
2838
3166
        """
2839
 
        note('checked branch %s format %s', self.branch.base,
 
3167
        note('checked branch %s format %s', self.branch.user_url,
2840
3168
            self.branch._format)
2841
3169
        for error in self.errors:
2842
3170
            note('found error:%s', error)
2937
3265
    _optimisers = []
2938
3266
    """The available optimised InterBranch types."""
2939
3267
 
2940
 
    @staticmethod
2941
 
    def _get_branch_formats_to_test():
2942
 
        """Return a tuple with the Branch formats to use when testing."""
2943
 
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
 
3268
    @classmethod
 
3269
    def _get_branch_formats_to_test(klass):
 
3270
        """Return an iterable of format tuples for testing.
 
3271
        
 
3272
        :return: An iterable of (from_format, to_format) to use when testing
 
3273
            this InterBranch class. Each InterBranch class should define this
 
3274
            method itself.
 
3275
        """
 
3276
        raise NotImplementedError(klass._get_branch_formats_to_test)
2944
3277
 
 
3278
    @needs_write_lock
2945
3279
    def pull(self, overwrite=False, stop_revision=None,
2946
3280
             possible_transports=None, local=False):
2947
3281
        """Mirror source into target branch.
2952
3286
        """
2953
3287
        raise NotImplementedError(self.pull)
2954
3288
 
 
3289
    @needs_write_lock
2955
3290
    def update_revisions(self, stop_revision=None, overwrite=False,
2956
3291
                         graph=None):
2957
3292
        """Pull in new perfect-fit revisions.
2965
3300
        """
2966
3301
        raise NotImplementedError(self.update_revisions)
2967
3302
 
 
3303
    @needs_write_lock
2968
3304
    def push(self, overwrite=False, stop_revision=None,
2969
3305
             _override_hook_source_branch=None):
2970
3306
        """Mirror the source branch into the target branch.
2975
3311
 
2976
3312
 
2977
3313
class GenericInterBranch(InterBranch):
2978
 
    """InterBranch implementation that uses public Branch functions.
2979
 
    """
2980
 
 
2981
 
    @staticmethod
2982
 
    def _get_branch_formats_to_test():
2983
 
        return BranchFormat._default_format, BranchFormat._default_format
2984
 
 
 
3314
    """InterBranch implementation that uses public Branch functions."""
 
3315
 
 
3316
    @classmethod
 
3317
    def is_compatible(klass, source, target):
 
3318
        # GenericBranch uses the public API, so always compatible
 
3319
        return True
 
3320
 
 
3321
    @classmethod
 
3322
    def _get_branch_formats_to_test(klass):
 
3323
        return [(BranchFormat._default_format, BranchFormat._default_format)]
 
3324
 
 
3325
    @classmethod
 
3326
    def unwrap_format(klass, format):
 
3327
        if isinstance(format, remote.RemoteBranchFormat):
 
3328
            format._ensure_real()
 
3329
            return format._custom_format
 
3330
        return format                                                                                                  
 
3331
 
 
3332
    @needs_write_lock
 
3333
    def copy_content_into(self, revision_id=None):
 
3334
        """Copy the content of source into target
 
3335
 
 
3336
        revision_id: if not None, the revision history in the new branch will
 
3337
                     be truncated to end with revision_id.
 
3338
        """
 
3339
        self.source.update_references(self.target)
 
3340
        self.source._synchronize_history(self.target, revision_id)
 
3341
        try:
 
3342
            parent = self.source.get_parent()
 
3343
        except errors.InaccessibleParent, e:
 
3344
            mutter('parent was not accessible to copy: %s', e)
 
3345
        else:
 
3346
            if parent:
 
3347
                self.target.set_parent(parent)
 
3348
        if self.source._push_should_merge_tags():
 
3349
            self.source.tags.merge_to(self.target.tags)
 
3350
 
 
3351
    @needs_write_lock
2985
3352
    def update_revisions(self, stop_revision=None, overwrite=False,
2986
3353
        graph=None):
2987
3354
        """See InterBranch.update_revisions()."""
2988
 
        self.source.lock_read()
2989
 
        try:
2990
 
            other_revno, other_last_revision = self.source.last_revision_info()
2991
 
            stop_revno = None # unknown
2992
 
            if stop_revision is None:
2993
 
                stop_revision = other_last_revision
2994
 
                if _mod_revision.is_null(stop_revision):
2995
 
                    # if there are no commits, we're done.
2996
 
                    return
2997
 
                stop_revno = other_revno
2998
 
 
2999
 
            # what's the current last revision, before we fetch [and change it
3000
 
            # possibly]
3001
 
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
3002
 
            # we fetch here so that we don't process data twice in the common
3003
 
            # case of having something to pull, and so that the check for
3004
 
            # already merged can operate on the just fetched graph, which will
3005
 
            # be cached in memory.
3006
 
            self.target.fetch(self.source, stop_revision)
3007
 
            # Check to see if one is an ancestor of the other
3008
 
            if not overwrite:
3009
 
                if graph is None:
3010
 
                    graph = self.target.repository.get_graph()
3011
 
                if self.target._check_if_descendant_or_diverged(
3012
 
                        stop_revision, last_rev, graph, self.source):
3013
 
                    # stop_revision is a descendant of last_rev, but we aren't
3014
 
                    # overwriting, so we're done.
3015
 
                    return
3016
 
            if stop_revno is None:
3017
 
                if graph is None:
3018
 
                    graph = self.target.repository.get_graph()
3019
 
                this_revno, this_last_revision = \
3020
 
                        self.target.last_revision_info()
3021
 
                stop_revno = graph.find_distance_to_null(stop_revision,
3022
 
                                [(other_last_revision, other_revno),
3023
 
                                 (this_last_revision, this_revno)])
3024
 
            self.target.set_last_revision_info(stop_revno, stop_revision)
3025
 
        finally:
3026
 
            self.source.unlock()
3027
 
 
 
3355
        other_revno, other_last_revision = self.source.last_revision_info()
 
3356
        stop_revno = None # unknown
 
3357
        if stop_revision is None:
 
3358
            stop_revision = other_last_revision
 
3359
            if _mod_revision.is_null(stop_revision):
 
3360
                # if there are no commits, we're done.
 
3361
                return
 
3362
            stop_revno = other_revno
 
3363
 
 
3364
        # what's the current last revision, before we fetch [and change it
 
3365
        # possibly]
 
3366
        last_rev = _mod_revision.ensure_null(self.target.last_revision())
 
3367
        # we fetch here so that we don't process data twice in the common
 
3368
        # case of having something to pull, and so that the check for
 
3369
        # already merged can operate on the just fetched graph, which will
 
3370
        # be cached in memory.
 
3371
        self.target.fetch(self.source, stop_revision)
 
3372
        # Check to see if one is an ancestor of the other
 
3373
        if not overwrite:
 
3374
            if graph is None:
 
3375
                graph = self.target.repository.get_graph()
 
3376
            if self.target._check_if_descendant_or_diverged(
 
3377
                    stop_revision, last_rev, graph, self.source):
 
3378
                # stop_revision is a descendant of last_rev, but we aren't
 
3379
                # overwriting, so we're done.
 
3380
                return
 
3381
        if stop_revno is None:
 
3382
            if graph is None:
 
3383
                graph = self.target.repository.get_graph()
 
3384
            this_revno, this_last_revision = \
 
3385
                    self.target.last_revision_info()
 
3386
            stop_revno = graph.find_distance_to_null(stop_revision,
 
3387
                            [(other_last_revision, other_revno),
 
3388
                             (this_last_revision, this_revno)])
 
3389
        self.target.set_last_revision_info(stop_revno, stop_revision)
 
3390
 
 
3391
    @needs_write_lock
3028
3392
    def pull(self, overwrite=False, stop_revision=None,
3029
 
             possible_transports=None, _hook_master=None, run_hooks=True,
 
3393
             possible_transports=None, run_hooks=True,
3030
3394
             _override_hook_target=None, local=False):
3031
 
        """See Branch.pull.
 
3395
        """Pull from source into self, updating my master if any.
3032
3396
 
3033
 
        :param _hook_master: Private parameter - set the branch to
3034
 
            be supplied as the master to pull hooks.
3035
3397
        :param run_hooks: Private parameter - if false, this branch
3036
3398
            is being called because it's the master of the primary branch,
3037
3399
            so it should not run its hooks.
3038
 
        :param _override_hook_target: Private parameter - set the branch to be
3039
 
            supplied as the target_branch to pull hooks.
3040
 
        :param local: Only update the local branch, and not the bound branch.
3041
3400
        """
3042
 
        # This type of branch can't be bound.
3043
 
        if local:
 
3401
        bound_location = self.target.get_bound_location()
 
3402
        if local and not bound_location:
3044
3403
            raise errors.LocalRequiresBoundBranch()
3045
 
        result = PullResult()
3046
 
        result.source_branch = self.source
3047
 
        if _override_hook_target is None:
3048
 
            result.target_branch = self.target
3049
 
        else:
3050
 
            result.target_branch = _override_hook_target
3051
 
        self.source.lock_read()
 
3404
        master_branch = None
 
3405
        if not local and bound_location and self.source.user_url != bound_location:
 
3406
            # not pulling from master, so we need to update master.
 
3407
            master_branch = self.target.get_master_branch(possible_transports)
 
3408
            master_branch.lock_write()
3052
3409
        try:
3053
 
            # We assume that during 'pull' the target repository is closer than
3054
 
            # the source one.
3055
 
            self.source.update_references(self.target)
3056
 
            graph = self.target.repository.get_graph(self.source.repository)
3057
 
            # TODO: Branch formats should have a flag that indicates 
3058
 
            # that revno's are expensive, and pull() should honor that flag.
3059
 
            # -- JRV20090506
3060
 
            result.old_revno, result.old_revid = \
3061
 
                self.target.last_revision_info()
3062
 
            self.target.update_revisions(self.source, stop_revision,
3063
 
                overwrite=overwrite, graph=graph)
3064
 
            # TODO: The old revid should be specified when merging tags, 
3065
 
            # so a tags implementation that versions tags can only 
3066
 
            # pull in the most recent changes. -- JRV20090506
3067
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3068
 
                overwrite)
3069
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3070
 
            if _hook_master:
3071
 
                result.master_branch = _hook_master
3072
 
                result.local_branch = result.target_branch
3073
 
            else:
3074
 
                result.master_branch = result.target_branch
3075
 
                result.local_branch = None
3076
 
            if run_hooks:
3077
 
                for hook in Branch.hooks['post_pull']:
3078
 
                    hook(result)
 
3410
            if master_branch:
 
3411
                # pull from source into master.
 
3412
                master_branch.pull(self.source, overwrite, stop_revision,
 
3413
                    run_hooks=False)
 
3414
            return self._pull(overwrite,
 
3415
                stop_revision, _hook_master=master_branch,
 
3416
                run_hooks=run_hooks,
 
3417
                _override_hook_target=_override_hook_target)
3079
3418
        finally:
3080
 
            self.source.unlock()
3081
 
        return result
 
3419
            if master_branch:
 
3420
                master_branch.unlock()
3082
3421
 
3083
3422
    def push(self, overwrite=False, stop_revision=None,
3084
3423
             _override_hook_source_branch=None):
3146
3485
            _run_hooks()
3147
3486
            return result
3148
3487
 
3149
 
    @classmethod
3150
 
    def is_compatible(self, source, target):
3151
 
        # GenericBranch uses the public API, so always compatible
3152
 
        return True
3153
 
 
3154
 
 
3155
 
class InterToBranch5(GenericInterBranch):
3156
 
 
3157
 
    @staticmethod
3158
 
    def _get_branch_formats_to_test():
3159
 
        return BranchFormat._default_format, BzrBranchFormat5()
3160
 
 
3161
 
    def pull(self, overwrite=False, stop_revision=None,
3162
 
             possible_transports=None, run_hooks=True,
 
3488
    def _pull(self, overwrite=False, stop_revision=None,
 
3489
             possible_transports=None, _hook_master=None, run_hooks=True,
3163
3490
             _override_hook_target=None, local=False):
3164
 
        """Pull from source into self, updating my master if any.
3165
 
 
 
3491
        """See Branch.pull.
 
3492
 
 
3493
        This function is the core worker, used by GenericInterBranch.pull to
 
3494
        avoid duplication when pulling source->master and source->local.
 
3495
 
 
3496
        :param _hook_master: Private parameter - set the branch to
 
3497
            be supplied as the master to pull hooks.
3166
3498
        :param run_hooks: Private parameter - if false, this branch
3167
3499
            is being called because it's the master of the primary branch,
3168
3500
            so it should not run its hooks.
 
3501
        :param _override_hook_target: Private parameter - set the branch to be
 
3502
            supplied as the target_branch to pull hooks.
 
3503
        :param local: Only update the local branch, and not the bound branch.
3169
3504
        """
3170
 
        bound_location = self.target.get_bound_location()
3171
 
        if local and not bound_location:
 
3505
        # This type of branch can't be bound.
 
3506
        if local:
3172
3507
            raise errors.LocalRequiresBoundBranch()
3173
 
        master_branch = None
3174
 
        if not local and bound_location and self.source.base != bound_location:
3175
 
            # not pulling from master, so we need to update master.
3176
 
            master_branch = self.target.get_master_branch(possible_transports)
3177
 
            master_branch.lock_write()
 
3508
        result = PullResult()
 
3509
        result.source_branch = self.source
 
3510
        if _override_hook_target is None:
 
3511
            result.target_branch = self.target
 
3512
        else:
 
3513
            result.target_branch = _override_hook_target
 
3514
        self.source.lock_read()
3178
3515
        try:
3179
 
            if master_branch:
3180
 
                # pull from source into master.
3181
 
                master_branch.pull(self.source, overwrite, stop_revision,
3182
 
                    run_hooks=False)
3183
 
            return super(InterToBranch5, self).pull(overwrite,
3184
 
                stop_revision, _hook_master=master_branch,
3185
 
                run_hooks=run_hooks,
3186
 
                _override_hook_target=_override_hook_target)
 
3516
            # We assume that during 'pull' the target repository is closer than
 
3517
            # the source one.
 
3518
            self.source.update_references(self.target)
 
3519
            graph = self.target.repository.get_graph(self.source.repository)
 
3520
            # TODO: Branch formats should have a flag that indicates 
 
3521
            # that revno's are expensive, and pull() should honor that flag.
 
3522
            # -- JRV20090506
 
3523
            result.old_revno, result.old_revid = \
 
3524
                self.target.last_revision_info()
 
3525
            self.target.update_revisions(self.source, stop_revision,
 
3526
                overwrite=overwrite, graph=graph)
 
3527
            # TODO: The old revid should be specified when merging tags, 
 
3528
            # so a tags implementation that versions tags can only 
 
3529
            # pull in the most recent changes. -- JRV20090506
 
3530
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3531
                overwrite)
 
3532
            result.new_revno, result.new_revid = self.target.last_revision_info()
 
3533
            if _hook_master:
 
3534
                result.master_branch = _hook_master
 
3535
                result.local_branch = result.target_branch
 
3536
            else:
 
3537
                result.master_branch = result.target_branch
 
3538
                result.local_branch = None
 
3539
            if run_hooks:
 
3540
                for hook in Branch.hooks['post_pull']:
 
3541
                    hook(result)
3187
3542
        finally:
3188
 
            if master_branch:
3189
 
                master_branch.unlock()
 
3543
            self.source.unlock()
 
3544
        return result
3190
3545
 
3191
3546
 
3192
3547
InterBranch.register_optimiser(GenericInterBranch)
3193
 
InterBranch.register_optimiser(InterToBranch5)