/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):
166
164
        """
167
165
        control = bzrdir.BzrDir.open(base, _unsupported,
168
166
                                     possible_transports=possible_transports)
169
 
        return control.open_branch(_unsupported)
 
167
        return control.open_branch(unsupported=_unsupported)
170
168
 
171
169
    @staticmethod
172
 
    def open_from_transport(transport, _unsupported=False):
 
170
    def open_from_transport(transport, name=None, _unsupported=False):
173
171
        """Open the branch rooted at transport"""
174
172
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
175
 
        return control.open_branch(_unsupported)
 
173
        return control.open_branch(name=name, unsupported=_unsupported)
176
174
 
177
175
    @staticmethod
178
176
    def open_containing(url, possible_transports=None):
216
214
    def _get_fallback_repository(self, url):
217
215
        """Get the repository we fallback to at url."""
218
216
        url = urlutils.join(self.base, url)
219
 
        a_bzrdir = bzrdir.BzrDir.open(url,
 
217
        a_branch = Branch.open(url,
220
218
            possible_transports=[self.bzrdir.root_transport])
221
 
        return a_bzrdir.open_branch().repository
 
219
        return a_branch.repository
222
220
 
223
221
    def _get_tags_bytes(self):
224
222
        """Get the bytes of a serialised tags dict.
419
417
            * 'include' - the stop revision is the last item in the result
420
418
            * 'with-merges' - include the stop revision and all of its
421
419
              merged revisions in the result
 
420
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
421
              that are in both ancestries
422
422
        :param direction: either 'reverse' or 'forward':
423
423
            * reverse means return the start_revision_id first, i.e.
424
424
              start at the most recent revision and go backwards in history
446
446
        # start_revision_id.
447
447
        if self._merge_sorted_revisions_cache is None:
448
448
            last_revision = self.last_revision()
449
 
            last_key = (last_revision,)
450
 
            known_graph = self.repository.revisions.get_known_graph_ancestry(
451
 
                [last_key])
 
449
            known_graph = self.repository.get_known_graph_ancestry(
 
450
                [last_revision])
452
451
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
453
 
                last_key)
 
452
                last_revision)
454
453
        filtered = self._filter_merge_sorted_revisions(
455
454
            self._merge_sorted_revisions_cache, start_revision_id,
456
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)
457
459
        if direction == 'reverse':
458
460
            return filtered
459
461
        if direction == 'forward':
496
498
                       node.end_of_merge)
497
499
                if rev_id == stop_revision_id:
498
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)
499
513
        elif stop_rule == 'with-merges':
500
514
            stop_rev = self.repository.get_revision(stop_revision_id)
501
515
            if stop_rev.parent_ids:
502
516
                left_parent = stop_rev.parent_ids[0]
503
517
            else:
504
518
                left_parent = _mod_revision.NULL_REVISION
 
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 = []
505
523
            for node in rev_iter:
506
524
                rev_id = node.key[-1]
507
525
                if rev_id == left_parent:
 
526
                    # reached the left parent after the stop_revision
508
527
                    return
509
 
                yield (rev_id, node.merge_depth, node.revno,
 
528
                if (not reached_stop_revision_id or
 
529
                        rev_id in revision_id_whitelist):
 
530
                    yield (rev_id, node.merge_depth, node.revno,
510
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)
511
538
        else:
512
539
            raise ValueError('invalid stop_rule %r' % stop_rule)
513
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
 
514
586
    def leave_lock_in_place(self):
515
587
        """Tell this branch object not to release the physical lock when this
516
588
        object is unlocked.
533
605
        :param other: The branch to bind to
534
606
        :type other: Branch
535
607
        """
536
 
        raise errors.UpgradeRequired(self.base)
 
608
        raise errors.UpgradeRequired(self.user_url)
537
609
 
538
610
    def set_append_revisions_only(self, enabled):
539
611
        if not self._format.supports_set_append_revisions_only():
540
 
            raise errors.UpgradeRequired(self.base)
 
612
            raise errors.UpgradeRequired(self.user_url)
541
613
        if enabled:
542
614
            value = 'True'
543
615
        else:
591
663
    def get_old_bound_location(self):
592
664
        """Return the URL of the branch we used to be bound to
593
665
        """
594
 
        raise errors.UpgradeRequired(self.base)
 
666
        raise errors.UpgradeRequired(self.user_url)
595
667
 
596
668
    def get_commit_builder(self, parents, config=None, timestamp=None,
597
669
                           timezone=None, committer=None, revprops=None,
675
747
            stacking.
676
748
        """
677
749
        if not self._format.supports_stacking():
678
 
            raise errors.UnstackableBranchFormat(self._format, self.base)
 
750
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
679
751
        # XXX: Changing from one fallback repository to another does not check
680
752
        # that all the data you need is present in the new fallback.
681
753
        # Possibly it should.
832
904
 
833
905
    def unbind(self):
834
906
        """Older format branches cannot bind or unbind."""
835
 
        raise errors.UpgradeRequired(self.base)
 
907
        raise errors.UpgradeRequired(self.user_url)
836
908
 
837
909
    def last_revision(self):
838
910
        """Return last revision id, or NULL_REVISION."""
998
1070
        try:
999
1071
            return urlutils.join(self.base[:-1], parent)
1000
1072
        except errors.InvalidURLJoin, e:
1001
 
            raise errors.InaccessibleParent(parent, self.base)
 
1073
            raise errors.InaccessibleParent(parent, self.user_url)
1002
1074
 
1003
1075
    def _get_parent_location(self):
1004
1076
        raise NotImplementedError(self._get_parent_location)
1089
1161
        params = ChangeBranchTipParams(
1090
1162
            self, old_revno, new_revno, old_revid, new_revid)
1091
1163
        for hook in hooks:
1092
 
            try:
1093
 
                hook(params)
1094
 
            except errors.TipChangeRejected:
1095
 
                raise
1096
 
            except Exception:
1097
 
                exc_info = sys.exc_info()
1098
 
                hook_name = Branch.hooks.get_hook_name(hook)
1099
 
                raise errors.HookFailed(
1100
 
                    'pre_change_branch_tip', hook_name, exc_info)
 
1164
            hook(params)
1101
1165
 
1102
1166
    @needs_write_lock
1103
1167
    def update(self):
1311
1375
        if lightweight:
1312
1376
            format = self._get_checkout_format()
1313
1377
            checkout = format.initialize_on_transport(t)
1314
 
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
1378
            from_branch = BranchReferenceFormat().initialize(checkout, 
 
1379
                target_branch=self)
1315
1380
        else:
1316
1381
            format = self._get_checkout_format()
1317
1382
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1359
1424
    def supports_tags(self):
1360
1425
        return self._format.supports_tags()
1361
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
 
1362
1439
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1363
1440
                                         other_branch):
1364
1441
        """Ensure that revision_b is a descendant of revision_a.
1428
1505
        return not (self == other)
1429
1506
 
1430
1507
    @classmethod
1431
 
    def find_format(klass, a_bzrdir):
 
1508
    def find_format(klass, a_bzrdir, name=None):
1432
1509
        """Return the format for the branch object in a_bzrdir."""
1433
1510
        try:
1434
 
            transport = a_bzrdir.get_branch_transport(None)
1435
 
            format_string = transport.get("format").read()
 
1511
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
1512
            format_string = transport.get_bytes("format")
1436
1513
            return klass._formats[format_string]
1437
1514
        except errors.NoSuchFile:
1438
 
            raise errors.NotBranchError(path=transport.base)
 
1515
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1439
1516
        except KeyError:
1440
1517
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1441
1518
 
1477
1554
        """Return the short format description for this format."""
1478
1555
        raise NotImplementedError(self.get_format_description)
1479
1556
 
1480
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1481
 
                           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):
1482
1567
        """Initialize a branch in a bzrdir, with specified files
1483
1568
 
1484
1569
        :param a_bzrdir: The bzrdir to initialize the branch in
1485
1570
        :param utf8_files: The files to create as a list of
1486
1571
            (filename, content) tuples
 
1572
        :param name: Name of colocated branch to create, if any
1487
1573
        :param set_format: If True, set the format with
1488
1574
            self.get_format_string.  (BzrBranch4 has its format set
1489
1575
            elsewhere)
1490
1576
        :return: a branch in this format
1491
1577
        """
1492
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1493
 
        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)
1494
1580
        lock_map = {
1495
1581
            'metadir': ('lock', lockdir.LockDir),
1496
1582
            'branch4': ('branch-lock', lockable_files.TransportLock),
1517
1603
        finally:
1518
1604
            if lock_taken:
1519
1605
                control_files.unlock()
1520
 
        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
1521
1609
 
1522
 
    def initialize(self, a_bzrdir):
1523
 
        """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
        """
1524
1615
        raise NotImplementedError(self.initialize)
1525
1616
 
1526
1617
    def is_supported(self):
1556
1647
        """
1557
1648
        raise NotImplementedError(self.network_name)
1558
1649
 
1559
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1650
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1560
1651
        """Return the branch object for a_bzrdir
1561
1652
 
1562
1653
        :param a_bzrdir: A BzrDir that contains a branch.
 
1654
        :param name: Name of colocated branch to open
1563
1655
        :param _found: a private parameter, do not use it. It is used to
1564
1656
            indicate if format probing has already be done.
1565
1657
        :param ignore_fallbacks: when set, no fallback branches will be opened
1673
1765
            "multiple hooks installed for transform_fallback_location, "
1674
1766
            "all are called with the url returned from the previous hook."
1675
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
 
1676
1785
 
1677
1786
 
1678
1787
# install the default hooks into the Branch class.
1717
1826
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1718
1827
 
1719
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
 
1720
1907
class BzrBranchFormat4(BranchFormat):
1721
1908
    """Bzr branch format 4.
1722
1909
 
1729
1916
        """See BranchFormat.get_format_description()."""
1730
1917
        return "Branch format 4"
1731
1918
 
1732
 
    def initialize(self, a_bzrdir):
 
1919
    def initialize(self, a_bzrdir, name=None):
1733
1920
        """Create a branch of this format in a_bzrdir."""
1734
1921
        utf8_files = [('revision-history', ''),
1735
1922
                      ('branch-name', ''),
1736
1923
                      ]
1737
 
        return self._initialize_helper(a_bzrdir, utf8_files,
 
1924
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1738
1925
                                       lock_type='branch4', set_format=False)
1739
1926
 
1740
1927
    def __init__(self):
1745
1932
        """The network name for this format is the control dirs disk label."""
1746
1933
        return self._matchingbzrdir.get_format_string()
1747
1934
 
1748
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1935
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1749
1936
        """See BranchFormat.open()."""
1750
1937
        if not _found:
1751
1938
            # we are being called directly and must probe.
1753
1940
        return BzrBranch(_format=self,
1754
1941
                         _control_files=a_bzrdir._control_files,
1755
1942
                         a_bzrdir=a_bzrdir,
 
1943
                         name=name,
1756
1944
                         _repository=a_bzrdir.open_repository())
1757
1945
 
1758
1946
    def __str__(self):
1773
1961
        """
1774
1962
        return self.get_format_string()
1775
1963
 
1776
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1964
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1777
1965
        """See BranchFormat.open()."""
1778
1966
        if not _found:
1779
 
            format = BranchFormat.find_format(a_bzrdir)
 
1967
            format = BranchFormat.find_format(a_bzrdir, name=name)
1780
1968
            if format.__class__ != self.__class__:
1781
1969
                raise AssertionError("wrong format %r found for %r" %
1782
1970
                    (format, self))
 
1971
        transport = a_bzrdir.get_branch_transport(None, name=name)
1783
1972
        try:
1784
 
            transport = a_bzrdir.get_branch_transport(None)
1785
1973
            control_files = lockable_files.LockableFiles(transport, 'lock',
1786
1974
                                                         lockdir.LockDir)
1787
1975
            return self._branch_class()(_format=self,
1788
1976
                              _control_files=control_files,
 
1977
                              name=name,
1789
1978
                              a_bzrdir=a_bzrdir,
1790
1979
                              _repository=a_bzrdir.find_repository(),
1791
1980
                              ignore_fallbacks=ignore_fallbacks)
1792
1981
        except errors.NoSuchFile:
1793
 
            raise errors.NotBranchError(path=transport.base)
 
1982
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1794
1983
 
1795
1984
    def __init__(self):
1796
1985
        super(BranchFormatMetadir, self).__init__()
1825
2014
        """See BranchFormat.get_format_description()."""
1826
2015
        return "Branch format 5"
1827
2016
 
1828
 
    def initialize(self, a_bzrdir):
 
2017
    def initialize(self, a_bzrdir, name=None):
1829
2018
        """Create a branch of this format in a_bzrdir."""
1830
2019
        utf8_files = [('revision-history', ''),
1831
2020
                      ('branch-name', ''),
1832
2021
                      ]
1833
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2022
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1834
2023
 
1835
2024
    def supports_tags(self):
1836
2025
        return False
1858
2047
        """See BranchFormat.get_format_description()."""
1859
2048
        return "Branch format 6"
1860
2049
 
1861
 
    def initialize(self, a_bzrdir):
 
2050
    def initialize(self, a_bzrdir, name=None):
1862
2051
        """Create a branch of this format in a_bzrdir."""
1863
2052
        utf8_files = [('last-revision', '0 null:\n'),
1864
2053
                      ('branch.conf', ''),
1865
2054
                      ('tags', ''),
1866
2055
                      ]
1867
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2056
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1868
2057
 
1869
2058
    def make_tags(self, branch):
1870
2059
        """See bzrlib.branch.BranchFormat.make_tags()."""
1888
2077
        """See BranchFormat.get_format_description()."""
1889
2078
        return "Branch format 8"
1890
2079
 
1891
 
    def initialize(self, a_bzrdir):
 
2080
    def initialize(self, a_bzrdir, name=None):
1892
2081
        """Create a branch of this format in a_bzrdir."""
1893
2082
        utf8_files = [('last-revision', '0 null:\n'),
1894
2083
                      ('branch.conf', ''),
1895
2084
                      ('tags', ''),
1896
2085
                      ('references', '')
1897
2086
                      ]
1898
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2087
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1899
2088
 
1900
2089
    def __init__(self):
1901
2090
        super(BzrBranchFormat8, self).__init__()
1924
2113
    This format was introduced in bzr 1.6.
1925
2114
    """
1926
2115
 
1927
 
    def initialize(self, a_bzrdir):
 
2116
    def initialize(self, a_bzrdir, name=None):
1928
2117
        """Create a branch of this format in a_bzrdir."""
1929
2118
        utf8_files = [('last-revision', '0 null:\n'),
1930
2119
                      ('branch.conf', ''),
1931
2120
                      ('tags', ''),
1932
2121
                      ]
1933
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2122
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1934
2123
 
1935
2124
    def _branch_class(self):
1936
2125
        return BzrBranch7
1971
2160
    def get_reference(self, a_bzrdir):
1972
2161
        """See BranchFormat.get_reference()."""
1973
2162
        transport = a_bzrdir.get_branch_transport(None)
1974
 
        return transport.get('location').read()
 
2163
        return transport.get_bytes('location')
1975
2164
 
1976
2165
    def set_reference(self, a_bzrdir, to_branch):
1977
2166
        """See BranchFormat.set_reference()."""
1978
2167
        transport = a_bzrdir.get_branch_transport(None)
1979
2168
        location = transport.put_bytes('location', to_branch.base)
1980
2169
 
1981
 
    def initialize(self, a_bzrdir, target_branch=None):
 
2170
    def initialize(self, a_bzrdir, name=None, target_branch=None):
1982
2171
        """Create a branch of this format in a_bzrdir."""
1983
2172
        if target_branch is None:
1984
2173
            # this format does not implement branch itself, thus the implicit
1985
2174
            # creation contract must see it as uninitializable
1986
2175
            raise errors.UninitializableFormat(self)
1987
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1988
 
        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)
1989
2178
        branch_transport.put_bytes('location',
1990
 
            target_branch.bzrdir.root_transport.base)
 
2179
            target_branch.bzrdir.user_url)
1991
2180
        branch_transport.put_bytes('format', self.get_format_string())
1992
 
        return self.open(
1993
 
            a_bzrdir, _found=True,
 
2181
        branch = self.open(
 
2182
            a_bzrdir, name, _found=True,
1994
2183
            possible_transports=[target_branch.bzrdir.root_transport])
 
2184
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2185
        return branch
1995
2186
 
1996
2187
    def __init__(self):
1997
2188
        super(BranchReferenceFormat, self).__init__()
2003
2194
        def clone(to_bzrdir, revision_id=None,
2004
2195
            repository_policy=None):
2005
2196
            """See Branch.clone()."""
2006
 
            return format.initialize(to_bzrdir, a_branch)
 
2197
            return format.initialize(to_bzrdir, target_branch=a_branch)
2007
2198
            # cannot obey revision_id limits when cloning a reference ...
2008
2199
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2009
2200
            # emit some sort of warning/error to the caller ?!
2010
2201
        return clone
2011
2202
 
2012
 
    def open(self, a_bzrdir, _found=False, location=None,
 
2203
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2013
2204
             possible_transports=None, ignore_fallbacks=False):
2014
2205
        """Return the branch that the branch reference in a_bzrdir points at.
2015
2206
 
2016
2207
        :param a_bzrdir: A BzrDir that contains a branch.
 
2208
        :param name: Name of colocated branch to open, if any
2017
2209
        :param _found: a private parameter, do not use it. It is used to
2018
2210
            indicate if format probing has already be done.
2019
2211
        :param ignore_fallbacks: when set, no fallback branches will be opened
2024
2216
        :param possible_transports: An optional reusable transports list.
2025
2217
        """
2026
2218
        if not _found:
2027
 
            format = BranchFormat.find_format(a_bzrdir)
 
2219
            format = BranchFormat.find_format(a_bzrdir, name=name)
2028
2220
            if format.__class__ != self.__class__:
2029
2221
                raise AssertionError("wrong format %r found for %r" %
2030
2222
                    (format, self))
2032
2224
            location = self.get_reference(a_bzrdir)
2033
2225
        real_bzrdir = bzrdir.BzrDir.open(
2034
2226
            location, possible_transports=possible_transports)
2035
 
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2227
        result = real_bzrdir.open_branch(name=name, 
 
2228
            ignore_fallbacks=ignore_fallbacks)
2036
2229
        # this changes the behaviour of result.clone to create a new reference
2037
2230
        # rather than a copy of the content of the branch.
2038
2231
        # I did not use a proxy object because that needs much more extensive
2072
2265
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2073
2266
 
2074
2267
 
2075
 
class BzrBranch(Branch):
 
2268
class BzrBranch(Branch, _RelockDebugMixin):
2076
2269
    """A branch stored in the actual filesystem.
2077
2270
 
2078
2271
    Note that it's "local" in the context of the filesystem; it doesn't
2084
2277
    :ivar repository: Repository for this branch.
2085
2278
    :ivar base: The url of the base directory for this branch; the one
2086
2279
        containing the .bzr directory.
 
2280
    :ivar name: Optional colocated branch name as it exists in the control
 
2281
        directory.
2087
2282
    """
2088
2283
 
2089
2284
    def __init__(self, _format=None,
2090
 
                 _control_files=None, a_bzrdir=None, _repository=None,
2091
 
                 ignore_fallbacks=False):
 
2285
                 _control_files=None, a_bzrdir=None, name=None,
 
2286
                 _repository=None, ignore_fallbacks=False):
2092
2287
        """Create new branch object at a particular location."""
2093
2288
        if a_bzrdir is None:
2094
2289
            raise ValueError('a_bzrdir must be supplied')
2095
2290
        else:
2096
2291
            self.bzrdir = a_bzrdir
2097
2292
        self._base = self.bzrdir.transport.clone('..').base
 
2293
        self.name = name
2098
2294
        # XXX: We should be able to just do
2099
2295
        #   self.base = self.bzrdir.root_transport.base
2100
2296
        # but this does not quite work yet -- mbp 20080522
2107
2303
        Branch.__init__(self)
2108
2304
 
2109
2305
    def __str__(self):
2110
 
        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)
2111
2311
 
2112
2312
    __repr__ = __str__
2113
2313
 
2124
2324
        return self.control_files.is_locked()
2125
2325
 
2126
2326
    def lock_write(self, token=None):
 
2327
        if not self.is_locked():
 
2328
            self._note_lock('w')
2127
2329
        # All-in-one needs to always unlock/lock.
2128
2330
        repo_control = getattr(self.repository, 'control_files', None)
2129
2331
        if self.control_files == repo_control or not self.is_locked():
 
2332
            self.repository._warn_if_deprecated(self)
2130
2333
            self.repository.lock_write()
2131
2334
            took_lock = True
2132
2335
        else:
2139
2342
            raise
2140
2343
 
2141
2344
    def lock_read(self):
 
2345
        if not self.is_locked():
 
2346
            self._note_lock('r')
2142
2347
        # All-in-one needs to always unlock/lock.
2143
2348
        repo_control = getattr(self.repository, 'control_files', None)
2144
2349
        if self.control_files == repo_control or not self.is_locked():
 
2350
            self.repository._warn_if_deprecated(self)
2145
2351
            self.repository.lock_read()
2146
2352
            took_lock = True
2147
2353
        else:
2153
2359
                self.repository.unlock()
2154
2360
            raise
2155
2361
 
 
2362
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2156
2363
    def unlock(self):
2157
2364
        try:
2158
2365
            self.control_files.unlock()
2321
2528
        return result
2322
2529
 
2323
2530
    def get_stacked_on_url(self):
2324
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2531
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2325
2532
 
2326
2533
    def set_push_location(self, location):
2327
2534
        """See Branch.set_push_location."""
2517
2724
        if _mod_revision.is_null(last_revision):
2518
2725
            return
2519
2726
        if last_revision not in self._lefthand_history(revision_id):
2520
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2727
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2521
2728
 
2522
2729
    def _gen_revision_history(self):
2523
2730
        """Generate the revision history from last revision
2623
2830
        if branch_location is None:
2624
2831
            return Branch.reference_parent(self, file_id, path,
2625
2832
                                           possible_transports)
2626
 
        branch_location = urlutils.join(self.base, branch_location)
 
2833
        branch_location = urlutils.join(self.user_url, branch_location)
2627
2834
        return Branch.open(branch_location,
2628
2835
                           possible_transports=possible_transports)
2629
2836
 
2675
2882
        return stacked_url
2676
2883
 
2677
2884
    def _get_append_revisions_only(self):
2678
 
        value = self.get_config().get_user_option('append_revisions_only')
2679
 
        return value == 'True'
 
2885
        return self.get_config(
 
2886
            ).get_user_option_as_bool('append_revisions_only')
2680
2887
 
2681
2888
    @needs_write_lock
2682
2889
    def generate_revision_history(self, revision_id, last_rev=None,
2744
2951
    """
2745
2952
 
2746
2953
    def get_stacked_on_url(self):
2747
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2954
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2748
2955
 
2749
2956
 
2750
2957
######################################################################
2837
3044
        :param verbose: Requests more detailed display of what was checked,
2838
3045
            if any.
2839
3046
        """
2840
 
        note('checked branch %s format %s', self.branch.base,
 
3047
        note('checked branch %s format %s', self.branch.user_url,
2841
3048
            self.branch._format)
2842
3049
        for error in self.errors:
2843
3050
            note('found error:%s', error)
3172
3379
        if local and not bound_location:
3173
3380
            raise errors.LocalRequiresBoundBranch()
3174
3381
        master_branch = None
3175
 
        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:
3176
3383
            # not pulling from master, so we need to update master.
3177
3384
            master_branch = self.target.get_master_branch(possible_transports)
3178
3385
            master_branch.lock_write()