← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/branch.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2010-09-01 08:02:42 UTC
  • mfrom: (5390.3.3 faster-revert-593560)
  • Revision ID: pqm@pqm.ubuntu.com-20100901080242-esg62ody4frwmy66
(spiv) Avoid repeatedly calling self.target.all_file_ids() in
 InterTree.iter_changes. (Andrew Bennetts)

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
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
 
 
18
from cStringIO import StringIO
18
19
import sys
19
20
 
20
21
from bzrlib.lazy_import import lazy_import
24
25
        bzrdir,
25
26
        cache_utf8,
26
27
        config as _mod_config,
 
28
        controldir,
27
29
        debug,
28
30
        errors,
29
31
        lockdir,
30
32
        lockable_files,
 
33
        remote,
31
34
        repository,
32
35
        revision as _mod_revision,
 
36
        rio,
33
37
        symbol_versioning,
34
38
        transport,
35
39
        tsort,
36
40
        ui,
37
41
        urlutils,
38
42
        )
39
 
from bzrlib.config import BranchConfig
 
43
from bzrlib.config import BranchConfig, TransportConfig
40
44
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
41
45
from bzrlib.tag import (
42
46
    BasicTags,
44
48
    )
45
49
""")
46
50
 
47
 
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
51
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
48
52
from bzrlib.hooks import HookPoint, Hooks
49
53
from bzrlib.inter import InterObject
 
54
from bzrlib.lock import _RelockDebugMixin, LogicalLockResult
50
55
from bzrlib import registry
51
56
from bzrlib.symbol_versioning import (
52
57
    deprecated_in,
60
65
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
61
66
 
62
67
 
63
 
# TODO: Maybe include checks for common corruption of newlines, etc?
64
 
 
65
 
# TODO: Some operations like log might retrieve the same revisions
66
 
# repeatedly to calculate deltas.  We could perhaps have a weakref
67
 
# cache in memory to make this faster.  In general anything can be
68
 
# cached in memory between lock and unlock operations. .. nb thats
69
 
# what the transaction identity map provides
70
 
 
71
 
 
72
 
######################################################################
73
 
# branch objects
74
 
 
75
 
class Branch(object):
 
68
class Branch(controldir.ControlComponent):
76
69
    """Branch holding a history of revisions.
77
70
 
78
 
    base
79
 
        Base directory/url of the branch.
 
71
    :ivar base:
 
72
        Base directory/url of the branch; using control_url and
 
73
        control_transport is more standardized.
80
74
 
81
75
    hooks: An instance of BranchHooks.
82
76
    """
84
78
    # - RBC 20060112
85
79
    base = None
86
80
 
 
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
 
87
89
    def __init__(self, *ignored, **ignored_too):
88
90
        self.tags = self._format.make_tags(self)
89
91
        self._revision_history_cache = None
90
92
        self._revision_id_to_revno_cache = None
91
93
        self._partial_revision_id_to_revno_cache = {}
 
94
        self._partial_revision_history_cache = []
92
95
        self._last_revision_info_cache = None
93
96
        self._merge_sorted_revisions_cache = None
94
97
        self._open_hook()
99
102
    def _open_hook(self):
100
103
        """Called by init to allow simpler extension of the base class."""
101
104
 
 
105
    def _activate_fallback_location(self, url):
 
106
        """Activate the branch/repository from url as a fallback repository."""
 
107
        repo = self._get_fallback_repository(url)
 
108
        if repo.has_same_location(self.repository):
 
109
            raise errors.UnstackableLocationError(self.user_url, url)
 
110
        self.repository.add_fallback_repository(repo)
 
111
 
102
112
    def break_lock(self):
103
113
        """Break a lock if one is present from another instance.
104
114
 
113
123
        if master is not None:
114
124
            master.break_lock()
115
125
 
 
126
    def _check_stackable_repo(self):
 
127
        if not self.repository._format.supports_external_lookups:
 
128
            raise errors.UnstackableRepositoryFormat(self.repository._format,
 
129
                self.repository.base)
 
130
 
 
131
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
 
132
        """Extend the partial history to include a given index
 
133
 
 
134
        If a stop_index is supplied, stop when that index has been reached.
 
135
        If a stop_revision is supplied, stop when that revision is
 
136
        encountered.  Otherwise, stop when the beginning of history is
 
137
        reached.
 
138
 
 
139
        :param stop_index: The index which should be present.  When it is
 
140
            present, history extension will stop.
 
141
        :param stop_revision: The revision id which should be present.  When
 
142
            it is encountered, history extension will stop.
 
143
        """
 
144
        if len(self._partial_revision_history_cache) == 0:
 
145
            self._partial_revision_history_cache = [self.last_revision()]
 
146
        repository._iter_for_revno(
 
147
            self.repository, self._partial_revision_history_cache,
 
148
            stop_index=stop_index, stop_revision=stop_revision)
 
149
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
 
150
            self._partial_revision_history_cache.pop()
 
151
 
 
152
    def _get_check_refs(self):
 
153
        """Get the references needed for check().
 
154
 
 
155
        See bzrlib.check.
 
156
        """
 
157
        revid = self.last_revision()
 
158
        return [('revision-existence', revid), ('lefthand-distance', revid)]
 
159
 
116
160
    @staticmethod
117
161
    def open(base, _unsupported=False, possible_transports=None):
118
162
        """Open the branch rooted at base.
122
166
        """
123
167
        control = bzrdir.BzrDir.open(base, _unsupported,
124
168
                                     possible_transports=possible_transports)
125
 
        return control.open_branch(_unsupported)
 
169
        return control.open_branch(unsupported=_unsupported)
126
170
 
127
171
    @staticmethod
128
 
    def open_from_transport(transport, _unsupported=False):
 
172
    def open_from_transport(transport, name=None, _unsupported=False):
129
173
        """Open the branch rooted at transport"""
130
174
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
131
 
        return control.open_branch(_unsupported)
 
175
        return control.open_branch(name=name, unsupported=_unsupported)
132
176
 
133
177
    @staticmethod
134
178
    def open_containing(url, possible_transports=None):
155
199
        return self.supports_tags() and self.tags.get_tag_dict()
156
200
 
157
201
    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
        """
158
209
        return BranchConfig(self)
159
210
 
 
211
    def _get_config(self):
 
212
        """Get the concrete config for just the config in this branch.
 
213
 
 
214
        This is not intended for client use; see Branch.get_config for the
 
215
        public API.
 
216
 
 
217
        Added in 1.14.
 
218
 
 
219
        :return: An object supporting get_option and set_option.
 
220
        """
 
221
        raise NotImplementedError(self._get_config)
 
222
 
 
223
    def _get_fallback_repository(self, url):
 
224
        """Get the repository we fallback to at url."""
 
225
        url = urlutils.join(self.base, url)
 
226
        a_branch = Branch.open(url,
 
227
            possible_transports=[self.bzrdir.root_transport])
 
228
        return a_branch.repository
 
229
 
160
230
    def _get_tags_bytes(self):
161
231
        """Get the bytes of a serialised tags dict.
162
232
 
177
247
        if not local and not config.has_explicit_nickname():
178
248
            try:
179
249
                master = self.get_master_branch(possible_transports)
 
250
                if master and self.user_url == master.user_url:
 
251
                    raise errors.RecursiveBind(self.user_url)
180
252
                if master is not None:
181
253
                    # return the master branch value
182
254
                    return master.nick
 
255
            except errors.RecursiveBind, e:
 
256
                raise e
183
257
            except errors.BzrError, e:
184
258
                # Silently fall back to local implicit nick if the master is
185
259
                # unavailable
222
296
        new_history.reverse()
223
297
        return new_history
224
298
 
225
 
    def lock_write(self):
 
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
        """
226
306
        raise NotImplementedError(self.lock_write)
227
307
 
228
308
    def lock_read(self):
 
309
        """Lock the branch for read operations.
 
310
 
 
311
        :return: A bzrlib.lock.LogicalLockResult.
 
312
        """
229
313
        raise NotImplementedError(self.lock_read)
230
314
 
231
315
    def unlock(self):
356
440
            * 'include' - the stop revision is the last item in the result
357
441
            * 'with-merges' - include the stop revision and all of its
358
442
              merged revisions in the result
 
443
            * 'with-merges-without-common-ancestry' - filter out revisions 
 
444
              that are in both ancestries
359
445
        :param direction: either 'reverse' or 'forward':
360
446
            * reverse means return the start_revision_id first, i.e.
361
447
              start at the most recent revision and go backwards in history
383
469
        # start_revision_id.
384
470
        if self._merge_sorted_revisions_cache is None:
385
471
            last_revision = self.last_revision()
386
 
            graph = self.repository.get_graph()
387
 
            parent_map = dict(((key, value) for key, value in
388
 
                     graph.iter_ancestry([last_revision]) if value is not None))
389
 
            revision_graph = repository._strip_NULL_ghosts(parent_map)
390
 
            revs = tsort.merge_sort(revision_graph, last_revision, None,
391
 
                generate_revno=True)
392
 
            # Drop the sequence # before caching
393
 
            self._merge_sorted_revisions_cache = [r[1:] for r in revs]
394
 
 
 
472
            known_graph = self.repository.get_known_graph_ancestry(
 
473
                [last_revision])
 
474
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
 
475
                last_revision)
395
476
        filtered = self._filter_merge_sorted_revisions(
396
477
            self._merge_sorted_revisions_cache, start_revision_id,
397
478
            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)
398
482
        if direction == 'reverse':
399
483
            return filtered
400
484
        if direction == 'forward':
407
491
        """Iterate over an inclusive range of sorted revisions."""
408
492
        rev_iter = iter(merge_sorted_revisions)
409
493
        if start_revision_id is not None:
410
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
494
            for node in rev_iter:
 
495
                rev_id = node.key[-1]
411
496
                if rev_id != start_revision_id:
412
497
                    continue
413
498
                else:
414
499
                    # The decision to include the start or not
415
500
                    # depends on the stop_rule if a stop is provided
416
 
                    rev_iter = chain(
417
 
                        iter([(rev_id, depth, revno, end_of_merge)]),
418
 
                        rev_iter)
 
501
                    # so pop this node back into the iterator
 
502
                    rev_iter = chain(iter([node]), rev_iter)
419
503
                    break
420
504
        if stop_revision_id is None:
421
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
422
 
                yield rev_id, depth, revno, end_of_merge
 
505
            # Yield everything
 
506
            for node in rev_iter:
 
507
                rev_id = node.key[-1]
 
508
                yield (rev_id, node.merge_depth, node.revno,
 
509
                       node.end_of_merge)
423
510
        elif stop_rule == 'exclude':
424
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
511
            for node in rev_iter:
 
512
                rev_id = node.key[-1]
425
513
                if rev_id == stop_revision_id:
426
514
                    return
427
 
                yield rev_id, depth, revno, end_of_merge
 
515
                yield (rev_id, node.merge_depth, node.revno,
 
516
                       node.end_of_merge)
428
517
        elif stop_rule == 'include':
429
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
430
 
                yield rev_id, depth, revno, end_of_merge
 
518
            for node in rev_iter:
 
519
                rev_id = node.key[-1]
 
520
                yield (rev_id, node.merge_depth, node.revno,
 
521
                       node.end_of_merge)
431
522
                if rev_id == stop_revision_id:
432
523
                    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)
433
536
        elif stop_rule == 'with-merges':
434
537
            stop_rev = self.repository.get_revision(stop_revision_id)
435
538
            if stop_rev.parent_ids:
436
539
                left_parent = stop_rev.parent_ids[0]
437
540
            else:
438
541
                left_parent = _mod_revision.NULL_REVISION
439
 
            for rev_id, depth, revno, end_of_merge in rev_iter:
 
542
            # left_parent is the actual revision we want to stop logging at,
 
543
            # since we want to show the merged revisions after the stop_rev too
 
544
            reached_stop_revision_id = False
 
545
            revision_id_whitelist = []
 
546
            for node in rev_iter:
 
547
                rev_id = node.key[-1]
440
548
                if rev_id == left_parent:
 
549
                    # reached the left parent after the stop_revision
441
550
                    return
442
 
                yield rev_id, depth, revno, end_of_merge
 
551
                if (not reached_stop_revision_id or
 
552
                        rev_id in revision_id_whitelist):
 
553
                    yield (rev_id, node.merge_depth, node.revno,
 
554
                       node.end_of_merge)
 
555
                    if reached_stop_revision_id or rev_id == stop_revision_id:
 
556
                        # only do the merged revs of rev_id from now on
 
557
                        rev = self.repository.get_revision(rev_id)
 
558
                        if rev.parent_ids:
 
559
                            reached_stop_revision_id = True
 
560
                            revision_id_whitelist.extend(rev.parent_ids)
443
561
        else:
444
562
            raise ValueError('invalid stop_rule %r' % stop_rule)
445
563
 
 
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
 
446
609
    def leave_lock_in_place(self):
447
610
        """Tell this branch object not to release the physical lock when this
448
611
        object is unlocked.
465
628
        :param other: The branch to bind to
466
629
        :type other: Branch
467
630
        """
468
 
        raise errors.UpgradeRequired(self.base)
 
631
        raise errors.UpgradeRequired(self.user_url)
 
632
 
 
633
    def set_append_revisions_only(self, enabled):
 
634
        if not self._format.supports_set_append_revisions_only():
 
635
            raise errors.UpgradeRequired(self.user_url)
 
636
        if enabled:
 
637
            value = 'True'
 
638
        else:
 
639
            value = 'False'
 
640
        self.get_config().set_user_option('append_revisions_only', value,
 
641
            warn_masked=True)
 
642
 
 
643
    def set_reference_info(self, file_id, tree_path, branch_location):
 
644
        """Set the branch location to use for a tree reference."""
 
645
        raise errors.UnsupportedOperation(self.set_reference_info, self)
 
646
 
 
647
    def get_reference_info(self, file_id):
 
648
        """Get the tree_path and branch_location for a tree reference."""
 
649
        raise errors.UnsupportedOperation(self.get_reference_info, self)
469
650
 
470
651
    @needs_write_lock
471
652
    def fetch(self, from_branch, last_revision=None, pb=None):
505
686
    def get_old_bound_location(self):
506
687
        """Return the URL of the branch we used to be bound to
507
688
        """
508
 
        raise errors.UpgradeRequired(self.base)
 
689
        raise errors.UpgradeRequired(self.user_url)
509
690
 
510
691
    def get_commit_builder(self, parents, config=None, timestamp=None,
511
692
                           timezone=None, committer=None, revprops=None,
561
742
    def set_revision_history(self, rev_history):
562
743
        raise NotImplementedError(self.set_revision_history)
563
744
 
 
745
    @needs_write_lock
 
746
    def set_parent(self, url):
 
747
        """See Branch.set_parent."""
 
748
        # TODO: Maybe delete old location files?
 
749
        # URLs should never be unicode, even on the local fs,
 
750
        # FIXUP this and get_parent in a future branch format bump:
 
751
        # read and rewrite the file. RBC 20060125
 
752
        if url is not None:
 
753
            if isinstance(url, unicode):
 
754
                try:
 
755
                    url = url.encode('ascii')
 
756
                except UnicodeEncodeError:
 
757
                    raise errors.InvalidURL(url,
 
758
                        "Urls must be 7-bit ascii, "
 
759
                        "use bzrlib.urlutils.escape")
 
760
            url = urlutils.relative_url(self.base, url)
 
761
        self._set_parent_location(url)
 
762
 
 
763
    @needs_write_lock
564
764
    def set_stacked_on_url(self, url):
565
765
        """Set the URL this branch is stacked against.
566
766
 
569
769
        :raises UnstackableRepositoryFormat: If the repository does not support
570
770
            stacking.
571
771
        """
572
 
        raise NotImplementedError(self.set_stacked_on_url)
 
772
        if not self._format.supports_stacking():
 
773
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
774
        # XXX: Changing from one fallback repository to another does not check
 
775
        # that all the data you need is present in the new fallback.
 
776
        # Possibly it should.
 
777
        self._check_stackable_repo()
 
778
        if not url:
 
779
            try:
 
780
                old_url = self.get_stacked_on_url()
 
781
            except (errors.NotStacked, errors.UnstackableBranchFormat,
 
782
                errors.UnstackableRepositoryFormat):
 
783
                return
 
784
            self._unstack()
 
785
        else:
 
786
            self._activate_fallback_location(url)
 
787
        # write this out after the repository is stacked to avoid setting a
 
788
        # stacked config that doesn't work.
 
789
        self._set_config_location('stacked_on_location', url)
 
790
 
 
791
    def _unstack(self):
 
792
        """Change a branch to be unstacked, copying data as needed.
 
793
        
 
794
        Don't call this directly, use set_stacked_on_url(None).
 
795
        """
 
796
        pb = ui.ui_factory.nested_progress_bar()
 
797
        try:
 
798
            pb.update("Unstacking")
 
799
            # The basic approach here is to fetch the tip of the branch,
 
800
            # including all available ghosts, from the existing stacked
 
801
            # repository into a new repository object without the fallbacks. 
 
802
            #
 
803
            # XXX: See <https://launchpad.net/bugs/397286> - this may not be
 
804
            # correct for CHKMap repostiories
 
805
            old_repository = self.repository
 
806
            if len(old_repository._fallback_repositories) != 1:
 
807
                raise AssertionError("can't cope with fallback repositories "
 
808
                    "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()
 
836
            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):
 
855
                self.repository.lock_write()
 
856
            # Fetch from the old repository into the new.
 
857
            old_repository.lock_read()
 
858
            try:
 
859
                # XXX: If you unstack a branch while it has a working tree
 
860
                # with a pending merge, the pending-merged revisions will no
 
861
                # longer be present.  You can (probably) revert and remerge.
 
862
                #
 
863
                # XXX: This only fetches up to the tip of the repository; it
 
864
                # doesn't bring across any tags.  That's fairly consistent
 
865
                # with how branch works, but perhaps not ideal.
 
866
                self.repository.fetch(old_repository,
 
867
                    revision_id=self.last_revision(),
 
868
                    find_ghosts=True)
 
869
            finally:
 
870
                old_repository.unlock()
 
871
        finally:
 
872
            pb.finished()
573
873
 
574
874
    def _set_tags_bytes(self, bytes):
575
875
        """Mirror method for _get_tags_bytes.
611
911
        self._revision_id_to_revno_cache = None
612
912
        self._last_revision_info_cache = None
613
913
        self._merge_sorted_revisions_cache = None
 
914
        self._partial_revision_history_cache = []
 
915
        self._partial_revision_id_to_revno_cache = {}
614
916
 
615
917
    def _gen_revision_history(self):
616
918
        """Return sequence of revision hashes on to this branch.
653
955
 
654
956
    def unbind(self):
655
957
        """Older format branches cannot bind or unbind."""
656
 
        raise errors.UpgradeRequired(self.base)
657
 
 
658
 
    def set_append_revisions_only(self, enabled):
659
 
        """Older format branches are never restricted to append-only"""
660
 
        raise errors.UpgradeRequired(self.base)
 
958
        raise errors.UpgradeRequired(self.user_url)
661
959
 
662
960
    def last_revision(self):
663
961
        """Return last revision id, or NULL_REVISION."""
704
1002
                raise errors.NoSuchRevision(self, stop_revision)
705
1003
        return other_history[self_len:stop_revision]
706
1004
 
707
 
    @needs_write_lock
708
1005
    def update_revisions(self, other, stop_revision=None, overwrite=False,
709
1006
                         graph=None):
710
1007
        """Pull in new perfect-fit revisions.
744
1041
        except ValueError:
745
1042
            raise errors.NoSuchRevision(self, revision_id)
746
1043
 
 
1044
    @needs_read_lock
747
1045
    def get_rev_id(self, revno, history=None):
748
1046
        """Find the revision id of the specified revno."""
749
1047
        if revno == 0:
750
1048
            return _mod_revision.NULL_REVISION
751
 
        if history is None:
752
 
            history = self.revision_history()
753
 
        if revno <= 0 or revno > len(history):
 
1049
        last_revno, last_revid = self.last_revision_info()
 
1050
        if revno == last_revno:
 
1051
            return last_revid
 
1052
        if revno <= 0 or revno > last_revno:
754
1053
            raise errors.NoSuchRevision(self, revno)
755
 
        return history[revno - 1]
 
1054
        distance_from_last = last_revno - revno
 
1055
        if len(self._partial_revision_history_cache) <= distance_from_last:
 
1056
            self._extend_partial_history(distance_from_last)
 
1057
        return self._partial_revision_history_cache[distance_from_last]
756
1058
 
757
1059
    def pull(self, source, overwrite=False, stop_revision=None,
758
 
             possible_transports=None, _override_hook_target=None):
 
1060
             possible_transports=None, *args, **kwargs):
759
1061
        """Mirror source into this branch.
760
1062
 
761
1063
        This branch is considered to be 'local', having low latency.
762
1064
 
763
1065
        :returns: PullResult instance
764
1066
        """
765
 
        raise NotImplementedError(self.pull)
 
1067
        return InterBranch.get(source, self).pull(overwrite=overwrite,
 
1068
            stop_revision=stop_revision,
 
1069
            possible_transports=possible_transports, *args, **kwargs)
766
1070
 
767
 
    def push(self, target, overwrite=False, stop_revision=None):
 
1071
    def push(self, target, overwrite=False, stop_revision=None, *args,
 
1072
        **kwargs):
768
1073
        """Mirror this branch into target.
769
1074
 
770
1075
        This branch is considered to be 'local', having low latency.
771
1076
        """
772
 
        raise NotImplementedError(self.push)
 
1077
        return InterBranch.get(self, target).push(overwrite, stop_revision,
 
1078
            *args, **kwargs)
 
1079
 
 
1080
    def lossy_push(self, target, stop_revision=None):
 
1081
        """Push deltas into another branch.
 
1082
 
 
1083
        :note: This does not, like push, retain the revision ids from 
 
1084
            the source branch and will, rather than adding bzr-specific 
 
1085
            metadata, push only those semantics of the revision that can be 
 
1086
            natively represented by this branch' VCS.
 
1087
 
 
1088
        :param target: Target branch
 
1089
        :param stop_revision: Revision to push, defaults to last revision.
 
1090
        :return: BranchPushResult with an extra member revidmap: 
 
1091
            A dictionary mapping revision ids from the target branch 
 
1092
            to new revision ids in the target branch, for each 
 
1093
            revision that was pushed.
 
1094
        """
 
1095
        inter = InterBranch.get(self, target)
 
1096
        lossy_push = getattr(inter, "lossy_push", None)
 
1097
        if lossy_push is None:
 
1098
            raise errors.LossyPushToSameVCS(self, target)
 
1099
        return lossy_push(stop_revision)
773
1100
 
774
1101
    def basis_tree(self):
775
1102
        """Return `Tree` object for last revision."""
792
1119
        try:
793
1120
            return urlutils.join(self.base[:-1], parent)
794
1121
        except errors.InvalidURLJoin, e:
795
 
            raise errors.InaccessibleParent(parent, self.base)
 
1122
            raise errors.InaccessibleParent(parent, self.user_url)
796
1123
 
797
1124
    def _get_parent_location(self):
798
1125
        raise NotImplementedError(self._get_parent_location)
815
1142
            location = None
816
1143
        return location
817
1144
 
 
1145
    def get_child_submit_format(self):
 
1146
        """Return the preferred format of submissions to this branch."""
 
1147
        return self.get_config().get_user_option("child_submit_format")
 
1148
 
818
1149
    def get_submit_branch(self):
819
1150
        """Return the submit location of the branch.
820
1151
 
837
1168
    def get_public_branch(self):
838
1169
        """Return the public location of the branch.
839
1170
 
840
 
        This is is used by merge directives.
 
1171
        This is used by merge directives.
841
1172
        """
842
1173
        return self._get_config_location('public_branch')
843
1174
 
879
1210
        params = ChangeBranchTipParams(
880
1211
            self, old_revno, new_revno, old_revid, new_revid)
881
1212
        for hook in hooks:
882
 
            try:
883
 
                hook(params)
884
 
            except errors.TipChangeRejected:
885
 
                raise
886
 
            except Exception:
887
 
                exc_info = sys.exc_info()
888
 
                hook_name = Branch.hooks.get_hook_name(hook)
889
 
                raise errors.HookFailed(
890
 
                    'pre_change_branch_tip', hook_name, exc_info)
891
 
 
892
 
    def set_parent(self, url):
893
 
        raise NotImplementedError(self.set_parent)
 
1213
            hook(params)
894
1214
 
895
1215
    @needs_write_lock
896
1216
    def update(self):
927
1247
                     be truncated to end with revision_id.
928
1248
        """
929
1249
        result = to_bzrdir.create_branch()
930
 
        if repository_policy is not None:
931
 
            repository_policy.configure_branch(result)
932
 
        self.copy_content_into(result, revision_id=revision_id)
933
 
        return  result
 
1250
        result.lock_write()
 
1251
        try:
 
1252
            if repository_policy is not None:
 
1253
                repository_policy.configure_branch(result)
 
1254
            self.copy_content_into(result, revision_id=revision_id)
 
1255
        finally:
 
1256
            result.unlock()
 
1257
        return result
934
1258
 
935
1259
    @needs_read_lock
936
1260
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
941
1265
        revision_id: if not None, the revision history in the new branch will
942
1266
                     be truncated to end with revision_id.
943
1267
        """
 
1268
        if (repository_policy is not None and
 
1269
            repository_policy.requires_stacking()):
 
1270
            to_bzrdir._format.require_stacking(_skip_repo=True)
944
1271
        result = to_bzrdir.create_branch()
945
 
        if repository_policy is not None:
946
 
            repository_policy.configure_branch(result)
947
 
        self.copy_content_into(result, revision_id=revision_id)
948
 
        result.set_parent(self.bzrdir.root_transport.base)
 
1272
        result.lock_write()
 
1273
        try:
 
1274
            if repository_policy is not None:
 
1275
                repository_policy.configure_branch(result)
 
1276
            self.copy_content_into(result, revision_id=revision_id)
 
1277
            result.set_parent(self.bzrdir.root_transport.base)
 
1278
        finally:
 
1279
            result.unlock()
949
1280
        return result
950
1281
 
951
1282
    def _synchronize_history(self, destination, revision_id):
963
1294
        source_revno, source_revision_id = self.last_revision_info()
964
1295
        if revision_id is None:
965
1296
            revno, revision_id = source_revno, source_revision_id
966
 
        elif source_revision_id == revision_id:
967
 
            # we know the revno without needing to walk all of history
968
 
            revno = source_revno
969
1297
        else:
970
 
            # To figure out the revno for a random revision, we need to build
971
 
            # the revision history, and count its length.
972
 
            # We don't care about the order, just how long it is.
973
 
            # Alternatively, we could start at the current location, and count
974
 
            # backwards. But there is no guarantee that we will find it since
975
 
            # it may be a merged revision.
976
 
            revno = len(list(self.repository.iter_reverse_revision_history(
977
 
                                                                revision_id)))
 
1298
            graph = self.repository.get_graph()
 
1299
            try:
 
1300
                revno = graph.find_distance_to_null(revision_id, 
 
1301
                    [(source_revision_id, source_revno)])
 
1302
            except errors.GhostRevisionsHaveNoRevno:
 
1303
                # Default to 1, if we can't find anything else
 
1304
                revno = 1
978
1305
        destination.set_last_revision_info(revno, revision_id)
979
1306
 
980
 
    @needs_read_lock
981
1307
    def copy_content_into(self, destination, revision_id=None):
982
1308
        """Copy the content of self into destination.
983
1309
 
984
1310
        revision_id: if not None, the revision history in the new branch will
985
1311
                     be truncated to end with revision_id.
986
1312
        """
987
 
        self._synchronize_history(destination, revision_id)
988
 
        try:
989
 
            parent = self.get_parent()
990
 
        except errors.InaccessibleParent, e:
991
 
            mutter('parent was not accessible to copy: %s', e)
992
 
        else:
993
 
            if parent:
994
 
                destination.set_parent(parent)
995
 
        if self._push_should_merge_tags():
996
 
            self.tags.merge_to(destination.tags)
 
1313
        return InterBranch.get(self, destination).copy_content_into(
 
1314
            revision_id=revision_id)
 
1315
 
 
1316
    def update_references(self, target):
 
1317
        if not getattr(self._format, 'supports_reference_locations', False):
 
1318
            return
 
1319
        reference_dict = self._get_all_reference_info()
 
1320
        if len(reference_dict) == 0:
 
1321
            return
 
1322
        old_base = self.base
 
1323
        new_base = target.base
 
1324
        target_reference_dict = target._get_all_reference_info()
 
1325
        for file_id, (tree_path, branch_location) in (
 
1326
            reference_dict.items()):
 
1327
            branch_location = urlutils.rebase_url(branch_location,
 
1328
                                                  old_base, new_base)
 
1329
            target_reference_dict.setdefault(
 
1330
                file_id, (tree_path, branch_location))
 
1331
        target._set_all_reference_info(target_reference_dict)
997
1332
 
998
1333
    @needs_read_lock
999
 
    def check(self):
 
1334
    def check(self, refs):
1000
1335
        """Check consistency of the branch.
1001
1336
 
1002
1337
        In particular this checks that revisions given in the revision-history
1005
1340
 
1006
1341
        Callers will typically also want to check the repository.
1007
1342
 
 
1343
        :param refs: Calculated refs for this branch as specified by
 
1344
            branch._get_check_refs()
1008
1345
        :return: A BranchCheckResult.
1009
1346
        """
1010
 
        mainline_parent_id = None
 
1347
        result = BranchCheckResult(self)
1011
1348
        last_revno, last_revision_id = self.last_revision_info()
1012
 
        real_rev_history = list(self.repository.iter_reverse_revision_history(
1013
 
                                last_revision_id))
1014
 
        real_rev_history.reverse()
1015
 
        if len(real_rev_history) != last_revno:
1016
 
            raise errors.BzrCheckError('revno does not match len(mainline)'
1017
 
                ' %s != %s' % (last_revno, len(real_rev_history)))
1018
 
        # TODO: We should probably also check that real_rev_history actually
1019
 
        #       matches self.revision_history()
1020
 
        for revision_id in real_rev_history:
1021
 
            try:
1022
 
                revision = self.repository.get_revision(revision_id)
1023
 
            except errors.NoSuchRevision, e:
1024
 
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
1025
 
                            % revision_id)
1026
 
            # In general the first entry on the revision history has no parents.
1027
 
            # But it's not illegal for it to have parents listed; this can happen
1028
 
            # in imports from Arch when the parents weren't reachable.
1029
 
            if mainline_parent_id is not None:
1030
 
                if mainline_parent_id not in revision.parent_ids:
1031
 
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
1032
 
                                        "parents of {%s}"
1033
 
                                        % (mainline_parent_id, revision_id))
1034
 
            mainline_parent_id = revision_id
1035
 
        return BranchCheckResult(self)
 
1349
        actual_revno = refs[('lefthand-distance', last_revision_id)]
 
1350
        if actual_revno != last_revno:
 
1351
            result.errors.append(errors.BzrCheckError(
 
1352
                'revno does not match len(mainline) %s != %s' % (
 
1353
                last_revno, actual_revno)))
 
1354
        # TODO: We should probably also check that self.revision_history
 
1355
        # matches the repository for older branch formats.
 
1356
        # If looking for the code that cross-checks repository parents against
 
1357
        # the iter_reverse_revision_history output, that is now a repository
 
1358
        # specific check.
 
1359
        return result
1036
1360
 
1037
1361
    def _get_checkout_format(self):
1038
1362
        """Return the most suitable metadir for a checkout of this branch.
1048
1372
        return format
1049
1373
 
1050
1374
    def create_clone_on_transport(self, to_transport, revision_id=None,
1051
 
        stacked_on=None):
 
1375
        stacked_on=None, create_prefix=False, use_existing_dir=False):
1052
1376
        """Create a clone of this branch and its bzrdir.
1053
1377
 
1054
1378
        :param to_transport: The transport to clone onto.
1055
1379
        :param revision_id: The revision id to use as tip in the new branch.
1056
1380
            If None the tip is obtained from this branch.
1057
1381
        :param stacked_on: An optional URL to stack the clone on.
 
1382
        :param create_prefix: Create any missing directories leading up to
 
1383
            to_transport.
 
1384
        :param use_existing_dir: Use an existing directory if one exists.
1058
1385
        """
1059
1386
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1060
1387
        # 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
        if revision_id is None:
 
1391
            revision_id = self.last_revision()
1061
1392
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1062
 
            revision_id=revision_id, stacked_on=stacked_on)
 
1393
            revision_id=revision_id, stacked_on=stacked_on,
 
1394
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1063
1395
        return dir_to.open_branch()
1064
1396
 
1065
1397
    def create_checkout(self, to_location, revision_id=None,
1084
1416
        if lightweight:
1085
1417
            format = self._get_checkout_format()
1086
1418
            checkout = format.initialize_on_transport(t)
1087
 
            from_branch = BranchReferenceFormat().initialize(checkout, self)
 
1419
            from_branch = BranchReferenceFormat().initialize(checkout, 
 
1420
                target_branch=self)
1088
1421
        else:
1089
1422
            format = self._get_checkout_format()
1090
1423
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1119
1452
        reconciler.reconcile()
1120
1453
        return reconciler
1121
1454
 
1122
 
    def reference_parent(self, file_id, path):
 
1455
    def reference_parent(self, file_id, path, possible_transports=None):
1123
1456
        """Return the parent branch for a tree-reference file_id
1124
1457
        :param file_id: The file_id of the tree reference
1125
1458
        :param path: The path of the file_id in the tree
1126
1459
        :return: A branch associated with the file_id
1127
1460
        """
1128
1461
        # FIXME should provide multiple branches, based on config
1129
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
 
1462
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
 
1463
                           possible_transports=possible_transports)
1130
1464
 
1131
1465
    def supports_tags(self):
1132
1466
        return self._format.supports_tags()
1133
1467
 
 
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
 
1134
1480
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1135
1481
                                         other_branch):
1136
1482
        """Ensure that revision_b is a descendant of revision_a.
1191
1537
    _formats = {}
1192
1538
    """The known formats."""
1193
1539
 
 
1540
    can_set_append_revisions_only = True
 
1541
 
1194
1542
    def __eq__(self, other):
1195
1543
        return self.__class__ is other.__class__
1196
1544
 
1198
1546
        return not (self == other)
1199
1547
 
1200
1548
    @classmethod
1201
 
    def find_format(klass, a_bzrdir):
 
1549
    def find_format(klass, a_bzrdir, name=None):
1202
1550
        """Return the format for the branch object in a_bzrdir."""
1203
1551
        try:
1204
 
            transport = a_bzrdir.get_branch_transport(None)
1205
 
            format_string = transport.get("format").read()
1206
 
            return klass._formats[format_string]
 
1552
            transport = a_bzrdir.get_branch_transport(None, name=name)
 
1553
            format_string = transport.get_bytes("format")
 
1554
            format = klass._formats[format_string]
 
1555
            if isinstance(format, MetaDirBranchFormatFactory):
 
1556
                return format()
 
1557
            return format
1207
1558
        except errors.NoSuchFile:
1208
 
            raise errors.NotBranchError(path=transport.base)
 
1559
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1209
1560
        except KeyError:
1210
1561
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1211
1562
 
1214
1565
        """Return the current default format."""
1215
1566
        return klass._default_format
1216
1567
 
1217
 
    def get_reference(self, a_bzrdir):
 
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):
1218
1583
        """Get the target reference of the branch in a_bzrdir.
1219
1584
 
1220
1585
        format probing must have been completed before calling
1222
1587
        in a_bzrdir is correct.
1223
1588
 
1224
1589
        :param a_bzrdir: The bzrdir to get the branch data from.
 
1590
        :param name: Name of the colocated branch to fetch
1225
1591
        :return: None if the branch is not a reference branch.
1226
1592
        """
1227
1593
        return None
1228
1594
 
1229
1595
    @classmethod
1230
 
    def set_reference(self, a_bzrdir, to_branch):
 
1596
    def set_reference(self, a_bzrdir, name, to_branch):
1231
1597
        """Set the target reference of the branch in a_bzrdir.
1232
1598
 
1233
1599
        format probing must have been completed before calling
1235
1601
        in a_bzrdir is correct.
1236
1602
 
1237
1603
        :param a_bzrdir: The bzrdir to set the branch reference for.
 
1604
        :param name: Name of colocated branch to set, None for default
1238
1605
        :param to_branch: branch that the checkout is to reference
1239
1606
        """
1240
1607
        raise NotImplementedError(self.set_reference)
1247
1614
        """Return the short format description for this format."""
1248
1615
        raise NotImplementedError(self.get_format_description)
1249
1616
 
1250
 
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
1251
 
                           set_format=True):
 
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):
1252
1627
        """Initialize a branch in a bzrdir, with specified files
1253
1628
 
1254
1629
        :param a_bzrdir: The bzrdir to initialize the branch in
1255
1630
        :param utf8_files: The files to create as a list of
1256
1631
            (filename, content) tuples
 
1632
        :param name: Name of colocated branch to create, if any
1257
1633
        :param set_format: If True, set the format with
1258
1634
            self.get_format_string.  (BzrBranch4 has its format set
1259
1635
            elsewhere)
1260
1636
        :return: a branch in this format
1261
1637
        """
1262
 
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
1263
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
1638
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
 
1639
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1264
1640
        lock_map = {
1265
1641
            'metadir': ('lock', lockdir.LockDir),
1266
1642
            'branch4': ('branch-lock', lockable_files.TransportLock),
1269
1645
        control_files = lockable_files.LockableFiles(branch_transport,
1270
1646
            lock_name, lock_class)
1271
1647
        control_files.create_lock()
1272
 
        control_files.lock_write()
 
1648
        try:
 
1649
            control_files.lock_write()
 
1650
        except errors.LockContention:
 
1651
            if lock_type != 'branch4':
 
1652
                raise
 
1653
            lock_taken = False
 
1654
        else:
 
1655
            lock_taken = True
1273
1656
        if set_format:
1274
1657
            utf8_files += [('format', self.get_format_string())]
1275
1658
        try:
1278
1661
                    filename, content,
1279
1662
                    mode=a_bzrdir._get_file_mode())
1280
1663
        finally:
1281
 
            control_files.unlock()
1282
 
        return self.open(a_bzrdir, _found=True)
 
1664
            if lock_taken:
 
1665
                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
1283
1669
 
1284
 
    def initialize(self, a_bzrdir):
1285
 
        """Create a branch of this format in a_bzrdir."""
 
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
        """
1286
1675
        raise NotImplementedError(self.initialize)
1287
1676
 
1288
1677
    def is_supported(self):
1318
1707
        """
1319
1708
        raise NotImplementedError(self.network_name)
1320
1709
 
1321
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
1710
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1322
1711
        """Return the branch object for a_bzrdir
1323
1712
 
1324
1713
        :param a_bzrdir: A BzrDir that contains a branch.
 
1714
        :param name: Name of colocated branch to open
1325
1715
        :param _found: a private parameter, do not use it. It is used to
1326
1716
            indicate if format probing has already be done.
1327
1717
        :param ignore_fallbacks: when set, no fallback branches will be opened
1331
1721
 
1332
1722
    @classmethod
1333
1723
    def register_format(klass, format):
1334
 
        """Register a metadir 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
        """
1335
1729
        klass._formats[format.get_format_string()] = format
1336
1730
        # Metadir formats have a network name of their format string, and get
1337
 
        # registered as class factories.
1338
 
        network_format_registry.register(format.get_format_string(), format.__class__)
 
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__)
1339
1737
 
1340
1738
    @classmethod
1341
1739
    def set_default_format(klass, format):
1342
1740
        klass._default_format = format
1343
1741
 
 
1742
    def supports_set_append_revisions_only(self):
 
1743
        """True if this format supports set_append_revisions_only."""
 
1744
        return False
 
1745
 
1344
1746
    def supports_stacking(self):
1345
1747
        """True if this format records a stacked-on branch."""
1346
1748
        return False
1357
1759
        return False  # by default
1358
1760
 
1359
1761
 
 
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
 
1360
1790
class BranchHooks(Hooks):
1361
1791
    """A dictionary mapping hook name to a list of callables for branch hooks.
1362
1792
 
1408
1838
            "post_uncommit is called with (local, master, old_revno, "
1409
1839
            "old_revid, new_revno, new_revid) where local is the local branch "
1410
1840
            "or None, master is the target branch, and an empty branch "
1411
 
            "recieves new_revno of 0, new_revid of None.", (0, 15), None))
 
1841
            "receives new_revno of 0, new_revid of None.", (0, 15), None))
1412
1842
        self.create_hook(HookPoint('pre_change_branch_tip',
1413
1843
            "Called in bzr client and server before a change to the tip of a "
1414
1844
            "branch is made. pre_change_branch_tip is called with a "
1431
1861
            "multiple hooks installed for transform_fallback_location, "
1432
1862
            "all are called with the url returned from the previous hook."
1433
1863
            "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
 
1434
1881
 
1435
1882
 
1436
1883
# install the default hooks into the Branch class.
1475
1922
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1476
1923
 
1477
1924
 
 
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
 
1478
1998
class BzrBranchFormat4(BranchFormat):
1479
1999
    """Bzr branch format 4.
1480
2000
 
1487
2007
        """See BranchFormat.get_format_description()."""
1488
2008
        return "Branch format 4"
1489
2009
 
1490
 
    def initialize(self, a_bzrdir):
 
2010
    def initialize(self, a_bzrdir, name=None):
1491
2011
        """Create a branch of this format in a_bzrdir."""
1492
2012
        utf8_files = [('revision-history', ''),
1493
2013
                      ('branch-name', ''),
1494
2014
                      ]
1495
 
        return self._initialize_helper(a_bzrdir, utf8_files,
 
2015
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
1496
2016
                                       lock_type='branch4', set_format=False)
1497
2017
 
1498
2018
    def __init__(self):
1503
2023
        """The network name for this format is the control dirs disk label."""
1504
2024
        return self._matchingbzrdir.get_format_string()
1505
2025
 
1506
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
2026
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1507
2027
        """See BranchFormat.open()."""
1508
2028
        if not _found:
1509
2029
            # we are being called directly and must probe.
1511
2031
        return BzrBranch(_format=self,
1512
2032
                         _control_files=a_bzrdir._control_files,
1513
2033
                         a_bzrdir=a_bzrdir,
 
2034
                         name=name,
1514
2035
                         _repository=a_bzrdir.open_repository())
1515
2036
 
1516
2037
    def __str__(self):
1531
2052
        """
1532
2053
        return self.get_format_string()
1533
2054
 
1534
 
    def open(self, a_bzrdir, _found=False, ignore_fallbacks=False):
 
2055
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1535
2056
        """See BranchFormat.open()."""
1536
2057
        if not _found:
1537
 
            format = BranchFormat.find_format(a_bzrdir)
 
2058
            format = BranchFormat.find_format(a_bzrdir, name=name)
1538
2059
            if format.__class__ != self.__class__:
1539
2060
                raise AssertionError("wrong format %r found for %r" %
1540
2061
                    (format, self))
 
2062
        transport = a_bzrdir.get_branch_transport(None, name=name)
1541
2063
        try:
1542
 
            transport = a_bzrdir.get_branch_transport(None)
1543
2064
            control_files = lockable_files.LockableFiles(transport, 'lock',
1544
2065
                                                         lockdir.LockDir)
1545
2066
            return self._branch_class()(_format=self,
1546
2067
                              _control_files=control_files,
 
2068
                              name=name,
1547
2069
                              a_bzrdir=a_bzrdir,
1548
2070
                              _repository=a_bzrdir.find_repository(),
1549
2071
                              ignore_fallbacks=ignore_fallbacks)
1550
2072
        except errors.NoSuchFile:
1551
 
            raise errors.NotBranchError(path=transport.base)
 
2073
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
1552
2074
 
1553
2075
    def __init__(self):
1554
2076
        super(BranchFormatMetadir, self).__init__()
1583
2105
        """See BranchFormat.get_format_description()."""
1584
2106
        return "Branch format 5"
1585
2107
 
1586
 
    def initialize(self, a_bzrdir):
 
2108
    def initialize(self, a_bzrdir, name=None):
1587
2109
        """Create a branch of this format in a_bzrdir."""
1588
2110
        utf8_files = [('revision-history', ''),
1589
2111
                      ('branch-name', ''),
1590
2112
                      ]
1591
 
        return self._initialize_helper(a_bzrdir, utf8_files)
 
2113
        return self._initialize_helper(a_bzrdir, utf8_files, name)
1592
2114
 
1593
2115
    def supports_tags(self):
1594
2116
        return False
1616
2138
        """See BranchFormat.get_format_description()."""
1617
2139
        return "Branch format 6"
1618
2140
 
1619
 
    def initialize(self, a_bzrdir):
1620
 
        """Create a branch of this format in a_bzrdir."""
1621
 
        utf8_files = [('last-revision', '0 null:\n'),
1622
 
                      ('branch.conf', ''),
1623
 
                      ('tags', ''),
1624
 
                      ]
1625
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1626
 
 
1627
 
    def make_tags(self, branch):
1628
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
1629
 
        return BasicTags(branch)
1630
 
 
1631
 
 
1632
 
 
1633
 
class BzrBranchFormat7(BranchFormatMetadir):
 
2141
    def initialize(self, a_bzrdir, name=None):
 
2142
        """Create a branch of this format in a_bzrdir."""
 
2143
        utf8_files = [('last-revision', '0 null:\n'),
 
2144
                      ('branch.conf', ''),
 
2145
                      ('tags', ''),
 
2146
                      ]
 
2147
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2148
 
 
2149
    def make_tags(self, branch):
 
2150
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2151
        return BasicTags(branch)
 
2152
 
 
2153
    def supports_set_append_revisions_only(self):
 
2154
        return True
 
2155
 
 
2156
 
 
2157
class BzrBranchFormat8(BranchFormatMetadir):
 
2158
    """Metadir format supporting storing locations of subtree branches."""
 
2159
 
 
2160
    def _branch_class(self):
 
2161
        return BzrBranch8
 
2162
 
 
2163
    def get_format_string(self):
 
2164
        """See BranchFormat.get_format_string()."""
 
2165
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
 
2166
 
 
2167
    def get_format_description(self):
 
2168
        """See BranchFormat.get_format_description()."""
 
2169
        return "Branch format 8"
 
2170
 
 
2171
    def initialize(self, a_bzrdir, name=None):
 
2172
        """Create a branch of this format in a_bzrdir."""
 
2173
        utf8_files = [('last-revision', '0 null:\n'),
 
2174
                      ('branch.conf', ''),
 
2175
                      ('tags', ''),
 
2176
                      ('references', '')
 
2177
                      ]
 
2178
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2179
 
 
2180
    def __init__(self):
 
2181
        super(BzrBranchFormat8, self).__init__()
 
2182
        self._matchingbzrdir.repository_format = \
 
2183
            RepositoryFormatKnitPack5RichRoot()
 
2184
 
 
2185
    def make_tags(self, branch):
 
2186
        """See bzrlib.branch.BranchFormat.make_tags()."""
 
2187
        return BasicTags(branch)
 
2188
 
 
2189
    def supports_set_append_revisions_only(self):
 
2190
        return True
 
2191
 
 
2192
    def supports_stacking(self):
 
2193
        return True
 
2194
 
 
2195
    supports_reference_locations = True
 
2196
 
 
2197
 
 
2198
class BzrBranchFormat7(BzrBranchFormat8):
1634
2199
    """Branch format with last-revision, tags, and a stacked location pointer.
1635
2200
 
1636
2201
    The stacked location pointer is passed down to the repository and requires
1639
2204
    This format was introduced in bzr 1.6.
1640
2205
    """
1641
2206
 
 
2207
    def initialize(self, a_bzrdir, name=None):
 
2208
        """Create a branch of this format in a_bzrdir."""
 
2209
        utf8_files = [('last-revision', '0 null:\n'),
 
2210
                      ('branch.conf', ''),
 
2211
                      ('tags', ''),
 
2212
                      ]
 
2213
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
2214
 
1642
2215
    def _branch_class(self):
1643
2216
        return BzrBranch7
1644
2217
 
1650
2223
        """See BranchFormat.get_format_description()."""
1651
2224
        return "Branch format 7"
1652
2225
 
1653
 
    def initialize(self, a_bzrdir):
1654
 
        """Create a branch of this format in a_bzrdir."""
1655
 
        utf8_files = [('last-revision', '0 null:\n'),
1656
 
                      ('branch.conf', ''),
1657
 
                      ('tags', ''),
1658
 
                      ]
1659
 
        return self._initialize_helper(a_bzrdir, utf8_files)
1660
 
 
1661
 
    def __init__(self):
1662
 
        super(BzrBranchFormat7, self).__init__()
1663
 
        self._matchingbzrdir.repository_format = \
1664
 
            RepositoryFormatKnitPack5RichRoot()
1665
 
 
1666
 
    def make_tags(self, branch):
1667
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
1668
 
        return BasicTags(branch)
1669
 
 
1670
 
    def supports_stacking(self):
 
2226
    def supports_set_append_revisions_only(self):
1671
2227
        return True
1672
2228
 
 
2229
    supports_reference_locations = False
 
2230
 
1673
2231
 
1674
2232
class BranchReferenceFormat(BranchFormat):
1675
2233
    """Bzr branch reference format.
1690
2248
        """See BranchFormat.get_format_description()."""
1691
2249
        return "Checkout reference format 1"
1692
2250
 
1693
 
    def get_reference(self, a_bzrdir):
 
2251
    def get_reference(self, a_bzrdir, name=None):
1694
2252
        """See BranchFormat.get_reference()."""
1695
 
        transport = a_bzrdir.get_branch_transport(None)
1696
 
        return transport.get('location').read()
 
2253
        transport = a_bzrdir.get_branch_transport(None, name=name)
 
2254
        return transport.get_bytes('location')
1697
2255
 
1698
 
    def set_reference(self, a_bzrdir, to_branch):
 
2256
    def set_reference(self, a_bzrdir, name, to_branch):
1699
2257
        """See BranchFormat.set_reference()."""
1700
 
        transport = a_bzrdir.get_branch_transport(None)
 
2258
        transport = a_bzrdir.get_branch_transport(None, name=name)
1701
2259
        location = transport.put_bytes('location', to_branch.base)
1702
2260
 
1703
 
    def initialize(self, a_bzrdir, target_branch=None):
 
2261
    def initialize(self, a_bzrdir, name=None, target_branch=None):
1704
2262
        """Create a branch of this format in a_bzrdir."""
1705
2263
        if target_branch is None:
1706
2264
            # this format does not implement branch itself, thus the implicit
1707
2265
            # creation contract must see it as uninitializable
1708
2266
            raise errors.UninitializableFormat(self)
1709
 
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
1710
 
        branch_transport = a_bzrdir.get_branch_transport(self)
 
2267
        mutter('creating branch reference in %s', a_bzrdir.user_url)
 
2268
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
1711
2269
        branch_transport.put_bytes('location',
1712
 
            target_branch.bzrdir.root_transport.base)
 
2270
            target_branch.bzrdir.user_url)
1713
2271
        branch_transport.put_bytes('format', self.get_format_string())
1714
 
        return self.open(
1715
 
            a_bzrdir, _found=True,
 
2272
        branch = self.open(
 
2273
            a_bzrdir, name, _found=True,
1716
2274
            possible_transports=[target_branch.bzrdir.root_transport])
 
2275
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
 
2276
        return branch
1717
2277
 
1718
2278
    def __init__(self):
1719
2279
        super(BranchReferenceFormat, self).__init__()
1725
2285
        def clone(to_bzrdir, revision_id=None,
1726
2286
            repository_policy=None):
1727
2287
            """See Branch.clone()."""
1728
 
            return format.initialize(to_bzrdir, a_branch)
 
2288
            return format.initialize(to_bzrdir, target_branch=a_branch)
1729
2289
            # cannot obey revision_id limits when cloning a reference ...
1730
2290
            # FIXME RBC 20060210 either nuke revision_id for clone, or
1731
2291
            # emit some sort of warning/error to the caller ?!
1732
2292
        return clone
1733
2293
 
1734
 
    def open(self, a_bzrdir, _found=False, location=None,
 
2294
    def open(self, a_bzrdir, name=None, _found=False, location=None,
1735
2295
             possible_transports=None, ignore_fallbacks=False):
1736
2296
        """Return the branch that the branch reference in a_bzrdir points at.
1737
2297
 
1738
2298
        :param a_bzrdir: A BzrDir that contains a branch.
 
2299
        :param name: Name of colocated branch to open, if any
1739
2300
        :param _found: a private parameter, do not use it. It is used to
1740
2301
            indicate if format probing has already be done.
1741
2302
        :param ignore_fallbacks: when set, no fallback branches will be opened
1746
2307
        :param possible_transports: An optional reusable transports list.
1747
2308
        """
1748
2309
        if not _found:
1749
 
            format = BranchFormat.find_format(a_bzrdir)
 
2310
            format = BranchFormat.find_format(a_bzrdir, name=name)
1750
2311
            if format.__class__ != self.__class__:
1751
2312
                raise AssertionError("wrong format %r found for %r" %
1752
2313
                    (format, self))
1753
2314
        if location is None:
1754
 
            location = self.get_reference(a_bzrdir)
 
2315
            location = self.get_reference(a_bzrdir, name)
1755
2316
        real_bzrdir = bzrdir.BzrDir.open(
1756
2317
            location, possible_transports=possible_transports)
1757
 
        result = real_bzrdir.open_branch(ignore_fallbacks=ignore_fallbacks)
 
2318
        result = real_bzrdir.open_branch(name=name, 
 
2319
            ignore_fallbacks=ignore_fallbacks)
1758
2320
        # this changes the behaviour of result.clone to create a new reference
1759
2321
        # rather than a copy of the content of the branch.
1760
2322
        # I did not use a proxy object because that needs much more extensive
1781
2343
__format5 = BzrBranchFormat5()
1782
2344
__format6 = BzrBranchFormat6()
1783
2345
__format7 = BzrBranchFormat7()
 
2346
__format8 = BzrBranchFormat8()
1784
2347
BranchFormat.register_format(__format5)
1785
2348
BranchFormat.register_format(BranchReferenceFormat())
1786
2349
BranchFormat.register_format(__format6)
1787
2350
BranchFormat.register_format(__format7)
1788
 
BranchFormat.set_default_format(__format6)
 
2351
BranchFormat.register_format(__format8)
 
2352
BranchFormat.set_default_format(__format7)
1789
2353
_legacy_formats = [BzrBranchFormat4(),
1790
2354
    ]
1791
2355
network_format_registry.register(
1792
2356
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
1793
2357
 
1794
2358
 
1795
 
class BzrBranch(Branch):
 
2359
class BranchWriteLockResult(LogicalLockResult):
 
2360
    """The result of write locking a branch.
 
2361
 
 
2362
    :ivar branch_token: The token obtained from the underlying branch lock, or
 
2363
        None.
 
2364
    :ivar unlock: A callable which will unlock the lock.
 
2365
    """
 
2366
 
 
2367
    def __init__(self, unlock, branch_token):
 
2368
        LogicalLockResult.__init__(self, unlock)
 
2369
        self.branch_token = branch_token
 
2370
 
 
2371
    def __repr__(self):
 
2372
        return "BranchWriteLockResult(%s, %s)" % (self.branch_token,
 
2373
            self.unlock)
 
2374
 
 
2375
 
 
2376
class BzrBranch(Branch, _RelockDebugMixin):
1796
2377
    """A branch stored in the actual filesystem.
1797
2378
 
1798
2379
    Note that it's "local" in the context of the filesystem; it doesn't
1804
2385
    :ivar repository: Repository for this branch.
1805
2386
    :ivar base: The url of the base directory for this branch; the one
1806
2387
        containing the .bzr directory.
 
2388
    :ivar name: Optional colocated branch name as it exists in the control
 
2389
        directory.
1807
2390
    """
1808
2391
 
1809
2392
    def __init__(self, _format=None,
1810
 
                 _control_files=None, a_bzrdir=None, _repository=None,
1811
 
                 ignore_fallbacks=False):
 
2393
                 _control_files=None, a_bzrdir=None, name=None,
 
2394
                 _repository=None, ignore_fallbacks=False):
1812
2395
        """Create new branch object at a particular location."""
1813
2396
        if a_bzrdir is None:
1814
2397
            raise ValueError('a_bzrdir must be supplied')
1815
2398
        else:
1816
2399
            self.bzrdir = a_bzrdir
1817
2400
        self._base = self.bzrdir.transport.clone('..').base
 
2401
        self.name = name
1818
2402
        # XXX: We should be able to just do
1819
2403
        #   self.base = self.bzrdir.root_transport.base
1820
2404
        # but this does not quite work yet -- mbp 20080522
1827
2411
        Branch.__init__(self)
1828
2412
 
1829
2413
    def __str__(self):
1830
 
        return '%s(%r)' % (self.__class__.__name__, self.base)
 
2414
        if self.name is None:
 
2415
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
 
2416
        else:
 
2417
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
 
2418
                self.name)
1831
2419
 
1832
2420
    __repr__ = __str__
1833
2421
 
1837
2425
 
1838
2426
    base = property(_get_base, doc="The URL for the root of this branch.")
1839
2427
 
 
2428
    def _get_config(self):
 
2429
        return TransportConfig(self._transport, 'branch.conf')
 
2430
 
1840
2431
    def is_locked(self):
1841
2432
        return self.control_files.is_locked()
1842
2433
 
1843
2434
    def lock_write(self, token=None):
1844
 
        repo_token = self.repository.lock_write()
 
2435
        """Lock the branch for write operations.
 
2436
 
 
2437
        :param token: A token to permit reacquiring a previously held and
 
2438
            preserved lock.
 
2439
        :return: A BranchWriteLockResult.
 
2440
        """
 
2441
        if not self.is_locked():
 
2442
            self._note_lock('w')
 
2443
        # All-in-one needs to always unlock/lock.
 
2444
        repo_control = getattr(self.repository, 'control_files', None)
 
2445
        if self.control_files == repo_control or not self.is_locked():
 
2446
            self.repository._warn_if_deprecated(self)
 
2447
            self.repository.lock_write()
 
2448
            took_lock = True
 
2449
        else:
 
2450
            took_lock = False
1845
2451
        try:
1846
 
            token = self.control_files.lock_write(token=token)
 
2452
            return BranchWriteLockResult(self.unlock,
 
2453
                self.control_files.lock_write(token=token))
1847
2454
        except:
1848
 
            self.repository.unlock()
 
2455
            if took_lock:
 
2456
                self.repository.unlock()
1849
2457
            raise
1850
 
        return token
1851
2458
 
1852
2459
    def lock_read(self):
1853
 
        self.repository.lock_read()
 
2460
        """Lock the branch for read operations.
 
2461
 
 
2462
        :return: A bzrlib.lock.LogicalLockResult.
 
2463
        """
 
2464
        if not self.is_locked():
 
2465
            self._note_lock('r')
 
2466
        # All-in-one needs to always unlock/lock.
 
2467
        repo_control = getattr(self.repository, 'control_files', None)
 
2468
        if self.control_files == repo_control or not self.is_locked():
 
2469
            self.repository._warn_if_deprecated(self)
 
2470
            self.repository.lock_read()
 
2471
            took_lock = True
 
2472
        else:
 
2473
            took_lock = False
1854
2474
        try:
1855
2475
            self.control_files.lock_read()
 
2476
            return LogicalLockResult(self.unlock)
1856
2477
        except:
1857
 
            self.repository.unlock()
 
2478
            if took_lock:
 
2479
                self.repository.unlock()
1858
2480
            raise
1859
2481
 
 
2482
    @only_raises(errors.LockNotHeld, errors.LockBroken)
1860
2483
    def unlock(self):
1861
 
        # TODO: test for failed two phase locks. This is known broken.
1862
2484
        try:
1863
2485
            self.control_files.unlock()
1864
2486
        finally:
1865
 
            self.repository.unlock()
1866
 
        if not self.control_files.is_locked():
1867
 
            # we just released the lock
1868
 
            self._clear_cached_state()
 
2487
            # All-in-one needs to always unlock/lock.
 
2488
            repo_control = getattr(self.repository, 'control_files', None)
 
2489
            if (self.control_files == repo_control or
 
2490
                not self.control_files.is_locked()):
 
2491
                self.repository.unlock()
 
2492
            if not self.control_files.is_locked():
 
2493
                # we just released the lock
 
2494
                self._clear_cached_state()
1869
2495
 
1870
2496
    def peek_lock_mode(self):
1871
2497
        if self.control_files._lock_count == 0:
1990
2616
        """See Branch.basis_tree."""
1991
2617
        return self.repository.revision_tree(self.last_revision())
1992
2618
 
1993
 
    @needs_write_lock
1994
 
    def pull(self, source, overwrite=False, stop_revision=None,
1995
 
             _hook_master=None, run_hooks=True, possible_transports=None,
1996
 
             _override_hook_target=None):
1997
 
        """See Branch.pull.
1998
 
 
1999
 
        :param _hook_master: Private parameter - set the branch to
2000
 
            be supplied as the master to pull hooks.
2001
 
        :param run_hooks: Private parameter - if false, this branch
2002
 
            is being called because it's the master of the primary branch,
2003
 
            so it should not run its hooks.
2004
 
        :param _override_hook_target: Private parameter - set the branch to be
2005
 
            supplied as the target_branch to pull hooks.
2006
 
        """
2007
 
        result = PullResult()
2008
 
        result.source_branch = source
2009
 
        if _override_hook_target is None:
2010
 
            result.target_branch = self
2011
 
        else:
2012
 
            result.target_branch = _override_hook_target
2013
 
        source.lock_read()
2014
 
        try:
2015
 
            # We assume that during 'pull' the local repository is closer than
2016
 
            # the remote one.
2017
 
            graph = self.repository.get_graph(source.repository)
2018
 
            result.old_revno, result.old_revid = self.last_revision_info()
2019
 
            self.update_revisions(source, stop_revision, overwrite=overwrite,
2020
 
                                  graph=graph)
2021
 
            result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
2022
 
            result.new_revno, result.new_revid = self.last_revision_info()
2023
 
            if _hook_master:
2024
 
                result.master_branch = _hook_master
2025
 
                result.local_branch = result.target_branch
2026
 
            else:
2027
 
                result.master_branch = result.target_branch
2028
 
                result.local_branch = None
2029
 
            if run_hooks:
2030
 
                for hook in Branch.hooks['post_pull']:
2031
 
                    hook(result)
2032
 
        finally:
2033
 
            source.unlock()
2034
 
        return result
2035
 
 
2036
2619
    def _get_parent_location(self):
2037
2620
        _locs = ['parent', 'pull', 'x-pull']
2038
2621
        for l in _locs:
2042
2625
                pass
2043
2626
        return None
2044
2627
 
2045
 
    @needs_read_lock
2046
 
    def push(self, target, overwrite=False, stop_revision=None,
2047
 
             _override_hook_source_branch=None):
2048
 
        """See Branch.push.
2049
 
 
2050
 
        This is the basic concrete implementation of push()
2051
 
 
2052
 
        :param _override_hook_source_branch: If specified, run
2053
 
        the hooks passing this Branch as the source, rather than self.
2054
 
        This is for use of RemoteBranch, where push is delegated to the
2055
 
        underlying vfs-based Branch.
2056
 
        """
2057
 
        # TODO: Public option to disable running hooks - should be trivial but
2058
 
        # needs tests.
2059
 
        return _run_with_write_locked_target(
2060
 
            target, self._push_with_bound_branches, target, overwrite,
2061
 
            stop_revision,
2062
 
            _override_hook_source_branch=_override_hook_source_branch)
2063
 
 
2064
 
    def _push_with_bound_branches(self, target, overwrite,
2065
 
            stop_revision,
2066
 
            _override_hook_source_branch=None):
2067
 
        """Push from self into target, and into target's master if any.
2068
 
 
2069
 
        This is on the base BzrBranch class even though it doesn't support
2070
 
        bound branches because the *target* might be bound.
2071
 
        """
2072
 
        def _run_hooks():
2073
 
            if _override_hook_source_branch:
2074
 
                result.source_branch = _override_hook_source_branch
2075
 
            for hook in Branch.hooks['post_push']:
2076
 
                hook(result)
2077
 
 
2078
 
        bound_location = target.get_bound_location()
2079
 
        if bound_location and target.base != bound_location:
2080
 
            # there is a master branch.
2081
 
            #
2082
 
            # XXX: Why the second check?  Is it even supported for a branch to
2083
 
            # be bound to itself? -- mbp 20070507
2084
 
            master_branch = target.get_master_branch()
2085
 
            master_branch.lock_write()
2086
 
            try:
2087
 
                # push into the master from this branch.
2088
 
                self._basic_push(master_branch, overwrite, stop_revision)
2089
 
                # and push into the target branch from this. Note that we push from
2090
 
                # this branch again, because its considered the highest bandwidth
2091
 
                # repository.
2092
 
                result = self._basic_push(target, overwrite, stop_revision)
2093
 
                result.master_branch = master_branch
2094
 
                result.local_branch = target
2095
 
                _run_hooks()
2096
 
                return result
2097
 
            finally:
2098
 
                master_branch.unlock()
2099
 
        else:
2100
 
            # no master branch
2101
 
            result = self._basic_push(target, overwrite, stop_revision)
2102
 
            # TODO: Why set master_branch and local_branch if there's no
2103
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
2104
 
            # 20070504
2105
 
            result.master_branch = target
2106
 
            result.local_branch = None
2107
 
            _run_hooks()
2108
 
            return result
2109
 
 
2110
2628
    def _basic_push(self, target, overwrite, stop_revision):
2111
2629
        """Basic implementation of push without bound branches or hooks.
2112
2630
 
2113
 
        Must be called with self read locked and target write locked.
 
2631
        Must be called with source read locked and target write locked.
2114
2632
        """
2115
2633
        result = BranchPushResult()
2116
2634
        result.source_branch = self
2117
2635
        result.target_branch = target
2118
2636
        result.old_revno, result.old_revid = target.last_revision_info()
 
2637
        self.update_references(target)
2119
2638
        if result.old_revid != self.last_revision():
2120
2639
            # We assume that during 'push' this repository is closer than
2121
2640
            # the target.
2122
2641
            graph = self.repository.get_graph(target.repository)
2123
 
            target.update_revisions(self, stop_revision, overwrite=overwrite,
2124
 
                                    graph=graph)
 
2642
            target.update_revisions(self, stop_revision,
 
2643
                overwrite=overwrite, graph=graph)
2125
2644
        if self._push_should_merge_tags():
2126
 
            result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
 
2645
            result.tag_conflicts = self.tags.merge_to(target.tags,
 
2646
                overwrite)
2127
2647
        result.new_revno, result.new_revid = target.last_revision_info()
2128
2648
        return result
2129
2649
 
2130
2650
    def get_stacked_on_url(self):
2131
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2651
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2132
2652
 
2133
2653
    def set_push_location(self, location):
2134
2654
        """See Branch.set_push_location."""
2136
2656
            'push_location', location,
2137
2657
            store=_mod_config.STORE_LOCATION_NORECURSE)
2138
2658
 
2139
 
    @needs_write_lock
2140
 
    def set_parent(self, url):
2141
 
        """See Branch.set_parent."""
2142
 
        # TODO: Maybe delete old location files?
2143
 
        # URLs should never be unicode, even on the local fs,
2144
 
        # FIXUP this and get_parent in a future branch format bump:
2145
 
        # read and rewrite the file. RBC 20060125
2146
 
        if url is not None:
2147
 
            if isinstance(url, unicode):
2148
 
                try:
2149
 
                    url = url.encode('ascii')
2150
 
                except UnicodeEncodeError:
2151
 
                    raise errors.InvalidURL(url,
2152
 
                        "Urls must be 7-bit ascii, "
2153
 
                        "use bzrlib.urlutils.escape")
2154
 
            url = urlutils.relative_url(self.base, url)
2155
 
        self._set_parent_location(url)
2156
 
 
2157
2659
    def _set_parent_location(self, url):
2158
2660
        if url is None:
2159
2661
            self._transport.delete('parent')
2161
2663
            self._transport.put_bytes('parent', url + '\n',
2162
2664
                mode=self.bzrdir._get_file_mode())
2163
2665
 
2164
 
    def set_stacked_on_url(self, url):
2165
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
2166
 
 
2167
2666
 
2168
2667
class BzrBranch5(BzrBranch):
2169
2668
    """A format 5 branch. This supports new features over plain branches.
2171
2670
    It has support for a master_branch which is the data for bound branches.
2172
2671
    """
2173
2672
 
2174
 
    @needs_write_lock
2175
 
    def pull(self, source, overwrite=False, stop_revision=None,
2176
 
             run_hooks=True, possible_transports=None,
2177
 
             _override_hook_target=None):
2178
 
        """Pull from source into self, updating my master if any.
2179
 
 
2180
 
        :param run_hooks: Private parameter - if false, this branch
2181
 
            is being called because it's the master of the primary branch,
2182
 
            so it should not run its hooks.
2183
 
        """
2184
 
        bound_location = self.get_bound_location()
2185
 
        master_branch = None
2186
 
        if bound_location and source.base != bound_location:
2187
 
            # not pulling from master, so we need to update master.
2188
 
            master_branch = self.get_master_branch(possible_transports)
2189
 
            master_branch.lock_write()
2190
 
        try:
2191
 
            if master_branch:
2192
 
                # pull from source into master.
2193
 
                master_branch.pull(source, overwrite, stop_revision,
2194
 
                    run_hooks=False)
2195
 
            return super(BzrBranch5, self).pull(source, overwrite,
2196
 
                stop_revision, _hook_master=master_branch,
2197
 
                run_hooks=run_hooks,
2198
 
                _override_hook_target=_override_hook_target)
2199
 
        finally:
2200
 
            if master_branch:
2201
 
                master_branch.unlock()
2202
 
 
2203
2673
    def get_bound_location(self):
2204
2674
        try:
2205
2675
            return self._transport.get_bytes('bound')[:-1]
2292
2762
        return None
2293
2763
 
2294
2764
 
2295
 
class BzrBranch7(BzrBranch5):
2296
 
    """A branch with support for a fallback repository."""
2297
 
 
2298
 
    def _get_fallback_repository(self, url):
2299
 
        """Get the repository we fallback to at url."""
2300
 
        url = urlutils.join(self.base, url)
2301
 
        a_bzrdir = bzrdir.BzrDir.open(url,
2302
 
                                      possible_transports=[self._transport])
2303
 
        return a_bzrdir.open_branch().repository
2304
 
 
2305
 
    def _activate_fallback_location(self, url):
2306
 
        """Activate the branch/repository from url as a fallback repository."""
2307
 
        self.repository.add_fallback_repository(
2308
 
            self._get_fallback_repository(url))
 
2765
class BzrBranch8(BzrBranch5):
 
2766
    """A branch that stores tree-reference locations."""
2309
2767
 
2310
2768
    def _open_hook(self):
2311
2769
        if self._ignore_fallbacks:
2325
2783
                        "None, not a URL." % hook_name)
2326
2784
            self._activate_fallback_location(url)
2327
2785
 
2328
 
    def _check_stackable_repo(self):
2329
 
        if not self.repository._format.supports_external_lookups:
2330
 
            raise errors.UnstackableRepositoryFormat(self.repository._format,
2331
 
                self.repository.base)
2332
 
 
2333
2786
    def __init__(self, *args, **kwargs):
2334
2787
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2335
 
        super(BzrBranch7, self).__init__(*args, **kwargs)
 
2788
        super(BzrBranch8, self).__init__(*args, **kwargs)
2336
2789
        self._last_revision_info_cache = None
2337
 
        self._partial_revision_history_cache = []
 
2790
        self._reference_info = None
2338
2791
 
2339
2792
    def _clear_cached_state(self):
2340
 
        super(BzrBranch7, self)._clear_cached_state()
 
2793
        super(BzrBranch8, self)._clear_cached_state()
2341
2794
        self._last_revision_info_cache = None
2342
 
        self._partial_revision_history_cache = []
 
2795
        self._reference_info = None
2343
2796
 
2344
2797
    def _last_revision_info(self):
2345
2798
        revision_string = self._transport.get_bytes('last-revision')
2391
2844
        if _mod_revision.is_null(last_revision):
2392
2845
            return
2393
2846
        if last_revision not in self._lefthand_history(revision_id):
2394
 
            raise errors.AppendRevisionsOnlyViolation(self.base)
 
2847
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
2395
2848
 
2396
2849
    def _gen_revision_history(self):
2397
2850
        """Generate the revision history from last revision
2400
2853
        self._extend_partial_history(stop_index=last_revno-1)
2401
2854
        return list(reversed(self._partial_revision_history_cache))
2402
2855
 
2403
 
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
2404
 
        """Extend the partial history to include a given index
2405
 
 
2406
 
        If a stop_index is supplied, stop when that index has been reached.
2407
 
        If a stop_revision is supplied, stop when that revision is
2408
 
        encountered.  Otherwise, stop when the beginning of history is
2409
 
        reached.
2410
 
 
2411
 
        :param stop_index: The index which should be present.  When it is
2412
 
            present, history extension will stop.
2413
 
        :param revision_id: The revision id which should be present.  When
2414
 
            it is encountered, history extension will stop.
2415
 
        """
2416
 
        repo = self.repository
2417
 
        if len(self._partial_revision_history_cache) == 0:
2418
 
            iterator = repo.iter_reverse_revision_history(self.last_revision())
2419
 
        else:
2420
 
            start_revision = self._partial_revision_history_cache[-1]
2421
 
            iterator = repo.iter_reverse_revision_history(start_revision)
2422
 
            #skip the last revision in the list
2423
 
            next_revision = iterator.next()
2424
 
        for revision_id in iterator:
2425
 
            self._partial_revision_history_cache.append(revision_id)
2426
 
            if (stop_index is not None and
2427
 
                len(self._partial_revision_history_cache) > stop_index):
2428
 
                break
2429
 
            if revision_id == stop_revision:
2430
 
                break
2431
 
 
2432
2856
    def _write_revision_history(self, history):
2433
2857
        """Factored out of set_revision_history.
2434
2858
 
2455
2879
        """Set the parent branch"""
2456
2880
        return self._get_config_location('parent_location')
2457
2881
 
 
2882
    @needs_write_lock
 
2883
    def _set_all_reference_info(self, info_dict):
 
2884
        """Replace all reference info stored in a branch.
 
2885
 
 
2886
        :param info_dict: A dict of {file_id: (tree_path, branch_location)}
 
2887
        """
 
2888
        s = StringIO()
 
2889
        writer = rio.RioWriter(s)
 
2890
        for key, (tree_path, branch_location) in info_dict.iteritems():
 
2891
            stanza = rio.Stanza(file_id=key, tree_path=tree_path,
 
2892
                                branch_location=branch_location)
 
2893
            writer.write_stanza(stanza)
 
2894
        self._transport.put_bytes('references', s.getvalue())
 
2895
        self._reference_info = info_dict
 
2896
 
 
2897
    @needs_read_lock
 
2898
    def _get_all_reference_info(self):
 
2899
        """Return all the reference info stored in a branch.
 
2900
 
 
2901
        :return: A dict of {file_id: (tree_path, branch_location)}
 
2902
        """
 
2903
        if self._reference_info is not None:
 
2904
            return self._reference_info
 
2905
        rio_file = self._transport.get('references')
 
2906
        try:
 
2907
            stanzas = rio.read_stanzas(rio_file)
 
2908
            info_dict = dict((s['file_id'], (s['tree_path'],
 
2909
                             s['branch_location'])) for s in stanzas)
 
2910
        finally:
 
2911
            rio_file.close()
 
2912
        self._reference_info = info_dict
 
2913
        return info_dict
 
2914
 
 
2915
    def set_reference_info(self, file_id, tree_path, branch_location):
 
2916
        """Set the branch location to use for a tree reference.
 
2917
 
 
2918
        :param file_id: The file-id of the tree reference.
 
2919
        :param tree_path: The path of the tree reference in the tree.
 
2920
        :param branch_location: The location of the branch to retrieve tree
 
2921
            references from.
 
2922
        """
 
2923
        info_dict = self._get_all_reference_info()
 
2924
        info_dict[file_id] = (tree_path, branch_location)
 
2925
        if None in (tree_path, branch_location):
 
2926
            if tree_path is not None:
 
2927
                raise ValueError('tree_path must be None when branch_location'
 
2928
                                 ' is None.')
 
2929
            if branch_location is not None:
 
2930
                raise ValueError('branch_location must be None when tree_path'
 
2931
                                 ' is None.')
 
2932
            del info_dict[file_id]
 
2933
        self._set_all_reference_info(info_dict)
 
2934
 
 
2935
    def get_reference_info(self, file_id):
 
2936
        """Get the tree_path and branch_location for a tree reference.
 
2937
 
 
2938
        :return: a tuple of (tree_path, branch_location)
 
2939
        """
 
2940
        return self._get_all_reference_info().get(file_id, (None, None))
 
2941
 
 
2942
    def reference_parent(self, file_id, path, possible_transports=None):
 
2943
        """Return the parent branch for a tree-reference file_id.
 
2944
 
 
2945
        :param file_id: The file_id of the tree reference
 
2946
        :param path: The path of the file_id in the tree
 
2947
        :return: A branch associated with the file_id
 
2948
        """
 
2949
        branch_location = self.get_reference_info(file_id)[1]
 
2950
        if branch_location is None:
 
2951
            return Branch.reference_parent(self, file_id, path,
 
2952
                                           possible_transports)
 
2953
        branch_location = urlutils.join(self.user_url, branch_location)
 
2954
        return Branch.open(branch_location,
 
2955
                           possible_transports=possible_transports)
 
2956
 
2458
2957
    def set_push_location(self, location):
2459
2958
        """See Branch.set_push_location."""
2460
2959
        self._set_config_location('push_location', location)
2502
3001
            raise errors.NotStacked(self)
2503
3002
        return stacked_url
2504
3003
 
2505
 
    def set_append_revisions_only(self, enabled):
2506
 
        if enabled:
2507
 
            value = 'True'
2508
 
        else:
2509
 
            value = 'False'
2510
 
        self.get_config().set_user_option('append_revisions_only', value,
2511
 
            warn_masked=True)
2512
 
 
2513
 
    def set_stacked_on_url(self, url):
2514
 
        self._check_stackable_repo()
2515
 
        if not url:
2516
 
            try:
2517
 
                old_url = self.get_stacked_on_url()
2518
 
            except (errors.NotStacked, errors.UnstackableBranchFormat,
2519
 
                errors.UnstackableRepositoryFormat):
2520
 
                return
2521
 
            url = ''
2522
 
            # repositories don't offer an interface to remove fallback
2523
 
            # repositories today; take the conceptually simpler option and just
2524
 
            # reopen it.
2525
 
            self.repository = self.bzrdir.find_repository()
2526
 
            # for every revision reference the branch has, ensure it is pulled
2527
 
            # in.
2528
 
            source_repository = self._get_fallback_repository(old_url)
2529
 
            for revision_id in chain([self.last_revision()],
2530
 
                self.tags.get_reverse_tag_dict()):
2531
 
                self.repository.fetch(source_repository, revision_id,
2532
 
                    find_ghosts=True)
2533
 
        else:
2534
 
            self._activate_fallback_location(url)
2535
 
        # write this out after the repository is stacked to avoid setting a
2536
 
        # stacked config that doesn't work.
2537
 
        self._set_config_location('stacked_on_location', url)
2538
 
 
2539
3004
    def _get_append_revisions_only(self):
2540
 
        value = self.get_config().get_user_option('append_revisions_only')
2541
 
        return value == 'True'
 
3005
        return self.get_config(
 
3006
            ).get_user_option_as_bool('append_revisions_only')
2542
3007
 
2543
3008
    @needs_write_lock
2544
3009
    def generate_revision_history(self, revision_id, last_rev=None,
2584
3049
        return self.revno() - index
2585
3050
 
2586
3051
 
 
3052
class BzrBranch7(BzrBranch8):
 
3053
    """A branch with support for a fallback repository."""
 
3054
 
 
3055
    def set_reference_info(self, file_id, tree_path, branch_location):
 
3056
        Branch.set_reference_info(self, file_id, tree_path, branch_location)
 
3057
 
 
3058
    def get_reference_info(self, file_id):
 
3059
        Branch.get_reference_info(self, file_id)
 
3060
 
 
3061
    def reference_parent(self, file_id, path, possible_transports=None):
 
3062
        return Branch.reference_parent(self, file_id, path,
 
3063
                                       possible_transports)
 
3064
 
 
3065
 
2587
3066
class BzrBranch6(BzrBranch7):
2588
3067
    """See BzrBranchFormat6 for the capabilities of this branch.
2589
3068
 
2592
3071
    """
2593
3072
 
2594
3073
    def get_stacked_on_url(self):
2595
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
2596
 
 
2597
 
    def set_stacked_on_url(self, url):
2598
 
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
3074
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
2599
3075
 
2600
3076
 
2601
3077
######################################################################
2680
3156
 
2681
3157
    def __init__(self, branch):
2682
3158
        self.branch = branch
 
3159
        self.errors = []
2683
3160
 
2684
3161
    def report_results(self, verbose):
2685
3162
        """Report the check results via trace.note.
2687
3164
        :param verbose: Requests more detailed display of what was checked,
2688
3165
            if any.
2689
3166
        """
2690
 
        note('checked branch %s format %s',
2691
 
             self.branch.base,
2692
 
             self.branch._format)
 
3167
        note('checked branch %s format %s', self.branch.user_url,
 
3168
            self.branch._format)
 
3169
        for error in self.errors:
 
3170
            note('found error:%s', error)
2693
3171
 
2694
3172
 
2695
3173
class Converter5to6(object):
2733
3211
        branch._transport.put_bytes('format', format.get_format_string())
2734
3212
 
2735
3213
 
 
3214
class Converter7to8(object):
 
3215
    """Perform an in-place upgrade of format 6 to format 7"""
 
3216
 
 
3217
    def convert(self, branch):
 
3218
        format = BzrBranchFormat8()
 
3219
        branch._transport.put_bytes('references', '')
 
3220
        # update target format
 
3221
        branch._transport.put_bytes('format', format.get_format_string())
 
3222
 
2736
3223
 
2737
3224
def _run_with_write_locked_target(target, callable, *args, **kwargs):
2738
3225
    """Run ``callable(*args, **kwargs)``, write-locking target for the
2778
3265
    _optimisers = []
2779
3266
    """The available optimised InterBranch types."""
2780
3267
 
2781
 
    @staticmethod
2782
 
    def _get_branch_formats_to_test():
2783
 
        """Return a tuple with the Branch formats to use when testing."""
2784
 
        raise NotImplementedError(self._get_branch_formats_to_test)
2785
 
 
 
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)
 
3277
 
 
3278
    @needs_write_lock
 
3279
    def pull(self, overwrite=False, stop_revision=None,
 
3280
             possible_transports=None, local=False):
 
3281
        """Mirror source into target branch.
 
3282
 
 
3283
        The target branch is considered to be 'local', having low latency.
 
3284
 
 
3285
        :returns: PullResult instance
 
3286
        """
 
3287
        raise NotImplementedError(self.pull)
 
3288
 
 
3289
    @needs_write_lock
2786
3290
    def update_revisions(self, stop_revision=None, overwrite=False,
2787
3291
                         graph=None):
2788
3292
        """Pull in new perfect-fit revisions.
2796
3300
        """
2797
3301
        raise NotImplementedError(self.update_revisions)
2798
3302
 
 
3303
    @needs_write_lock
 
3304
    def push(self, overwrite=False, stop_revision=None,
 
3305
             _override_hook_source_branch=None):
 
3306
        """Mirror the source branch into the target branch.
 
3307
 
 
3308
        The source branch is considered to be 'local', having low latency.
 
3309
        """
 
3310
        raise NotImplementedError(self.push)
 
3311
 
 
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
 
2799
3321
 
2800
3322
class GenericInterBranch(InterBranch):
2801
 
    """InterBranch implementation that uses public Branch functions.
2802
 
    """
2803
 
 
2804
 
    @staticmethod
2805
 
    def _get_branch_formats_to_test():
2806
 
        return BranchFormat._default_format, BranchFormat._default_format
2807
 
 
 
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
2808
3361
    def update_revisions(self, stop_revision=None, overwrite=False,
2809
3362
        graph=None):
2810
3363
        """See InterBranch.update_revisions()."""
2811
 
        self.source.lock_read()
2812
 
        try:
2813
 
            other_revno, other_last_revision = self.source.last_revision_info()
2814
 
            stop_revno = None # unknown
2815
 
            if stop_revision is None:
2816
 
                stop_revision = other_last_revision
2817
 
                if _mod_revision.is_null(stop_revision):
2818
 
                    # if there are no commits, we're done.
2819
 
                    return
2820
 
                stop_revno = other_revno
2821
 
 
2822
 
            # what's the current last revision, before we fetch [and change it
2823
 
            # possibly]
2824
 
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
2825
 
            # we fetch here so that we don't process data twice in the common
2826
 
            # case of having something to pull, and so that the check for
2827
 
            # already merged can operate on the just fetched graph, which will
2828
 
            # be cached in memory.
2829
 
            self.target.fetch(self.source, stop_revision)
2830
 
            # Check to see if one is an ancestor of the other
2831
 
            if not overwrite:
2832
 
                if graph is None:
2833
 
                    graph = self.target.repository.get_graph()
2834
 
                if self.target._check_if_descendant_or_diverged(
2835
 
                        stop_revision, last_rev, graph, self.source):
2836
 
                    # stop_revision is a descendant of last_rev, but we aren't
2837
 
                    # overwriting, so we're done.
2838
 
                    return
2839
 
            if stop_revno is None:
2840
 
                if graph is None:
2841
 
                    graph = self.target.repository.get_graph()
2842
 
                this_revno, this_last_revision = \
2843
 
                        self.target.last_revision_info()
2844
 
                stop_revno = graph.find_distance_to_null(stop_revision,
2845
 
                                [(other_last_revision, other_revno),
2846
 
                                 (this_last_revision, this_revno)])
2847
 
            self.target.set_last_revision_info(stop_revno, stop_revision)
2848
 
        finally:
2849
 
            self.source.unlock()
2850
 
 
2851
 
    @classmethod
2852
 
    def is_compatible(self, source, target):
2853
 
        # GenericBranch uses the public API, so always compatible
2854
 
        return True
 
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
 
3401
    def pull(self, overwrite=False, stop_revision=None,
 
3402
             possible_transports=None, run_hooks=True,
 
3403
             _override_hook_target=None, local=False):
 
3404
        """Pull from source into self, updating my master if any.
 
3405
 
 
3406
        :param run_hooks: Private parameter - if false, this branch
 
3407
            is being called because it's the master of the primary branch,
 
3408
            so it should not run its hooks.
 
3409
        """
 
3410
        bound_location = self.target.get_bound_location()
 
3411
        if local and not bound_location:
 
3412
            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()
 
3418
        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)
 
3427
        finally:
 
3428
            if master_branch:
 
3429
                master_branch.unlock()
 
3430
 
 
3431
    def push(self, overwrite=False, stop_revision=None,
 
3432
             _override_hook_source_branch=None):
 
3433
        """See InterBranch.push.
 
3434
 
 
3435
        This is the basic concrete implementation of push()
 
3436
 
 
3437
        :param _override_hook_source_branch: If specified, run
 
3438
        the hooks passing this Branch as the source, rather than self.
 
3439
        This is for use of RemoteBranch, where push is delegated to the
 
3440
        underlying vfs-based Branch.
 
3441
        """
 
3442
        # TODO: Public option to disable running hooks - should be trivial but
 
3443
        # needs tests.
 
3444
        self.source.lock_read()
 
3445
        try:
 
3446
            return _run_with_write_locked_target(
 
3447
                self.target, self._push_with_bound_branches, overwrite,
 
3448
                stop_revision,
 
3449
                _override_hook_source_branch=_override_hook_source_branch)
 
3450
        finally:
 
3451
            self.source.unlock()
 
3452
 
 
3453
    def _push_with_bound_branches(self, overwrite, stop_revision,
 
3454
            _override_hook_source_branch=None):
 
3455
        """Push from source into target, and into target's master if any.
 
3456
        """
 
3457
        def _run_hooks():
 
3458
            if _override_hook_source_branch:
 
3459
                result.source_branch = _override_hook_source_branch
 
3460
            for hook in Branch.hooks['post_push']:
 
3461
                hook(result)
 
3462
 
 
3463
        bound_location = self.target.get_bound_location()
 
3464
        if bound_location and self.target.base != bound_location:
 
3465
            # there is a master branch.
 
3466
            #
 
3467
            # XXX: Why the second check?  Is it even supported for a branch to
 
3468
            # be bound to itself? -- mbp 20070507
 
3469
            master_branch = self.target.get_master_branch()
 
3470
            master_branch.lock_write()
 
3471
            try:
 
3472
                # push into the master from the source branch.
 
3473
                self.source._basic_push(master_branch, overwrite, stop_revision)
 
3474
                # and push into the target branch from the source. Note that we
 
3475
                # push from the source branch again, because its considered the
 
3476
                # highest bandwidth repository.
 
3477
                result = self.source._basic_push(self.target, overwrite,
 
3478
                    stop_revision)
 
3479
                result.master_branch = master_branch
 
3480
                result.local_branch = self.target
 
3481
                _run_hooks()
 
3482
                return result
 
3483
            finally:
 
3484
                master_branch.unlock()
 
3485
        else:
 
3486
            # no master branch
 
3487
            result = self.source._basic_push(self.target, overwrite,
 
3488
                stop_revision)
 
3489
            # TODO: Why set master_branch and local_branch if there's no
 
3490
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
3491
            # 20070504
 
3492
            result.master_branch = self.target
 
3493
            result.local_branch = None
 
3494
            _run_hooks()
 
3495
            return result
 
3496
 
 
3497
    def _pull(self, overwrite=False, stop_revision=None,
 
3498
             possible_transports=None, _hook_master=None, run_hooks=True,
 
3499
             _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.
 
3507
        :param run_hooks: Private parameter - if false, this branch
 
3508
            is being called because it's the master of the primary branch,
 
3509
            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
        """
 
3514
        # This type of branch can't be bound.
 
3515
        if local:
 
3516
            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()
 
3524
        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)
 
3551
        finally:
 
3552
            self.source.unlock()
 
3553
        return result
2855
3554
 
2856
3555
 
2857
3556
InterBranch.register_optimiser(GenericInterBranch)