/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Robert Collins
  • Date: 2010-05-06 11:08:10 UTC
  • mto: This revision was merged to the branch mainline in revision 5223.
  • Revision ID: robertc@robertcollins.net-20100506110810-h3j07fh5gmw54s25
Cleaner matcher matching revised unlocking protocol.

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
46
46
    )
47
47
""")
48
48
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
49
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
50
from bzrlib.hooks import HookPoint, Hooks
51
51
from bzrlib.inter import InterObject
 
52
from bzrlib.lock import _RelockDebugMixin
52
53
from bzrlib import registry
53
54
from bzrlib.symbol_versioning import (
54
55
    deprecated_in,
62
63
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
63
64
 
64
65
 
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):
 
66
class Branch(bzrdir.ControlComponent):
78
67
    """Branch holding a history of revisions.
79
68
 
80
 
    base
81
 
        Base directory/url of the branch.
 
69
    :ivar base:
 
70
        Base directory/url of the branch; using control_url and
 
71
        control_transport is more standardized.
82
72
 
83
73
    hooks: An instance of BranchHooks.
84
74
    """
86
76
    # - RBC 20060112
87
77
    base = None
88
78
 
 
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
 
89
87
    def __init__(self, *ignored, **ignored_too):
90
88
        self.tags = self._format.make_tags(self)
91
89
        self._revision_history_cache = None
106
104
        """Activate the branch/repository from url as a fallback repository."""
107
105
        repo = self._get_fallback_repository(url)
108
106
        if repo.has_same_location(self.repository):
109
 
            raise errors.UnstackableLocationError(self.base, url)
 
107
            raise errors.UnstackableLocationError(self.user_url, url)
110
108
        self.repository.add_fallback_repository(repo)
111
109
 
112
110
    def break_lock(self):
149
147
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
150
148
            self._partial_revision_history_cache.pop()
151
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
 
152
158
    @staticmethod
153
159
    def open(base, _unsupported=False, possible_transports=None):
154
160
        """Open the branch rooted at base.
158
164
        """
159
165
        control = bzrdir.BzrDir.open(base, _unsupported,
160
166
                                     possible_transports=possible_transports)
161
 
        return control.open_branch(_unsupported)
 
167
        return control.open_branch(unsupported=_unsupported)
162
168
 
163
169
    @staticmethod
164
 
    def open_from_transport(transport, _unsupported=False):
 
170
    def open_from_transport(transport, name=None, _unsupported=False):
165
171
        """Open the branch rooted at transport"""
166
172
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
167
 
        return control.open_branch(_unsupported)
 
173
        return control.open_branch(name=name, unsupported=_unsupported)
168
174
 
169
175
    @staticmethod
170
176
    def open_containing(url, possible_transports=None):
208
214
    def _get_fallback_repository(self, url):
209
215
        """Get the repository we fallback to at url."""
210
216
        url = urlutils.join(self.base, url)
211
 
        a_bzrdir = bzrdir.BzrDir.open(url,
 
217
        a_branch = Branch.open(url,
212
218
            possible_transports=[self.bzrdir.root_transport])
213
 
        return a_bzrdir.open_branch().repository
 
219
        return a_branch.repository
214
220
 
215
221
    def _get_tags_bytes(self):
216
222
        """Get the bytes of a serialised tags dict.
411
417
            * 'include' - the stop revision is the last item in the result
412
418
            * 'with-merges' - include the stop revision and all of its
413
419
              merged revisions in the result
 
420
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
421
              that are in both ancestries
414
422
        :param direction: either 'reverse' or 'forward':
415
423
            * reverse means return the start_revision_id first, i.e.
416
424
              start at the most recent revision and go backwards in history
438
446
        # start_revision_id.
439
447
        if self._merge_sorted_revisions_cache is None:
440
448
            last_revision = self.last_revision()
441
 
            graph = self.repository.get_graph()
442
 
            parent_map = dict(((key, value) for key, value in
443
 
                     graph.iter_ancestry([last_revision]) if value is not None))
444
 
            revision_graph = repository._strip_NULL_ghosts(parent_map)
445
 
            revs = tsort.merge_sort(revision_graph, last_revision, None,
446
 
                generate_revno=True)
447
 
            # Drop the sequence # before caching
448
 
            self._merge_sorted_revisions_cache = [r[1:] for r in revs]
449
 
 
 
449
            known_graph = self.repository.get_known_graph_ancestry(
 
450
                [last_revision])
 
451
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
 
452
                last_revision)
450
453
        filtered = self._filter_merge_sorted_revisions(
451
454
            self._merge_sorted_revisions_cache, start_revision_id,
452
455
            stop_revision_id, stop_rule)
 
456
        # Make sure we don't return revisions that are not part of the
 
457
        # start_revision_id ancestry.
 
458
        filtered = self._filter_start_non_ancestors(filtered)
453
459
        if direction == 'reverse':
454
460
            return filtered
455
461
        if direction == 'forward':
462
468
        """Iterate over an inclusive range of sorted revisions."""
463
469
        rev_iter = iter(merge_sorted_revisions)
464
470
        if start_revision_id is not None:
465
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
471
            for node in rev_iter:
 
472
                rev_id = node.key[-1]
466
473
                if rev_id != start_revision_id:
467
474
                    continue
468
475
                else:
469
476
                    # The decision to include the start or not
470
477
                    # depends on the stop_rule if a stop is provided
471
 
                    rev_iter = chain(
472
 
                        iter([(rev_id, depth, revno, end_of_merge)]),
473
 
                        rev_iter)
 
478
                    # so pop this node back into the iterator
 
479
                    rev_iter = chain(iter([node]), rev_iter)
474
480
                    break
475
481
        if stop_revision_id is None:
476
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
477
 
                yield rev_id, depth, revno, end_of_merge
 
482
            # Yield everything
 
483
            for node in rev_iter:
 
484
                rev_id = node.key[-1]
 
485
                yield (rev_id, node.merge_depth, node.revno,
 
486
                       node.end_of_merge)
478
487
        elif stop_rule == 'exclude':
479
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
488
            for node in rev_iter:
 
489
                rev_id = node.key[-1]
480
490
                if rev_id == stop_revision_id:
481
491
                    return
482
 
                yield rev_id, depth, revno, end_of_merge
 
492
                yield (rev_id, node.merge_depth, node.revno,
 
493
                       node.end_of_merge)
483
494
        elif stop_rule == 'include':
484
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
485
 
                yield rev_id, depth, revno, end_of_merge
 
495
            for node in rev_iter:
 
496
                rev_id = node.key[-1]
 
497
                yield (rev_id, node.merge_depth, node.revno,
 
498
                       node.end_of_merge)
486
499
                if rev_id == stop_revision_id:
487
500
                    return
 
501
        elif stop_rule == 'with-merges-without-common-ancestry':
 
502
            # We want to exclude all revisions that are already part of the
 
503
            # stop_revision_id ancestry.
 
504
            graph = self.repository.get_graph()
 
505
            ancestors = graph.find_unique_ancestors(start_revision_id,
 
506
                                                    [stop_revision_id])
 
507
            for node in rev_iter:
 
508
                rev_id = node.key[-1]
 
509
                if rev_id not in ancestors:
 
510
                    continue
 
511
                yield (rev_id, node.merge_depth, node.revno,
 
512
                       node.end_of_merge)
488
513
        elif stop_rule == 'with-merges':
489
514
            stop_rev = self.repository.get_revision(stop_revision_id)
490
515
            if stop_rev.parent_ids:
491
516
                left_parent = stop_rev.parent_ids[0]
492
517
            else:
493
518
                left_parent = _mod_revision.NULL_REVISION
494
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
519
            # left_parent is the actual revision we want to stop logging at,
 
520
            # since we want to show the merged revisions after the stop_rev too
 
521
            reached_stop_revision_id = False
 
522
            revision_id_whitelist = []
 
523
            for node in rev_iter:
 
524
                rev_id = node.key[-1]
495
525
                if rev_id == left_parent:
 
526
                    # reached the left parent after the stop_revision
496
527
                    return
497
 
                yield rev_id, depth, revno, end_of_merge
 
528
                if (not reached_stop_revision_id or
 
529
                        rev_id in revision_id_whitelist):
 
530
                    yield (rev_id, node.merge_depth, node.revno,
 
531
                       node.end_of_merge)
 
532
                    if reached_stop_revision_id or rev_id == stop_revision_id:
 
533
                        # only do the merged revs of rev_id from now on
 
534
                        rev = self.repository.get_revision(rev_id)
 
535
                        if rev.parent_ids:
 
536
                            reached_stop_revision_id = True
 
537
                            revision_id_whitelist.extend(rev.parent_ids)
498
538
        else:
499
539
            raise ValueError('invalid stop_rule %r' % stop_rule)
500
540
 
 
541
    def _filter_start_non_ancestors(self, rev_iter):
 
542
        # If we started from a dotted revno, we want to consider it as a tip
 
543
        # and don't want to yield revisions that are not part of its
 
544
        # ancestry. Given the order guaranteed by the merge sort, we will see
 
545
        # uninteresting descendants of the first parent of our tip before the
 
546
        # tip itself.
 
547
        first = rev_iter.next()
 
548
        (rev_id, merge_depth, revno, end_of_merge) = first
 
549
        yield first
 
550
        if not merge_depth:
 
551
            # We start at a mainline revision so by definition, all others
 
552
            # revisions in rev_iter are ancestors
 
553
            for node in rev_iter:
 
554
                yield node
 
555
 
 
556
        clean = False
 
557
        whitelist = set()
 
558
        pmap = self.repository.get_parent_map([rev_id])
 
559
        parents = pmap.get(rev_id, [])
 
560
        if parents:
 
561
            whitelist.update(parents)
 
562
        else:
 
563
            # If there is no parents, there is nothing of interest left
 
564
 
 
565
            # FIXME: It's hard to test this scenario here as this code is never
 
566
            # called in that case. -- vila 20100322
 
567
            return
 
568
 
 
569
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
 
570
            if not clean:
 
571
                if rev_id in whitelist:
 
572
                    pmap = self.repository.get_parent_map([rev_id])
 
573
                    parents = pmap.get(rev_id, [])
 
574
                    whitelist.remove(rev_id)
 
575
                    whitelist.update(parents)
 
576
                    if merge_depth == 0:
 
577
                        # We've reached the mainline, there is nothing left to
 
578
                        # filter
 
579
                        clean = True
 
580
                else:
 
581
                    # A revision that is not part of the ancestry of our
 
582
                    # starting revision.
 
583
                    continue
 
584
            yield (rev_id, merge_depth, revno, end_of_merge)
 
585
 
501
586
    def leave_lock_in_place(self):
502
587
        """Tell this branch object not to release the physical lock when this
503
588
        object is unlocked.
520
605
        :param other: The branch to bind to
521
606
        :type other: Branch
522
607
        """
523
 
        raise errors.UpgradeRequired(self.base)
 
608
        raise errors.UpgradeRequired(self.user_url)
524
609
 
525
610
    def set_append_revisions_only(self, enabled):
526
611
        if not self._format.supports_set_append_revisions_only():
527
 
            raise errors.UpgradeRequired(self.base)
 
612
            raise errors.UpgradeRequired(self.user_url)
528
613
        if enabled:
529
614
            value = 'True'
530
615
        else:
578
663
    def get_old_bound_location(self):
579
664
        """Return the URL of the branch we used to be bound to
580
665
        """
581
 
        raise errors.UpgradeRequired(self.base)
 
666
        raise errors.UpgradeRequired(self.user_url)
582
667
 
583
668
    def get_commit_builder(self, parents, config=None, timestamp=None,
584
669
                           timezone=None, committer=None, revprops=None,
662
747
            stacking.
663
748
        """
664
749
        if not self._format.supports_stacking():
665
 
            raise errors.UnstackableBranchFormat(self._format, self.base)
 
750
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
666
751
        # XXX: Changing from one fallback repository to another does not check
667
752
        # that all the data you need is present in the new fallback.
668
753
        # Possibly it should.
819
904
 
820
905
    def unbind(self):
821
906
        """Older format branches cannot bind or unbind."""
822
 
        raise errors.UpgradeRequired(self.base)
 
907
        raise errors.UpgradeRequired(self.user_url)
823
908
 
824
909
    def last_revision(self):
825
910
        """Return last revision id, or NULL_REVISION."""
985
1070
        try:
986
1071
            return urlutils.join(self.base[:-1], parent)
987
1072
        except errors.InvalidURLJoin, e:
988
 
            raise errors.InaccessibleParent(parent, self.base)
 
1073
            raise errors.InaccessibleParent(parent, self.user_url)
989
1074
 
990
1075
    def _get_parent_location(self):
991
1076
        raise NotImplementedError(self._get_parent_location)
1076
1161
        params = ChangeBranchTipParams(
1077
1162
            self, old_revno, new_revno, old_revid, new_revid)
1078
1163
        for hook in hooks:
1079
 
            try:
1080
 
                hook(params)
1081
 
            except errors.TipChangeRejected:
1082
 
                raise
1083
 
            except Exception:
1084
 
                exc_info = sys.exc_info()
1085
 
                hook_name = Branch.hooks.get_hook_name(hook)
1086
 
                raise errors.HookFailed(
1087
 
                    'pre_change_branch_tip', hook_name, exc_info)
 
1164
            hook(params)
1088
1165
 
1089
1166
    @needs_write_lock
1090
1167
    def update(self):
1139
1216
        revision_id: if not None, the revision history in the new branch will
1140
1217
                     be truncated to end with revision_id.
1141
1218
        """
 
1219
        if (repository_policy is not None and
 
1220
            repository_policy.requires_stacking()):
 
1221
            to_bzrdir._format.require_stacking(_skip_repo=True)
1142
1222
        result = to_bzrdir.create_branch()
1143
1223
        result.lock_write()
1144
1224
        try:
1212
1292
        target._set_all_reference_info(target_reference_dict)
1213
1293
 
1214
1294
    @needs_read_lock
1215
 
    def check(self):
 
1295
    def check(self, refs):
1216
1296
        """Check consistency of the branch.
1217
1297
 
1218
1298
        In particular this checks that revisions given in the revision-history
1221
1301
 
1222
1302
        Callers will typically also want to check the repository.
1223
1303
 
 
1304
        :param refs: Calculated refs for this branch as specified by
 
1305
            branch._get_check_refs()
1224
1306
        :return: A BranchCheckResult.
1225
1307
        """
1226
 
        ret = BranchCheckResult(self)
1227
 
        mainline_parent_id = None
 
1308
        result = BranchCheckResult(self)
1228
1309
        last_revno, last_revision_id = self.last_revision_info()
1229
 
        real_rev_history = []
1230
 
        try:
1231
 
            for revid in self.repository.iter_reverse_revision_history(
1232
 
                last_revision_id):
1233
 
                real_rev_history.append(revid)
1234
 
        except errors.RevisionNotPresent:
1235
 
            ret.ghosts_in_mainline = True
1236
 
        else:
1237
 
            ret.ghosts_in_mainline = False
1238
 
        real_rev_history.reverse()
1239
 
        if len(real_rev_history) != last_revno:
1240
 
            raise errors.BzrCheckError('revno does not match len(mainline)'
1241
 
                ' %s != %s' % (last_revno, len(real_rev_history)))
1242
 
        # TODO: We should probably also check that real_rev_history actually
1243
 
        #       matches self.revision_history()
1244
 
        for revision_id in real_rev_history:
1245
 
            try:
1246
 
                revision = self.repository.get_revision(revision_id)
1247
 
            except errors.NoSuchRevision, e:
1248
 
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
1249
 
                            % revision_id)
1250
 
            # In general the first entry on the revision history has no parents.
1251
 
            # But it's not illegal for it to have parents listed; this can happen
1252
 
            # in imports from Arch when the parents weren't reachable.
1253
 
            if mainline_parent_id is not None:
1254
 
                if mainline_parent_id not in revision.parent_ids:
1255
 
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
1256
 
                                        "parents of {%s}"
1257
 
                                        % (mainline_parent_id, revision_id))
1258
 
            mainline_parent_id = revision_id
1259
 
        return ret
 
1310
        actual_revno = refs[('lefthand-distance', last_revision_id)]
 
1311
        if actual_revno != last_revno:
 
1312
            result.errors.append(errors.BzrCheckError(
 
1313
                'revno does not match len(mainline) %s != %s' % (
 
1314
                last_revno, actual_revno)))
 
1315
        # TODO: We should probably also check that self.revision_history
 
1316
        # matches the repository for older branch formats.
 
1317
        # If looking for the code that cross-checks repository parents against
 
1318
        # the iter_reverse_revision_history output, that is now a repository
 
1319
        # specific check.
 
1320
        return result
1260
1321
 
1261
1322
    def _get_checkout_format(self):
1262
1323
        """Return the most suitable metadir for a checkout of this branch.
1287
1348
        # clone call. Or something. 20090224 RBC/spiv.
1288
1349
        if revision_id is None:
1289
1350
            revision_id = self.last_revision()
1290
 
        try:
1291
 
            dir_to = self.bzrdir.clone_on_transport(to_transport,
1292
 
                revision_id=revision_id, stacked_on=stacked_on,
1293
 
                create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1294
 
        except errors.FileExists:
1295
 
            if not use_existing_dir:
1296
 
                raise
1297
 
        except errors.NoSuchFile:
1298
 
            if not create_prefix:
1299
 
                raise
 
1351
        dir_to = self.bzrdir.clone_on_transport(to_transport,
 
1352
            revision_id=revision_id, stacked_on=stacked_on,
 
1353
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1300
1354
        return dir_to.open_branch()
1301
1355
 
1302
1356
    def create_checkout(self, to_location, revision_id=None,
1321
1375
        if lightweight:
1322
1376
            format = self._get_checkout_format()
1323
1377
            checkout = format.initialize_on_transport(t)
1324
 
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
1378
            from_branch = BranchReferenceFormat().initialize(checkout, 
 
1379
                target_branch=self)
1325
1380
        else:
1326
1381
            format = self._get_checkout_format()
1327
1382
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1369
1424
    def supports_tags(self):
1370
1425
        return self._format.supports_tags()
1371
1426
 
 
1427
    def automatic_tag_name(self, revision_id):
 
1428
        """Try to automatically find the tag name for a revision.
 
1429
 
 
1430
        :param revision_id: Revision id of the revision.
 
1431
        :return: A tag name or None if no tag name could be determined.
 
1432
        """
 
1433
        for hook in Branch.hooks['automatic_tag_name']:
 
1434
            ret = hook(self, revision_id)
 
1435
            if ret is not None:
 
1436
                return ret
 
1437
        return None
 
1438
 
1372
1439
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1373
1440
                                         other_branch):
1374
1441
        """Ensure that revision_b is a descendant of revision_a.
1438
1505
        return not (self == other)
1439
1506
 
1440
1507
    @classmethod
1441
 
    def find_format(klass, a_bzrdir):
 
1508
    def find_format(klass, a_bzrdir, name=None):
1442
1509
        """Return the format for the branch object in a_bzrdir."""
1443
1510
        try:
1444
 
            transport = a_bzrdir.get_branch_transport(None)
1445
 
            format_string = transport.get("format").read()
 
1511
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
1512
            format_string = transport.get_bytes("format")
1446
1513
            return klass._formats[format_string]
1447
1514
        except errors.NoSuchFile:
1448
 
            raise errors.NotBranchError(path=transport.base)
 
1515
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1449
1516
        except KeyError:
1450
1517
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1451
1518
 
1487
1554
        """Return the short format description for this format."""
1488
1555
        raise NotImplementedError(self.get_format_description)
1489
1556
 
1490
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1491
 
                           set_format=True):
 
1557
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
 
1558
        hooks = Branch.hooks['post_branch_init']
 
1559
        if not hooks:
 
1560
            return
 
1561
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
 
1562
        for hook in hooks:
 
1563
            hook(params)
 
1564
 
 
1565
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
 
1566
                           lock_type='metadir', set_format=True):
1492
1567
        """Initialize a branch in a bzrdir, with specified files
1493
1568
 
1494
1569
        :param a_bzrdir: The bzrdir to initialize the branch in
1495
1570
        :param utf8_files: The files to create as a list of
1496
1571
            (filename, content) tuples
 
1572
        :param name: Name of colocated branch to create, if any
1497
1573
        :param set_format: If True, set the format with
1498
1574
            self.get_format_string.  (BzrBranch4 has its format set
1499
1575
            elsewhere)
1500
1576
        :return: a branch in this format
1501
1577
        """
1502
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1503
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1578
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
 
1579
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1504
1580
        lock_map = {
1505
1581
            'metadir': ('lock', lockdir.LockDir),
1506
1582
            'branch4': ('branch-lock', lockable_files.TransportLock),
1527
1603
        finally:
1528
1604
            if lock_taken:
1529
1605
                control_files.unlock()
1530
 
        return self.open(a_bzrdir, _found=True)
 
1606
        branch = self.open(a_bzrdir, name, _found=True)
 
1607
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
1608
        return branch
1531
1609
 
1532
 
    def initialize(self, a_bzrdir):
1533
 
        """Create a branch of this format in a_bzrdir."""
 
1610
    def initialize(self, a_bzrdir, name=None):
 
1611
        """Create a branch of this format in a_bzrdir.
 
1612
        
 
1613
        :param name: Name of the colocated branch to create.
 
1614
        """
1534
1615
        raise NotImplementedError(self.initialize)
1535
1616
 
1536
1617
    def is_supported(self):
1566
1647
        """
1567
1648
        raise NotImplementedError(self.network_name)
1568
1649
 
1569
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1650
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1570
1651
        """Return the branch object for a_bzrdir
1571
1652
 
1572
1653
        :param a_bzrdir: A BzrDir that contains a branch.
 
1654
        :param name: Name of colocated branch to open
1573
1655
        :param _found: a private parameter, do not use it. It is used to
1574
1656
            indicate if format probing has already be done.
1575
1657
        :param ignore_fallbacks: when set, no fallback branches will be opened
1683
1765
            "multiple hooks installed for transform_fallback_location, "
1684
1766
            "all are called with the url returned from the previous hook."
1685
1767
            "The order is however undefined.", (1, 9), None))
 
1768
        self.create_hook(HookPoint('automatic_tag_name',
 
1769
            "Called to determine an automatic tag name for a revision."
 
1770
            "automatic_tag_name is called with (branch, revision_id) and "
 
1771
            "should return a tag name or None if no tag name could be "
 
1772
            "determined. The first non-None tag name returned will be used.",
 
1773
            (2, 2), None))
 
1774
        self.create_hook(HookPoint('post_branch_init',
 
1775
            "Called after new branch initialization completes. "
 
1776
            "post_branch_init is called with a "
 
1777
            "bzrlib.branch.BranchInitHookParams. "
 
1778
            "Note that init, branch and checkout (both heavyweight and "
 
1779
            "lightweight) will all trigger this hook.", (2, 2), None))
 
1780
        self.create_hook(HookPoint('post_switch',
 
1781
            "Called after a checkout switches branch. "
 
1782
            "post_switch is called with a "
 
1783
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
 
1784
 
1686
1785
 
1687
1786
 
1688
1787
# install the default hooks into the Branch class.
1727
1826
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1728
1827
 
1729
1828
 
 
1829
class BranchInitHookParams(object):
 
1830
    """Object holding parameters passed to *_branch_init hooks.
 
1831
 
 
1832
    There are 4 fields that hooks may wish to access:
 
1833
 
 
1834
    :ivar format: the branch format
 
1835
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
 
1836
    :ivar name: name of colocated branch, if any (or None)
 
1837
    :ivar branch: the branch created
 
1838
 
 
1839
    Note that for lightweight checkouts, the bzrdir and format fields refer to
 
1840
    the checkout, hence they are different from the corresponding fields in
 
1841
    branch, which refer to the original branch.
 
1842
    """
 
1843
 
 
1844
    def __init__(self, format, a_bzrdir, name, branch):
 
1845
        """Create a group of BranchInitHook parameters.
 
1846
 
 
1847
        :param format: the branch format
 
1848
        :param a_bzrdir: the BzrDir where the branch will be/has been
 
1849
            initialized
 
1850
        :param name: name of colocated branch, if any (or None)
 
1851
        :param branch: the branch created
 
1852
 
 
1853
        Note that for lightweight checkouts, the bzrdir and format fields refer
 
1854
        to the checkout, hence they are different from the corresponding fields
 
1855
        in branch, which refer to the original branch.
 
1856
        """
 
1857
        self.format = format
 
1858
        self.bzrdir = a_bzrdir
 
1859
        self.name = name
 
1860
        self.branch = branch
 
1861
 
 
1862
    def __eq__(self, other):
 
1863
        return self.__dict__ == other.__dict__
 
1864
 
 
1865
    def __repr__(self):
 
1866
        if self.branch:
 
1867
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
 
1868
        else:
 
1869
            return "<%s of format:%s bzrdir:%s>" % (
 
1870
                self.__class__.__name__, self.branch,
 
1871
                self.format, self.bzrdir)
 
1872
 
 
1873
 
 
1874
class SwitchHookParams(object):
 
1875
    """Object holding parameters passed to *_switch hooks.
 
1876
 
 
1877
    There are 4 fields that hooks may wish to access:
 
1878
 
 
1879
    :ivar control_dir: BzrDir of the checkout to change
 
1880
    :ivar to_branch: branch that the checkout is to reference
 
1881
    :ivar force: skip the check for local commits in a heavy checkout
 
1882
    :ivar revision_id: revision ID to switch to (or None)
 
1883
    """
 
1884
 
 
1885
    def __init__(self, control_dir, to_branch, force, revision_id):
 
1886
        """Create a group of SwitchHook parameters.
 
1887
 
 
1888
        :param control_dir: BzrDir of the checkout to change
 
1889
        :param to_branch: branch that the checkout is to reference
 
1890
        :param force: skip the check for local commits in a heavy checkout
 
1891
        :param revision_id: revision ID to switch to (or None)
 
1892
        """
 
1893
        self.control_dir = control_dir
 
1894
        self.to_branch = to_branch
 
1895
        self.force = force
 
1896
        self.revision_id = revision_id
 
1897
 
 
1898
    def __eq__(self, other):
 
1899
        return self.__dict__ == other.__dict__
 
1900
 
 
1901
    def __repr__(self):
 
1902
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
 
1903
            self.control_dir, self.to_branch,
 
1904
            self.revision_id)
 
1905
 
 
1906
 
1730
1907
class BzrBranchFormat4(BranchFormat):
1731
1908
    """Bzr branch format 4.
1732
1909
 
1739
1916
        """See BranchFormat.get_format_description()."""
1740
1917
        return "Branch format 4"
1741
1918
 
1742
 
    def initialize(self, a_bzrdir):
 
1919
    def initialize(self, a_bzrdir, name=None):
1743
1920
        """Create a branch of this format in a_bzrdir."""
1744
1921
        utf8_files = [('revision-history', ''),
1745
1922
                      ('branch-name', ''),
1746
1923
                      ]
1747
 
        return self._initialize_helper(a_bzrdir, utf8_files,
 
1924
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1748
1925
                                       lock_type='branch4', set_format=False)
1749
1926
 
1750
1927
    def __init__(self):
1755
1932
        """The network name for this format is the control dirs disk label."""
1756
1933
        return self._matchingbzrdir.get_format_string()
1757
1934
 
1758
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1935
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1759
1936
        """See BranchFormat.open()."""
1760
1937
        if not _found:
1761
1938
            # we are being called directly and must probe.
1763
1940
        return BzrBranch(_format=self,
1764
1941
                         _control_files=a_bzrdir._control_files,
1765
1942
                         a_bzrdir=a_bzrdir,
 
1943
                         name=name,
1766
1944
                         _repository=a_bzrdir.open_repository())
1767
1945
 
1768
1946
    def __str__(self):
1783
1961
        """
1784
1962
        return self.get_format_string()
1785
1963
 
1786
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1964
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1787
1965
        """See BranchFormat.open()."""
1788
1966
        if not _found:
1789
 
            format = BranchFormat.find_format(a_bzrdir)
 
1967
            format = BranchFormat.find_format(a_bzrdir, name=name)
1790
1968
            if format.__class__ != self.__class__:
1791
1969
                raise AssertionError("wrong format %r found for %r" %
1792
1970
                    (format, self))
 
1971
        transport = a_bzrdir.get_branch_transport(None, name=name)
1793
1972
        try:
1794
 
            transport = a_bzrdir.get_branch_transport(None)
1795
1973
            control_files = lockable_files.LockableFiles(transport, 'lock',
1796
1974
                                                         lockdir.LockDir)
1797
1975
            return self._branch_class()(_format=self,
1798
1976
                              _control_files=control_files,
 
1977
                              name=name,
1799
1978
                              a_bzrdir=a_bzrdir,
1800
1979
                              _repository=a_bzrdir.find_repository(),
1801
1980
                              ignore_fallbacks=ignore_fallbacks)
1802
1981
        except errors.NoSuchFile:
1803
 
            raise errors.NotBranchError(path=transport.base)
 
1982
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1804
1983
 
1805
1984
    def __init__(self):
1806
1985
        super(BranchFormatMetadir, self).__init__()
1835
2014
        """See BranchFormat.get_format_description()."""
1836
2015
        return "Branch format 5"
1837
2016
 
1838
 
    def initialize(self, a_bzrdir):
 
2017
    def initialize(self, a_bzrdir, name=None):
1839
2018
        """Create a branch of this format in a_bzrdir."""
1840
2019
        utf8_files = [('revision-history', ''),
1841
2020
                      ('branch-name', ''),
1842
2021
                      ]
1843
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2022
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1844
2023
 
1845
2024
    def supports_tags(self):
1846
2025
        return False
1868
2047
        """See BranchFormat.get_format_description()."""
1869
2048
        return "Branch format 6"
1870
2049
 
1871
 
    def initialize(self, a_bzrdir):
 
2050
    def initialize(self, a_bzrdir, name=None):
1872
2051
        """Create a branch of this format in a_bzrdir."""
1873
2052
        utf8_files = [('last-revision', '0 null:\n'),
1874
2053
                      ('branch.conf', ''),
1875
2054
                      ('tags', ''),
1876
2055
                      ]
1877
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2056
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1878
2057
 
1879
2058
    def make_tags(self, branch):
1880
2059
        """See bzrlib.branch.BranchFormat.make_tags()."""
1898
2077
        """See BranchFormat.get_format_description()."""
1899
2078
        return "Branch format 8"
1900
2079
 
1901
 
    def initialize(self, a_bzrdir):
 
2080
    def initialize(self, a_bzrdir, name=None):
1902
2081
        """Create a branch of this format in a_bzrdir."""
1903
2082
        utf8_files = [('last-revision', '0 null:\n'),
1904
2083
                      ('branch.conf', ''),
1905
2084
                      ('tags', ''),
1906
2085
                      ('references', '')
1907
2086
                      ]
1908
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2087
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1909
2088
 
1910
2089
    def __init__(self):
1911
2090
        super(BzrBranchFormat8, self).__init__()
1934
2113
    This format was introduced in bzr 1.6.
1935
2114
    """
1936
2115
 
1937
 
    def initialize(self, a_bzrdir):
 
2116
    def initialize(self, a_bzrdir, name=None):
1938
2117
        """Create a branch of this format in a_bzrdir."""
1939
2118
        utf8_files = [('last-revision', '0 null:\n'),
1940
2119
                      ('branch.conf', ''),
1941
2120
                      ('tags', ''),
1942
2121
                      ]
1943
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2122
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1944
2123
 
1945
2124
    def _branch_class(self):
1946
2125
        return BzrBranch7
1981
2160
    def get_reference(self, a_bzrdir):
1982
2161
        """See BranchFormat.get_reference()."""
1983
2162
        transport = a_bzrdir.get_branch_transport(None)
1984
 
        return transport.get('location').read()
 
2163
        return transport.get_bytes('location')
1985
2164
 
1986
2165
    def set_reference(self, a_bzrdir, to_branch):
1987
2166
        """See BranchFormat.set_reference()."""
1988
2167
        transport = a_bzrdir.get_branch_transport(None)
1989
2168
        location = transport.put_bytes('location', to_branch.base)
1990
2169
 
1991
 
    def initialize(self, a_bzrdir, target_branch=None):
 
2170
    def initialize(self, a_bzrdir, name=None, target_branch=None):
1992
2171
        """Create a branch of this format in a_bzrdir."""
1993
2172
        if target_branch is None:
1994
2173
            # this format does not implement branch itself, thus the implicit
1995
2174
            # creation contract must see it as uninitializable
1996
2175
            raise errors.UninitializableFormat(self)
1997
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1998
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
2176
        mutter('creating branch reference in %s', a_bzrdir.user_url)
 
2177
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1999
2178
        branch_transport.put_bytes('location',
2000
 
            target_branch.bzrdir.root_transport.base)
 
2179
            target_branch.bzrdir.user_url)
2001
2180
        branch_transport.put_bytes('format', self.get_format_string())
2002
 
        return self.open(
2003
 
            a_bzrdir, _found=True,
 
2181
        branch = self.open(
 
2182
            a_bzrdir, name, _found=True,
2004
2183
            possible_transports=[target_branch.bzrdir.root_transport])
 
2184
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2185
        return branch
2005
2186
 
2006
2187
    def __init__(self):
2007
2188
        super(BranchReferenceFormat, self).__init__()
2013
2194
        def clone(to_bzrdir, revision_id=None,
2014
2195
            repository_policy=None):
2015
2196
            """See Branch.clone()."""
2016
 
            return format.initialize(to_bzrdir, a_branch)
 
2197
            return format.initialize(to_bzrdir, target_branch=a_branch)
2017
2198
            # cannot obey revision_id limits when cloning a reference ...
2018
2199
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2019
2200
            # emit some sort of warning/error to the caller ?!
2020
2201
        return clone
2021
2202
 
2022
 
    def open(self, a_bzrdir, _found=False, location=None,
 
2203
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2023
2204
             possible_transports=None, ignore_fallbacks=False):
2024
2205
        """Return the branch that the branch reference in a_bzrdir points at.
2025
2206
 
2026
2207
        :param a_bzrdir: A BzrDir that contains a branch.
 
2208
        :param name: Name of colocated branch to open, if any
2027
2209
        :param _found: a private parameter, do not use it. It is used to
2028
2210
            indicate if format probing has already be done.
2029
2211
        :param ignore_fallbacks: when set, no fallback branches will be opened
2034
2216
        :param possible_transports: An optional reusable transports list.
2035
2217
        """
2036
2218
        if not _found:
2037
 
            format = BranchFormat.find_format(a_bzrdir)
 
2219
            format = BranchFormat.find_format(a_bzrdir, name=name)
2038
2220
            if format.__class__ != self.__class__:
2039
2221
                raise AssertionError("wrong format %r found for %r" %
2040
2222
                    (format, self))
2042
2224
            location = self.get_reference(a_bzrdir)
2043
2225
        real_bzrdir = bzrdir.BzrDir.open(
2044
2226
            location, possible_transports=possible_transports)
2045
 
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2227
        result = real_bzrdir.open_branch(name=name, 
 
2228
            ignore_fallbacks=ignore_fallbacks)
2046
2229
        # this changes the behaviour of result.clone to create a new reference
2047
2230
        # rather than a copy of the content of the branch.
2048
2231
        # I did not use a proxy object because that needs much more extensive
2075
2258
BranchFormat.register_format(__format6)
2076
2259
BranchFormat.register_format(__format7)
2077
2260
BranchFormat.register_format(__format8)
2078
 
BranchFormat.set_default_format(__format6)
 
2261
BranchFormat.set_default_format(__format7)
2079
2262
_legacy_formats = [BzrBranchFormat4(),
2080
2263
    ]
2081
2264
network_format_registry.register(
2082
2265
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2083
2266
 
2084
2267
 
2085
 
class BzrBranch(Branch):
 
2268
class BzrBranch(Branch, _RelockDebugMixin):
2086
2269
    """A branch stored in the actual filesystem.
2087
2270
 
2088
2271
    Note that it's "local" in the context of the filesystem; it doesn't
2094
2277
    :ivar repository: Repository for this branch.
2095
2278
    :ivar base: The url of the base directory for this branch; the one
2096
2279
        containing the .bzr directory.
 
2280
    :ivar name: Optional colocated branch name as it exists in the control
 
2281
        directory.
2097
2282
    """
2098
2283
 
2099
2284
    def __init__(self, _format=None,
2100
 
                 _control_files=None, a_bzrdir=None, _repository=None,
2101
 
                 ignore_fallbacks=False):
 
2285
                 _control_files=None, a_bzrdir=None, name=None,
 
2286
                 _repository=None, ignore_fallbacks=False):
2102
2287
        """Create new branch object at a particular location."""
2103
2288
        if a_bzrdir is None:
2104
2289
            raise ValueError('a_bzrdir must be supplied')
2105
2290
        else:
2106
2291
            self.bzrdir = a_bzrdir
2107
2292
        self._base = self.bzrdir.transport.clone('..').base
 
2293
        self.name = name
2108
2294
        # XXX: We should be able to just do
2109
2295
        #   self.base = self.bzrdir.root_transport.base
2110
2296
        # but this does not quite work yet -- mbp 20080522
2117
2303
        Branch.__init__(self)
2118
2304
 
2119
2305
    def __str__(self):
2120
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
2306
        if self.name is None:
 
2307
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
 
2308
        else:
 
2309
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
 
2310
                self.name)
2121
2311
 
2122
2312
    __repr__ = __str__
2123
2313
 
2134
2324
        return self.control_files.is_locked()
2135
2325
 
2136
2326
    def lock_write(self, token=None):
 
2327
        if not self.is_locked():
 
2328
            self._note_lock('w')
2137
2329
        # All-in-one needs to always unlock/lock.
2138
2330
        repo_control = getattr(self.repository, 'control_files', None)
2139
2331
        if self.control_files == repo_control or not self.is_locked():
 
2332
            self.repository._warn_if_deprecated(self)
2140
2333
            self.repository.lock_write()
2141
2334
            took_lock = True
2142
2335
        else:
2149
2342
            raise
2150
2343
 
2151
2344
    def lock_read(self):
 
2345
        if not self.is_locked():
 
2346
            self._note_lock('r')
2152
2347
        # All-in-one needs to always unlock/lock.
2153
2348
        repo_control = getattr(self.repository, 'control_files', None)
2154
2349
        if self.control_files == repo_control or not self.is_locked():
 
2350
            self.repository._warn_if_deprecated(self)
2155
2351
            self.repository.lock_read()
2156
2352
            took_lock = True
2157
2353
        else:
2163
2359
                self.repository.unlock()
2164
2360
            raise
2165
2361
 
 
2362
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2166
2363
    def unlock(self):
2167
2364
        try:
2168
2365
            self.control_files.unlock()
2331
2528
        return result
2332
2529
 
2333
2530
    def get_stacked_on_url(self):
2334
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2531
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2335
2532
 
2336
2533
    def set_push_location(self, location):
2337
2534
        """See Branch.set_push_location."""
2527
2724
        if _mod_revision.is_null(last_revision):
2528
2725
            return
2529
2726
        if last_revision not in self._lefthand_history(revision_id):
2530
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2727
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2531
2728
 
2532
2729
    def _gen_revision_history(self):
2533
2730
        """Generate the revision history from last revision
2633
2830
        if branch_location is None:
2634
2831
            return Branch.reference_parent(self, file_id, path,
2635
2832
                                           possible_transports)
2636
 
        branch_location = urlutils.join(self.base, branch_location)
 
2833
        branch_location = urlutils.join(self.user_url, branch_location)
2637
2834
        return Branch.open(branch_location,
2638
2835
                           possible_transports=possible_transports)
2639
2836
 
2685
2882
        return stacked_url
2686
2883
 
2687
2884
    def _get_append_revisions_only(self):
2688
 
        value = self.get_config().get_user_option('append_revisions_only')
2689
 
        return value == 'True'
 
2885
        return self.get_config(
 
2886
            ).get_user_option_as_bool('append_revisions_only')
2690
2887
 
2691
2888
    @needs_write_lock
2692
2889
    def generate_revision_history(self, revision_id, last_rev=None,
2754
2951
    """
2755
2952
 
2756
2953
    def get_stacked_on_url(self):
2757
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2954
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2758
2955
 
2759
2956
 
2760
2957
######################################################################
2839
3036
 
2840
3037
    def __init__(self, branch):
2841
3038
        self.branch = branch
2842
 
        self.ghosts_in_mainline = False
 
3039
        self.errors = []
2843
3040
 
2844
3041
    def report_results(self, verbose):
2845
3042
        """Report the check results via trace.note.
2847
3044
        :param verbose: Requests more detailed display of what was checked,
2848
3045
            if any.
2849
3046
        """
2850
 
        note('checked branch %s format %s',
2851
 
             self.branch.base,
2852
 
             self.branch._format)
2853
 
        if self.ghosts_in_mainline:
2854
 
            note('branch contains ghosts in mainline')
 
3047
        note('checked branch %s format %s', self.branch.user_url,
 
3048
            self.branch._format)
 
3049
        for error in self.errors:
 
3050
            note('found error:%s', error)
2855
3051
 
2856
3052
 
2857
3053
class Converter5to6(object):
3183
3379
        if local and not bound_location:
3184
3380
            raise errors.LocalRequiresBoundBranch()
3185
3381
        master_branch = None
3186
 
        if not local and bound_location and self.source.base != bound_location:
 
3382
        if not local and bound_location and self.source.user_url != bound_location:
3187
3383
            # not pulling from master, so we need to update master.
3188
3384
            master_branch = self.target.get_master_branch(possible_transports)
3189
3385
            master_branch.lock_write()