← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: John Arbash Meinel
  • Date: 2010-02-17 17:11:16 UTC
  • mfrom: (4797.2.17 2.1)
  • mto: (4797.2.18 2.1)
  • mto: This revision was merged to the branch mainline in revision 5055.
  • Revision ID: john@arbash-meinel.com-20100217171116-h7t9223ystbnx5h8
merge bzr.2.1 in preparation for NEWS entry.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/branch.py
25
25
        bzrdir,
26
26
        cache_utf8,
27
27
        config as _mod_config,
28
 
        controldir,
29
28
        debug,
30
29
        errors,
31
30
        lockdir,
32
31
        lockable_files,
33
 
        remote,
34
32
        repository,
35
33
        revision as _mod_revision,
36
34
        rio,
51
49
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
52
50
from bzrlib.hooks import HookPoint, Hooks
53
51
from bzrlib.inter import InterObject
54
 
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
 
52
from bzrlib.lock import _RelockDebugMixin
55
53
from bzrlib import registry
56
54
from bzrlib.symbol_versioning import (
57
55
    deprecated_in,
65
63
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
66
64
 
67
65
 
68
 
class Branch(controldir.ControlComponent):
 
66
# TODO: Maybe include checks for common corruption of newlines, etc?
 
67
 
 
68
# TODO: Some operations like log might retrieve the same revisions
 
69
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
70
# cache in memory to make this faster.  In general anything can be
 
71
# cached in memory between lock and unlock operations. .. nb thats
 
72
# what the transaction identity map provides
 
73
 
 
74
 
 
75
######################################################################
 
76
# branch objects
 
77
 
 
78
class Branch(object):
69
79
    """Branch holding a history of revisions.
70
80
 
71
 
    :ivar base:
72
 
        Base directory/url of the branch; using control_url and
73
 
        control_transport is more standardized.
 
81
    base
 
82
        Base directory/url of the branch.
74
83
 
75
84
    hooks: An instance of BranchHooks.
76
85
    """
78
87
    # - RBC 20060112
79
88
    base = None
80
89
 
81
 
    @property
82
 
    def control_transport(self):
83
 
        return self._transport
84
 
 
85
 
    @property
86
 
    def user_transport(self):
87
 
        return self.bzrdir.user_transport
88
 
 
89
90
    def __init__(self, *ignored, **ignored_too):
90
91
        self.tags = self._format.make_tags(self)
91
92
        self._revision_history_cache = None
106
107
        """Activate the branch/repository from url as a fallback repository."""
107
108
        repo = self._get_fallback_repository(url)
108
109
        if repo.has_same_location(self.repository):
109
 
            raise errors.UnstackableLocationError(self.user_url, url)
 
110
            raise errors.UnstackableLocationError(self.base, url)
110
111
        self.repository.add_fallback_repository(repo)
111
112
 
112
113
    def break_lock(self):
166
167
        """
167
168
        control = bzrdir.BzrDir.open(base, _unsupported,
168
169
                                     possible_transports=possible_transports)
169
 
        return control.open_branch(unsupported=_unsupported)
 
170
        return control.open_branch(_unsupported)
170
171
 
171
172
    @staticmethod
172
 
    def open_from_transport(transport, name=None, _unsupported=False):
 
173
    def open_from_transport(transport, _unsupported=False):
173
174
        """Open the branch rooted at transport"""
174
175
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
175
 
        return control.open_branch(name=name, unsupported=_unsupported)
 
176
        return control.open_branch(_unsupported)
176
177
 
177
178
    @staticmethod
178
179
    def open_containing(url, possible_transports=None):
199
200
        return self.supports_tags() and self.tags.get_tag_dict()
200
201
 
201
202
    def get_config(self):
202
 
        """Get a bzrlib.config.BranchConfig for this Branch.
203
 
 
204
 
        This can then be used to get and set configuration options for the
205
 
        branch.
206
 
 
207
 
        :return: A bzrlib.config.BranchConfig.
208
 
        """
209
203
        return BranchConfig(self)
210
204
 
211
205
    def _get_config(self):
223
217
    def _get_fallback_repository(self, url):
224
218
        """Get the repository we fallback to at url."""
225
219
        url = urlutils.join(self.base, url)
226
 
        a_branch = Branch.open(url,
 
220
        a_bzrdir = bzrdir.BzrDir.open(url,
227
221
            possible_transports=[self.bzrdir.root_transport])
228
 
        return a_branch.repository
 
222
        return a_bzrdir.open_branch().repository
229
223
 
230
224
    def _get_tags_bytes(self):
231
225
        """Get the bytes of a serialised tags dict.
247
241
        if not local and not config.has_explicit_nickname():
248
242
            try:
249
243
                master = self.get_master_branch(possible_transports)
250
 
                if master and self.user_url == master.user_url:
251
 
                    raise errors.RecursiveBind(self.user_url)
252
244
                if master is not None:
253
245
                    # return the master branch value
254
246
                    return master.nick
255
 
            except errors.RecursiveBind, e:
256
 
                raise e
257
247
            except errors.BzrError, e:
258
248
                # Silently fall back to local implicit nick if the master is
259
249
                # unavailable
296
286
        new_history.reverse()
297
287
        return new_history
298
288
 
299
 
    def lock_write(self, token=None):
300
 
        """Lock the branch for write operations.
301
 
 
302
 
        :param token: A token to permit reacquiring a previously held and
303
 
            preserved lock.
304
 
        :return: A BranchWriteLockResult.
305
 
        """
 
289
    def lock_write(self):
306
290
        raise NotImplementedError(self.lock_write)
307
291
 
308
292
    def lock_read(self):
309
 
        """Lock the branch for read operations.
310
 
 
311
 
        :return: A bzrlib.lock.LogicalLockResult.
312
 
        """
313
293
        raise NotImplementedError(self.lock_read)
314
294
 
315
295
    def unlock(self):
440
420
            * 'include' - the stop revision is the last item in the result
441
421
            * 'with-merges' - include the stop revision and all of its
442
422
              merged revisions in the result
443
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
444
 
              that are in both ancestries
445
423
        :param direction: either 'reverse' or 'forward':
446
424
            * reverse means return the start_revision_id first, i.e.
447
425
              start at the most recent revision and go backwards in history
469
447
        # start_revision_id.
470
448
        if self._merge_sorted_revisions_cache is None:
471
449
            last_revision = self.last_revision()
472
 
            known_graph = self.repository.get_known_graph_ancestry(
473
 
                [last_revision])
 
450
            last_key = (last_revision,)
 
451
            known_graph = self.repository.revisions.get_known_graph_ancestry(
 
452
                [last_key])
474
453
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
475
 
                last_revision)
 
454
                last_key)
476
455
        filtered = self._filter_merge_sorted_revisions(
477
456
            self._merge_sorted_revisions_cache, start_revision_id,
478
457
            stop_revision_id, stop_rule)
479
 
        # Make sure we don't return revisions that are not part of the
480
 
        # start_revision_id ancestry.
481
 
        filtered = self._filter_start_non_ancestors(filtered)
482
458
        if direction == 'reverse':
483
459
            return filtered
484
460
        if direction == 'forward':
521
497
                       node.end_of_merge)
522
498
                if rev_id == stop_revision_id:
523
499
                    return
524
 
        elif stop_rule == 'with-merges-without-common-ancestry':
525
 
            # We want to exclude all revisions that are already part of the
526
 
            # stop_revision_id ancestry.
527
 
            graph = self.repository.get_graph()
528
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
529
 
                                                    [stop_revision_id])
530
 
            for node in rev_iter:
531
 
                rev_id = node.key[-1]
532
 
                if rev_id not in ancestors:
533
 
                    continue
534
 
                yield (rev_id, node.merge_depth, node.revno,
535
 
                       node.end_of_merge)
536
500
        elif stop_rule == 'with-merges':
537
501
            stop_rev = self.repository.get_revision(stop_revision_id)
538
502
            if stop_rev.parent_ids:
561
525
        else:
562
526
            raise ValueError('invalid stop_rule %r' % stop_rule)
563
527
 
564
 
    def _filter_start_non_ancestors(self, rev_iter):
565
 
        # If we started from a dotted revno, we want to consider it as a tip
566
 
        # and don't want to yield revisions that are not part of its
567
 
        # ancestry. Given the order guaranteed by the merge sort, we will see
568
 
        # uninteresting descendants of the first parent of our tip before the
569
 
        # tip itself.
570
 
        first = rev_iter.next()
571
 
        (rev_id, merge_depth, revno, end_of_merge) = first
572
 
        yield first
573
 
        if not merge_depth:
574
 
            # We start at a mainline revision so by definition, all others
575
 
            # revisions in rev_iter are ancestors
576
 
            for node in rev_iter:
577
 
                yield node
578
 
 
579
 
        clean = False
580
 
        whitelist = set()
581
 
        pmap = self.repository.get_parent_map([rev_id])
582
 
        parents = pmap.get(rev_id, [])
583
 
        if parents:
584
 
            whitelist.update(parents)
585
 
        else:
586
 
            # If there is no parents, there is nothing of interest left
587
 
 
588
 
            # FIXME: It's hard to test this scenario here as this code is never
589
 
            # called in that case. -- vila 20100322
590
 
            return
591
 
 
592
 
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
593
 
            if not clean:
594
 
                if rev_id in whitelist:
595
 
                    pmap = self.repository.get_parent_map([rev_id])
596
 
                    parents = pmap.get(rev_id, [])
597
 
                    whitelist.remove(rev_id)
598
 
                    whitelist.update(parents)
599
 
                    if merge_depth == 0:
600
 
                        # We've reached the mainline, there is nothing left to
601
 
                        # filter
602
 
                        clean = True
603
 
                else:
604
 
                    # A revision that is not part of the ancestry of our
605
 
                    # starting revision.
606
 
                    continue
607
 
            yield (rev_id, merge_depth, revno, end_of_merge)
608
 
 
609
528
    def leave_lock_in_place(self):
610
529
        """Tell this branch object not to release the physical lock when this
611
530
        object is unlocked.
628
547
        :param other: The branch to bind to
629
548
        :type other: Branch
630
549
        """
631
 
        raise errors.UpgradeRequired(self.user_url)
 
550
        raise errors.UpgradeRequired(self.base)
632
551
 
633
552
    def set_append_revisions_only(self, enabled):
634
553
        if not self._format.supports_set_append_revisions_only():
635
 
            raise errors.UpgradeRequired(self.user_url)
 
554
            raise errors.UpgradeRequired(self.base)
636
555
        if enabled:
637
556
            value = 'True'
638
557
        else:
686
605
    def get_old_bound_location(self):
687
606
        """Return the URL of the branch we used to be bound to
688
607
        """
689
 
        raise errors.UpgradeRequired(self.user_url)
 
608
        raise errors.UpgradeRequired(self.base)
690
609
 
691
610
    def get_commit_builder(self, parents, config=None, timestamp=None,
692
611
                           timezone=None, committer=None, revprops=None,
770
689
            stacking.
771
690
        """
772
691
        if not self._format.supports_stacking():
773
 
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
692
            raise errors.UnstackableBranchFormat(self._format, self.base)
774
693
        # XXX: Changing from one fallback repository to another does not check
775
694
        # that all the data you need is present in the new fallback.
776
695
        # Possibly it should.
806
725
            if len(old_repository._fallback_repositories) != 1:
807
726
                raise AssertionError("can't cope with fallback repositories "
808
727
                    "of %r" % (self.repository,))
809
 
            # Open the new repository object.
810
 
            # Repositories don't offer an interface to remove fallback
811
 
            # repositories today; take the conceptually simpler option and just
812
 
            # reopen it.  We reopen it starting from the URL so that we
813
 
            # get a separate connection for RemoteRepositories and can
814
 
            # stream from one of them to the other.  This does mean doing
815
 
            # separate SSH connection setup, but unstacking is not a
816
 
            # common operation so it's tolerable.
817
 
            new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
818
 
            new_repository = new_bzrdir.find_repository()
819
 
            if new_repository._fallback_repositories:
820
 
                raise AssertionError("didn't expect %r to have "
821
 
                    "fallback_repositories"
822
 
                    % (self.repository,))
823
 
            # Replace self.repository with the new repository.
824
 
            # Do our best to transfer the lock state (i.e. lock-tokens and
825
 
            # lock count) of self.repository to the new repository.
826
 
            lock_token = old_repository.lock_write().repository_token
827
 
            self.repository = new_repository
828
 
            if isinstance(self, remote.RemoteBranch):
829
 
                # Remote branches can have a second reference to the old
830
 
                # repository that need to be replaced.
831
 
                if self._real_branch is not None:
832
 
                    self._real_branch.repository = new_repository
833
 
            self.repository.lock_write(token=lock_token)
834
 
            if lock_token is not None:
835
 
                old_repository.leave_lock_in_place()
 
728
            # unlock it, including unlocking the fallback
836
729
            old_repository.unlock()
837
 
            if lock_token is not None:
838
 
                # XXX: self.repository.leave_lock_in_place() before this
839
 
                # function will not be preserved.  Fortunately that doesn't
840
 
                # affect the current default format (2a), and would be a
841
 
                # corner-case anyway.
842
 
                #  - Andrew Bennetts, 2010/06/30
843
 
                self.repository.dont_leave_lock_in_place()
844
 
            old_lock_count = 0
845
 
            while True:
846
 
                try:
847
 
                    old_repository.unlock()
848
 
                except errors.LockNotHeld:
849
 
                    break
850
 
                old_lock_count += 1
851
 
            if old_lock_count == 0:
852
 
                raise AssertionError(
853
 
                    'old_repository should have been locked at least once.')
854
 
            for i in range(old_lock_count-1):
 
730
            old_repository.lock_read()
 
731
            try:
 
732
                # Repositories don't offer an interface to remove fallback
 
733
                # repositories today; take the conceptually simpler option and just
 
734
                # reopen it.  We reopen it starting from the URL so that we
 
735
                # get a separate connection for RemoteRepositories and can
 
736
                # stream from one of them to the other.  This does mean doing
 
737
                # separate SSH connection setup, but unstacking is not a
 
738
                # common operation so it's tolerable.
 
739
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
 
740
                new_repository = new_bzrdir.find_repository()
 
741
                self.repository = new_repository
 
742
                if self.repository._fallback_repositories:
 
743
                    raise AssertionError("didn't expect %r to have "
 
744
                        "fallback_repositories"
 
745
                        % (self.repository,))
 
746
                # this is not paired with an unlock because it's just restoring
 
747
                # the previous state; the lock's released when set_stacked_on_url
 
748
                # returns
855
749
                self.repository.lock_write()
856
 
            # Fetch from the old repository into the new.
857
 
            old_repository.lock_read()
858
 
            try:
859
750
                # XXX: If you unstack a branch while it has a working tree
860
751
                # with a pending merge, the pending-merged revisions will no
861
752
                # longer be present.  You can (probably) revert and remerge.
955
846
 
956
847
    def unbind(self):
957
848
        """Older format branches cannot bind or unbind."""
958
 
        raise errors.UpgradeRequired(self.user_url)
 
849
        raise errors.UpgradeRequired(self.base)
959
850
 
960
851
    def last_revision(self):
961
852
        """Return last revision id, or NULL_REVISION."""
1002
893
                raise errors.NoSuchRevision(self, stop_revision)
1003
894
        return other_history[self_len:stop_revision]
1004
895
 
 
896
    @needs_write_lock
1005
897
    def update_revisions(self, other, stop_revision=None, overwrite=False,
1006
898
                         graph=None):
1007
899
        """Pull in new perfect-fit revisions.
1056
948
            self._extend_partial_history(distance_from_last)
1057
949
        return self._partial_revision_history_cache[distance_from_last]
1058
950
 
 
951
    @needs_write_lock
1059
952
    def pull(self, source, overwrite=False, stop_revision=None,
1060
953
             possible_transports=None, *args, **kwargs):
1061
954
        """Mirror source into this branch.
1119
1012
        try:
1120
1013
            return urlutils.join(self.base[:-1], parent)
1121
1014
        except errors.InvalidURLJoin, e:
1122
 
            raise errors.InaccessibleParent(parent, self.user_url)
 
1015
            raise errors.InaccessibleParent(parent, self.base)
1123
1016
 
1124
1017
    def _get_parent_location(self):
1125
1018
        raise NotImplementedError(self._get_parent_location)
1304
1197
                revno = 1
1305
1198
        destination.set_last_revision_info(revno, revision_id)
1306
1199
 
 
1200
    @needs_read_lock
1307
1201
    def copy_content_into(self, destination, revision_id=None):
1308
1202
        """Copy the content of self into destination.
1309
1203
 
1310
1204
        revision_id: if not None, the revision history in the new branch will
1311
1205
                     be truncated to end with revision_id.
1312
1206
        """
1313
 
        return InterBranch.get(self, destination).copy_content_into(
1314
 
            revision_id=revision_id)
 
1207
        self.update_references(destination)
 
1208
        self._synchronize_history(destination, revision_id)
 
1209
        try:
 
1210
            parent = self.get_parent()
 
1211
        except errors.InaccessibleParent, e:
 
1212
            mutter('parent was not accessible to copy: %s', e)
 
1213
        else:
 
1214
            if parent:
 
1215
                destination.set_parent(parent)
 
1216
        if self._push_should_merge_tags():
 
1217
            self.tags.merge_to(destination.tags)
1315
1218
 
1316
1219
    def update_references(self, target):
1317
1220
        if not getattr(self._format, 'supports_reference_locations', False):
1385
1288
        """
1386
1289
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1387
1290
        # clone call. Or something. 20090224 RBC/spiv.
1388
 
        # XXX: Should this perhaps clone colocated branches as well, 
1389
 
        # rather than just the default branch? 20100319 JRV
1390
1291
        if revision_id is None:
1391
1292
            revision_id = self.last_revision()
1392
1293
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1416
1317
        if lightweight:
1417
1318
            format = self._get_checkout_format()
1418
1319
            checkout = format.initialize_on_transport(t)
1419
 
            from_branch = BranchReferenceFormat().initialize(checkout, 
1420
 
                target_branch=self)
 
1320
            from_branch = BranchReferenceFormat().initialize(checkout, self)
1421
1321
        else:
1422
1322
            format = self._get_checkout_format()
1423
1323
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1465
1365
    def supports_tags(self):
1466
1366
        return self._format.supports_tags()
1467
1367
 
1468
 
    def automatic_tag_name(self, revision_id):
1469
 
        """Try to automatically find the tag name for a revision.
1470
 
 
1471
 
        :param revision_id: Revision id of the revision.
1472
 
        :return: A tag name or None if no tag name could be determined.
1473
 
        """
1474
 
        for hook in Branch.hooks['automatic_tag_name']:
1475
 
            ret = hook(self, revision_id)
1476
 
            if ret is not None:
1477
 
                return ret
1478
 
        return None
1479
 
 
1480
1368
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1481
1369
                                         other_branch):
1482
1370
        """Ensure that revision_b is a descendant of revision_a.
1546
1434
        return not (self == other)
1547
1435
 
1548
1436
    @classmethod
1549
 
    def find_format(klass, a_bzrdir, name=None):
 
1437
    def find_format(klass, a_bzrdir):
1550
1438
        """Return the format for the branch object in a_bzrdir."""
1551
1439
        try:
1552
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
1440
            transport = a_bzrdir.get_branch_transport(None)
1553
1441
            format_string = transport.get_bytes("format")
1554
 
            format = klass._formats[format_string]
1555
 
            if isinstance(format, MetaDirBranchFormatFactory):
1556
 
                return format()
1557
 
            return format
 
1442
            return klass._formats[format_string]
1558
1443
        except errors.NoSuchFile:
1559
1444
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1560
1445
        except KeyError:
1565
1450
        """Return the current default format."""
1566
1451
        return klass._default_format
1567
1452
 
1568
 
    @classmethod
1569
 
    def get_formats(klass):
1570
 
        """Get all the known formats.
1571
 
 
1572
 
        Warning: This triggers a load of all lazy registered formats: do not
1573
 
        use except when that is desireed.
1574
 
        """
1575
 
        result = []
1576
 
        for fmt in klass._formats.values():
1577
 
            if isinstance(fmt, MetaDirBranchFormatFactory):
1578
 
                fmt = fmt()
1579
 
            result.append(fmt)
1580
 
        return result
1581
 
 
1582
 
    def get_reference(self, a_bzrdir, name=None):
 
1453
    def get_reference(self, a_bzrdir):
1583
1454
        """Get the target reference of the branch in a_bzrdir.
1584
1455
 
1585
1456
        format probing must have been completed before calling
1587
1458
        in a_bzrdir is correct.
1588
1459
 
1589
1460
        :param a_bzrdir: The bzrdir to get the branch data from.
1590
 
        :param name: Name of the colocated branch to fetch
1591
1461
        :return: None if the branch is not a reference branch.
1592
1462
        """
1593
1463
        return None
1594
1464
 
1595
1465
    @classmethod
1596
 
    def set_reference(self, a_bzrdir, name, to_branch):
 
1466
    def set_reference(self, a_bzrdir, to_branch):
1597
1467
        """Set the target reference of the branch in a_bzrdir.
1598
1468
 
1599
1469
        format probing must have been completed before calling
1601
1471
        in a_bzrdir is correct.
1602
1472
 
1603
1473
        :param a_bzrdir: The bzrdir to set the branch reference for.
1604
 
        :param name: Name of colocated branch to set, None for default
1605
1474
        :param to_branch: branch that the checkout is to reference
1606
1475
        """
1607
1476
        raise NotImplementedError(self.set_reference)
1614
1483
        """Return the short format description for this format."""
1615
1484
        raise NotImplementedError(self.get_format_description)
1616
1485
 
1617
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1618
 
        hooks = Branch.hooks['post_branch_init']
1619
 
        if not hooks:
1620
 
            return
1621
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1622
 
        for hook in hooks:
1623
 
            hook(params)
1624
 
 
1625
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1626
 
                           lock_type='metadir', set_format=True):
 
1486
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
1487
                           set_format=True):
1627
1488
        """Initialize a branch in a bzrdir, with specified files
1628
1489
 
1629
1490
        :param a_bzrdir: The bzrdir to initialize the branch in
1630
1491
        :param utf8_files: The files to create as a list of
1631
1492
            (filename, content) tuples
1632
 
        :param name: Name of colocated branch to create, if any
1633
1493
        :param set_format: If True, set the format with
1634
1494
            self.get_format_string.  (BzrBranch4 has its format set
1635
1495
            elsewhere)
1636
1496
        :return: a branch in this format
1637
1497
        """
1638
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1639
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
1498
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
1499
        branch_transport = a_bzrdir.get_branch_transport(self)
1640
1500
        lock_map = {
1641
1501
            'metadir': ('lock', lockdir.LockDir),
1642
1502
            'branch4': ('branch-lock', lockable_files.TransportLock),
1663
1523
        finally:
1664
1524
            if lock_taken:
1665
1525
                control_files.unlock()
1666
 
        branch = self.open(a_bzrdir, name, _found=True)
1667
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1668
 
        return branch
 
1526
        return self.open(a_bzrdir, _found=True)
1669
1527
 
1670
 
    def initialize(self, a_bzrdir, name=None):
1671
 
        """Create a branch of this format in a_bzrdir.
1672
 
        
1673
 
        :param name: Name of the colocated branch to create.
1674
 
        """
 
1528
    def initialize(self, a_bzrdir):
 
1529
        """Create a branch of this format in a_bzrdir."""
1675
1530
        raise NotImplementedError(self.initialize)
1676
1531
 
1677
1532
    def is_supported(self):
1707
1562
        """
1708
1563
        raise NotImplementedError(self.network_name)
1709
1564
 
1710
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1565
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
1711
1566
        """Return the branch object for a_bzrdir
1712
1567
 
1713
1568
        :param a_bzrdir: A BzrDir that contains a branch.
1714
 
        :param name: Name of colocated branch to open
1715
1569
        :param _found: a private parameter, do not use it. It is used to
1716
1570
            indicate if format probing has already be done.
1717
1571
        :param ignore_fallbacks: when set, no fallback branches will be opened
1721
1575
 
1722
1576
    @classmethod
1723
1577
    def register_format(klass, format):
1724
 
        """Register a metadir format.
1725
 
        
1726
 
        See MetaDirBranchFormatFactory for the ability to register a format
1727
 
        without loading the code the format needs until it is actually used.
1728
 
        """
 
1578
        """Register a metadir format."""
1729
1579
        klass._formats[format.get_format_string()] = format
1730
1580
        # Metadir formats have a network name of their format string, and get
1731
 
        # registered as factories.
1732
 
        if isinstance(format, MetaDirBranchFormatFactory):
1733
 
            network_format_registry.register(format.get_format_string(), format)
1734
 
        else:
1735
 
            network_format_registry.register(format.get_format_string(),
1736
 
                format.__class__)
 
1581
        # registered as class factories.
 
1582
        network_format_registry.register(format.get_format_string(), format.__class__)
1737
1583
 
1738
1584
    @classmethod
1739
1585
    def set_default_format(klass, format):
1759
1605
        return False  # by default
1760
1606
 
1761
1607
 
1762
 
class MetaDirBranchFormatFactory(registry._LazyObjectGetter):
1763
 
    """A factory for a BranchFormat object, permitting simple lazy registration.
1764
 
    
1765
 
    While none of the built in BranchFormats are lazy registered yet,
1766
 
    bzrlib.tests.test_branch.TestMetaDirBranchFormatFactory demonstrates how to
1767
 
    use it, and the bzr-loom plugin uses it as well (see
1768
 
    bzrlib.plugins.loom.formats).
1769
 
    """
1770
 
 
1771
 
    def __init__(self, format_string, module_name, member_name):
1772
 
        """Create a MetaDirBranchFormatFactory.
1773
 
 
1774
 
        :param format_string: The format string the format has.
1775
 
        :param module_name: Module to load the format class from.
1776
 
        :param member_name: Attribute name within the module for the format class.
1777
 
        """
1778
 
        registry._LazyObjectGetter.__init__(self, module_name, member_name)
1779
 
        self._format_string = format_string
1780
 
        
1781
 
    def get_format_string(self):
1782
 
        """See BranchFormat.get_format_string."""
1783
 
        return self._format_string
1784
 
 
1785
 
    def __call__(self):
1786
 
        """Used for network_format_registry support."""
1787
 
        return self.get_obj()()
1788
 
 
1789
 
 
1790
1608
class BranchHooks(Hooks):
1791
1609
    """A dictionary mapping hook name to a list of callables for branch hooks.
1792
1610
 
1861
1679
            "multiple hooks installed for transform_fallback_location, "
1862
1680
            "all are called with the url returned from the previous hook."
1863
1681
            "The order is however undefined.", (1, 9), None))
1864
 
        self.create_hook(HookPoint('automatic_tag_name',
1865
 
            "Called to determine an automatic tag name for a revision. "
1866
 
            "automatic_tag_name is called with (branch, revision_id) and "
1867
 
            "should return a tag name or None if no tag name could be "
1868
 
            "determined. The first non-None tag name returned will be used.",
1869
 
            (2, 2), None))
1870
 
        self.create_hook(HookPoint('post_branch_init',
1871
 
            "Called after new branch initialization completes. "
1872
 
            "post_branch_init is called with a "
1873
 
            "bzrlib.branch.BranchInitHookParams. "
1874
 
            "Note that init, branch and checkout (both heavyweight and "
1875
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1876
 
        self.create_hook(HookPoint('post_switch',
1877
 
            "Called after a checkout switches branch. "
1878
 
            "post_switch is called with a "
1879
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1880
 
 
1881
1682
 
1882
1683
 
1883
1684
# install the default hooks into the Branch class.
1922
1723
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1923
1724
 
1924
1725
 
1925
 
class BranchInitHookParams(object):
1926
 
    """Object holding parameters passed to *_branch_init hooks.
1927
 
 
1928
 
    There are 4 fields that hooks may wish to access:
1929
 
 
1930
 
    :ivar format: the branch format
1931
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1932
 
    :ivar name: name of colocated branch, if any (or None)
1933
 
    :ivar branch: the branch created
1934
 
 
1935
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1936
 
    the checkout, hence they are different from the corresponding fields in
1937
 
    branch, which refer to the original branch.
1938
 
    """
1939
 
 
1940
 
    def __init__(self, format, a_bzrdir, name, branch):
1941
 
        """Create a group of BranchInitHook parameters.
1942
 
 
1943
 
        :param format: the branch format
1944
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
1945
 
            initialized
1946
 
        :param name: name of colocated branch, if any (or None)
1947
 
        :param branch: the branch created
1948
 
 
1949
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1950
 
        to the checkout, hence they are different from the corresponding fields
1951
 
        in branch, which refer to the original branch.
1952
 
        """
1953
 
        self.format = format
1954
 
        self.bzrdir = a_bzrdir
1955
 
        self.name = name
1956
 
        self.branch = branch
1957
 
 
1958
 
    def __eq__(self, other):
1959
 
        return self.__dict__ == other.__dict__
1960
 
 
1961
 
    def __repr__(self):
1962
 
        return "<%s of %s>" % (self.__class__.__name__, self.branch)
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
 
 
1998
1726
class BzrBranchFormat4(BranchFormat):
1999
1727
    """Bzr branch format 4.
2000
1728
 
2007
1735
        """See BranchFormat.get_format_description()."""
2008
1736
        return "Branch format 4"
2009
1737
 
2010
 
    def initialize(self, a_bzrdir, name=None):
 
1738
    def initialize(self, a_bzrdir):
2011
1739
        """Create a branch of this format in a_bzrdir."""
2012
1740
        utf8_files = [('revision-history', ''),
2013
1741
                      ('branch-name', ''),
2014
1742
                      ]
2015
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
 
1743
        return self._initialize_helper(a_bzrdir, utf8_files,
2016
1744
                                       lock_type='branch4', set_format=False)
2017
1745
 
2018
1746
    def __init__(self):
2023
1751
        """The network name for this format is the control dirs disk label."""
2024
1752
        return self._matchingbzrdir.get_format_string()
2025
1753
 
2026
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1754
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
2027
1755
        """See BranchFormat.open()."""
2028
1756
        if not _found:
2029
1757
            # we are being called directly and must probe.
2031
1759
        return BzrBranch(_format=self,
2032
1760
                         _control_files=a_bzrdir._control_files,
2033
1761
                         a_bzrdir=a_bzrdir,
2034
 
                         name=name,
2035
1762
                         _repository=a_bzrdir.open_repository())
2036
1763
 
2037
1764
    def __str__(self):
2052
1779
        """
2053
1780
        return self.get_format_string()
2054
1781
 
2055
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1782
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
2056
1783
        """See BranchFormat.open()."""
2057
1784
        if not _found:
2058
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
1785
            format = BranchFormat.find_format(a_bzrdir)
2059
1786
            if format.__class__ != self.__class__:
2060
1787
                raise AssertionError("wrong format %r found for %r" %
2061
1788
                    (format, self))
2062
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
2063
1789
        try:
 
1790
            transport = a_bzrdir.get_branch_transport(None)
2064
1791
            control_files = lockable_files.LockableFiles(transport, 'lock',
2065
1792
                                                         lockdir.LockDir)
2066
1793
            return self._branch_class()(_format=self,
2067
1794
                              _control_files=control_files,
2068
 
                              name=name,
2069
1795
                              a_bzrdir=a_bzrdir,
2070
1796
                              _repository=a_bzrdir.find_repository(),
2071
1797
                              ignore_fallbacks=ignore_fallbacks)
2105
1831
        """See BranchFormat.get_format_description()."""
2106
1832
        return "Branch format 5"
2107
1833
 
2108
 
    def initialize(self, a_bzrdir, name=None):
 
1834
    def initialize(self, a_bzrdir):
2109
1835
        """Create a branch of this format in a_bzrdir."""
2110
1836
        utf8_files = [('revision-history', ''),
2111
1837
                      ('branch-name', ''),
2112
1838
                      ]
2113
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
1839
        return self._initialize_helper(a_bzrdir, utf8_files)
2114
1840
 
2115
1841
    def supports_tags(self):
2116
1842
        return False
2138
1864
        """See BranchFormat.get_format_description()."""
2139
1865
        return "Branch format 6"
2140
1866
 
2141
 
    def initialize(self, a_bzrdir, name=None):
 
1867
    def initialize(self, a_bzrdir):
2142
1868
        """Create a branch of this format in a_bzrdir."""
2143
1869
        utf8_files = [('last-revision', '0 null:\n'),
2144
1870
                      ('branch.conf', ''),
2145
1871
                      ('tags', ''),
2146
1872
                      ]
2147
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
1873
        return self._initialize_helper(a_bzrdir, utf8_files)
2148
1874
 
2149
1875
    def make_tags(self, branch):
2150
1876
        """See bzrlib.branch.BranchFormat.make_tags()."""
2168
1894
        """See BranchFormat.get_format_description()."""
2169
1895
        return "Branch format 8"
2170
1896
 
2171
 
    def initialize(self, a_bzrdir, name=None):
 
1897
    def initialize(self, a_bzrdir):
2172
1898
        """Create a branch of this format in a_bzrdir."""
2173
1899
        utf8_files = [('last-revision', '0 null:\n'),
2174
1900
                      ('branch.conf', ''),
2175
1901
                      ('tags', ''),
2176
1902
                      ('references', '')
2177
1903
                      ]
2178
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
1904
        return self._initialize_helper(a_bzrdir, utf8_files)
2179
1905
 
2180
1906
    def __init__(self):
2181
1907
        super(BzrBranchFormat8, self).__init__()
2204
1930
    This format was introduced in bzr 1.6.
2205
1931
    """
2206
1932
 
2207
 
    def initialize(self, a_bzrdir, name=None):
 
1933
    def initialize(self, a_bzrdir):
2208
1934
        """Create a branch of this format in a_bzrdir."""
2209
1935
        utf8_files = [('last-revision', '0 null:\n'),
2210
1936
                      ('branch.conf', ''),
2211
1937
                      ('tags', ''),
2212
1938
                      ]
2213
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
1939
        return self._initialize_helper(a_bzrdir, utf8_files)
2214
1940
 
2215
1941
    def _branch_class(self):
2216
1942
        return BzrBranch7
2248
1974
        """See BranchFormat.get_format_description()."""
2249
1975
        return "Checkout reference format 1"
2250
1976
 
2251
 
    def get_reference(self, a_bzrdir, name=None):
 
1977
    def get_reference(self, a_bzrdir):
2252
1978
        """See BranchFormat.get_reference()."""
2253
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
 
1979
        transport = a_bzrdir.get_branch_transport(None)
2254
1980
        return transport.get_bytes('location')
2255
1981
 
2256
 
    def set_reference(self, a_bzrdir, name, to_branch):
 
1982
    def set_reference(self, a_bzrdir, to_branch):
2257
1983
        """See BranchFormat.set_reference()."""
2258
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
 
1984
        transport = a_bzrdir.get_branch_transport(None)
2259
1985
        location = transport.put_bytes('location', to_branch.base)
2260
1986
 
2261
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
 
1987
    def initialize(self, a_bzrdir, target_branch=None):
2262
1988
        """Create a branch of this format in a_bzrdir."""
2263
1989
        if target_branch is None:
2264
1990
            # this format does not implement branch itself, thus the implicit
2265
1991
            # creation contract must see it as uninitializable
2266
1992
            raise errors.UninitializableFormat(self)
2267
 
        mutter('creating branch reference in %s', a_bzrdir.user_url)
2268
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
1993
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1994
        branch_transport = a_bzrdir.get_branch_transport(self)
2269
1995
        branch_transport.put_bytes('location',
2270
 
            target_branch.bzrdir.user_url)
 
1996
            target_branch.bzrdir.root_transport.base)
2271
1997
        branch_transport.put_bytes('format', self.get_format_string())
2272
 
        branch = self.open(
2273
 
            a_bzrdir, name, _found=True,
 
1998
        return self.open(
 
1999
            a_bzrdir, _found=True,
2274
2000
            possible_transports=[target_branch.bzrdir.root_transport])
2275
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2276
 
        return branch
2277
2001
 
2278
2002
    def __init__(self):
2279
2003
        super(BranchReferenceFormat, self).__init__()
2285
2009
        def clone(to_bzrdir, revision_id=None,
2286
2010
            repository_policy=None):
2287
2011
            """See Branch.clone()."""
2288
 
            return format.initialize(to_bzrdir, target_branch=a_branch)
 
2012
            return format.initialize(to_bzrdir, a_branch)
2289
2013
            # cannot obey revision_id limits when cloning a reference ...
2290
2014
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2291
2015
            # emit some sort of warning/error to the caller ?!
2292
2016
        return clone
2293
2017
 
2294
 
    def open(self, a_bzrdir, name=None, _found=False, location=None,
 
2018
    def open(self, a_bzrdir, _found=False, location=None,
2295
2019
             possible_transports=None, ignore_fallbacks=False):
2296
2020
        """Return the branch that the branch reference in a_bzrdir points at.
2297
2021
 
2298
2022
        :param a_bzrdir: A BzrDir that contains a branch.
2299
 
        :param name: Name of colocated branch to open, if any
2300
2023
        :param _found: a private parameter, do not use it. It is used to
2301
2024
            indicate if format probing has already be done.
2302
2025
        :param ignore_fallbacks: when set, no fallback branches will be opened
2307
2030
        :param possible_transports: An optional reusable transports list.
2308
2031
        """
2309
2032
        if not _found:
2310
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
2033
            format = BranchFormat.find_format(a_bzrdir)
2311
2034
            if format.__class__ != self.__class__:
2312
2035
                raise AssertionError("wrong format %r found for %r" %
2313
2036
                    (format, self))
2314
2037
        if location is None:
2315
 
            location = self.get_reference(a_bzrdir, name)
 
2038
            location = self.get_reference(a_bzrdir)
2316
2039
        real_bzrdir = bzrdir.BzrDir.open(
2317
2040
            location, possible_transports=possible_transports)
2318
 
        result = real_bzrdir.open_branch(name=name, 
2319
 
            ignore_fallbacks=ignore_fallbacks)
 
2041
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
2320
2042
        # this changes the behaviour of result.clone to create a new reference
2321
2043
        # rather than a copy of the content of the branch.
2322
2044
        # I did not use a proxy object because that needs much more extensive
2356
2078
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2357
2079
 
2358
2080
 
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
2081
class BzrBranch(Branch, _RelockDebugMixin):
2377
2082
    """A branch stored in the actual filesystem.
2378
2083
 
2385
2090
    :ivar repository: Repository for this branch.
2386
2091
    :ivar base: The url of the base directory for this branch; the one
2387
2092
        containing the .bzr directory.
2388
 
    :ivar name: Optional colocated branch name as it exists in the control
2389
 
        directory.
2390
2093
    """
2391
2094
 
2392
2095
    def __init__(self, _format=None,
2393
 
                 _control_files=None, a_bzrdir=None, name=None,
2394
 
                 _repository=None, ignore_fallbacks=False):
 
2096
                 _control_files=None, a_bzrdir=None, _repository=None,
 
2097
                 ignore_fallbacks=False):
2395
2098
        """Create new branch object at a particular location."""
2396
2099
        if a_bzrdir is None:
2397
2100
            raise ValueError('a_bzrdir must be supplied')
2398
2101
        else:
2399
2102
            self.bzrdir = a_bzrdir
2400
2103
        self._base = self.bzrdir.transport.clone('..').base
2401
 
        self.name = name
2402
2104
        # XXX: We should be able to just do
2403
2105
        #   self.base = self.bzrdir.root_transport.base
2404
2106
        # but this does not quite work yet -- mbp 20080522
2411
2113
        Branch.__init__(self)
2412
2114
 
2413
2115
    def __str__(self):
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)
 
2116
        return '%s(%r)' % (self.__class__.__name__, self.base)
2419
2117
 
2420
2118
    __repr__ = __str__
2421
2119
 
2432
2130
        return self.control_files.is_locked()
2433
2131
 
2434
2132
    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
2133
        if not self.is_locked():
2442
2134
            self._note_lock('w')
2443
2135
        # All-in-one needs to always unlock/lock.
2449
2141
        else:
2450
2142
            took_lock = False
2451
2143
        try:
2452
 
            return BranchWriteLockResult(self.unlock,
2453
 
                self.control_files.lock_write(token=token))
 
2144
            return self.control_files.lock_write(token=token)
2454
2145
        except:
2455
2146
            if took_lock:
2456
2147
                self.repository.unlock()
2457
2148
            raise
2458
2149
 
2459
2150
    def lock_read(self):
2460
 
        """Lock the branch for read operations.
2461
 
 
2462
 
        :return: A bzrlib.lock.LogicalLockResult.
2463
 
        """
2464
2151
        if not self.is_locked():
2465
2152
            self._note_lock('r')
2466
2153
        # All-in-one needs to always unlock/lock.
2473
2160
            took_lock = False
2474
2161
        try:
2475
2162
            self.control_files.lock_read()
2476
 
            return LogicalLockResult(self.unlock)
2477
2163
        except:
2478
2164
            if took_lock:
2479
2165
                self.repository.unlock()
2648
2334
        return result
2649
2335
 
2650
2336
    def get_stacked_on_url(self):
2651
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
2337
        raise errors.UnstackableBranchFormat(self._format, self.base)
2652
2338
 
2653
2339
    def set_push_location(self, location):
2654
2340
        """See Branch.set_push_location."""
2844
2530
        if _mod_revision.is_null(last_revision):
2845
2531
            return
2846
2532
        if last_revision not in self._lefthand_history(revision_id):
2847
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
 
2533
            raise errors.AppendRevisionsOnlyViolation(self.base)
2848
2534
 
2849
2535
    def _gen_revision_history(self):
2850
2536
        """Generate the revision history from last revision
2950
2636
        if branch_location is None:
2951
2637
            return Branch.reference_parent(self, file_id, path,
2952
2638
                                           possible_transports)
2953
 
        branch_location = urlutils.join(self.user_url, branch_location)
 
2639
        branch_location = urlutils.join(self.base, branch_location)
2954
2640
        return Branch.open(branch_location,
2955
2641
                           possible_transports=possible_transports)
2956
2642
 
3002
2688
        return stacked_url
3003
2689
 
3004
2690
    def _get_append_revisions_only(self):
3005
 
        return self.get_config(
3006
 
            ).get_user_option_as_bool('append_revisions_only')
 
2691
        value = self.get_config().get_user_option('append_revisions_only')
 
2692
        return value == 'True'
3007
2693
 
3008
2694
    @needs_write_lock
3009
2695
    def generate_revision_history(self, revision_id, last_rev=None,
3071
2757
    """
3072
2758
 
3073
2759
    def get_stacked_on_url(self):
3074
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
2760
        raise errors.UnstackableBranchFormat(self._format, self.base)
3075
2761
 
3076
2762
 
3077
2763
######################################################################
3164
2850
        :param verbose: Requests more detailed display of what was checked,
3165
2851
            if any.
3166
2852
        """
3167
 
        note('checked branch %s format %s', self.branch.user_url,
 
2853
        note('checked branch %s format %s', self.branch.base,
3168
2854
            self.branch._format)
3169
2855
        for error in self.errors:
3170
2856
            note('found error:%s', error)
3265
2951
    _optimisers = []
3266
2952
    """The available optimised InterBranch types."""
3267
2953
 
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)
 
2954
    @staticmethod
 
2955
    def _get_branch_formats_to_test():
 
2956
        """Return a tuple with the Branch formats to use when testing."""
 
2957
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
3277
2958
 
3278
 
    @needs_write_lock
3279
2959
    def pull(self, overwrite=False, stop_revision=None,
3280
2960
             possible_transports=None, local=False):
3281
2961
        """Mirror source into target branch.
3286
2966
        """
3287
2967
        raise NotImplementedError(self.pull)
3288
2968
 
3289
 
    @needs_write_lock
3290
2969
    def update_revisions(self, stop_revision=None, overwrite=False,
3291
2970
                         graph=None):
3292
2971
        """Pull in new perfect-fit revisions.
3300
2979
        """
3301
2980
        raise NotImplementedError(self.update_revisions)
3302
2981
 
3303
 
    @needs_write_lock
3304
2982
    def push(self, overwrite=False, stop_revision=None,
3305
2983
             _override_hook_source_branch=None):
3306
2984
        """Mirror the source branch into the target branch.
3309
2987
        """
3310
2988
        raise NotImplementedError(self.push)
3311
2989
 
3312
 
    @needs_write_lock
3313
 
    def copy_content_into(self, revision_id=None):
3314
 
        """Copy the content of source into target
3315
 
 
3316
 
        revision_id: if not None, the revision history in the new branch will
3317
 
                     be truncated to end with revision_id.
3318
 
        """
3319
 
        raise NotImplementedError(self.copy_content_into)
3320
 
 
3321
2990
 
3322
2991
class GenericInterBranch(InterBranch):
3323
 
    """InterBranch implementation that uses public Branch functions."""
3324
 
 
3325
 
    @classmethod
3326
 
    def is_compatible(klass, source, target):
3327
 
        # GenericBranch uses the public API, so always compatible
3328
 
        return True
3329
 
 
3330
 
    @classmethod
3331
 
    def _get_branch_formats_to_test(klass):
3332
 
        return [(BranchFormat._default_format, BranchFormat._default_format)]
3333
 
 
3334
 
    @classmethod
3335
 
    def unwrap_format(klass, format):
3336
 
        if isinstance(format, remote.RemoteBranchFormat):
3337
 
            format._ensure_real()
3338
 
            return format._custom_format
3339
 
        return format                                                                                                  
3340
 
 
3341
 
    @needs_write_lock
3342
 
    def copy_content_into(self, revision_id=None):
3343
 
        """Copy the content of source into target
3344
 
 
3345
 
        revision_id: if not None, the revision history in the new branch will
3346
 
                     be truncated to end with revision_id.
3347
 
        """
3348
 
        self.source.update_references(self.target)
3349
 
        self.source._synchronize_history(self.target, revision_id)
3350
 
        try:
3351
 
            parent = self.source.get_parent()
3352
 
        except errors.InaccessibleParent, e:
3353
 
            mutter('parent was not accessible to copy: %s', e)
3354
 
        else:
3355
 
            if parent:
3356
 
                self.target.set_parent(parent)
3357
 
        if self.source._push_should_merge_tags():
3358
 
            self.source.tags.merge_to(self.target.tags)
3359
 
 
3360
 
    @needs_write_lock
 
2992
    """InterBranch implementation that uses public Branch functions.
 
2993
    """
 
2994
 
 
2995
    @staticmethod
 
2996
    def _get_branch_formats_to_test():
 
2997
        return BranchFormat._default_format, BranchFormat._default_format
 
2998
 
3361
2999
    def update_revisions(self, stop_revision=None, overwrite=False,
3362
3000
        graph=None):
3363
3001
        """See InterBranch.update_revisions()."""
3364
 
        other_revno, other_last_revision = self.source.last_revision_info()
3365
 
        stop_revno = None # unknown
3366
 
        if stop_revision is None:
3367
 
            stop_revision = other_last_revision
3368
 
            if _mod_revision.is_null(stop_revision):
3369
 
                # if there are no commits, we're done.
3370
 
                return
3371
 
            stop_revno = other_revno
3372
 
 
3373
 
        # what's the current last revision, before we fetch [and change it
3374
 
        # possibly]
3375
 
        last_rev = _mod_revision.ensure_null(self.target.last_revision())
3376
 
        # we fetch here so that we don't process data twice in the common
3377
 
        # case of having something to pull, and so that the check for
3378
 
        # already merged can operate on the just fetched graph, which will
3379
 
        # be cached in memory.
3380
 
        self.target.fetch(self.source, stop_revision)
3381
 
        # Check to see if one is an ancestor of the other
3382
 
        if not overwrite:
3383
 
            if graph is None:
3384
 
                graph = self.target.repository.get_graph()
3385
 
            if self.target._check_if_descendant_or_diverged(
3386
 
                    stop_revision, last_rev, graph, self.source):
3387
 
                # stop_revision is a descendant of last_rev, but we aren't
3388
 
                # overwriting, so we're done.
3389
 
                return
3390
 
        if stop_revno is None:
3391
 
            if graph is None:
3392
 
                graph = self.target.repository.get_graph()
3393
 
            this_revno, this_last_revision = \
3394
 
                    self.target.last_revision_info()
3395
 
            stop_revno = graph.find_distance_to_null(stop_revision,
3396
 
                            [(other_last_revision, other_revno),
3397
 
                             (this_last_revision, this_revno)])
3398
 
        self.target.set_last_revision_info(stop_revno, stop_revision)
3399
 
 
3400
 
    @needs_write_lock
 
3002
        self.source.lock_read()
 
3003
        try:
 
3004
            other_revno, other_last_revision = self.source.last_revision_info()
 
3005
            stop_revno = None # unknown
 
3006
            if stop_revision is None:
 
3007
                stop_revision = other_last_revision
 
3008
                if _mod_revision.is_null(stop_revision):
 
3009
                    # if there are no commits, we're done.
 
3010
                    return
 
3011
                stop_revno = other_revno
 
3012
 
 
3013
            # what's the current last revision, before we fetch [and change it
 
3014
            # possibly]
 
3015
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
 
3016
            # we fetch here so that we don't process data twice in the common
 
3017
            # case of having something to pull, and so that the check for
 
3018
            # already merged can operate on the just fetched graph, which will
 
3019
            # be cached in memory.
 
3020
            self.target.fetch(self.source, stop_revision)
 
3021
            # Check to see if one is an ancestor of the other
 
3022
            if not overwrite:
 
3023
                if graph is None:
 
3024
                    graph = self.target.repository.get_graph()
 
3025
                if self.target._check_if_descendant_or_diverged(
 
3026
                        stop_revision, last_rev, graph, self.source):
 
3027
                    # stop_revision is a descendant of last_rev, but we aren't
 
3028
                    # overwriting, so we're done.
 
3029
                    return
 
3030
            if stop_revno is None:
 
3031
                if graph is None:
 
3032
                    graph = self.target.repository.get_graph()
 
3033
                this_revno, this_last_revision = \
 
3034
                        self.target.last_revision_info()
 
3035
                stop_revno = graph.find_distance_to_null(stop_revision,
 
3036
                                [(other_last_revision, other_revno),
 
3037
                                 (this_last_revision, this_revno)])
 
3038
            self.target.set_last_revision_info(stop_revno, stop_revision)
 
3039
        finally:
 
3040
            self.source.unlock()
 
3041
 
3401
3042
    def pull(self, overwrite=False, stop_revision=None,
3402
 
             possible_transports=None, run_hooks=True,
 
3043
             possible_transports=None, _hook_master=None, run_hooks=True,
3403
3044
             _override_hook_target=None, local=False):
3404
 
        """Pull from source into self, updating my master if any.
 
3045
        """See Branch.pull.
3405
3046
 
 
3047
        :param _hook_master: Private parameter - set the branch to
 
3048
            be supplied as the master to pull hooks.
3406
3049
        :param run_hooks: Private parameter - if false, this branch
3407
3050
            is being called because it's the master of the primary branch,
3408
3051
            so it should not run its hooks.
 
3052
        :param _override_hook_target: Private parameter - set the branch to be
 
3053
            supplied as the target_branch to pull hooks.
 
3054
        :param local: Only update the local branch, and not the bound branch.
3409
3055
        """
3410
 
        bound_location = self.target.get_bound_location()
3411
 
        if local and not bound_location:
 
3056
        # This type of branch can't be bound.
 
3057
        if local:
3412
3058
            raise errors.LocalRequiresBoundBranch()
3413
 
        master_branch = None
3414
 
        if not local and bound_location and self.source.user_url != bound_location:
3415
 
            # not pulling from master, so we need to update master.
3416
 
            master_branch = self.target.get_master_branch(possible_transports)
3417
 
            master_branch.lock_write()
 
3059
        result = PullResult()
 
3060
        result.source_branch = self.source
 
3061
        if _override_hook_target is None:
 
3062
            result.target_branch = self.target
 
3063
        else:
 
3064
            result.target_branch = _override_hook_target
 
3065
        self.source.lock_read()
3418
3066
        try:
3419
 
            if master_branch:
3420
 
                # pull from source into master.
3421
 
                master_branch.pull(self.source, overwrite, stop_revision,
3422
 
                    run_hooks=False)
3423
 
            return self._pull(overwrite,
3424
 
                stop_revision, _hook_master=master_branch,
3425
 
                run_hooks=run_hooks,
3426
 
                _override_hook_target=_override_hook_target)
 
3067
            # We assume that during 'pull' the target repository is closer than
 
3068
            # the source one.
 
3069
            self.source.update_references(self.target)
 
3070
            graph = self.target.repository.get_graph(self.source.repository)
 
3071
            # TODO: Branch formats should have a flag that indicates 
 
3072
            # that revno's are expensive, and pull() should honor that flag.
 
3073
            # -- JRV20090506
 
3074
            result.old_revno, result.old_revid = \
 
3075
                self.target.last_revision_info()
 
3076
            self.target.update_revisions(self.source, stop_revision,
 
3077
                overwrite=overwrite, graph=graph)
 
3078
            # TODO: The old revid should be specified when merging tags, 
 
3079
            # so a tags implementation that versions tags can only 
 
3080
            # pull in the most recent changes. -- JRV20090506
 
3081
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
 
3082
                overwrite)
 
3083
            result.new_revno, result.new_revid = self.target.last_revision_info()
 
3084
            if _hook_master:
 
3085
                result.master_branch = _hook_master
 
3086
                result.local_branch = result.target_branch
 
3087
            else:
 
3088
                result.master_branch = result.target_branch
 
3089
                result.local_branch = None
 
3090
            if run_hooks:
 
3091
                for hook in Branch.hooks['post_pull']:
 
3092
                    hook(result)
3427
3093
        finally:
3428
 
            if master_branch:
3429
 
                master_branch.unlock()
 
3094
            self.source.unlock()
 
3095
        return result
3430
3096
 
3431
3097
    def push(self, overwrite=False, stop_revision=None,
3432
3098
             _override_hook_source_branch=None):
3494
3160
            _run_hooks()
3495
3161
            return result
3496
3162
 
3497
 
    def _pull(self, overwrite=False, stop_revision=None,
3498
 
             possible_transports=None, _hook_master=None, run_hooks=True,
 
3163
    @classmethod
 
3164
    def is_compatible(self, source, target):
 
3165
        # GenericBranch uses the public API, so always compatible
 
3166
        return True
 
3167
 
 
3168
 
 
3169
class InterToBranch5(GenericInterBranch):
 
3170
 
 
3171
    @staticmethod
 
3172
    def _get_branch_formats_to_test():
 
3173
        return BranchFormat._default_format, BzrBranchFormat5()
 
3174
 
 
3175
    def pull(self, overwrite=False, stop_revision=None,
 
3176
             possible_transports=None, run_hooks=True,
3499
3177
             _override_hook_target=None, local=False):
3500
 
        """See Branch.pull.
3501
 
 
3502
 
        This function is the core worker, used by GenericInterBranch.pull to
3503
 
        avoid duplication when pulling source->master and source->local.
3504
 
 
3505
 
        :param _hook_master: Private parameter - set the branch to
3506
 
            be supplied as the master to pull hooks.
 
3178
        """Pull from source into self, updating my master if any.
 
3179
 
3507
3180
        :param run_hooks: Private parameter - if false, this branch
3508
3181
            is being called because it's the master of the primary branch,
3509
3182
            so it should not run its hooks.
3510
 
        :param _override_hook_target: Private parameter - set the branch to be
3511
 
            supplied as the target_branch to pull hooks.
3512
 
        :param local: Only update the local branch, and not the bound branch.
3513
3183
        """
3514
 
        # This type of branch can't be bound.
3515
 
        if local:
 
3184
        bound_location = self.target.get_bound_location()
 
3185
        if local and not bound_location:
3516
3186
            raise errors.LocalRequiresBoundBranch()
3517
 
        result = PullResult()
3518
 
        result.source_branch = self.source
3519
 
        if _override_hook_target is None:
3520
 
            result.target_branch = self.target
3521
 
        else:
3522
 
            result.target_branch = _override_hook_target
3523
 
        self.source.lock_read()
 
3187
        master_branch = None
 
3188
        if not local and bound_location and self.source.base != bound_location:
 
3189
            # not pulling from master, so we need to update master.
 
3190
            master_branch = self.target.get_master_branch(possible_transports)
 
3191
            master_branch.lock_write()
3524
3192
        try:
3525
 
            # We assume that during 'pull' the target repository is closer than
3526
 
            # the source one.
3527
 
            self.source.update_references(self.target)
3528
 
            graph = self.target.repository.get_graph(self.source.repository)
3529
 
            # TODO: Branch formats should have a flag that indicates 
3530
 
            # that revno's are expensive, and pull() should honor that flag.
3531
 
            # -- JRV20090506
3532
 
            result.old_revno, result.old_revid = \
3533
 
                self.target.last_revision_info()
3534
 
            self.target.update_revisions(self.source, stop_revision,
3535
 
                overwrite=overwrite, graph=graph)
3536
 
            # TODO: The old revid should be specified when merging tags, 
3537
 
            # so a tags implementation that versions tags can only 
3538
 
            # pull in the most recent changes. -- JRV20090506
3539
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3540
 
                overwrite)
3541
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3542
 
            if _hook_master:
3543
 
                result.master_branch = _hook_master
3544
 
                result.local_branch = result.target_branch
3545
 
            else:
3546
 
                result.master_branch = result.target_branch
3547
 
                result.local_branch = None
3548
 
            if run_hooks:
3549
 
                for hook in Branch.hooks['post_pull']:
3550
 
                    hook(result)
 
3193
            if master_branch:
 
3194
                # pull from source into master.
 
3195
                master_branch.pull(self.source, overwrite, stop_revision,
 
3196
                    run_hooks=False)
 
3197
            return super(InterToBranch5, self).pull(overwrite,
 
3198
                stop_revision, _hook_master=master_branch,
 
3199
                run_hooks=run_hooks,
 
3200
                _override_hook_target=_override_hook_target)
3551
3201
        finally:
3552
 
            self.source.unlock()
3553
 
        return result
 
3202
            if master_branch:
 
3203
                master_branch.unlock()
3554
3204
 
3555
3205
 
3556
3206
InterBranch.register_optimiser(GenericInterBranch)
 
3207
InterBranch.register_optimiser(InterToBranch5)