~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: 2008-08-14 17:25:43 UTC
  • mfrom: (3620.2.2 rules.disable)
  • Revision ID: pqm@pqm.ubuntu.com-20080814172543-nl22gdcodusa8rt0
(robertc) Disable .bzrrules from being read from the WT

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006, 2007, 2008 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
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
 
18
 
from cStringIO import StringIO
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
 
19
18
import sys
20
19
 
21
20
from bzrlib.lazy_import import lazy_import
31
30
        lockable_files,
32
31
        repository,
33
32
        revision as _mod_revision,
34
 
        rio,
35
 
        symbol_versioning,
36
33
        transport,
37
34
        tsort,
38
35
        ui,
39
36
        urlutils,
40
37
        )
41
 
from bzrlib.config import BranchConfig, TransportConfig
42
 
from bzrlib.repofmt.pack_repo import RepositoryFormatKnitPack5RichRoot
 
38
from bzrlib.config import BranchConfig
 
39
from bzrlib.repofmt.pack_repo import RepositoryFormatPackDevelopment1Subtree
43
40
from bzrlib.tag import (
44
41
    BasicTags,
45
42
    DisabledTags,
46
43
    )
47
44
""")
48
45
 
49
 
from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises
50
 
from bzrlib.hooks import HookPoint, Hooks
51
 
from bzrlib.inter import InterObject
52
 
from bzrlib.lock import _RelockDebugMixin
53
 
from bzrlib import registry
 
46
from bzrlib.decorators import needs_read_lock, needs_write_lock
 
47
from bzrlib.hooks import Hooks
54
48
from bzrlib.symbol_versioning import (
55
49
    deprecated_in,
56
50
    deprecated_method,
63
57
BZR_BRANCH_FORMAT_6 = "Bazaar Branch Format 6 (bzr 0.15)\n"
64
58
 
65
59
 
66
 
class Branch(bzrdir.ControlComponent):
 
60
# TODO: Maybe include checks for common corruption of newlines, etc?
 
61
 
 
62
# TODO: Some operations like log might retrieve the same revisions
 
63
# repeatedly to calculate deltas.  We could perhaps have a weakref
 
64
# cache in memory to make this faster.  In general anything can be
 
65
# cached in memory between lock and unlock operations. .. nb thats
 
66
# what the transaction identity map provides
 
67
 
 
68
 
 
69
######################################################################
 
70
# branch objects
 
71
 
 
72
class Branch(object):
67
73
    """Branch holding a history of revisions.
68
74
 
69
 
    :ivar base:
70
 
        Base directory/url of the branch; using control_url and
71
 
        control_transport is more standardized.
 
75
    base
 
76
        Base directory/url of the branch.
72
77
 
73
78
    hooks: An instance of BranchHooks.
74
79
    """
76
81
    # - RBC 20060112
77
82
    base = None
78
83
 
79
 
    @property
80
 
    def control_transport(self):
81
 
        return self._transport
82
 
 
83
 
    @property
84
 
    def user_transport(self):
85
 
        return self.bzrdir.user_transport
 
84
    # override this to set the strategy for storing tags
 
85
    def _make_tags(self):
 
86
        return DisabledTags(self)
86
87
 
87
88
    def __init__(self, *ignored, **ignored_too):
88
 
        self.tags = self._format.make_tags(self)
 
89
        self.tags = self._make_tags()
89
90
        self._revision_history_cache = None
90
91
        self._revision_id_to_revno_cache = None
91
 
        self._partial_revision_id_to_revno_cache = {}
92
 
        self._partial_revision_history_cache = []
93
92
        self._last_revision_info_cache = None
94
 
        self._merge_sorted_revisions_cache = None
95
93
        self._open_hook()
96
 
        hooks = Branch.hooks['open']
97
 
        for hook in hooks:
98
 
            hook(self)
99
94
 
100
95
    def _open_hook(self):
101
96
        """Called by init to allow simpler extension of the base class."""
102
97
 
103
 
    def _activate_fallback_location(self, url):
104
 
        """Activate the branch/repository from url as a fallback repository."""
105
 
        repo = self._get_fallback_repository(url)
106
 
        if repo.has_same_location(self.repository):
107
 
            raise errors.UnstackableLocationError(self.user_url, url)
108
 
        self.repository.add_fallback_repository(repo)
109
 
 
110
98
    def break_lock(self):
111
99
        """Break a lock if one is present from another instance.
112
100
 
121
109
        if master is not None:
122
110
            master.break_lock()
123
111
 
124
 
    def _check_stackable_repo(self):
125
 
        if not self.repository._format.supports_external_lookups:
126
 
            raise errors.UnstackableRepositoryFormat(self.repository._format,
127
 
                self.repository.base)
128
 
 
129
 
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
130
 
        """Extend the partial history to include a given index
131
 
 
132
 
        If a stop_index is supplied, stop when that index has been reached.
133
 
        If a stop_revision is supplied, stop when that revision is
134
 
        encountered.  Otherwise, stop when the beginning of history is
135
 
        reached.
136
 
 
137
 
        :param stop_index: The index which should be present.  When it is
138
 
            present, history extension will stop.
139
 
        :param stop_revision: The revision id which should be present.  When
140
 
            it is encountered, history extension will stop.
141
 
        """
142
 
        if len(self._partial_revision_history_cache) == 0:
143
 
            self._partial_revision_history_cache = [self.last_revision()]
144
 
        repository._iter_for_revno(
145
 
            self.repository, self._partial_revision_history_cache,
146
 
            stop_index=stop_index, stop_revision=stop_revision)
147
 
        if self._partial_revision_history_cache[-1] == _mod_revision.NULL_REVISION:
148
 
            self._partial_revision_history_cache.pop()
149
 
 
150
 
    def _get_check_refs(self):
151
 
        """Get the references needed for check().
152
 
 
153
 
        See bzrlib.check.
154
 
        """
155
 
        revid = self.last_revision()
156
 
        return [('revision-existence', revid), ('lefthand-distance', revid)]
157
 
 
158
112
    @staticmethod
159
113
    def open(base, _unsupported=False, possible_transports=None):
160
114
        """Open the branch rooted at base.
164
118
        """
165
119
        control = bzrdir.BzrDir.open(base, _unsupported,
166
120
                                     possible_transports=possible_transports)
167
 
        return control.open_branch(unsupported=_unsupported)
 
121
        return control.open_branch(_unsupported)
168
122
 
169
123
    @staticmethod
170
 
    def open_from_transport(transport, name=None, _unsupported=False):
 
124
    def open_from_transport(transport, _unsupported=False):
171
125
        """Open the branch rooted at transport"""
172
126
        control = bzrdir.BzrDir.open_from_transport(transport, _unsupported)
173
 
        return control.open_branch(name=name, unsupported=_unsupported)
 
127
        return control.open_branch(_unsupported)
174
128
 
175
129
    @staticmethod
176
130
    def open_containing(url, possible_transports=None):
177
131
        """Open an existing branch which contains url.
178
 
 
 
132
        
179
133
        This probes for a branch at url, and searches upwards from there.
180
134
 
181
135
        Basically we keep looking up until we find the control directory or
182
136
        run into the root.  If there isn't one, raises NotBranchError.
183
 
        If there is one and it is either an unrecognised format or an unsupported
 
137
        If there is one and it is either an unrecognised format or an unsupported 
184
138
        format, UnknownFormatError or UnsupportedFormatError are raised.
185
139
        If there is one, it is returned, along with the unused portion of url.
186
140
        """
188
142
                                                         possible_transports)
189
143
        return control.open_branch(), relpath
190
144
 
191
 
    def _push_should_merge_tags(self):
192
 
        """Should _basic_push merge this branch's tags into the target?
193
 
 
194
 
        The default implementation returns False if this branch has no tags,
195
 
        and True the rest of the time.  Subclasses may override this.
196
 
        """
197
 
        return self.supports_tags() and self.tags.get_tag_dict()
198
 
 
199
145
    def get_config(self):
200
146
        return BranchConfig(self)
201
147
 
202
 
    def _get_config(self):
203
 
        """Get the concrete config for just the config in this branch.
204
 
 
205
 
        This is not intended for client use; see Branch.get_config for the
206
 
        public API.
207
 
 
208
 
        Added in 1.14.
209
 
 
210
 
        :return: An object supporting get_option and set_option.
211
 
        """
212
 
        raise NotImplementedError(self._get_config)
213
 
 
214
 
    def _get_fallback_repository(self, url):
215
 
        """Get the repository we fallback to at url."""
216
 
        url = urlutils.join(self.base, url)
217
 
        a_branch = Branch.open(url,
218
 
            possible_transports=[self.bzrdir.root_transport])
219
 
        return a_branch.repository
220
 
 
221
 
    def _get_tags_bytes(self):
222
 
        """Get the bytes of a serialised tags dict.
223
 
 
224
 
        Note that not all branches support tags, nor do all use the same tags
225
 
        logic: this method is specific to BasicTags. Other tag implementations
226
 
        may use the same method name and behave differently, safely, because
227
 
        of the double-dispatch via
228
 
        format.make_tags->tags_instance->get_tags_dict.
229
 
 
230
 
        :return: The bytes of the tags file.
231
 
        :seealso: Branch._set_tags_bytes.
232
 
        """
233
 
        return self._transport.get_bytes('tags')
234
 
 
235
 
    def _get_nick(self, local=False, possible_transports=None):
236
 
        config = self.get_config()
237
 
        # explicit overrides master, but don't look for master if local is True
238
 
        if not local and not config.has_explicit_nickname():
239
 
            try:
240
 
                master = self.get_master_branch(possible_transports)
241
 
                if master is not None:
242
 
                    # return the master branch value
243
 
                    return master.nick
244
 
            except errors.BzrError, e:
245
 
                # Silently fall back to local implicit nick if the master is
246
 
                # unavailable
247
 
                mutter("Could not connect to bound branch, "
248
 
                    "falling back to local nick.\n " + str(e))
249
 
        return config.get_nickname()
 
148
    def _get_nick(self):
 
149
        return self.get_config().get_nickname()
250
150
 
251
151
    def _set_nick(self, nick):
252
152
        self.get_config().set_user_option('nickname', nick, warn_masked=True)
256
156
    def is_locked(self):
257
157
        raise NotImplementedError(self.is_locked)
258
158
 
259
 
    def _lefthand_history(self, revision_id, last_rev=None,
260
 
                          other_branch=None):
261
 
        if 'evil' in debug.debug_flags:
262
 
            mutter_callsite(4, "_lefthand_history scales with history.")
263
 
        # stop_revision must be a descendant of last_revision
264
 
        graph = self.repository.get_graph()
265
 
        if last_rev is not None:
266
 
            if not graph.is_ancestor(last_rev, revision_id):
267
 
                # our previous tip is not merged into stop_revision
268
 
                raise errors.DivergedBranches(self, other_branch)
269
 
        # make a new revision history from the graph
270
 
        parents_map = graph.get_parent_map([revision_id])
271
 
        if revision_id not in parents_map:
272
 
            raise errors.NoSuchRevision(self, revision_id)
273
 
        current_rev_id = revision_id
274
 
        new_history = []
275
 
        check_not_reserved_id = _mod_revision.check_not_reserved_id
276
 
        # Do not include ghosts or graph origin in revision_history
277
 
        while (current_rev_id in parents_map and
278
 
               len(parents_map[current_rev_id]) > 0):
279
 
            check_not_reserved_id(current_rev_id)
280
 
            new_history.append(current_rev_id)
281
 
            current_rev_id = parents_map[current_rev_id][0]
282
 
            parents_map = graph.get_parent_map([current_rev_id])
283
 
        new_history.reverse()
284
 
        return new_history
285
 
 
286
159
    def lock_write(self):
287
160
        raise NotImplementedError(self.lock_write)
288
161
 
300
173
        raise NotImplementedError(self.get_physical_lock_status)
301
174
 
302
175
    @needs_read_lock
303
 
    def dotted_revno_to_revision_id(self, revno, _cache_reverse=False):
304
 
        """Return the revision_id for a dotted revno.
305
 
 
306
 
        :param revno: a tuple like (1,) or (1,1,2)
307
 
        :param _cache_reverse: a private parameter enabling storage
308
 
           of the reverse mapping in a top level cache. (This should
309
 
           only be done in selective circumstances as we want to
310
 
           avoid having the mapping cached multiple times.)
311
 
        :return: the revision_id
312
 
        :raises errors.NoSuchRevision: if the revno doesn't exist
313
 
        """
314
 
        rev_id = self._do_dotted_revno_to_revision_id(revno)
315
 
        if _cache_reverse:
316
 
            self._partial_revision_id_to_revno_cache[rev_id] = revno
317
 
        return rev_id
318
 
 
319
 
    def _do_dotted_revno_to_revision_id(self, revno):
320
 
        """Worker function for dotted_revno_to_revision_id.
321
 
 
322
 
        Subclasses should override this if they wish to
323
 
        provide a more efficient implementation.
324
 
        """
325
 
        if len(revno) == 1:
326
 
            return self.get_rev_id(revno[0])
327
 
        revision_id_to_revno = self.get_revision_id_to_revno_map()
328
 
        revision_ids = [revision_id for revision_id, this_revno
329
 
                        in revision_id_to_revno.iteritems()
330
 
                        if revno == this_revno]
331
 
        if len(revision_ids) == 1:
332
 
            return revision_ids[0]
333
 
        else:
334
 
            revno_str = '.'.join(map(str, revno))
335
 
            raise errors.NoSuchRevision(self, revno_str)
336
 
 
337
 
    @needs_read_lock
338
 
    def revision_id_to_dotted_revno(self, revision_id):
339
 
        """Given a revision id, return its dotted revno.
340
 
 
341
 
        :return: a tuple like (1,) or (400,1,3).
342
 
        """
343
 
        return self._do_revision_id_to_dotted_revno(revision_id)
344
 
 
345
 
    def _do_revision_id_to_dotted_revno(self, revision_id):
346
 
        """Worker function for revision_id_to_revno."""
347
 
        # Try the caches if they are loaded
348
 
        result = self._partial_revision_id_to_revno_cache.get(revision_id)
349
 
        if result is not None:
350
 
            return result
351
 
        if self._revision_id_to_revno_cache:
352
 
            result = self._revision_id_to_revno_cache.get(revision_id)
353
 
            if result is None:
354
 
                raise errors.NoSuchRevision(self, revision_id)
355
 
        # Try the mainline as it's optimised
356
 
        try:
357
 
            revno = self.revision_id_to_revno(revision_id)
358
 
            return (revno,)
359
 
        except errors.NoSuchRevision:
360
 
            # We need to load and use the full revno map after all
361
 
            result = self.get_revision_id_to_revno_map().get(revision_id)
362
 
            if result is None:
363
 
                raise errors.NoSuchRevision(self, revision_id)
364
 
        return result
365
 
 
366
 
    @needs_read_lock
367
176
    def get_revision_id_to_revno_map(self):
368
177
        """Return the revision_id => dotted revno map.
369
178
 
393
202
 
394
203
        :return: A dictionary mapping revision_id => dotted revno.
395
204
        """
 
205
        last_revision = self.last_revision()
 
206
        revision_graph = repository._old_get_graph(self.repository,
 
207
            last_revision)
 
208
        merge_sorted_revisions = tsort.merge_sort(
 
209
            revision_graph,
 
210
            last_revision,
 
211
            None,
 
212
            generate_revno=True)
396
213
        revision_id_to_revno = dict((rev_id, revno)
397
 
            for rev_id, depth, revno, end_of_merge
398
 
             in self.iter_merge_sorted_revisions())
 
214
                                    for seq_num, rev_id, depth, revno, end_of_merge
 
215
                                     in merge_sorted_revisions)
399
216
        return revision_id_to_revno
400
217
 
401
 
    @needs_read_lock
402
 
    def iter_merge_sorted_revisions(self, start_revision_id=None,
403
 
            stop_revision_id=None, stop_rule='exclude', direction='reverse'):
404
 
        """Walk the revisions for a branch in merge sorted order.
405
 
 
406
 
        Merge sorted order is the output from a merge-aware,
407
 
        topological sort, i.e. all parents come before their
408
 
        children going forward; the opposite for reverse.
409
 
 
410
 
        :param start_revision_id: the revision_id to begin walking from.
411
 
            If None, the branch tip is used.
412
 
        :param stop_revision_id: the revision_id to terminate the walk
413
 
            after. If None, the rest of history is included.
414
 
        :param stop_rule: if stop_revision_id is not None, the precise rule
415
 
            to use for termination:
416
 
            * 'exclude' - leave the stop revision out of the result (default)
417
 
            * 'include' - the stop revision is the last item in the result
418
 
            * 'with-merges' - include the stop revision and all of its
419
 
              merged revisions in the result
420
 
            * 'with-merges-without-common-ancestry' - filter out revisions 
421
 
              that are in both ancestries
422
 
        :param direction: either 'reverse' or 'forward':
423
 
            * reverse means return the start_revision_id first, i.e.
424
 
              start at the most recent revision and go backwards in history
425
 
            * forward returns tuples in the opposite order to reverse.
426
 
              Note in particular that forward does *not* do any intelligent
427
 
              ordering w.r.t. depth as some clients of this API may like.
428
 
              (If required, that ought to be done at higher layers.)
429
 
 
430
 
        :return: an iterator over (revision_id, depth, revno, end_of_merge)
431
 
            tuples where:
432
 
 
433
 
            * revision_id: the unique id of the revision
434
 
            * depth: How many levels of merging deep this node has been
435
 
              found.
436
 
            * revno_sequence: This field provides a sequence of
437
 
              revision numbers for all revisions. The format is:
438
 
              (REVNO, BRANCHNUM, BRANCHREVNO). BRANCHNUM is the number of the
439
 
              branch that the revno is on. From left to right the REVNO numbers
440
 
              are the sequence numbers within that branch of the revision.
441
 
            * end_of_merge: When True the next node (earlier in history) is
442
 
              part of a different merge.
443
 
        """
444
 
        # Note: depth and revno values are in the context of the branch so
445
 
        # we need the full graph to get stable numbers, regardless of the
446
 
        # start_revision_id.
447
 
        if self._merge_sorted_revisions_cache is None:
448
 
            last_revision = self.last_revision()
449
 
            known_graph = self.repository.get_known_graph_ancestry(
450
 
                [last_revision])
451
 
            self._merge_sorted_revisions_cache = known_graph.merge_sort(
452
 
                last_revision)
453
 
        filtered = self._filter_merge_sorted_revisions(
454
 
            self._merge_sorted_revisions_cache, start_revision_id,
455
 
            stop_revision_id, stop_rule)
456
 
        # Make sure we don't return revisions that are not part of the
457
 
        # start_revision_id ancestry.
458
 
        filtered = self._filter_start_non_ancestors(filtered)
459
 
        if direction == 'reverse':
460
 
            return filtered
461
 
        if direction == 'forward':
462
 
            return reversed(list(filtered))
463
 
        else:
464
 
            raise ValueError('invalid direction %r' % direction)
465
 
 
466
 
    def _filter_merge_sorted_revisions(self, merge_sorted_revisions,
467
 
        start_revision_id, stop_revision_id, stop_rule):
468
 
        """Iterate over an inclusive range of sorted revisions."""
469
 
        rev_iter = iter(merge_sorted_revisions)
470
 
        if start_revision_id is not None:
471
 
            for node in rev_iter:
472
 
                rev_id = node.key[-1]
473
 
                if rev_id != start_revision_id:
474
 
                    continue
475
 
                else:
476
 
                    # The decision to include the start or not
477
 
                    # depends on the stop_rule if a stop is provided
478
 
                    # so pop this node back into the iterator
479
 
                    rev_iter = chain(iter([node]), rev_iter)
480
 
                    break
481
 
        if stop_revision_id is None:
482
 
            # Yield everything
483
 
            for node in rev_iter:
484
 
                rev_id = node.key[-1]
485
 
                yield (rev_id, node.merge_depth, node.revno,
486
 
                       node.end_of_merge)
487
 
        elif stop_rule == 'exclude':
488
 
            for node in rev_iter:
489
 
                rev_id = node.key[-1]
490
 
                if rev_id == stop_revision_id:
491
 
                    return
492
 
                yield (rev_id, node.merge_depth, node.revno,
493
 
                       node.end_of_merge)
494
 
        elif stop_rule == 'include':
495
 
            for node in rev_iter:
496
 
                rev_id = node.key[-1]
497
 
                yield (rev_id, node.merge_depth, node.revno,
498
 
                       node.end_of_merge)
499
 
                if rev_id == stop_revision_id:
500
 
                    return
501
 
        elif stop_rule == 'with-merges-without-common-ancestry':
502
 
            # We want to exclude all revisions that are already part of the
503
 
            # stop_revision_id ancestry.
504
 
            graph = self.repository.get_graph()
505
 
            ancestors = graph.find_unique_ancestors(start_revision_id,
506
 
                                                    [stop_revision_id])
507
 
            for node in rev_iter:
508
 
                rev_id = node.key[-1]
509
 
                if rev_id not in ancestors:
510
 
                    continue
511
 
                yield (rev_id, node.merge_depth, node.revno,
512
 
                       node.end_of_merge)
513
 
        elif stop_rule == 'with-merges':
514
 
            stop_rev = self.repository.get_revision(stop_revision_id)
515
 
            if stop_rev.parent_ids:
516
 
                left_parent = stop_rev.parent_ids[0]
517
 
            else:
518
 
                left_parent = _mod_revision.NULL_REVISION
519
 
            # left_parent is the actual revision we want to stop logging at,
520
 
            # since we want to show the merged revisions after the stop_rev too
521
 
            reached_stop_revision_id = False
522
 
            revision_id_whitelist = []
523
 
            for node in rev_iter:
524
 
                rev_id = node.key[-1]
525
 
                if rev_id == left_parent:
526
 
                    # reached the left parent after the stop_revision
527
 
                    return
528
 
                if (not reached_stop_revision_id or
529
 
                        rev_id in revision_id_whitelist):
530
 
                    yield (rev_id, node.merge_depth, node.revno,
531
 
                       node.end_of_merge)
532
 
                    if reached_stop_revision_id or rev_id == stop_revision_id:
533
 
                        # only do the merged revs of rev_id from now on
534
 
                        rev = self.repository.get_revision(rev_id)
535
 
                        if rev.parent_ids:
536
 
                            reached_stop_revision_id = True
537
 
                            revision_id_whitelist.extend(rev.parent_ids)
538
 
        else:
539
 
            raise ValueError('invalid stop_rule %r' % stop_rule)
540
 
 
541
 
    def _filter_start_non_ancestors(self, rev_iter):
542
 
        # If we started from a dotted revno, we want to consider it as a tip
543
 
        # and don't want to yield revisions that are not part of its
544
 
        # ancestry. Given the order guaranteed by the merge sort, we will see
545
 
        # uninteresting descendants of the first parent of our tip before the
546
 
        # tip itself.
547
 
        first = rev_iter.next()
548
 
        (rev_id, merge_depth, revno, end_of_merge) = first
549
 
        yield first
550
 
        if not merge_depth:
551
 
            # We start at a mainline revision so by definition, all others
552
 
            # revisions in rev_iter are ancestors
553
 
            for node in rev_iter:
554
 
                yield node
555
 
 
556
 
        clean = False
557
 
        whitelist = set()
558
 
        pmap = self.repository.get_parent_map([rev_id])
559
 
        parents = pmap.get(rev_id, [])
560
 
        if parents:
561
 
            whitelist.update(parents)
562
 
        else:
563
 
            # If there is no parents, there is nothing of interest left
564
 
 
565
 
            # FIXME: It's hard to test this scenario here as this code is never
566
 
            # called in that case. -- vila 20100322
567
 
            return
568
 
 
569
 
        for (rev_id, merge_depth, revno, end_of_merge) in rev_iter:
570
 
            if not clean:
571
 
                if rev_id in whitelist:
572
 
                    pmap = self.repository.get_parent_map([rev_id])
573
 
                    parents = pmap.get(rev_id, [])
574
 
                    whitelist.remove(rev_id)
575
 
                    whitelist.update(parents)
576
 
                    if merge_depth == 0:
577
 
                        # We've reached the mainline, there is nothing left to
578
 
                        # filter
579
 
                        clean = True
580
 
                else:
581
 
                    # A revision that is not part of the ancestry of our
582
 
                    # starting revision.
583
 
                    continue
584
 
            yield (rev_id, merge_depth, revno, end_of_merge)
585
 
 
586
218
    def leave_lock_in_place(self):
587
219
        """Tell this branch object not to release the physical lock when this
588
220
        object is unlocked.
589
 
 
 
221
        
590
222
        If lock_write doesn't return a token, then this method is not supported.
591
223
        """
592
224
        self.control_files.leave_in_place()
599
231
        """
600
232
        self.control_files.dont_leave_in_place()
601
233
 
 
234
    @deprecated_method(deprecated_in((0, 16, 0)))
 
235
    def abspath(self, name):
 
236
        """Return absolute filename for something in the branch
 
237
        
 
238
        XXX: Robert Collins 20051017 what is this used for? why is it a branch
 
239
        method and not a tree method.
 
240
        """
 
241
        raise NotImplementedError(self.abspath)
 
242
 
602
243
    def bind(self, other):
603
244
        """Bind the local branch the other branch.
604
245
 
605
246
        :param other: The branch to bind to
606
247
        :type other: Branch
607
248
        """
608
 
        raise errors.UpgradeRequired(self.user_url)
609
 
 
610
 
    def set_append_revisions_only(self, enabled):
611
 
        if not self._format.supports_set_append_revisions_only():
612
 
            raise errors.UpgradeRequired(self.user_url)
613
 
        if enabled:
614
 
            value = 'True'
615
 
        else:
616
 
            value = 'False'
617
 
        self.get_config().set_user_option('append_revisions_only', value,
618
 
            warn_masked=True)
619
 
 
620
 
    def set_reference_info(self, file_id, tree_path, branch_location):
621
 
        """Set the branch location to use for a tree reference."""
622
 
        raise errors.UnsupportedOperation(self.set_reference_info, self)
623
 
 
624
 
    def get_reference_info(self, file_id):
625
 
        """Get the tree_path and branch_location for a tree reference."""
626
 
        raise errors.UnsupportedOperation(self.get_reference_info, self)
 
249
        raise errors.UpgradeRequired(self.base)
627
250
 
628
251
    @needs_write_lock
629
252
    def fetch(self, from_branch, last_revision=None, pb=None):
633
256
        :param last_revision: What revision to stop at (None for at the end
634
257
                              of the branch.
635
258
        :param pb: An optional progress bar to use.
636
 
        :return: None
 
259
 
 
260
        Returns the copied revision count and the failed revisions in a tuple:
 
261
        (copied, failures).
637
262
        """
638
263
        if self.base == from_branch.base:
639
264
            return (0, [])
640
 
        if pb is not None:
641
 
            symbol_versioning.warn(
642
 
                symbol_versioning.deprecated_in((1, 14, 0))
643
 
                % "pb parameter to fetch()")
 
265
        if pb is None:
 
266
            nested_pb = ui.ui_factory.nested_progress_bar()
 
267
            pb = nested_pb
 
268
        else:
 
269
            nested_pb = None
 
270
 
644
271
        from_branch.lock_read()
645
272
        try:
646
273
            if last_revision is None:
 
274
                pb.update('get source history')
647
275
                last_revision = from_branch.last_revision()
648
276
                last_revision = _mod_revision.ensure_null(last_revision)
649
277
            return self.repository.fetch(from_branch.repository,
650
278
                                         revision_id=last_revision,
651
 
                                         pb=pb)
 
279
                                         pb=nested_pb)
652
280
        finally:
 
281
            if nested_pb is not None:
 
282
                nested_pb.finished()
653
283
            from_branch.unlock()
654
284
 
655
285
    def get_bound_location(self):
659
289
        branch.
660
290
        """
661
291
        return None
662
 
 
 
292
    
663
293
    def get_old_bound_location(self):
664
294
        """Return the URL of the branch we used to be bound to
665
295
        """
666
 
        raise errors.UpgradeRequired(self.user_url)
 
296
        raise errors.UpgradeRequired(self.base)
667
297
 
668
 
    def get_commit_builder(self, parents, config=None, timestamp=None,
669
 
                           timezone=None, committer=None, revprops=None,
 
298
    def get_commit_builder(self, parents, config=None, timestamp=None, 
 
299
                           timezone=None, committer=None, revprops=None, 
670
300
                           revision_id=None):
671
301
        """Obtain a CommitBuilder for this branch.
672
 
 
 
302
        
673
303
        :param parents: Revision ids of the parents of the new revision.
674
304
        :param config: Optional configuration to use.
675
305
        :param timestamp: Optional timestamp recorded for commit.
681
311
 
682
312
        if config is None:
683
313
            config = self.get_config()
684
 
 
 
314
        
685
315
        return self.repository.get_commit_builder(self, parents, config,
686
316
            timestamp, timezone, committer, revprops, revision_id)
687
317
 
688
318
    def get_master_branch(self, possible_transports=None):
689
319
        """Return the branch we are bound to.
690
 
 
 
320
        
691
321
        :return: Either a Branch, or None
692
322
        """
693
323
        return None
719
349
    def set_revision_history(self, rev_history):
720
350
        raise NotImplementedError(self.set_revision_history)
721
351
 
722
 
    @needs_write_lock
723
 
    def set_parent(self, url):
724
 
        """See Branch.set_parent."""
725
 
        # TODO: Maybe delete old location files?
726
 
        # URLs should never be unicode, even on the local fs,
727
 
        # FIXUP this and get_parent in a future branch format bump:
728
 
        # read and rewrite the file. RBC 20060125
729
 
        if url is not None:
730
 
            if isinstance(url, unicode):
731
 
                try:
732
 
                    url = url.encode('ascii')
733
 
                except UnicodeEncodeError:
734
 
                    raise errors.InvalidURL(url,
735
 
                        "Urls must be 7-bit ascii, "
736
 
                        "use bzrlib.urlutils.escape")
737
 
            url = urlutils.relative_url(self.base, url)
738
 
        self._set_parent_location(url)
739
 
 
740
 
    @needs_write_lock
741
352
    def set_stacked_on_url(self, url):
742
353
        """Set the URL this branch is stacked against.
743
354
 
746
357
        :raises UnstackableRepositoryFormat: If the repository does not support
747
358
            stacking.
748
359
        """
749
 
        if not self._format.supports_stacking():
750
 
            raise errors.UnstackableBranchFormat(self._format, self.user_url)
751
 
        # XXX: Changing from one fallback repository to another does not check
752
 
        # that all the data you need is present in the new fallback.
753
 
        # Possibly it should.
754
 
        self._check_stackable_repo()
755
 
        if not url:
756
 
            try:
757
 
                old_url = self.get_stacked_on_url()
758
 
            except (errors.NotStacked, errors.UnstackableBranchFormat,
759
 
                errors.UnstackableRepositoryFormat):
760
 
                return
761
 
            self._unstack()
762
 
        else:
763
 
            self._activate_fallback_location(url)
764
 
        # write this out after the repository is stacked to avoid setting a
765
 
        # stacked config that doesn't work.
766
 
        self._set_config_location('stacked_on_location', url)
767
 
 
768
 
    def _unstack(self):
769
 
        """Change a branch to be unstacked, copying data as needed.
770
 
        
771
 
        Don't call this directly, use set_stacked_on_url(None).
772
 
        """
773
 
        pb = ui.ui_factory.nested_progress_bar()
774
 
        try:
775
 
            pb.update("Unstacking")
776
 
            # The basic approach here is to fetch the tip of the branch,
777
 
            # including all available ghosts, from the existing stacked
778
 
            # repository into a new repository object without the fallbacks. 
779
 
            #
780
 
            # XXX: See <https://launchpad.net/bugs/397286> - this may not be
781
 
            # correct for CHKMap repostiories
782
 
            old_repository = self.repository
783
 
            if len(old_repository._fallback_repositories) != 1:
784
 
                raise AssertionError("can't cope with fallback repositories "
785
 
                    "of %r" % (self.repository,))
786
 
            # unlock it, including unlocking the fallback
787
 
            old_repository.unlock()
788
 
            old_repository.lock_read()
789
 
            try:
790
 
                # Repositories don't offer an interface to remove fallback
791
 
                # repositories today; take the conceptually simpler option and just
792
 
                # reopen it.  We reopen it starting from the URL so that we
793
 
                # get a separate connection for RemoteRepositories and can
794
 
                # stream from one of them to the other.  This does mean doing
795
 
                # separate SSH connection setup, but unstacking is not a
796
 
                # common operation so it's tolerable.
797
 
                new_bzrdir = bzrdir.BzrDir.open(self.bzrdir.root_transport.base)
798
 
                new_repository = new_bzrdir.find_repository()
799
 
                self.repository = new_repository
800
 
                if self.repository._fallback_repositories:
801
 
                    raise AssertionError("didn't expect %r to have "
802
 
                        "fallback_repositories"
803
 
                        % (self.repository,))
804
 
                # this is not paired with an unlock because it's just restoring
805
 
                # the previous state; the lock's released when set_stacked_on_url
806
 
                # returns
807
 
                self.repository.lock_write()
808
 
                # XXX: If you unstack a branch while it has a working tree
809
 
                # with a pending merge, the pending-merged revisions will no
810
 
                # longer be present.  You can (probably) revert and remerge.
811
 
                #
812
 
                # XXX: This only fetches up to the tip of the repository; it
813
 
                # doesn't bring across any tags.  That's fairly consistent
814
 
                # with how branch works, but perhaps not ideal.
815
 
                self.repository.fetch(old_repository,
816
 
                    revision_id=self.last_revision(),
817
 
                    find_ghosts=True)
818
 
            finally:
819
 
                old_repository.unlock()
820
 
        finally:
821
 
            pb.finished()
822
 
 
823
 
    def _set_tags_bytes(self, bytes):
824
 
        """Mirror method for _get_tags_bytes.
825
 
 
826
 
        :seealso: Branch._get_tags_bytes.
827
 
        """
828
 
        return _run_with_write_locked_target(self, self._transport.put_bytes,
829
 
            'tags', bytes)
 
360
        raise NotImplementedError(self.set_stacked_on_url)
830
361
 
831
362
    def _cache_revision_history(self, rev_history):
832
363
        """Set the cached revision history to rev_history.
859
390
        self._revision_history_cache = None
860
391
        self._revision_id_to_revno_cache = None
861
392
        self._last_revision_info_cache = None
862
 
        self._merge_sorted_revisions_cache = None
863
 
        self._partial_revision_history_cache = []
864
 
        self._partial_revision_id_to_revno_cache = {}
865
393
 
866
394
    def _gen_revision_history(self):
867
395
        """Return sequence of revision hashes on to this branch.
868
 
 
 
396
        
869
397
        Unlike revision_history, this method always regenerates or rereads the
870
398
        revision history, i.e. it does not cache the result, so repeated calls
871
399
        may be expensive.
872
400
 
873
401
        Concrete subclasses should override this instead of revision_history so
874
402
        that subclasses do not need to deal with caching logic.
875
 
 
 
403
        
876
404
        This API is semi-public; it only for use by subclasses, all other code
877
405
        should consider it to be private.
878
406
        """
881
409
    @needs_read_lock
882
410
    def revision_history(self):
883
411
        """Return sequence of revision ids on this branch.
884
 
 
 
412
        
885
413
        This method will cache the revision history for as long as it is safe to
886
414
        do so.
887
415
        """
904
432
 
905
433
    def unbind(self):
906
434
        """Older format branches cannot bind or unbind."""
907
 
        raise errors.UpgradeRequired(self.user_url)
 
435
        raise errors.UpgradeRequired(self.base)
 
436
 
 
437
    def set_append_revisions_only(self, enabled):
 
438
        """Older format branches are never restricted to append-only"""
 
439
        raise errors.UpgradeRequired(self.base)
908
440
 
909
441
    def last_revision(self):
910
442
        """Return last revision id, or NULL_REVISION."""
931
463
    @deprecated_method(deprecated_in((1, 6, 0)))
932
464
    def missing_revisions(self, other, stop_revision=None):
933
465
        """Return a list of new revisions that would perfectly fit.
934
 
 
 
466
        
935
467
        If self and other have not diverged, return a list of the revisions
936
468
        present in other, but missing from self.
937
469
        """
964
496
            information. This can be None.
965
497
        :return: None
966
498
        """
967
 
        return InterBranch.get(other, self).update_revisions(stop_revision,
968
 
            overwrite, graph)
969
 
 
970
 
    def import_last_revision_info(self, source_repo, revno, revid):
971
 
        """Set the last revision info, importing from another repo if necessary.
972
 
 
973
 
        This is used by the bound branch code to upload a revision to
974
 
        the master branch first before updating the tip of the local branch.
975
 
 
976
 
        :param source_repo: Source repository to optionally fetch from
977
 
        :param revno: Revision number of the new tip
978
 
        :param revid: Revision id of the new tip
979
 
        """
980
 
        if not self.repository.has_same_location(source_repo):
981
 
            self.repository.fetch(source_repo, revision_id=revid)
982
 
        self.set_last_revision_info(revno, revid)
 
499
        other.lock_read()
 
500
        try:
 
501
            other_revno, other_last_revision = other.last_revision_info()
 
502
            stop_revno = None # unknown
 
503
            if stop_revision is None:
 
504
                stop_revision = other_last_revision
 
505
                if _mod_revision.is_null(stop_revision):
 
506
                    # if there are no commits, we're done.
 
507
                    return
 
508
                stop_revno = other_revno
 
509
 
 
510
            # what's the current last revision, before we fetch [and change it
 
511
            # possibly]
 
512
            last_rev = _mod_revision.ensure_null(self.last_revision())
 
513
            # we fetch here so that we don't process data twice in the common
 
514
            # case of having something to pull, and so that the check for 
 
515
            # already merged can operate on the just fetched graph, which will
 
516
            # be cached in memory.
 
517
            self.fetch(other, stop_revision)
 
518
            # Check to see if one is an ancestor of the other
 
519
            if not overwrite:
 
520
                if graph is None:
 
521
                    graph = self.repository.get_graph()
 
522
                if self._check_if_descendant_or_diverged(
 
523
                        stop_revision, last_rev, graph, other):
 
524
                    # stop_revision is a descendant of last_rev, but we aren't
 
525
                    # overwriting, so we're done.
 
526
                    return
 
527
            if stop_revno is None:
 
528
                if graph is None:
 
529
                    graph = self.repository.get_graph()
 
530
                this_revno, this_last_revision = self.last_revision_info()
 
531
                stop_revno = graph.find_distance_to_null(stop_revision,
 
532
                                [(other_last_revision, other_revno),
 
533
                                 (this_last_revision, this_revno)])
 
534
            self.set_last_revision_info(stop_revno, stop_revision)
 
535
        finally:
 
536
            other.unlock()
983
537
 
984
538
    def revision_id_to_revno(self, revision_id):
985
539
        """Given a revision id, return its revno"""
991
545
        except ValueError:
992
546
            raise errors.NoSuchRevision(self, revision_id)
993
547
 
994
 
    @needs_read_lock
995
548
    def get_rev_id(self, revno, history=None):
996
549
        """Find the revision id of the specified revno."""
997
550
        if revno == 0:
998
551
            return _mod_revision.NULL_REVISION
999
 
        last_revno, last_revid = self.last_revision_info()
1000
 
        if revno == last_revno:
1001
 
            return last_revid
1002
 
        if revno <= 0 or revno > last_revno:
 
552
        if history is None:
 
553
            history = self.revision_history()
 
554
        if revno <= 0 or revno > len(history):
1003
555
            raise errors.NoSuchRevision(self, revno)
1004
 
        distance_from_last = last_revno - revno
1005
 
        if len(self._partial_revision_history_cache) <= distance_from_last:
1006
 
            self._extend_partial_history(distance_from_last)
1007
 
        return self._partial_revision_history_cache[distance_from_last]
 
556
        return history[revno - 1]
1008
557
 
1009
 
    @needs_write_lock
1010
558
    def pull(self, source, overwrite=False, stop_revision=None,
1011
 
             possible_transports=None, *args, **kwargs):
 
559
             possible_transports=None, _override_hook_target=None):
1012
560
        """Mirror source into this branch.
1013
561
 
1014
562
        This branch is considered to be 'local', having low latency.
1015
563
 
1016
564
        :returns: PullResult instance
1017
565
        """
1018
 
        return InterBranch.get(source, self).pull(overwrite=overwrite,
1019
 
            stop_revision=stop_revision,
1020
 
            possible_transports=possible_transports, *args, **kwargs)
 
566
        raise NotImplementedError(self.pull)
1021
567
 
1022
 
    def push(self, target, overwrite=False, stop_revision=None, *args,
1023
 
        **kwargs):
 
568
    def push(self, target, overwrite=False, stop_revision=None):
1024
569
        """Mirror this branch into target.
1025
570
 
1026
571
        This branch is considered to be 'local', having low latency.
1027
572
        """
1028
 
        return InterBranch.get(self, target).push(overwrite, stop_revision,
1029
 
            *args, **kwargs)
1030
 
 
1031
 
    def lossy_push(self, target, stop_revision=None):
1032
 
        """Push deltas into another branch.
1033
 
 
1034
 
        :note: This does not, like push, retain the revision ids from 
1035
 
            the source branch and will, rather than adding bzr-specific 
1036
 
            metadata, push only those semantics of the revision that can be 
1037
 
            natively represented by this branch' VCS.
1038
 
 
1039
 
        :param target: Target branch
1040
 
        :param stop_revision: Revision to push, defaults to last revision.
1041
 
        :return: BranchPushResult with an extra member revidmap: 
1042
 
            A dictionary mapping revision ids from the target branch 
1043
 
            to new revision ids in the target branch, for each 
1044
 
            revision that was pushed.
1045
 
        """
1046
 
        inter = InterBranch.get(self, target)
1047
 
        lossy_push = getattr(inter, "lossy_push", None)
1048
 
        if lossy_push is None:
1049
 
            raise errors.LossyPushToSameVCS(self, target)
1050
 
        return lossy_push(stop_revision)
 
573
        raise NotImplementedError(self.push)
1051
574
 
1052
575
    def basis_tree(self):
1053
576
        """Return `Tree` object for last revision."""
1054
577
        return self.repository.revision_tree(self.last_revision())
1055
578
 
 
579
    def rename_one(self, from_rel, to_rel):
 
580
        """Rename one file.
 
581
 
 
582
        This can change the directory or the filename or both.
 
583
        """
 
584
        raise NotImplementedError(self.rename_one)
 
585
 
 
586
    def move(self, from_paths, to_name):
 
587
        """Rename files.
 
588
 
 
589
        to_name must exist as a versioned directory.
 
590
 
 
591
        If to_name exists and is a directory, the files are moved into
 
592
        it, keeping their old names.  If it is a directory, 
 
593
 
 
594
        Note that to_name is only the last component of the new name;
 
595
        this doesn't change the directory.
 
596
 
 
597
        This returns a list of (from_path, to_path) pairs for each
 
598
        entry that is moved.
 
599
        """
 
600
        raise NotImplementedError(self.move)
 
601
 
1056
602
    def get_parent(self):
1057
603
        """Return the parent location of the branch.
1058
604
 
1059
 
        This is the default location for pull/missing.  The usual
 
605
        This is the default location for push/pull/missing.  The usual
1060
606
        pattern is that the user can override it by specifying a
1061
607
        location.
1062
608
        """
1063
 
        parent = self._get_parent_location()
1064
 
        if parent is None:
1065
 
            return parent
1066
 
        # This is an old-format absolute path to a local branch
1067
 
        # turn it into a url
1068
 
        if parent.startswith('/'):
1069
 
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
1070
 
        try:
1071
 
            return urlutils.join(self.base[:-1], parent)
1072
 
        except errors.InvalidURLJoin, e:
1073
 
            raise errors.InaccessibleParent(parent, self.user_url)
1074
 
 
1075
 
    def _get_parent_location(self):
1076
 
        raise NotImplementedError(self._get_parent_location)
 
609
        raise NotImplementedError(self.get_parent)
1077
610
 
1078
611
    def _set_config_location(self, name, url, config=None,
1079
612
                             make_relative=False):
1093
626
            location = None
1094
627
        return location
1095
628
 
1096
 
    def get_child_submit_format(self):
1097
 
        """Return the preferred format of submissions to this branch."""
1098
 
        return self.get_config().get_user_option("child_submit_format")
1099
 
 
1100
629
    def get_submit_branch(self):
1101
630
        """Return the submit location of the branch.
1102
631
 
1119
648
    def get_public_branch(self):
1120
649
        """Return the public location of the branch.
1121
650
 
1122
 
        This is used by merge directives.
 
651
        This is is used by merge directives.
1123
652
        """
1124
653
        return self._get_config_location('public_branch')
1125
654
 
1141
670
        """Set a new push location for this branch."""
1142
671
        raise NotImplementedError(self.set_push_location)
1143
672
 
1144
 
    def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
1145
 
        """Run the post_change_branch_tip hooks."""
1146
 
        hooks = Branch.hooks['post_change_branch_tip']
1147
 
        if not hooks:
1148
 
            return
1149
 
        new_revno, new_revid = self.last_revision_info()
1150
 
        params = ChangeBranchTipParams(
1151
 
            self, old_revno, new_revno, old_revid, new_revid)
1152
 
        for hook in hooks:
1153
 
            hook(params)
1154
 
 
1155
 
    def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
1156
 
        """Run the pre_change_branch_tip hooks."""
1157
 
        hooks = Branch.hooks['pre_change_branch_tip']
1158
 
        if not hooks:
1159
 
            return
1160
 
        old_revno, old_revid = self.last_revision_info()
1161
 
        params = ChangeBranchTipParams(
1162
 
            self, old_revno, new_revno, old_revid, new_revid)
1163
 
        for hook in hooks:
1164
 
            hook(params)
 
673
    def set_parent(self, url):
 
674
        raise NotImplementedError(self.set_parent)
1165
675
 
1166
676
    @needs_write_lock
1167
677
    def update(self):
1168
 
        """Synchronise this branch with the master branch if any.
 
678
        """Synchronise this branch with the master branch if any. 
1169
679
 
1170
680
        :return: None or the last_revision pivoted out during the update.
1171
681
        """
1178
688
        """
1179
689
        if revno != 0:
1180
690
            self.check_real_revno(revno)
1181
 
 
 
691
            
1182
692
    def check_real_revno(self, revno):
1183
693
        """\
1184
694
        Check whether a revno corresponds to a real revision.
1188
698
            raise errors.InvalidRevisionNumber(revno)
1189
699
 
1190
700
    @needs_read_lock
1191
 
    def clone(self, to_bzrdir, revision_id=None, repository_policy=None):
 
701
    def clone(self, to_bzrdir, revision_id=None):
1192
702
        """Clone this branch into to_bzrdir preserving all semantic values.
1193
 
 
1194
 
        Most API users will want 'create_clone_on_transport', which creates a
1195
 
        new bzrdir and branch on the fly.
1196
 
 
 
703
        
1197
704
        revision_id: if not None, the revision history in the new branch will
1198
705
                     be truncated to end with revision_id.
1199
706
        """
1200
 
        result = to_bzrdir.create_branch()
1201
 
        result.lock_write()
1202
 
        try:
1203
 
            if repository_policy is not None:
1204
 
                repository_policy.configure_branch(result)
1205
 
            self.copy_content_into(result, revision_id=revision_id)
1206
 
        finally:
1207
 
            result.unlock()
1208
 
        return result
 
707
        result = self._format.initialize(to_bzrdir)
 
708
        self.copy_content_into(result, revision_id=revision_id)
 
709
        return  result
1209
710
 
1210
711
    @needs_read_lock
1211
 
    def sprout(self, to_bzrdir, revision_id=None, repository_policy=None):
 
712
    def sprout(self, to_bzrdir, revision_id=None):
1212
713
        """Create a new line of development from the branch, into to_bzrdir.
1213
 
 
1214
 
        to_bzrdir controls the branch format.
1215
 
 
 
714
        
1216
715
        revision_id: if not None, the revision history in the new branch will
1217
716
                     be truncated to end with revision_id.
1218
717
        """
1219
 
        if (repository_policy is not None and
1220
 
            repository_policy.requires_stacking()):
1221
 
            to_bzrdir._format.require_stacking(_skip_repo=True)
1222
 
        result = to_bzrdir.create_branch()
1223
 
        result.lock_write()
1224
 
        try:
1225
 
            if repository_policy is not None:
1226
 
                repository_policy.configure_branch(result)
1227
 
            self.copy_content_into(result, revision_id=revision_id)
1228
 
            result.set_parent(self.bzrdir.root_transport.base)
1229
 
        finally:
1230
 
            result.unlock()
 
718
        result = self._format.initialize(to_bzrdir)
 
719
        self.copy_content_into(result, revision_id=revision_id)
 
720
        result.set_parent(self.bzrdir.root_transport.base)
1231
721
        return result
1232
722
 
1233
723
    def _synchronize_history(self, destination, revision_id):
1234
724
        """Synchronize last revision and revision history between branches.
1235
725
 
1236
726
        This version is most efficient when the destination is also a
1237
 
        BzrBranch6, but works for BzrBranch5, as long as the destination's
1238
 
        repository contains all the lefthand ancestors of the intended
1239
 
        last_revision.  If not, set_last_revision_info will fail.
 
727
        BzrBranch5, but works for BzrBranch6 as long as the revision
 
728
        history is the true lefthand parent history, and all of the revisions
 
729
        are in the destination's repository.  If not, set_revision_history
 
730
        will fail.
1240
731
 
1241
732
        :param destination: The branch to copy the history into
1242
733
        :param revision_id: The revision-id to truncate history at.  May
1243
734
          be None to copy complete history.
1244
735
        """
1245
 
        source_revno, source_revision_id = self.last_revision_info()
1246
 
        if revision_id is None:
1247
 
            revno, revision_id = source_revno, source_revision_id
1248
 
        else:
1249
 
            graph = self.repository.get_graph()
 
736
        if revision_id == _mod_revision.NULL_REVISION:
 
737
            new_history = []
 
738
        new_history = self.revision_history()
 
739
        if revision_id is not None and new_history != []:
1250
740
            try:
1251
 
                revno = graph.find_distance_to_null(revision_id, 
1252
 
                    [(source_revision_id, source_revno)])
1253
 
            except errors.GhostRevisionsHaveNoRevno:
1254
 
                # Default to 1, if we can't find anything else
1255
 
                revno = 1
1256
 
        destination.set_last_revision_info(revno, revision_id)
 
741
                new_history = new_history[:new_history.index(revision_id) + 1]
 
742
            except ValueError:
 
743
                rev = self.repository.get_revision(revision_id)
 
744
                new_history = rev.get_history(self.repository)[1:]
 
745
        destination.set_revision_history(new_history)
1257
746
 
1258
747
    @needs_read_lock
1259
748
    def copy_content_into(self, destination, revision_id=None):
1262
751
        revision_id: if not None, the revision history in the new branch will
1263
752
                     be truncated to end with revision_id.
1264
753
        """
1265
 
        self.update_references(destination)
1266
754
        self._synchronize_history(destination, revision_id)
1267
755
        try:
1268
756
            parent = self.get_parent()
1271
759
        else:
1272
760
            if parent:
1273
761
                destination.set_parent(parent)
1274
 
        if self._push_should_merge_tags():
1275
 
            self.tags.merge_to(destination.tags)
1276
 
 
1277
 
    def update_references(self, target):
1278
 
        if not getattr(self._format, 'supports_reference_locations', False):
1279
 
            return
1280
 
        reference_dict = self._get_all_reference_info()
1281
 
        if len(reference_dict) == 0:
1282
 
            return
1283
 
        old_base = self.base
1284
 
        new_base = target.base
1285
 
        target_reference_dict = target._get_all_reference_info()
1286
 
        for file_id, (tree_path, branch_location) in (
1287
 
            reference_dict.items()):
1288
 
            branch_location = urlutils.rebase_url(branch_location,
1289
 
                                                  old_base, new_base)
1290
 
            target_reference_dict.setdefault(
1291
 
                file_id, (tree_path, branch_location))
1292
 
        target._set_all_reference_info(target_reference_dict)
 
762
        self.tags.merge_to(destination.tags)
1293
763
 
1294
764
    @needs_read_lock
1295
 
    def check(self, refs):
 
765
    def check(self):
1296
766
        """Check consistency of the branch.
1297
767
 
1298
768
        In particular this checks that revisions given in the revision-history
1299
 
        do actually match up in the revision graph, and that they're all
 
769
        do actually match up in the revision graph, and that they're all 
1300
770
        present in the repository.
1301
 
 
 
771
        
1302
772
        Callers will typically also want to check the repository.
1303
773
 
1304
 
        :param refs: Calculated refs for this branch as specified by
1305
 
            branch._get_check_refs()
1306
774
        :return: A BranchCheckResult.
1307
775
        """
1308
 
        result = BranchCheckResult(self)
 
776
        mainline_parent_id = None
1309
777
        last_revno, last_revision_id = self.last_revision_info()
1310
 
        actual_revno = refs[('lefthand-distance', last_revision_id)]
1311
 
        if actual_revno != last_revno:
1312
 
            result.errors.append(errors.BzrCheckError(
1313
 
                'revno does not match len(mainline) %s != %s' % (
1314
 
                last_revno, actual_revno)))
1315
 
        # TODO: We should probably also check that self.revision_history
1316
 
        # matches the repository for older branch formats.
1317
 
        # If looking for the code that cross-checks repository parents against
1318
 
        # the iter_reverse_revision_history output, that is now a repository
1319
 
        # specific check.
1320
 
        return result
 
778
        real_rev_history = list(self.repository.iter_reverse_revision_history(
 
779
                                last_revision_id))
 
780
        real_rev_history.reverse()
 
781
        if len(real_rev_history) != last_revno:
 
782
            raise errors.BzrCheckError('revno does not match len(mainline)'
 
783
                ' %s != %s' % (last_revno, len(real_rev_history)))
 
784
        # TODO: We should probably also check that real_rev_history actually
 
785
        #       matches self.revision_history()
 
786
        for revision_id in real_rev_history:
 
787
            try:
 
788
                revision = self.repository.get_revision(revision_id)
 
789
            except errors.NoSuchRevision, e:
 
790
                raise errors.BzrCheckError("mainline revision {%s} not in repository"
 
791
                            % revision_id)
 
792
            # In general the first entry on the revision history has no parents.
 
793
            # But it's not illegal for it to have parents listed; this can happen
 
794
            # in imports from Arch when the parents weren't reachable.
 
795
            if mainline_parent_id is not None:
 
796
                if mainline_parent_id not in revision.parent_ids:
 
797
                    raise errors.BzrCheckError("previous revision {%s} not listed among "
 
798
                                        "parents of {%s}"
 
799
                                        % (mainline_parent_id, revision_id))
 
800
            mainline_parent_id = revision_id
 
801
        return BranchCheckResult(self)
1321
802
 
1322
803
    def _get_checkout_format(self):
1323
804
        """Return the most suitable metadir for a checkout of this branch.
1332
813
            format.set_branch_format(self._format)
1333
814
        return format
1334
815
 
1335
 
    def create_clone_on_transport(self, to_transport, revision_id=None,
1336
 
        stacked_on=None, create_prefix=False, use_existing_dir=False):
1337
 
        """Create a clone of this branch and its bzrdir.
1338
 
 
1339
 
        :param to_transport: The transport to clone onto.
1340
 
        :param revision_id: The revision id to use as tip in the new branch.
1341
 
            If None the tip is obtained from this branch.
1342
 
        :param stacked_on: An optional URL to stack the clone on.
1343
 
        :param create_prefix: Create any missing directories leading up to
1344
 
            to_transport.
1345
 
        :param use_existing_dir: Use an existing directory if one exists.
1346
 
        """
1347
 
        # XXX: Fix the bzrdir API to allow getting the branch back from the
1348
 
        # clone call. Or something. 20090224 RBC/spiv.
1349
 
        if revision_id is None:
1350
 
            revision_id = self.last_revision()
1351
 
        dir_to = self.bzrdir.clone_on_transport(to_transport,
1352
 
            revision_id=revision_id, stacked_on=stacked_on,
1353
 
            create_prefix=create_prefix, use_existing_dir=use_existing_dir)
1354
 
        return dir_to.open_branch()
1355
 
 
1356
816
    def create_checkout(self, to_location, revision_id=None,
1357
817
                        lightweight=False, accelerator_tree=None,
1358
818
                        hardlink=False):
1359
819
        """Create a checkout of a branch.
1360
 
 
 
820
        
1361
821
        :param to_location: The url to produce the checkout at
1362
822
        :param revision_id: The revision to check out
1363
823
        :param lightweight: If True, produce a lightweight checkout, otherwise,
1375
835
        if lightweight:
1376
836
            format = self._get_checkout_format()
1377
837
            checkout = format.initialize_on_transport(t)
1378
 
            from_branch = BranchReferenceFormat().initialize(checkout, 
1379
 
                target_branch=self)
 
838
            from_branch = BranchReferenceFormat().initialize(checkout, self)
1380
839
        else:
1381
840
            format = self._get_checkout_format()
1382
841
            checkout_branch = bzrdir.BzrDir.create_branch_convenience(
1383
842
                to_location, force_new_tree=False, format=format)
1384
843
            checkout = checkout_branch.bzrdir
1385
844
            checkout_branch.bind(self)
1386
 
            # pull up to the specified revision_id to set the initial
 
845
            # pull up to the specified revision_id to set the initial 
1387
846
            # branch tip correctly, and seed it with history.
1388
847
            checkout_branch.pull(self, stop_revision=revision_id)
1389
848
            from_branch=None
1411
870
        reconciler.reconcile()
1412
871
        return reconciler
1413
872
 
1414
 
    def reference_parent(self, file_id, path, possible_transports=None):
 
873
    def reference_parent(self, file_id, path):
1415
874
        """Return the parent branch for a tree-reference file_id
1416
875
        :param file_id: The file_id of the tree reference
1417
876
        :param path: The path of the file_id in the tree
1418
877
        :return: A branch associated with the file_id
1419
878
        """
1420
879
        # FIXME should provide multiple branches, based on config
1421
 
        return Branch.open(self.bzrdir.root_transport.clone(path).base,
1422
 
                           possible_transports=possible_transports)
 
880
        return Branch.open(self.bzrdir.root_transport.clone(path).base)
1423
881
 
1424
882
    def supports_tags(self):
1425
883
        return self._format.supports_tags()
1426
884
 
1427
 
    def automatic_tag_name(self, revision_id):
1428
 
        """Try to automatically find the tag name for a revision.
1429
 
 
1430
 
        :param revision_id: Revision id of the revision.
1431
 
        :return: A tag name or None if no tag name could be determined.
1432
 
        """
1433
 
        for hook in Branch.hooks['automatic_tag_name']:
1434
 
            ret = hook(self, revision_id)
1435
 
            if ret is not None:
1436
 
                return ret
1437
 
        return None
1438
 
 
1439
885
    def _check_if_descendant_or_diverged(self, revision_a, revision_b, graph,
1440
886
                                         other_branch):
1441
887
        """Ensure that revision_b is a descendant of revision_a.
1442
888
 
1443
889
        This is a helper function for update_revisions.
1444
 
 
 
890
        
1445
891
        :raises: DivergedBranches if revision_b has diverged from revision_a.
1446
892
        :returns: True if revision_b is a descendant of revision_a.
1447
893
        """
1457
903
 
1458
904
    def _revision_relations(self, revision_a, revision_b, graph):
1459
905
        """Determine the relationship between two revisions.
1460
 
 
 
906
        
1461
907
        :returns: One of: 'a_descends_from_b', 'b_descends_from_a', 'diverged'
1462
908
        """
1463
909
        heads = graph.heads([revision_a, revision_b])
1480
926
     * a format string,
1481
927
     * an open routine.
1482
928
 
1483
 
    Formats are placed in an dict by their format string for reference
 
929
    Formats are placed in an dict by their format string for reference 
1484
930
    during branch opening. Its not required that these be instances, they
1485
 
    can be classes themselves with class methods - it simply depends on
 
931
    can be classes themselves with class methods - it simply depends on 
1486
932
    whether state is needed for a given format or not.
1487
933
 
1488
934
    Once a format is deprecated, just deprecate the initialize and open
1489
 
    methods on the format class. Do not deprecate the object, as the
 
935
    methods on the format class. Do not deprecate the object, as the 
1490
936
    object will be created every time regardless.
1491
937
    """
1492
938
 
1496
942
    _formats = {}
1497
943
    """The known formats."""
1498
944
 
1499
 
    can_set_append_revisions_only = True
1500
 
 
1501
945
    def __eq__(self, other):
1502
946
        return self.__class__ is other.__class__
1503
947
 
1505
949
        return not (self == other)
1506
950
 
1507
951
    @classmethod
1508
 
    def find_format(klass, a_bzrdir, name=None):
 
952
    def find_format(klass, a_bzrdir):
1509
953
        """Return the format for the branch object in a_bzrdir."""
1510
954
        try:
1511
 
            transport = a_bzrdir.get_branch_transport(None, name=name)
1512
 
            format_string = transport.get_bytes("format")
 
955
            transport = a_bzrdir.get_branch_transport(None)
 
956
            format_string = transport.get("format").read()
1513
957
            return klass._formats[format_string]
1514
958
        except errors.NoSuchFile:
1515
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
 
959
            raise errors.NotBranchError(path=transport.base)
1516
960
        except KeyError:
1517
961
            raise errors.UnknownFormatError(format=format_string, kind='branch')
1518
962
 
1554
998
        """Return the short format description for this format."""
1555
999
        raise NotImplementedError(self.get_format_description)
1556
1000
 
1557
 
    def _run_post_branch_init_hooks(self, a_bzrdir, name, branch):
1558
 
        hooks = Branch.hooks['post_branch_init']
1559
 
        if not hooks:
1560
 
            return
1561
 
        params = BranchInitHookParams(self, a_bzrdir, name, branch)
1562
 
        for hook in hooks:
1563
 
            hook(params)
1564
 
 
1565
 
    def _initialize_helper(self, a_bzrdir, utf8_files, name=None,
1566
 
                           lock_type='metadir', set_format=True):
 
1001
    def _initialize_helper(self, a_bzrdir, utf8_files, lock_type='metadir',
 
1002
                           set_format=True):
1567
1003
        """Initialize a branch in a bzrdir, with specified files
1568
1004
 
1569
1005
        :param a_bzrdir: The bzrdir to initialize the branch in
1570
1006
        :param utf8_files: The files to create as a list of
1571
1007
            (filename, content) tuples
1572
 
        :param name: Name of colocated branch to create, if any
1573
1008
        :param set_format: If True, set the format with
1574
1009
            self.get_format_string.  (BzrBranch4 has its format set
1575
1010
            elsewhere)
1576
1011
        :return: a branch in this format
1577
1012
        """
1578
 
        mutter('creating branch %r in %s', self, a_bzrdir.user_url)
1579
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
1013
        mutter('creating branch %r in %s', self, a_bzrdir.transport.base)
 
1014
        branch_transport = a_bzrdir.get_branch_transport(self)
1580
1015
        lock_map = {
1581
1016
            'metadir': ('lock', lockdir.LockDir),
1582
1017
            'branch4': ('branch-lock', lockable_files.TransportLock),
1585
1020
        control_files = lockable_files.LockableFiles(branch_transport,
1586
1021
            lock_name, lock_class)
1587
1022
        control_files.create_lock()
1588
 
        try:
1589
 
            control_files.lock_write()
1590
 
        except errors.LockContention:
1591
 
            if lock_type != 'branch4':
1592
 
                raise
1593
 
            lock_taken = False
1594
 
        else:
1595
 
            lock_taken = True
 
1023
        control_files.lock_write()
1596
1024
        if set_format:
1597
1025
            utf8_files += [('format', self.get_format_string())]
1598
1026
        try:
1601
1029
                    filename, content,
1602
1030
                    mode=a_bzrdir._get_file_mode())
1603
1031
        finally:
1604
 
            if lock_taken:
1605
 
                control_files.unlock()
1606
 
        branch = self.open(a_bzrdir, name, _found=True)
1607
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
1608
 
        return branch
 
1032
            control_files.unlock()
 
1033
        return self.open(a_bzrdir, _found=True)
1609
1034
 
1610
 
    def initialize(self, a_bzrdir, name=None):
1611
 
        """Create a branch of this format in a_bzrdir.
1612
 
        
1613
 
        :param name: Name of the colocated branch to create.
1614
 
        """
 
1035
    def initialize(self, a_bzrdir):
 
1036
        """Create a branch of this format in a_bzrdir."""
1615
1037
        raise NotImplementedError(self.initialize)
1616
1038
 
1617
1039
    def is_supported(self):
1618
1040
        """Is this format supported?
1619
1041
 
1620
1042
        Supported formats can be initialized and opened.
1621
 
        Unsupported formats may not support initialization or committing or
 
1043
        Unsupported formats may not support initialization or committing or 
1622
1044
        some other features depending on the reason for not being supported.
1623
1045
        """
1624
1046
        return True
1625
1047
 
1626
 
    def make_tags(self, branch):
1627
 
        """Create a tags object for branch.
1628
 
 
1629
 
        This method is on BranchFormat, because BranchFormats are reflected
1630
 
        over the wire via network_name(), whereas full Branch instances require
1631
 
        multiple VFS method calls to operate at all.
1632
 
 
1633
 
        The default implementation returns a disabled-tags instance.
1634
 
 
1635
 
        Note that it is normal for branch to be a RemoteBranch when using tags
1636
 
        on a RemoteBranch.
1637
 
        """
1638
 
        return DisabledTags(branch)
1639
 
 
1640
 
    def network_name(self):
1641
 
        """A simple byte string uniquely identifying this format for RPC calls.
1642
 
 
1643
 
        MetaDir branch formats use their disk format string to identify the
1644
 
        repository over the wire. All in one formats such as bzr < 0.8, and
1645
 
        foreign formats like svn/git and hg should use some marker which is
1646
 
        unique and immutable.
1647
 
        """
1648
 
        raise NotImplementedError(self.network_name)
1649
 
 
1650
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
 
1048
    def open(self, a_bzrdir, _found=False):
1651
1049
        """Return the branch object for a_bzrdir
1652
1050
 
1653
 
        :param a_bzrdir: A BzrDir that contains a branch.
1654
 
        :param name: Name of colocated branch to open
1655
 
        :param _found: a private parameter, do not use it. It is used to
1656
 
            indicate if format probing has already be done.
1657
 
        :param ignore_fallbacks: when set, no fallback branches will be opened
1658
 
            (if there are any).  Default is to open fallbacks.
 
1051
        _found is a private parameter, do not use it. It is used to indicate
 
1052
               if format probing has already be done.
1659
1053
        """
1660
1054
        raise NotImplementedError(self.open)
1661
1055
 
1662
1056
    @classmethod
1663
1057
    def register_format(klass, format):
1664
 
        """Register a metadir format."""
1665
1058
        klass._formats[format.get_format_string()] = format
1666
 
        # Metadir formats have a network name of their format string, and get
1667
 
        # registered as class factories.
1668
 
        network_format_registry.register(format.get_format_string(), format.__class__)
1669
1059
 
1670
1060
    @classmethod
1671
1061
    def set_default_format(klass, format):
1672
1062
        klass._default_format = format
1673
1063
 
1674
 
    def supports_set_append_revisions_only(self):
1675
 
        """True if this format supports set_append_revisions_only."""
1676
 
        return False
1677
 
 
1678
1064
    def supports_stacking(self):
1679
1065
        """True if this format records a stacked-on branch."""
1680
1066
        return False
1684
1070
        del klass._formats[format.get_format_string()]
1685
1071
 
1686
1072
    def __str__(self):
1687
 
        return self.get_format_description().rstrip()
 
1073
        return self.get_format_string().rstrip()
1688
1074
 
1689
1075
    def supports_tags(self):
1690
1076
        """True if this format supports tags stored in the branch"""
1693
1079
 
1694
1080
class BranchHooks(Hooks):
1695
1081
    """A dictionary mapping hook name to a list of callables for branch hooks.
1696
 
 
 
1082
    
1697
1083
    e.g. ['set_rh'] Is the list of items to be called when the
1698
1084
    set_revision_history function is invoked.
1699
1085
    """
1705
1091
        notified.
1706
1092
        """
1707
1093
        Hooks.__init__(self)
1708
 
        self.create_hook(HookPoint('set_rh',
1709
 
            "Invoked whenever the revision history has been set via "
1710
 
            "set_revision_history. The api signature is (branch, "
1711
 
            "revision_history), and the branch will be write-locked. "
1712
 
            "The set_rh hook can be expensive for bzr to trigger, a better "
1713
 
            "hook to use is Branch.post_change_branch_tip.", (0, 15), None))
1714
 
        self.create_hook(HookPoint('open',
1715
 
            "Called with the Branch object that has been opened after a "
1716
 
            "branch is opened.", (1, 8), None))
1717
 
        self.create_hook(HookPoint('post_push',
1718
 
            "Called after a push operation completes. post_push is called "
1719
 
            "with a bzrlib.branch.BranchPushResult object and only runs in the "
1720
 
            "bzr client.", (0, 15), None))
1721
 
        self.create_hook(HookPoint('post_pull',
1722
 
            "Called after a pull operation completes. post_pull is called "
1723
 
            "with a bzrlib.branch.PullResult object and only runs in the "
1724
 
            "bzr client.", (0, 15), None))
1725
 
        self.create_hook(HookPoint('pre_commit',
1726
 
            "Called after a commit is calculated but before it is is "
1727
 
            "completed. pre_commit is called with (local, master, old_revno, "
1728
 
            "old_revid, future_revno, future_revid, tree_delta, future_tree"
1729
 
            "). old_revid is NULL_REVISION for the first commit to a branch, "
1730
 
            "tree_delta is a TreeDelta object describing changes from the "
1731
 
            "basis revision. hooks MUST NOT modify this delta. "
1732
 
            " future_tree is an in-memory tree obtained from "
1733
 
            "CommitBuilder.revision_tree() and hooks MUST NOT modify this "
1734
 
            "tree.", (0,91), None))
1735
 
        self.create_hook(HookPoint('post_commit',
1736
 
            "Called in the bzr client after a commit has completed. "
1737
 
            "post_commit is called with (local, master, old_revno, old_revid, "
1738
 
            "new_revno, new_revid). old_revid is NULL_REVISION for the first "
1739
 
            "commit to a branch.", (0, 15), None))
1740
 
        self.create_hook(HookPoint('post_uncommit',
1741
 
            "Called in the bzr client after an uncommit completes. "
1742
 
            "post_uncommit is called with (local, master, old_revno, "
1743
 
            "old_revid, new_revno, new_revid) where local is the local branch "
1744
 
            "or None, master is the target branch, and an empty branch "
1745
 
            "receives new_revno of 0, new_revid of None.", (0, 15), None))
1746
 
        self.create_hook(HookPoint('pre_change_branch_tip',
1747
 
            "Called in bzr client and server before a change to the tip of a "
1748
 
            "branch is made. pre_change_branch_tip is called with a "
1749
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1750
 
            "commit, uncommit will all trigger this hook.", (1, 6), None))
1751
 
        self.create_hook(HookPoint('post_change_branch_tip',
1752
 
            "Called in bzr client and server after a change to the tip of a "
1753
 
            "branch is made. post_change_branch_tip is called with a "
1754
 
            "bzrlib.branch.ChangeBranchTipParams. Note that push, pull, "
1755
 
            "commit, uncommit will all trigger this hook.", (1, 4), None))
1756
 
        self.create_hook(HookPoint('transform_fallback_location',
1757
 
            "Called when a stacked branch is activating its fallback "
1758
 
            "locations. transform_fallback_location is called with (branch, "
1759
 
            "url), and should return a new url. Returning the same url "
1760
 
            "allows it to be used as-is, returning a different one can be "
1761
 
            "used to cause the branch to stack on a closer copy of that "
1762
 
            "fallback_location. Note that the branch cannot have history "
1763
 
            "accessing methods called on it during this hook because the "
1764
 
            "fallback locations have not been activated. When there are "
1765
 
            "multiple hooks installed for transform_fallback_location, "
1766
 
            "all are called with the url returned from the previous hook."
1767
 
            "The order is however undefined.", (1, 9), None))
1768
 
        self.create_hook(HookPoint('automatic_tag_name',
1769
 
            "Called to determine an automatic tag name for a revision."
1770
 
            "automatic_tag_name is called with (branch, revision_id) and "
1771
 
            "should return a tag name or None if no tag name could be "
1772
 
            "determined. The first non-None tag name returned will be used.",
1773
 
            (2, 2), None))
1774
 
        self.create_hook(HookPoint('post_branch_init',
1775
 
            "Called after new branch initialization completes. "
1776
 
            "post_branch_init is called with a "
1777
 
            "bzrlib.branch.BranchInitHookParams. "
1778
 
            "Note that init, branch and checkout (both heavyweight and "
1779
 
            "lightweight) will all trigger this hook.", (2, 2), None))
1780
 
        self.create_hook(HookPoint('post_switch',
1781
 
            "Called after a checkout switches branch. "
1782
 
            "post_switch is called with a "
1783
 
            "bzrlib.branch.SwitchHookParams.", (2, 2), None))
1784
 
 
 
1094
        # Introduced in 0.15:
 
1095
        # invoked whenever the revision history has been set
 
1096
        # with set_revision_history. The api signature is
 
1097
        # (branch, revision_history), and the branch will
 
1098
        # be write-locked.
 
1099
        self['set_rh'] = []
 
1100
        # invoked after a push operation completes.
 
1101
        # the api signature is
 
1102
        # (push_result)
 
1103
        # containing the members
 
1104
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
1105
        # where local is the local target branch or None, master is the target 
 
1106
        # master branch, and the rest should be self explanatory. The source
 
1107
        # is read locked and the target branches write locked. Source will
 
1108
        # be the local low-latency branch.
 
1109
        self['post_push'] = []
 
1110
        # invoked after a pull operation completes.
 
1111
        # the api signature is
 
1112
        # (pull_result)
 
1113
        # containing the members
 
1114
        # (source, local, master, old_revno, old_revid, new_revno, new_revid)
 
1115
        # where local is the local branch or None, master is the target 
 
1116
        # master branch, and the rest should be self explanatory. The source
 
1117
        # is read locked and the target branches write locked. The local
 
1118
        # branch is the low-latency branch.
 
1119
        self['post_pull'] = []
 
1120
        # invoked before a commit operation takes place.
 
1121
        # the api signature is
 
1122
        # (local, master, old_revno, old_revid, future_revno, future_revid,
 
1123
        #  tree_delta, future_tree).
 
1124
        # old_revid is NULL_REVISION for the first commit to a branch
 
1125
        # tree_delta is a TreeDelta object describing changes from the basis
 
1126
        # revision, hooks MUST NOT modify this delta
 
1127
        # future_tree is an in-memory tree obtained from
 
1128
        # CommitBuilder.revision_tree() and hooks MUST NOT modify this tree
 
1129
        self['pre_commit'] = []
 
1130
        # invoked after a commit operation completes.
 
1131
        # the api signature is 
 
1132
        # (local, master, old_revno, old_revid, new_revno, new_revid)
 
1133
        # old_revid is NULL_REVISION for the first commit to a branch.
 
1134
        self['post_commit'] = []
 
1135
        # invoked after a uncommit operation completes.
 
1136
        # the api signature is
 
1137
        # (local, master, old_revno, old_revid, new_revno, new_revid) where
 
1138
        # local is the local branch or None, master is the target branch,
 
1139
        # and an empty branch recieves new_revno of 0, new_revid of None.
 
1140
        self['post_uncommit'] = []
 
1141
        # Introduced in 1.6
 
1142
        # Invoked before the tip of a branch changes.
 
1143
        # the api signature is
 
1144
        # (params) where params is a ChangeBranchTipParams with the members
 
1145
        # (branch, old_revno, new_revno, old_revid, new_revid)
 
1146
        self['pre_change_branch_tip'] = []
 
1147
        # Introduced in 1.4
 
1148
        # Invoked after the tip of a branch changes.
 
1149
        # the api signature is
 
1150
        # (params) where params is a ChangeBranchTipParams with the members
 
1151
        # (branch, old_revno, new_revno, old_revid, new_revid)
 
1152
        self['post_change_branch_tip'] = []
1785
1153
 
1786
1154
 
1787
1155
# install the default hooks into the Branch class.
1819
1187
 
1820
1188
    def __eq__(self, other):
1821
1189
        return self.__dict__ == other.__dict__
1822
 
 
 
1190
    
1823
1191
    def __repr__(self):
1824
1192
        return "<%s of %s from (%s, %s) to (%s, %s)>" % (
1825
 
            self.__class__.__name__, self.branch,
 
1193
            self.__class__.__name__, self.branch, 
1826
1194
            self.old_revno, self.old_revid, self.new_revno, self.new_revid)
1827
1195
 
1828
1196
 
1829
 
class BranchInitHookParams(object):
1830
 
    """Object holding parameters passed to *_branch_init hooks.
1831
 
 
1832
 
    There are 4 fields that hooks may wish to access:
1833
 
 
1834
 
    :ivar format: the branch format
1835
 
    :ivar bzrdir: the BzrDir where the branch will be/has been initialized
1836
 
    :ivar name: name of colocated branch, if any (or None)
1837
 
    :ivar branch: the branch created
1838
 
 
1839
 
    Note that for lightweight checkouts, the bzrdir and format fields refer to
1840
 
    the checkout, hence they are different from the corresponding fields in
1841
 
    branch, which refer to the original branch.
1842
 
    """
1843
 
 
1844
 
    def __init__(self, format, a_bzrdir, name, branch):
1845
 
        """Create a group of BranchInitHook parameters.
1846
 
 
1847
 
        :param format: the branch format
1848
 
        :param a_bzrdir: the BzrDir where the branch will be/has been
1849
 
            initialized
1850
 
        :param name: name of colocated branch, if any (or None)
1851
 
        :param branch: the branch created
1852
 
 
1853
 
        Note that for lightweight checkouts, the bzrdir and format fields refer
1854
 
        to the checkout, hence they are different from the corresponding fields
1855
 
        in branch, which refer to the original branch.
1856
 
        """
1857
 
        self.format = format
1858
 
        self.bzrdir = a_bzrdir
1859
 
        self.name = name
1860
 
        self.branch = branch
1861
 
 
1862
 
    def __eq__(self, other):
1863
 
        return self.__dict__ == other.__dict__
1864
 
 
1865
 
    def __repr__(self):
1866
 
        if self.branch:
1867
 
            return "<%s of %s>" % (self.__class__.__name__, self.branch)
1868
 
        else:
1869
 
            return "<%s of format:%s bzrdir:%s>" % (
1870
 
                self.__class__.__name__, self.branch,
1871
 
                self.format, self.bzrdir)
1872
 
 
1873
 
 
1874
 
class SwitchHookParams(object):
1875
 
    """Object holding parameters passed to *_switch hooks.
1876
 
 
1877
 
    There are 4 fields that hooks may wish to access:
1878
 
 
1879
 
    :ivar control_dir: BzrDir of the checkout to change
1880
 
    :ivar to_branch: branch that the checkout is to reference
1881
 
    :ivar force: skip the check for local commits in a heavy checkout
1882
 
    :ivar revision_id: revision ID to switch to (or None)
1883
 
    """
1884
 
 
1885
 
    def __init__(self, control_dir, to_branch, force, revision_id):
1886
 
        """Create a group of SwitchHook parameters.
1887
 
 
1888
 
        :param control_dir: BzrDir of the checkout to change
1889
 
        :param to_branch: branch that the checkout is to reference
1890
 
        :param force: skip the check for local commits in a heavy checkout
1891
 
        :param revision_id: revision ID to switch to (or None)
1892
 
        """
1893
 
        self.control_dir = control_dir
1894
 
        self.to_branch = to_branch
1895
 
        self.force = force
1896
 
        self.revision_id = revision_id
1897
 
 
1898
 
    def __eq__(self, other):
1899
 
        return self.__dict__ == other.__dict__
1900
 
 
1901
 
    def __repr__(self):
1902
 
        return "<%s for %s to (%s, %s)>" % (self.__class__.__name__,
1903
 
            self.control_dir, self.to_branch,
1904
 
            self.revision_id)
1905
 
 
1906
 
 
1907
1197
class BzrBranchFormat4(BranchFormat):
1908
1198
    """Bzr branch format 4.
1909
1199
 
1916
1206
        """See BranchFormat.get_format_description()."""
1917
1207
        return "Branch format 4"
1918
1208
 
1919
 
    def initialize(self, a_bzrdir, name=None):
 
1209
    def initialize(self, a_bzrdir):
1920
1210
        """Create a branch of this format in a_bzrdir."""
1921
1211
        utf8_files = [('revision-history', ''),
1922
1212
                      ('branch-name', ''),
1923
1213
                      ]
1924
 
        return self._initialize_helper(a_bzrdir, utf8_files, name=name,
 
1214
        return self._initialize_helper(a_bzrdir, utf8_files,
1925
1215
                                       lock_type='branch4', set_format=False)
1926
1216
 
1927
1217
    def __init__(self):
1928
1218
        super(BzrBranchFormat4, self).__init__()
1929
1219
        self._matchingbzrdir = bzrdir.BzrDirFormat6()
1930
1220
 
1931
 
    def network_name(self):
1932
 
        """The network name for this format is the control dirs disk label."""
1933
 
        return self._matchingbzrdir.get_format_string()
 
1221
    def open(self, a_bzrdir, _found=False):
 
1222
        """Return the branch object for a_bzrdir
1934
1223
 
1935
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1936
 
        """See BranchFormat.open()."""
 
1224
        _found is a private parameter, do not use it. It is used to indicate
 
1225
               if format probing has already be done.
 
1226
        """
1937
1227
        if not _found:
1938
1228
            # we are being called directly and must probe.
1939
1229
            raise NotImplementedError
1940
1230
        return BzrBranch(_format=self,
1941
1231
                         _control_files=a_bzrdir._control_files,
1942
1232
                         a_bzrdir=a_bzrdir,
1943
 
                         name=name,
1944
1233
                         _repository=a_bzrdir.open_repository())
1945
1234
 
1946
1235
    def __str__(self):
1954
1243
        """What class to instantiate on open calls."""
1955
1244
        raise NotImplementedError(self._branch_class)
1956
1245
 
1957
 
    def network_name(self):
1958
 
        """A simple byte string uniquely identifying this format for RPC calls.
 
1246
    def open(self, a_bzrdir, _found=False):
 
1247
        """Return the branch object for a_bzrdir.
1959
1248
 
1960
 
        Metadir branch formats use their format string.
 
1249
        _found is a private parameter, do not use it. It is used to indicate
 
1250
               if format probing has already be done.
1961
1251
        """
1962
 
        return self.get_format_string()
1963
 
 
1964
 
    def open(self, a_bzrdir, name=None, _found=False, ignore_fallbacks=False):
1965
 
        """See BranchFormat.open()."""
1966
1252
        if not _found:
1967
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
1253
            format = BranchFormat.find_format(a_bzrdir)
1968
1254
            if format.__class__ != self.__class__:
1969
1255
                raise AssertionError("wrong format %r found for %r" %
1970
1256
                    (format, self))
1971
 
        transport = a_bzrdir.get_branch_transport(None, name=name)
1972
1257
        try:
 
1258
            transport = a_bzrdir.get_branch_transport(None)
1973
1259
            control_files = lockable_files.LockableFiles(transport, 'lock',
1974
1260
                                                         lockdir.LockDir)
1975
1261
            return self._branch_class()(_format=self,
1976
1262
                              _control_files=control_files,
1977
 
                              name=name,
1978
1263
                              a_bzrdir=a_bzrdir,
1979
 
                              _repository=a_bzrdir.find_repository(),
1980
 
                              ignore_fallbacks=ignore_fallbacks)
 
1264
                              _repository=a_bzrdir.find_repository())
1981
1265
        except errors.NoSuchFile:
1982
 
            raise errors.NotBranchError(path=transport.base, bzrdir=a_bzrdir)
 
1266
            raise errors.NotBranchError(path=transport.base)
1983
1267
 
1984
1268
    def __init__(self):
1985
1269
        super(BranchFormatMetadir, self).__init__()
1986
1270
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
1987
 
        self._matchingbzrdir.set_branch_format(self)
1988
1271
 
1989
1272
    def supports_tags(self):
1990
1273
        return True
2013
1296
    def get_format_description(self):
2014
1297
        """See BranchFormat.get_format_description()."""
2015
1298
        return "Branch format 5"
2016
 
 
2017
 
    def initialize(self, a_bzrdir, name=None):
 
1299
        
 
1300
    def initialize(self, a_bzrdir):
2018
1301
        """Create a branch of this format in a_bzrdir."""
2019
1302
        utf8_files = [('revision-history', ''),
2020
1303
                      ('branch-name', ''),
2021
1304
                      ]
2022
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
 
1305
        return self._initialize_helper(a_bzrdir, utf8_files)
2023
1306
 
2024
1307
    def supports_tags(self):
2025
1308
        return False
2047
1330
        """See BranchFormat.get_format_description()."""
2048
1331
        return "Branch format 6"
2049
1332
 
2050
 
    def initialize(self, a_bzrdir, name=None):
2051
 
        """Create a branch of this format in a_bzrdir."""
2052
 
        utf8_files = [('last-revision', '0 null:\n'),
2053
 
                      ('branch.conf', ''),
2054
 
                      ('tags', ''),
2055
 
                      ]
2056
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2057
 
 
2058
 
    def make_tags(self, branch):
2059
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2060
 
        return BasicTags(branch)
2061
 
 
2062
 
    def supports_set_append_revisions_only(self):
2063
 
        return True
2064
 
 
2065
 
 
2066
 
class BzrBranchFormat8(BranchFormatMetadir):
2067
 
    """Metadir format supporting storing locations of subtree branches."""
2068
 
 
2069
 
    def _branch_class(self):
2070
 
        return BzrBranch8
2071
 
 
2072
 
    def get_format_string(self):
2073
 
        """See BranchFormat.get_format_string()."""
2074
 
        return "Bazaar Branch Format 8 (needs bzr 1.15)\n"
2075
 
 
2076
 
    def get_format_description(self):
2077
 
        """See BranchFormat.get_format_description()."""
2078
 
        return "Branch format 8"
2079
 
 
2080
 
    def initialize(self, a_bzrdir, name=None):
2081
 
        """Create a branch of this format in a_bzrdir."""
2082
 
        utf8_files = [('last-revision', '0 null:\n'),
2083
 
                      ('branch.conf', ''),
2084
 
                      ('tags', ''),
2085
 
                      ('references', '')
2086
 
                      ]
2087
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2088
 
 
2089
 
    def __init__(self):
2090
 
        super(BzrBranchFormat8, self).__init__()
2091
 
        self._matchingbzrdir.repository_format = \
2092
 
            RepositoryFormatKnitPack5RichRoot()
2093
 
 
2094
 
    def make_tags(self, branch):
2095
 
        """See bzrlib.branch.BranchFormat.make_tags()."""
2096
 
        return BasicTags(branch)
2097
 
 
2098
 
    def supports_set_append_revisions_only(self):
2099
 
        return True
2100
 
 
2101
 
    def supports_stacking(self):
2102
 
        return True
2103
 
 
2104
 
    supports_reference_locations = True
2105
 
 
2106
 
 
2107
 
class BzrBranchFormat7(BzrBranchFormat8):
 
1333
    def initialize(self, a_bzrdir):
 
1334
        """Create a branch of this format in a_bzrdir."""
 
1335
        utf8_files = [('last-revision', '0 null:\n'),
 
1336
                      ('branch.conf', ''),
 
1337
                      ('tags', ''),
 
1338
                      ]
 
1339
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1340
 
 
1341
 
 
1342
class BzrBranchFormat7(BranchFormatMetadir):
2108
1343
    """Branch format with last-revision, tags, and a stacked location pointer.
2109
1344
 
2110
1345
    The stacked location pointer is passed down to the repository and requires
2113
1348
    This format was introduced in bzr 1.6.
2114
1349
    """
2115
1350
 
2116
 
    def initialize(self, a_bzrdir, name=None):
2117
 
        """Create a branch of this format in a_bzrdir."""
2118
 
        utf8_files = [('last-revision', '0 null:\n'),
2119
 
                      ('branch.conf', ''),
2120
 
                      ('tags', ''),
2121
 
                      ]
2122
 
        return self._initialize_helper(a_bzrdir, utf8_files, name)
2123
 
 
2124
1351
    def _branch_class(self):
2125
1352
        return BzrBranch7
2126
1353
 
2132
1359
        """See BranchFormat.get_format_description()."""
2133
1360
        return "Branch format 7"
2134
1361
 
2135
 
    def supports_set_append_revisions_only(self):
 
1362
    def initialize(self, a_bzrdir):
 
1363
        """Create a branch of this format in a_bzrdir."""
 
1364
        utf8_files = [('last-revision', '0 null:\n'),
 
1365
                      ('branch.conf', ''),
 
1366
                      ('tags', ''),
 
1367
                      ]
 
1368
        return self._initialize_helper(a_bzrdir, utf8_files)
 
1369
 
 
1370
    def __init__(self):
 
1371
        super(BzrBranchFormat7, self).__init__()
 
1372
        self._matchingbzrdir.repository_format = \
 
1373
            RepositoryFormatPackDevelopment1Subtree()
 
1374
 
 
1375
    def supports_stacking(self):
2136
1376
        return True
2137
1377
 
2138
 
    supports_reference_locations = False
2139
 
 
2140
1378
 
2141
1379
class BranchReferenceFormat(BranchFormat):
2142
1380
    """Bzr branch reference format.
2160
1398
    def get_reference(self, a_bzrdir):
2161
1399
        """See BranchFormat.get_reference()."""
2162
1400
        transport = a_bzrdir.get_branch_transport(None)
2163
 
        return transport.get_bytes('location')
 
1401
        return transport.get('location').read()
2164
1402
 
2165
1403
    def set_reference(self, a_bzrdir, to_branch):
2166
1404
        """See BranchFormat.set_reference()."""
2167
1405
        transport = a_bzrdir.get_branch_transport(None)
2168
1406
        location = transport.put_bytes('location', to_branch.base)
2169
1407
 
2170
 
    def initialize(self, a_bzrdir, name=None, target_branch=None):
 
1408
    def initialize(self, a_bzrdir, target_branch=None):
2171
1409
        """Create a branch of this format in a_bzrdir."""
2172
1410
        if target_branch is None:
2173
1411
            # this format does not implement branch itself, thus the implicit
2174
1412
            # creation contract must see it as uninitializable
2175
1413
            raise errors.UninitializableFormat(self)
2176
 
        mutter('creating branch reference in %s', a_bzrdir.user_url)
2177
 
        branch_transport = a_bzrdir.get_branch_transport(self, name=name)
 
1414
        mutter('creating branch reference in %s', a_bzrdir.transport.base)
 
1415
        branch_transport = a_bzrdir.get_branch_transport(self)
2178
1416
        branch_transport.put_bytes('location',
2179
 
            target_branch.bzrdir.user_url)
 
1417
            target_branch.bzrdir.root_transport.base)
2180
1418
        branch_transport.put_bytes('format', self.get_format_string())
2181
 
        branch = self.open(
2182
 
            a_bzrdir, name, _found=True,
 
1419
        return self.open(
 
1420
            a_bzrdir, _found=True,
2183
1421
            possible_transports=[target_branch.bzrdir.root_transport])
2184
 
        self._run_post_branch_init_hooks(a_bzrdir, name, branch)
2185
 
        return branch
2186
1422
 
2187
1423
    def __init__(self):
2188
1424
        super(BranchReferenceFormat, self).__init__()
2189
1425
        self._matchingbzrdir = bzrdir.BzrDirMetaFormat1()
2190
 
        self._matchingbzrdir.set_branch_format(self)
2191
1426
 
2192
1427
    def _make_reference_clone_function(format, a_branch):
2193
1428
        """Create a clone() routine for a branch dynamically."""
2194
 
        def clone(to_bzrdir, revision_id=None,
2195
 
            repository_policy=None):
 
1429
        def clone(to_bzrdir, revision_id=None):
2196
1430
            """See Branch.clone()."""
2197
 
            return format.initialize(to_bzrdir, target_branch=a_branch)
 
1431
            return format.initialize(to_bzrdir, a_branch)
2198
1432
            # cannot obey revision_id limits when cloning a reference ...
2199
1433
            # FIXME RBC 20060210 either nuke revision_id for clone, or
2200
1434
            # emit some sort of warning/error to the caller ?!
2201
1435
        return clone
2202
1436
 
2203
 
    def open(self, a_bzrdir, name=None, _found=False, location=None,
2204
 
             possible_transports=None, ignore_fallbacks=False):
 
1437
    def open(self, a_bzrdir, _found=False, location=None,
 
1438
             possible_transports=None):
2205
1439
        """Return the branch that the branch reference in a_bzrdir points at.
2206
1440
 
2207
 
        :param a_bzrdir: A BzrDir that contains a branch.
2208
 
        :param name: Name of colocated branch to open, if any
2209
 
        :param _found: a private parameter, do not use it. It is used to
2210
 
            indicate if format probing has already be done.
2211
 
        :param ignore_fallbacks: when set, no fallback branches will be opened
2212
 
            (if there are any).  Default is to open fallbacks.
2213
 
        :param location: The location of the referenced branch.  If
2214
 
            unspecified, this will be determined from the branch reference in
2215
 
            a_bzrdir.
2216
 
        :param possible_transports: An optional reusable transports list.
 
1441
        _found is a private parameter, do not use it. It is used to indicate
 
1442
               if format probing has already be done.
2217
1443
        """
2218
1444
        if not _found:
2219
 
            format = BranchFormat.find_format(a_bzrdir, name=name)
 
1445
            format = BranchFormat.find_format(a_bzrdir)
2220
1446
            if format.__class__ != self.__class__:
2221
1447
                raise AssertionError("wrong format %r found for %r" %
2222
1448
                    (format, self))
2224
1450
            location = self.get_reference(a_bzrdir)
2225
1451
        real_bzrdir = bzrdir.BzrDir.open(
2226
1452
            location, possible_transports=possible_transports)
2227
 
        result = real_bzrdir.open_branch(name=name, 
2228
 
            ignore_fallbacks=ignore_fallbacks)
 
1453
        result = real_bzrdir.open_branch()
2229
1454
        # this changes the behaviour of result.clone to create a new reference
2230
1455
        # rather than a copy of the content of the branch.
2231
1456
        # I did not use a proxy object because that needs much more extensive
2238
1463
        return result
2239
1464
 
2240
1465
 
2241
 
network_format_registry = registry.FormatRegistry()
2242
 
"""Registry of formats indexed by their network name.
2243
 
 
2244
 
The network name for a branch format is an identifier that can be used when
2245
 
referring to formats with smart server operations. See
2246
 
BranchFormat.network_name() for more detail.
2247
 
"""
2248
 
 
2249
 
 
2250
1466
# formats which have no format string are not discoverable
2251
1467
# and not independently creatable, so are not registered.
2252
1468
__format5 = BzrBranchFormat5()
2253
1469
__format6 = BzrBranchFormat6()
2254
1470
__format7 = BzrBranchFormat7()
2255
 
__format8 = BzrBranchFormat8()
2256
1471
BranchFormat.register_format(__format5)
2257
1472
BranchFormat.register_format(BranchReferenceFormat())
2258
1473
BranchFormat.register_format(__format6)
2259
1474
BranchFormat.register_format(__format7)
2260
 
BranchFormat.register_format(__format8)
2261
 
BranchFormat.set_default_format(__format7)
 
1475
BranchFormat.set_default_format(__format6)
2262
1476
_legacy_formats = [BzrBranchFormat4(),
2263
 
    ]
2264
 
network_format_registry.register(
2265
 
    _legacy_formats[0].network_name(), _legacy_formats[0].__class__)
2266
 
 
2267
 
 
2268
 
class BzrBranch(Branch, _RelockDebugMixin):
 
1477
                   ]
 
1478
 
 
1479
class BzrBranch(Branch):
2269
1480
    """A branch stored in the actual filesystem.
2270
1481
 
2271
1482
    Note that it's "local" in the context of the filesystem; it doesn't
2272
1483
    really matter if it's on an nfs/smb/afs/coda/... share, as long as
2273
1484
    it's writable, and can be accessed via the normal filesystem API.
2274
1485
 
2275
 
    :ivar _transport: Transport for file operations on this branch's
 
1486
    :ivar _transport: Transport for file operations on this branch's 
2276
1487
        control files, typically pointing to the .bzr/branch directory.
2277
1488
    :ivar repository: Repository for this branch.
2278
 
    :ivar base: The url of the base directory for this branch; the one
 
1489
    :ivar base: The url of the base directory for this branch; the one 
2279
1490
        containing the .bzr directory.
2280
 
    :ivar name: Optional colocated branch name as it exists in the control
2281
 
        directory.
2282
1491
    """
2283
 
 
 
1492
    
2284
1493
    def __init__(self, _format=None,
2285
 
                 _control_files=None, a_bzrdir=None, name=None,
2286
 
                 _repository=None, ignore_fallbacks=False):
 
1494
                 _control_files=None, a_bzrdir=None, _repository=None):
2287
1495
        """Create new branch object at a particular location."""
2288
1496
        if a_bzrdir is None:
2289
1497
            raise ValueError('a_bzrdir must be supplied')
2290
1498
        else:
2291
1499
            self.bzrdir = a_bzrdir
2292
1500
        self._base = self.bzrdir.transport.clone('..').base
2293
 
        self.name = name
2294
1501
        # XXX: We should be able to just do
2295
1502
        #   self.base = self.bzrdir.root_transport.base
2296
1503
        # but this does not quite work yet -- mbp 20080522
2303
1510
        Branch.__init__(self)
2304
1511
 
2305
1512
    def __str__(self):
2306
 
        if self.name is None:
2307
 
            return '%s(%s)' % (self.__class__.__name__, self.user_url)
2308
 
        else:
2309
 
            return '%s(%s,%s)' % (self.__class__.__name__, self.user_url,
2310
 
                self.name)
 
1513
        return '%s(%r)' % (self.__class__.__name__, self.base)
2311
1514
 
2312
1515
    __repr__ = __str__
2313
1516
 
2317
1520
 
2318
1521
    base = property(_get_base, doc="The URL for the root of this branch.")
2319
1522
 
2320
 
    def _get_config(self):
2321
 
        return TransportConfig(self._transport, 'branch.conf')
 
1523
    @deprecated_method(deprecated_in((0, 16, 0)))
 
1524
    def abspath(self, name):
 
1525
        """See Branch.abspath."""
 
1526
        return self._transport.abspath(name)
2322
1527
 
2323
1528
    def is_locked(self):
2324
1529
        return self.control_files.is_locked()
2325
1530
 
2326
1531
    def lock_write(self, token=None):
2327
 
        if not self.is_locked():
2328
 
            self._note_lock('w')
2329
 
        # All-in-one needs to always unlock/lock.
2330
 
        repo_control = getattr(self.repository, 'control_files', None)
2331
 
        if self.control_files == repo_control or not self.is_locked():
2332
 
            self.repository._warn_if_deprecated(self)
2333
 
            self.repository.lock_write()
2334
 
            took_lock = True
2335
 
        else:
2336
 
            took_lock = False
 
1532
        repo_token = self.repository.lock_write()
2337
1533
        try:
2338
 
            return self.control_files.lock_write(token=token)
 
1534
            token = self.control_files.lock_write(token=token)
2339
1535
        except:
2340
 
            if took_lock:
2341
 
                self.repository.unlock()
 
1536
            self.repository.unlock()
2342
1537
            raise
 
1538
        return token
2343
1539
 
2344
1540
    def lock_read(self):
2345
 
        if not self.is_locked():
2346
 
            self._note_lock('r')
2347
 
        # All-in-one needs to always unlock/lock.
2348
 
        repo_control = getattr(self.repository, 'control_files', None)
2349
 
        if self.control_files == repo_control or not self.is_locked():
2350
 
            self.repository._warn_if_deprecated(self)
2351
 
            self.repository.lock_read()
2352
 
            took_lock = True
2353
 
        else:
2354
 
            took_lock = False
 
1541
        self.repository.lock_read()
2355
1542
        try:
2356
1543
            self.control_files.lock_read()
2357
1544
        except:
2358
 
            if took_lock:
2359
 
                self.repository.unlock()
 
1545
            self.repository.unlock()
2360
1546
            raise
2361
1547
 
2362
 
    @only_raises(errors.LockNotHeld, errors.LockBroken)
2363
1548
    def unlock(self):
 
1549
        # TODO: test for failed two phase locks. This is known broken.
2364
1550
        try:
2365
1551
            self.control_files.unlock()
2366
1552
        finally:
2367
 
            # All-in-one needs to always unlock/lock.
2368
 
            repo_control = getattr(self.repository, 'control_files', None)
2369
 
            if (self.control_files == repo_control or
2370
 
                not self.control_files.is_locked()):
2371
 
                self.repository.unlock()
2372
 
            if not self.control_files.is_locked():
2373
 
                # we just released the lock
2374
 
                self._clear_cached_state()
2375
 
 
 
1553
            self.repository.unlock()
 
1554
        if not self.control_files.is_locked():
 
1555
            # we just released the lock
 
1556
            self._clear_cached_state()
 
1557
        
2376
1558
    def peek_lock_mode(self):
2377
1559
        if self.control_files._lock_count == 0:
2378
1560
            return None
2421
1603
        if Branch.hooks['post_change_branch_tip']:
2422
1604
            self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2423
1605
 
2424
 
    def _synchronize_history(self, destination, revision_id):
2425
 
        """Synchronize last revision and revision history between branches.
2426
 
 
2427
 
        This version is most efficient when the destination is also a
2428
 
        BzrBranch5, but works for BzrBranch6 as long as the revision
2429
 
        history is the true lefthand parent history, and all of the revisions
2430
 
        are in the destination's repository.  If not, set_revision_history
2431
 
        will fail.
2432
 
 
2433
 
        :param destination: The branch to copy the history into
2434
 
        :param revision_id: The revision-id to truncate history at.  May
2435
 
          be None to copy complete history.
2436
 
        """
2437
 
        if not isinstance(destination._format, BzrBranchFormat5):
2438
 
            super(BzrBranch, self)._synchronize_history(
2439
 
                destination, revision_id)
 
1606
    def _run_pre_change_branch_tip_hooks(self, new_revno, new_revid):
 
1607
        """Run the pre_change_branch_tip hooks."""
 
1608
        hooks = Branch.hooks['pre_change_branch_tip']
 
1609
        if not hooks:
2440
1610
            return
2441
 
        if revision_id == _mod_revision.NULL_REVISION:
2442
 
            new_history = []
2443
 
        else:
2444
 
            new_history = self.revision_history()
2445
 
        if revision_id is not None and new_history != []:
 
1611
        old_revno, old_revid = self.last_revision_info()
 
1612
        params = ChangeBranchTipParams(
 
1613
            self, old_revno, new_revno, old_revid, new_revid)
 
1614
        for hook in hooks:
2446
1615
            try:
2447
 
                new_history = new_history[:new_history.index(revision_id) + 1]
2448
 
            except ValueError:
2449
 
                rev = self.repository.get_revision(revision_id)
2450
 
                new_history = rev.get_history(self.repository)[1:]
2451
 
        destination.set_revision_history(new_history)
2452
 
 
 
1616
                hook(params)
 
1617
            except errors.TipChangeRejected:
 
1618
                raise
 
1619
            except Exception:
 
1620
                exc_info = sys.exc_info()
 
1621
                hook_name = Branch.hooks.get_hook_name(hook)
 
1622
                raise errors.HookFailed(
 
1623
                    'pre_change_branch_tip', hook_name, exc_info)
 
1624
 
 
1625
    def _run_post_change_branch_tip_hooks(self, old_revno, old_revid):
 
1626
        """Run the post_change_branch_tip hooks."""
 
1627
        hooks = Branch.hooks['post_change_branch_tip']
 
1628
        if not hooks:
 
1629
            return
 
1630
        new_revno, new_revid = self.last_revision_info()
 
1631
        params = ChangeBranchTipParams(
 
1632
            self, old_revno, new_revno, old_revid, new_revid)
 
1633
        for hook in hooks:
 
1634
            hook(params)
 
1635
 
2453
1636
    @needs_write_lock
2454
1637
    def set_last_revision_info(self, revno, revision_id):
2455
1638
        """Set the last revision of this branch.
2458
1641
        for this revision id.
2459
1642
 
2460
1643
        It may be possible to set the branch last revision to an id not
2461
 
        present in the repository.  However, branches can also be
 
1644
        present in the repository.  However, branches can also be 
2462
1645
        configured to check constraints on history, in which case this may not
2463
1646
        be permitted.
2464
1647
        """
2478
1661
            history.pop()
2479
1662
        return history
2480
1663
 
 
1664
    def _lefthand_history(self, revision_id, last_rev=None,
 
1665
                          other_branch=None):
 
1666
        if 'evil' in debug.debug_flags:
 
1667
            mutter_callsite(4, "_lefthand_history scales with history.")
 
1668
        # stop_revision must be a descendant of last_revision
 
1669
        graph = self.repository.get_graph()
 
1670
        if last_rev is not None:
 
1671
            if not graph.is_ancestor(last_rev, revision_id):
 
1672
                # our previous tip is not merged into stop_revision
 
1673
                raise errors.DivergedBranches(self, other_branch)
 
1674
        # make a new revision history from the graph
 
1675
        parents_map = graph.get_parent_map([revision_id])
 
1676
        if revision_id not in parents_map:
 
1677
            raise errors.NoSuchRevision(self, revision_id)
 
1678
        current_rev_id = revision_id
 
1679
        new_history = []
 
1680
        check_not_reserved_id = _mod_revision.check_not_reserved_id
 
1681
        # Do not include ghosts or graph origin in revision_history
 
1682
        while (current_rev_id in parents_map and
 
1683
               len(parents_map[current_rev_id]) > 0):
 
1684
            check_not_reserved_id(current_rev_id)
 
1685
            new_history.append(current_rev_id)
 
1686
            current_rev_id = parents_map[current_rev_id][0]
 
1687
            parents_map = graph.get_parent_map([current_rev_id])
 
1688
        new_history.reverse()
 
1689
        return new_history
 
1690
 
2481
1691
    @needs_write_lock
2482
1692
    def generate_revision_history(self, revision_id, last_rev=None,
2483
1693
        other_branch=None):
2496
1706
        """See Branch.basis_tree."""
2497
1707
        return self.repository.revision_tree(self.last_revision())
2498
1708
 
 
1709
    @needs_write_lock
 
1710
    def pull(self, source, overwrite=False, stop_revision=None,
 
1711
             _hook_master=None, run_hooks=True, possible_transports=None,
 
1712
             _override_hook_target=None):
 
1713
        """See Branch.pull.
 
1714
 
 
1715
        :param _hook_master: Private parameter - set the branch to 
 
1716
            be supplied as the master to pull hooks.
 
1717
        :param run_hooks: Private parameter - if false, this branch
 
1718
            is being called because it's the master of the primary branch,
 
1719
            so it should not run its hooks.
 
1720
        :param _override_hook_target: Private parameter - set the branch to be
 
1721
            supplied as the target_branch to pull hooks.
 
1722
        """
 
1723
        result = PullResult()
 
1724
        result.source_branch = source
 
1725
        if _override_hook_target is None:
 
1726
            result.target_branch = self
 
1727
        else:
 
1728
            result.target_branch = _override_hook_target
 
1729
        source.lock_read()
 
1730
        try:
 
1731
            # We assume that during 'pull' the local repository is closer than
 
1732
            # the remote one.
 
1733
            graph = self.repository.get_graph(source.repository)
 
1734
            result.old_revno, result.old_revid = self.last_revision_info()
 
1735
            self.update_revisions(source, stop_revision, overwrite=overwrite,
 
1736
                                  graph=graph)
 
1737
            result.tag_conflicts = source.tags.merge_to(self.tags, overwrite)
 
1738
            result.new_revno, result.new_revid = self.last_revision_info()
 
1739
            if _hook_master:
 
1740
                result.master_branch = _hook_master
 
1741
                result.local_branch = result.target_branch
 
1742
            else:
 
1743
                result.master_branch = result.target_branch
 
1744
                result.local_branch = None
 
1745
            if run_hooks:
 
1746
                for hook in Branch.hooks['post_pull']:
 
1747
                    hook(result)
 
1748
        finally:
 
1749
            source.unlock()
 
1750
        return result
 
1751
 
2499
1752
    def _get_parent_location(self):
2500
1753
        _locs = ['parent', 'pull', 'x-pull']
2501
1754
        for l in _locs:
2505
1758
                pass
2506
1759
        return None
2507
1760
 
 
1761
    @needs_read_lock
 
1762
    def push(self, target, overwrite=False, stop_revision=None,
 
1763
             _override_hook_source_branch=None):
 
1764
        """See Branch.push.
 
1765
 
 
1766
        This is the basic concrete implementation of push()
 
1767
 
 
1768
        :param _override_hook_source_branch: If specified, run
 
1769
        the hooks passing this Branch as the source, rather than self.  
 
1770
        This is for use of RemoteBranch, where push is delegated to the
 
1771
        underlying vfs-based Branch. 
 
1772
        """
 
1773
        # TODO: Public option to disable running hooks - should be trivial but
 
1774
        # needs tests.
 
1775
        target.lock_write()
 
1776
        try:
 
1777
            result = self._push_with_bound_branches(target, overwrite,
 
1778
                    stop_revision,
 
1779
                    _override_hook_source_branch=_override_hook_source_branch)
 
1780
            return result
 
1781
        finally:
 
1782
            target.unlock()
 
1783
 
 
1784
    def _push_with_bound_branches(self, target, overwrite,
 
1785
            stop_revision,
 
1786
            _override_hook_source_branch=None):
 
1787
        """Push from self into target, and into target's master if any.
 
1788
        
 
1789
        This is on the base BzrBranch class even though it doesn't support 
 
1790
        bound branches because the *target* might be bound.
 
1791
        """
 
1792
        def _run_hooks():
 
1793
            if _override_hook_source_branch:
 
1794
                result.source_branch = _override_hook_source_branch
 
1795
            for hook in Branch.hooks['post_push']:
 
1796
                hook(result)
 
1797
 
 
1798
        bound_location = target.get_bound_location()
 
1799
        if bound_location and target.base != bound_location:
 
1800
            # there is a master branch.
 
1801
            #
 
1802
            # XXX: Why the second check?  Is it even supported for a branch to
 
1803
            # be bound to itself? -- mbp 20070507
 
1804
            master_branch = target.get_master_branch()
 
1805
            master_branch.lock_write()
 
1806
            try:
 
1807
                # push into the master from this branch.
 
1808
                self._basic_push(master_branch, overwrite, stop_revision)
 
1809
                # and push into the target branch from this. Note that we push from
 
1810
                # this branch again, because its considered the highest bandwidth
 
1811
                # repository.
 
1812
                result = self._basic_push(target, overwrite, stop_revision)
 
1813
                result.master_branch = master_branch
 
1814
                result.local_branch = target
 
1815
                _run_hooks()
 
1816
                return result
 
1817
            finally:
 
1818
                master_branch.unlock()
 
1819
        else:
 
1820
            # no master branch
 
1821
            result = self._basic_push(target, overwrite, stop_revision)
 
1822
            # TODO: Why set master_branch and local_branch if there's no
 
1823
            # binding?  Maybe cleaner to just leave them unset? -- mbp
 
1824
            # 20070504
 
1825
            result.master_branch = target
 
1826
            result.local_branch = None
 
1827
            _run_hooks()
 
1828
            return result
 
1829
 
2508
1830
    def _basic_push(self, target, overwrite, stop_revision):
2509
1831
        """Basic implementation of push without bound branches or hooks.
2510
1832
 
2511
 
        Must be called with source read locked and target write locked.
 
1833
        Must be called with self read locked and target write locked.
2512
1834
        """
2513
 
        result = BranchPushResult()
 
1835
        result = PushResult()
2514
1836
        result.source_branch = self
2515
1837
        result.target_branch = target
2516
1838
        result.old_revno, result.old_revid = target.last_revision_info()
2517
 
        self.update_references(target)
2518
 
        if result.old_revid != self.last_revision():
2519
 
            # We assume that during 'push' this repository is closer than
2520
 
            # the target.
2521
 
            graph = self.repository.get_graph(target.repository)
2522
 
            target.update_revisions(self, stop_revision,
2523
 
                overwrite=overwrite, graph=graph)
2524
 
        if self._push_should_merge_tags():
2525
 
            result.tag_conflicts = self.tags.merge_to(target.tags,
2526
 
                overwrite)
 
1839
 
 
1840
        # We assume that during 'push' this repository is closer than
 
1841
        # the target.
 
1842
        graph = self.repository.get_graph(target.repository)
 
1843
        target.update_revisions(self, stop_revision, overwrite=overwrite,
 
1844
                                graph=graph)
 
1845
        result.tag_conflicts = self.tags.merge_to(target.tags, overwrite)
2527
1846
        result.new_revno, result.new_revid = target.last_revision_info()
2528
1847
        return result
2529
1848
 
 
1849
    def get_parent(self):
 
1850
        """See Branch.get_parent."""
 
1851
        parent = self._get_parent_location()
 
1852
        if parent is None:
 
1853
            return parent
 
1854
        # This is an old-format absolute path to a local branch
 
1855
        # turn it into a url
 
1856
        if parent.startswith('/'):
 
1857
            parent = urlutils.local_path_to_url(parent.decode('utf8'))
 
1858
        try:
 
1859
            return urlutils.join(self.base[:-1], parent)
 
1860
        except errors.InvalidURLJoin, e:
 
1861
            raise errors.InaccessibleParent(parent, self.base)
 
1862
 
2530
1863
    def get_stacked_on_url(self):
2531
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
1864
        raise errors.UnstackableBranchFormat(self._format, self.base)
2532
1865
 
2533
1866
    def set_push_location(self, location):
2534
1867
        """See Branch.set_push_location."""
2536
1869
            'push_location', location,
2537
1870
            store=_mod_config.STORE_LOCATION_NORECURSE)
2538
1871
 
 
1872
    @needs_write_lock
 
1873
    def set_parent(self, url):
 
1874
        """See Branch.set_parent."""
 
1875
        # TODO: Maybe delete old location files?
 
1876
        # URLs should never be unicode, even on the local fs,
 
1877
        # FIXUP this and get_parent in a future branch format bump:
 
1878
        # read and rewrite the file. RBC 20060125
 
1879
        if url is not None:
 
1880
            if isinstance(url, unicode):
 
1881
                try:
 
1882
                    url = url.encode('ascii')
 
1883
                except UnicodeEncodeError:
 
1884
                    raise errors.InvalidURL(url,
 
1885
                        "Urls must be 7-bit ascii, "
 
1886
                        "use bzrlib.urlutils.escape")
 
1887
            url = urlutils.relative_url(self.base, url)
 
1888
        self._set_parent_location(url)
 
1889
 
2539
1890
    def _set_parent_location(self, url):
2540
1891
        if url is None:
2541
1892
            self._transport.delete('parent')
2543
1894
            self._transport.put_bytes('parent', url + '\n',
2544
1895
                mode=self.bzrdir._get_file_mode())
2545
1896
 
 
1897
    def set_stacked_on_url(self, url):
 
1898
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
1899
 
2546
1900
 
2547
1901
class BzrBranch5(BzrBranch):
2548
1902
    """A format 5 branch. This supports new features over plain branches.
2550
1904
    It has support for a master_branch which is the data for bound branches.
2551
1905
    """
2552
1906
 
 
1907
    @needs_write_lock
 
1908
    def pull(self, source, overwrite=False, stop_revision=None,
 
1909
             run_hooks=True, possible_transports=None,
 
1910
             _override_hook_target=None):
 
1911
        """Pull from source into self, updating my master if any.
 
1912
        
 
1913
        :param run_hooks: Private parameter - if false, this branch
 
1914
            is being called because it's the master of the primary branch,
 
1915
            so it should not run its hooks.
 
1916
        """
 
1917
        bound_location = self.get_bound_location()
 
1918
        master_branch = None
 
1919
        if bound_location and source.base != bound_location:
 
1920
            # not pulling from master, so we need to update master.
 
1921
            master_branch = self.get_master_branch(possible_transports)
 
1922
            master_branch.lock_write()
 
1923
        try:
 
1924
            if master_branch:
 
1925
                # pull from source into master.
 
1926
                master_branch.pull(source, overwrite, stop_revision,
 
1927
                    run_hooks=False)
 
1928
            return super(BzrBranch5, self).pull(source, overwrite,
 
1929
                stop_revision, _hook_master=master_branch,
 
1930
                run_hooks=run_hooks,
 
1931
                _override_hook_target=_override_hook_target)
 
1932
        finally:
 
1933
            if master_branch:
 
1934
                master_branch.unlock()
 
1935
 
2553
1936
    def get_bound_location(self):
2554
1937
        try:
2555
1938
            return self._transport.get_bytes('bound')[:-1]
2559
1942
    @needs_read_lock
2560
1943
    def get_master_branch(self, possible_transports=None):
2561
1944
        """Return the branch we are bound to.
2562
 
 
 
1945
        
2563
1946
        :return: Either a Branch, or None
2564
1947
 
2565
1948
        This could memoise the branch, but if thats done
2601
1984
        check for divergence to raise an error when the branches are not
2602
1985
        either the same, or one a prefix of the other. That behaviour may not
2603
1986
        be useful, so that check may be removed in future.
2604
 
 
 
1987
        
2605
1988
        :param other: The branch to bind to
2606
1989
        :type other: Branch
2607
1990
        """
2626
2009
 
2627
2010
    @needs_write_lock
2628
2011
    def update(self, possible_transports=None):
2629
 
        """Synchronise this branch with the master branch if any.
 
2012
        """Synchronise this branch with the master branch if any. 
2630
2013
 
2631
2014
        :return: None or the last_revision that was pivoted out during the
2632
2015
                 update.
2642
2025
        return None
2643
2026
 
2644
2027
 
2645
 
class BzrBranch8(BzrBranch5):
2646
 
    """A branch that stores tree-reference locations."""
 
2028
class BzrBranch7(BzrBranch5):
 
2029
    """A branch with support for a fallback repository."""
 
2030
 
 
2031
    def _get_fallback_repository(self, url):
 
2032
        """Get the repository we fallback to at url."""
 
2033
        url = urlutils.join(self.base, url)
 
2034
        return bzrdir.BzrDir.open(url).open_branch().repository
 
2035
 
 
2036
    def _activate_fallback_location(self, url):
 
2037
        """Activate the branch/repository from url as a fallback repository."""
 
2038
        self.repository.add_fallback_repository(
 
2039
            self._get_fallback_repository(url))
2647
2040
 
2648
2041
    def _open_hook(self):
2649
 
        if self._ignore_fallbacks:
2650
 
            return
2651
2042
        try:
2652
2043
            url = self.get_stacked_on_url()
2653
2044
        except (errors.UnstackableRepositoryFormat, errors.NotStacked,
2654
2045
            errors.UnstackableBranchFormat):
2655
2046
            pass
2656
2047
        else:
2657
 
            for hook in Branch.hooks['transform_fallback_location']:
2658
 
                url = hook(self, url)
2659
 
                if url is None:
2660
 
                    hook_name = Branch.hooks.get_hook_name(hook)
2661
 
                    raise AssertionError(
2662
 
                        "'transform_fallback_location' hook %s returned "
2663
 
                        "None, not a URL." % hook_name)
2664
2048
            self._activate_fallback_location(url)
2665
2049
 
 
2050
    def _check_stackable_repo(self):
 
2051
        if not self.repository._format.supports_external_lookups:
 
2052
            raise errors.UnstackableRepositoryFormat(self.repository._format,
 
2053
                self.repository.base)
 
2054
 
2666
2055
    def __init__(self, *args, **kwargs):
2667
 
        self._ignore_fallbacks = kwargs.get('ignore_fallbacks', False)
2668
 
        super(BzrBranch8, self).__init__(*args, **kwargs)
 
2056
        super(BzrBranch7, self).__init__(*args, **kwargs)
2669
2057
        self._last_revision_info_cache = None
2670
 
        self._reference_info = None
 
2058
        self._partial_revision_history_cache = []
2671
2059
 
2672
2060
    def _clear_cached_state(self):
2673
 
        super(BzrBranch8, self)._clear_cached_state()
 
2061
        super(BzrBranch7, self)._clear_cached_state()
2674
2062
        self._last_revision_info_cache = None
2675
 
        self._reference_info = None
 
2063
        self._partial_revision_history_cache = []
2676
2064
 
2677
2065
    def _last_revision_info(self):
2678
2066
        revision_string = self._transport.get_bytes('last-revision')
2707
2095
        self._last_revision_info_cache = revno, revision_id
2708
2096
        self._run_post_change_branch_tip_hooks(old_revno, old_revid)
2709
2097
 
2710
 
    def _synchronize_history(self, destination, revision_id):
2711
 
        """Synchronize last revision and revision history between branches.
2712
 
 
2713
 
        :see: Branch._synchronize_history
2714
 
        """
2715
 
        # XXX: The base Branch has a fast implementation of this method based
2716
 
        # on set_last_revision_info, but BzrBranch/BzrBranch5 have a slower one
2717
 
        # that uses set_revision_history.  This class inherits from BzrBranch5,
2718
 
        # but wants the fast implementation, so it calls
2719
 
        # Branch._synchronize_history directly.
2720
 
        Branch._synchronize_history(self, destination, revision_id)
2721
 
 
2722
2098
    def _check_history_violation(self, revision_id):
2723
2099
        last_revision = _mod_revision.ensure_null(self.last_revision())
2724
2100
        if _mod_revision.is_null(last_revision):
2725
2101
            return
2726
2102
        if last_revision not in self._lefthand_history(revision_id):
2727
 
            raise errors.AppendRevisionsOnlyViolation(self.user_url)
 
2103
            raise errors.AppendRevisionsOnlyViolation(self.base)
2728
2104
 
2729
2105
    def _gen_revision_history(self):
2730
2106
        """Generate the revision history from last revision
2733
2109
        self._extend_partial_history(stop_index=last_revno-1)
2734
2110
        return list(reversed(self._partial_revision_history_cache))
2735
2111
 
 
2112
    def _extend_partial_history(self, stop_index=None, stop_revision=None):
 
2113
        """Extend the partial history to include a given index
 
2114
 
 
2115
        If a stop_index is supplied, stop when that index has been reached.
 
2116
        If a stop_revision is supplied, stop when that revision is
 
2117
        encountered.  Otherwise, stop when the beginning of history is
 
2118
        reached.
 
2119
 
 
2120
        :param stop_index: The index which should be present.  When it is
 
2121
            present, history extension will stop.
 
2122
        :param revision_id: The revision id which should be present.  When
 
2123
            it is encountered, history extension will stop.
 
2124
        """
 
2125
        repo = self.repository
 
2126
        if len(self._partial_revision_history_cache) == 0:
 
2127
            iterator = repo.iter_reverse_revision_history(self.last_revision())
 
2128
        else:
 
2129
            start_revision = self._partial_revision_history_cache[-1]
 
2130
            iterator = repo.iter_reverse_revision_history(start_revision)
 
2131
            #skip the last revision in the list
 
2132
            next_revision = iterator.next()
 
2133
        for revision_id in iterator:
 
2134
            self._partial_revision_history_cache.append(revision_id)
 
2135
            if (stop_index is not None and
 
2136
                len(self._partial_revision_history_cache) > stop_index):
 
2137
                break
 
2138
            if revision_id == stop_revision:
 
2139
                break
 
2140
 
2736
2141
    def _write_revision_history(self, history):
2737
2142
        """Factored out of set_revision_history.
2738
2143
 
2759
2164
        """Set the parent branch"""
2760
2165
        return self._get_config_location('parent_location')
2761
2166
 
2762
 
    @needs_write_lock
2763
 
    def _set_all_reference_info(self, info_dict):
2764
 
        """Replace all reference info stored in a branch.
2765
 
 
2766
 
        :param info_dict: A dict of {file_id: (tree_path, branch_location)}
2767
 
        """
2768
 
        s = StringIO()
2769
 
        writer = rio.RioWriter(s)
2770
 
        for key, (tree_path, branch_location) in info_dict.iteritems():
2771
 
            stanza = rio.Stanza(file_id=key, tree_path=tree_path,
2772
 
                                branch_location=branch_location)
2773
 
            writer.write_stanza(stanza)
2774
 
        self._transport.put_bytes('references', s.getvalue())
2775
 
        self._reference_info = info_dict
2776
 
 
2777
 
    @needs_read_lock
2778
 
    def _get_all_reference_info(self):
2779
 
        """Return all the reference info stored in a branch.
2780
 
 
2781
 
        :return: A dict of {file_id: (tree_path, branch_location)}
2782
 
        """
2783
 
        if self._reference_info is not None:
2784
 
            return self._reference_info
2785
 
        rio_file = self._transport.get('references')
2786
 
        try:
2787
 
            stanzas = rio.read_stanzas(rio_file)
2788
 
            info_dict = dict((s['file_id'], (s['tree_path'],
2789
 
                             s['branch_location'])) for s in stanzas)
2790
 
        finally:
2791
 
            rio_file.close()
2792
 
        self._reference_info = info_dict
2793
 
        return info_dict
2794
 
 
2795
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2796
 
        """Set the branch location to use for a tree reference.
2797
 
 
2798
 
        :param file_id: The file-id of the tree reference.
2799
 
        :param tree_path: The path of the tree reference in the tree.
2800
 
        :param branch_location: The location of the branch to retrieve tree
2801
 
            references from.
2802
 
        """
2803
 
        info_dict = self._get_all_reference_info()
2804
 
        info_dict[file_id] = (tree_path, branch_location)
2805
 
        if None in (tree_path, branch_location):
2806
 
            if tree_path is not None:
2807
 
                raise ValueError('tree_path must be None when branch_location'
2808
 
                                 ' is None.')
2809
 
            if branch_location is not None:
2810
 
                raise ValueError('branch_location must be None when tree_path'
2811
 
                                 ' is None.')
2812
 
            del info_dict[file_id]
2813
 
        self._set_all_reference_info(info_dict)
2814
 
 
2815
 
    def get_reference_info(self, file_id):
2816
 
        """Get the tree_path and branch_location for a tree reference.
2817
 
 
2818
 
        :return: a tuple of (tree_path, branch_location)
2819
 
        """
2820
 
        return self._get_all_reference_info().get(file_id, (None, None))
2821
 
 
2822
 
    def reference_parent(self, file_id, path, possible_transports=None):
2823
 
        """Return the parent branch for a tree-reference file_id.
2824
 
 
2825
 
        :param file_id: The file_id of the tree reference
2826
 
        :param path: The path of the file_id in the tree
2827
 
        :return: A branch associated with the file_id
2828
 
        """
2829
 
        branch_location = self.get_reference_info(file_id)[1]
2830
 
        if branch_location is None:
2831
 
            return Branch.reference_parent(self, file_id, path,
2832
 
                                           possible_transports)
2833
 
        branch_location = urlutils.join(self.user_url, branch_location)
2834
 
        return Branch.open(branch_location,
2835
 
                           possible_transports=possible_transports)
2836
 
 
2837
2167
    def set_push_location(self, location):
2838
2168
        """See Branch.set_push_location."""
2839
2169
        self._set_config_location('push_location', location)
2873
2203
        return self._get_bound_location(False)
2874
2204
 
2875
2205
    def get_stacked_on_url(self):
2876
 
        # you can always ask for the URL; but you might not be able to use it
2877
 
        # if the repo can't support stacking.
2878
 
        ## self._check_stackable_repo()
 
2206
        self._check_stackable_repo()
2879
2207
        stacked_url = self._get_config_location('stacked_on_location')
2880
2208
        if stacked_url is None:
2881
2209
            raise errors.NotStacked(self)
2882
2210
        return stacked_url
2883
2211
 
 
2212
    def set_append_revisions_only(self, enabled):
 
2213
        if enabled:
 
2214
            value = 'True'
 
2215
        else:
 
2216
            value = 'False'
 
2217
        self.get_config().set_user_option('append_revisions_only', value,
 
2218
            warn_masked=True)
 
2219
 
 
2220
    def set_stacked_on_url(self, url):
 
2221
        self._check_stackable_repo()
 
2222
        if not url:
 
2223
            try:
 
2224
                old_url = self.get_stacked_on_url()
 
2225
            except (errors.NotStacked, errors.UnstackableBranchFormat,
 
2226
                errors.UnstackableRepositoryFormat):
 
2227
                return
 
2228
            url = ''
 
2229
            # repositories don't offer an interface to remove fallback
 
2230
            # repositories today; take the conceptually simpler option and just
 
2231
            # reopen it.
 
2232
            self.repository = self.bzrdir.find_repository()
 
2233
            # for every revision reference the branch has, ensure it is pulled
 
2234
            # in.
 
2235
            source_repository = self._get_fallback_repository(old_url)
 
2236
            for revision_id in chain([self.last_revision()],
 
2237
                self.tags.get_reverse_tag_dict()):
 
2238
                self.repository.fetch(source_repository, revision_id,
 
2239
                    find_ghosts=True)
 
2240
        else:
 
2241
            self._activate_fallback_location(url)
 
2242
        # write this out after the repository is stacked to avoid setting a
 
2243
        # stacked config that doesn't work.
 
2244
        self._set_config_location('stacked_on_location', url)
 
2245
 
2884
2246
    def _get_append_revisions_only(self):
2885
 
        return self.get_config(
2886
 
            ).get_user_option_as_bool('append_revisions_only')
 
2247
        value = self.get_config().get_user_option('append_revisions_only')
 
2248
        return value == 'True'
 
2249
 
 
2250
    def _synchronize_history(self, destination, revision_id):
 
2251
        """Synchronize last revision and revision history between branches.
 
2252
 
 
2253
        This version is most efficient when the destination is also a
 
2254
        BzrBranch6, but works for BzrBranch5, as long as the destination's
 
2255
        repository contains all the lefthand ancestors of the intended
 
2256
        last_revision.  If not, set_last_revision_info will fail.
 
2257
 
 
2258
        :param destination: The branch to copy the history into
 
2259
        :param revision_id: The revision-id to truncate history at.  May
 
2260
          be None to copy complete history.
 
2261
        """
 
2262
        source_revno, source_revision_id = self.last_revision_info()
 
2263
        if revision_id is None:
 
2264
            revno, revision_id = source_revno, source_revision_id
 
2265
        elif source_revision_id == revision_id:
 
2266
            # we know the revno without needing to walk all of history
 
2267
            revno = source_revno
 
2268
        else:
 
2269
            # To figure out the revno for a random revision, we need to build
 
2270
            # the revision history, and count its length.
 
2271
            # We don't care about the order, just how long it is.
 
2272
            # Alternatively, we could start at the current location, and count
 
2273
            # backwards. But there is no guarantee that we will find it since
 
2274
            # it may be a merged revision.
 
2275
            revno = len(list(self.repository.iter_reverse_revision_history(
 
2276
                                                                revision_id)))
 
2277
        destination.set_last_revision_info(revno, revision_id)
 
2278
 
 
2279
    def _make_tags(self):
 
2280
        return BasicTags(self)
2887
2281
 
2888
2282
    @needs_write_lock
2889
2283
    def generate_revision_history(self, revision_id, last_rev=None,
2929
2323
        return self.revno() - index
2930
2324
 
2931
2325
 
2932
 
class BzrBranch7(BzrBranch8):
2933
 
    """A branch with support for a fallback repository."""
2934
 
 
2935
 
    def set_reference_info(self, file_id, tree_path, branch_location):
2936
 
        Branch.set_reference_info(self, file_id, tree_path, branch_location)
2937
 
 
2938
 
    def get_reference_info(self, file_id):
2939
 
        Branch.get_reference_info(self, file_id)
2940
 
 
2941
 
    def reference_parent(self, file_id, path, possible_transports=None):
2942
 
        return Branch.reference_parent(self, file_id, path,
2943
 
                                       possible_transports)
2944
 
 
2945
 
 
2946
2326
class BzrBranch6(BzrBranch7):
2947
2327
    """See BzrBranchFormat6 for the capabilities of this branch.
2948
2328
 
2951
2331
    """
2952
2332
 
2953
2333
    def get_stacked_on_url(self):
2954
 
        raise errors.UnstackableBranchFormat(self._format, self.user_url)
 
2334
        raise errors.UnstackableBranchFormat(self._format, self.base)
 
2335
 
 
2336
    def set_stacked_on_url(self, url):
 
2337
        raise errors.UnstackableBranchFormat(self._format, self.base)
2955
2338
 
2956
2339
 
2957
2340
######################################################################
2975
2358
    :ivar new_revno: Revision number after pull.
2976
2359
    :ivar old_revid: Tip revision id before pull.
2977
2360
    :ivar new_revid: Tip revision id after pull.
2978
 
    :ivar source_branch: Source (local) branch object. (read locked)
 
2361
    :ivar source_branch: Source (local) branch object.
2979
2362
    :ivar master_branch: Master branch of the target, or the target if no
2980
2363
        Master
2981
2364
    :ivar local_branch: target branch if there is a Master, else None
2982
 
    :ivar target_branch: Target/destination branch object. (write locked)
 
2365
    :ivar target_branch: Target/destination branch object.
2983
2366
    :ivar tag_conflicts: A list of tag conflicts, see BasicTags.merge_to
2984
2367
    """
2985
2368
 
2996
2379
        self._show_tag_conficts(to_file)
2997
2380
 
2998
2381
 
2999
 
class BranchPushResult(_Result):
 
2382
class PushResult(_Result):
3000
2383
    """Result of a Branch.push operation.
3001
2384
 
3002
 
    :ivar old_revno: Revision number (eg 10) of the target before push.
3003
 
    :ivar new_revno: Revision number (eg 12) of the target after push.
3004
 
    :ivar old_revid: Tip revision id (eg joe@foo.com-1234234-aoeua34) of target
3005
 
        before the push.
3006
 
    :ivar new_revid: Tip revision id (eg joe@foo.com-5676566-boa234a) of target
3007
 
        after the push.
3008
 
    :ivar source_branch: Source branch object that the push was from. This is
3009
 
        read locked, and generally is a local (and thus low latency) branch.
3010
 
    :ivar master_branch: If target is a bound branch, the master branch of
3011
 
        target, or target itself. Always write locked.
3012
 
    :ivar target_branch: The direct Branch where data is being sent (write
3013
 
        locked).
3014
 
    :ivar local_branch: If the target is a bound branch this will be the
3015
 
        target, otherwise it will be None.
 
2385
    :ivar old_revno: Revision number before push.
 
2386
    :ivar new_revno: Revision number after push.
 
2387
    :ivar old_revid: Tip revision id before push.
 
2388
    :ivar new_revid: Tip revision id after push.
 
2389
    :ivar source_branch: Source branch object.
 
2390
    :ivar master_branch: Master branch of the target, or None.
 
2391
    :ivar target_branch: Target/destination branch object.
3016
2392
    """
3017
2393
 
3018
2394
    def __int__(self):
3022
2398
    def report(self, to_file):
3023
2399
        """Write a human-readable description of the result."""
3024
2400
        if self.old_revid == self.new_revid:
3025
 
            note('No new revisions to push.')
 
2401
            to_file.write('No new revisions to push.\n')
3026
2402
        else:
3027
 
            note('Pushed up to revision %d.' % self.new_revno)
 
2403
            to_file.write('Pushed up to revision %d.\n' % self.new_revno)
3028
2404
        self._show_tag_conficts(to_file)
3029
2405
 
3030
2406
 
3036
2412
 
3037
2413
    def __init__(self, branch):
3038
2414
        self.branch = branch
3039
 
        self.errors = []
3040
2415
 
3041
2416
    def report_results(self, verbose):
3042
2417
        """Report the check results via trace.note.
3043
 
 
 
2418
        
3044
2419
        :param verbose: Requests more detailed display of what was checked,
3045
2420
            if any.
3046
2421
        """
3047
 
        note('checked branch %s format %s', self.branch.user_url,
3048
 
            self.branch._format)
3049
 
        for error in self.errors:
3050
 
            note('found error:%s', error)
 
2422
        note('checked branch %s format %s',
 
2423
             self.branch.base,
 
2424
             self.branch._format)
3051
2425
 
3052
2426
 
3053
2427
class Converter5to6(object):
3089
2463
        branch._set_config_location('stacked_on_location', '')
3090
2464
        # update target format
3091
2465
        branch._transport.put_bytes('format', format.get_format_string())
3092
 
 
3093
 
 
3094
 
class Converter7to8(object):
3095
 
    """Perform an in-place upgrade of format 6 to format 7"""
3096
 
 
3097
 
    def convert(self, branch):
3098
 
        format = BzrBranchFormat8()
3099
 
        branch._transport.put_bytes('references', '')
3100
 
        # update target format
3101
 
        branch._transport.put_bytes('format', format.get_format_string())
3102
 
 
3103
 
 
3104
 
def _run_with_write_locked_target(target, callable, *args, **kwargs):
3105
 
    """Run ``callable(*args, **kwargs)``, write-locking target for the
3106
 
    duration.
3107
 
 
3108
 
    _run_with_write_locked_target will attempt to release the lock it acquires.
3109
 
 
3110
 
    If an exception is raised by callable, then that exception *will* be
3111
 
    propagated, even if the unlock attempt raises its own error.  Thus
3112
 
    _run_with_write_locked_target should be preferred to simply doing::
3113
 
 
3114
 
        target.lock_write()
3115
 
        try:
3116
 
            return callable(*args, **kwargs)
3117
 
        finally:
3118
 
            target.unlock()
3119
 
 
3120
 
    """
3121
 
    # This is very similar to bzrlib.decorators.needs_write_lock.  Perhaps they
3122
 
    # should share code?
3123
 
    target.lock_write()
3124
 
    try:
3125
 
        result = callable(*args, **kwargs)
3126
 
    except:
3127
 
        exc_info = sys.exc_info()
3128
 
        try:
3129
 
            target.unlock()
3130
 
        finally:
3131
 
            raise exc_info[0], exc_info[1], exc_info[2]
3132
 
    else:
3133
 
        target.unlock()
3134
 
        return result
3135
 
 
3136
 
 
3137
 
class InterBranch(InterObject):
3138
 
    """This class represents operations taking place between two branches.
3139
 
 
3140
 
    Its instances have methods like pull() and push() and contain
3141
 
    references to the source and target repositories these operations
3142
 
    can be carried out on.
3143
 
    """
3144
 
 
3145
 
    _optimisers = []
3146
 
    """The available optimised InterBranch types."""
3147
 
 
3148
 
    @staticmethod
3149
 
    def _get_branch_formats_to_test():
3150
 
        """Return a tuple with the Branch formats to use when testing."""
3151
 
        raise NotImplementedError(InterBranch._get_branch_formats_to_test)
3152
 
 
3153
 
    def pull(self, overwrite=False, stop_revision=None,
3154
 
             possible_transports=None, local=False):
3155
 
        """Mirror source into target branch.
3156
 
 
3157
 
        The target branch is considered to be 'local', having low latency.
3158
 
 
3159
 
        :returns: PullResult instance
3160
 
        """
3161
 
        raise NotImplementedError(self.pull)
3162
 
 
3163
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3164
 
                         graph=None):
3165
 
        """Pull in new perfect-fit revisions.
3166
 
 
3167
 
        :param stop_revision: Updated until the given revision
3168
 
        :param overwrite: Always set the branch pointer, rather than checking
3169
 
            to see if it is a proper descendant.
3170
 
        :param graph: A Graph object that can be used to query history
3171
 
            information. This can be None.
3172
 
        :return: None
3173
 
        """
3174
 
        raise NotImplementedError(self.update_revisions)
3175
 
 
3176
 
    def push(self, overwrite=False, stop_revision=None,
3177
 
             _override_hook_source_branch=None):
3178
 
        """Mirror the source branch into the target branch.
3179
 
 
3180
 
        The source branch is considered to be 'local', having low latency.
3181
 
        """
3182
 
        raise NotImplementedError(self.push)
3183
 
 
3184
 
 
3185
 
class GenericInterBranch(InterBranch):
3186
 
    """InterBranch implementation that uses public Branch functions.
3187
 
    """
3188
 
 
3189
 
    @staticmethod
3190
 
    def _get_branch_formats_to_test():
3191
 
        return BranchFormat._default_format, BranchFormat._default_format
3192
 
 
3193
 
    def update_revisions(self, stop_revision=None, overwrite=False,
3194
 
        graph=None):
3195
 
        """See InterBranch.update_revisions()."""
3196
 
        self.source.lock_read()
3197
 
        try:
3198
 
            other_revno, other_last_revision = self.source.last_revision_info()
3199
 
            stop_revno = None # unknown
3200
 
            if stop_revision is None:
3201
 
                stop_revision = other_last_revision
3202
 
                if _mod_revision.is_null(stop_revision):
3203
 
                    # if there are no commits, we're done.
3204
 
                    return
3205
 
                stop_revno = other_revno
3206
 
 
3207
 
            # what's the current last revision, before we fetch [and change it
3208
 
            # possibly]
3209
 
            last_rev = _mod_revision.ensure_null(self.target.last_revision())
3210
 
            # we fetch here so that we don't process data twice in the common
3211
 
            # case of having something to pull, and so that the check for
3212
 
            # already merged can operate on the just fetched graph, which will
3213
 
            # be cached in memory.
3214
 
            self.target.fetch(self.source, stop_revision)
3215
 
            # Check to see if one is an ancestor of the other
3216
 
            if not overwrite:
3217
 
                if graph is None:
3218
 
                    graph = self.target.repository.get_graph()
3219
 
                if self.target._check_if_descendant_or_diverged(
3220
 
                        stop_revision, last_rev, graph, self.source):
3221
 
                    # stop_revision is a descendant of last_rev, but we aren't
3222
 
                    # overwriting, so we're done.
3223
 
                    return
3224
 
            if stop_revno is None:
3225
 
                if graph is None:
3226
 
                    graph = self.target.repository.get_graph()
3227
 
                this_revno, this_last_revision = \
3228
 
                        self.target.last_revision_info()
3229
 
                stop_revno = graph.find_distance_to_null(stop_revision,
3230
 
                                [(other_last_revision, other_revno),
3231
 
                                 (this_last_revision, this_revno)])
3232
 
            self.target.set_last_revision_info(stop_revno, stop_revision)
3233
 
        finally:
3234
 
            self.source.unlock()
3235
 
 
3236
 
    def pull(self, overwrite=False, stop_revision=None,
3237
 
             possible_transports=None, _hook_master=None, run_hooks=True,
3238
 
             _override_hook_target=None, local=False):
3239
 
        """See Branch.pull.
3240
 
 
3241
 
        :param _hook_master: Private parameter - set the branch to
3242
 
            be supplied as the master to pull hooks.
3243
 
        :param run_hooks: Private parameter - if false, this branch
3244
 
            is being called because it's the master of the primary branch,
3245
 
            so it should not run its hooks.
3246
 
        :param _override_hook_target: Private parameter - set the branch to be
3247
 
            supplied as the target_branch to pull hooks.
3248
 
        :param local: Only update the local branch, and not the bound branch.
3249
 
        """
3250
 
        # This type of branch can't be bound.
3251
 
        if local:
3252
 
            raise errors.LocalRequiresBoundBranch()
3253
 
        result = PullResult()
3254
 
        result.source_branch = self.source
3255
 
        if _override_hook_target is None:
3256
 
            result.target_branch = self.target
3257
 
        else:
3258
 
            result.target_branch = _override_hook_target
3259
 
        self.source.lock_read()
3260
 
        try:
3261
 
            # We assume that during 'pull' the target repository is closer than
3262
 
            # the source one.
3263
 
            self.source.update_references(self.target)
3264
 
            graph = self.target.repository.get_graph(self.source.repository)
3265
 
            # TODO: Branch formats should have a flag that indicates 
3266
 
            # that revno's are expensive, and pull() should honor that flag.
3267
 
            # -- JRV20090506
3268
 
            result.old_revno, result.old_revid = \
3269
 
                self.target.last_revision_info()
3270
 
            self.target.update_revisions(self.source, stop_revision,
3271
 
                overwrite=overwrite, graph=graph)
3272
 
            # TODO: The old revid should be specified when merging tags, 
3273
 
            # so a tags implementation that versions tags can only 
3274
 
            # pull in the most recent changes. -- JRV20090506
3275
 
            result.tag_conflicts = self.source.tags.merge_to(self.target.tags,
3276
 
                overwrite)
3277
 
            result.new_revno, result.new_revid = self.target.last_revision_info()
3278
 
            if _hook_master:
3279
 
                result.master_branch = _hook_master
3280
 
                result.local_branch = result.target_branch
3281
 
            else:
3282
 
                result.master_branch = result.target_branch
3283
 
                result.local_branch = None
3284
 
            if run_hooks:
3285
 
                for hook in Branch.hooks['post_pull']:
3286
 
                    hook(result)
3287
 
        finally:
3288
 
            self.source.unlock()
3289
 
        return result
3290
 
 
3291
 
    def push(self, overwrite=False, stop_revision=None,
3292
 
             _override_hook_source_branch=None):
3293
 
        """See InterBranch.push.
3294
 
 
3295
 
        This is the basic concrete implementation of push()
3296
 
 
3297
 
        :param _override_hook_source_branch: If specified, run
3298
 
        the hooks passing this Branch as the source, rather than self.
3299
 
        This is for use of RemoteBranch, where push is delegated to the
3300
 
        underlying vfs-based Branch.
3301
 
        """
3302
 
        # TODO: Public option to disable running hooks - should be trivial but
3303
 
        # needs tests.
3304
 
        self.source.lock_read()
3305
 
        try:
3306
 
            return _run_with_write_locked_target(
3307
 
                self.target, self._push_with_bound_branches, overwrite,
3308
 
                stop_revision,
3309
 
                _override_hook_source_branch=_override_hook_source_branch)
3310
 
        finally:
3311
 
            self.source.unlock()
3312
 
 
3313
 
    def _push_with_bound_branches(self, overwrite, stop_revision,
3314
 
            _override_hook_source_branch=None):
3315
 
        """Push from source into target, and into target's master if any.
3316
 
        """
3317
 
        def _run_hooks():
3318
 
            if _override_hook_source_branch:
3319
 
                result.source_branch = _override_hook_source_branch
3320
 
            for hook in Branch.hooks['post_push']:
3321
 
                hook(result)
3322
 
 
3323
 
        bound_location = self.target.get_bound_location()
3324
 
        if bound_location and self.target.base != bound_location:
3325
 
            # there is a master branch.
3326
 
            #
3327
 
            # XXX: Why the second check?  Is it even supported for a branch to
3328
 
            # be bound to itself? -- mbp 20070507
3329
 
            master_branch = self.target.get_master_branch()
3330
 
            master_branch.lock_write()
3331
 
            try:
3332
 
                # push into the master from the source branch.
3333
 
                self.source._basic_push(master_branch, overwrite, stop_revision)
3334
 
                # and push into the target branch from the source. Note that we
3335
 
                # push from the source branch again, because its considered the
3336
 
                # highest bandwidth repository.
3337
 
                result = self.source._basic_push(self.target, overwrite,
3338
 
                    stop_revision)
3339
 
                result.master_branch = master_branch
3340
 
                result.local_branch = self.target
3341
 
                _run_hooks()
3342
 
                return result
3343
 
            finally:
3344
 
                master_branch.unlock()
3345
 
        else:
3346
 
            # no master branch
3347
 
            result = self.source._basic_push(self.target, overwrite,
3348
 
                stop_revision)
3349
 
            # TODO: Why set master_branch and local_branch if there's no
3350
 
            # binding?  Maybe cleaner to just leave them unset? -- mbp
3351
 
            # 20070504
3352
 
            result.master_branch = self.target
3353
 
            result.local_branch = None
3354
 
            _run_hooks()
3355
 
            return result
3356
 
 
3357
 
    @classmethod
3358
 
    def is_compatible(self, source, target):
3359
 
        # GenericBranch uses the public API, so always compatible
3360
 
        return True
3361
 
 
3362
 
 
3363
 
class InterToBranch5(GenericInterBranch):
3364
 
 
3365
 
    @staticmethod
3366
 
    def _get_branch_formats_to_test():
3367
 
        return BranchFormat._default_format, BzrBranchFormat5()
3368
 
 
3369
 
    def pull(self, overwrite=False, stop_revision=None,
3370
 
             possible_transports=None, run_hooks=True,
3371
 
             _override_hook_target=None, local=False):
3372
 
        """Pull from source into self, updating my master if any.
3373
 
 
3374
 
        :param run_hooks: Private parameter - if false, this branch
3375
 
            is being called because it's the master of the primary branch,
3376
 
            so it should not run its hooks.
3377
 
        """
3378
 
        bound_location = self.target.get_bound_location()
3379
 
        if local and not bound_location:
3380
 
            raise errors.LocalRequiresBoundBranch()
3381
 
        master_branch = None
3382
 
        if not local and bound_location and self.source.user_url != bound_location:
3383
 
            # not pulling from master, so we need to update master.
3384
 
            master_branch = self.target.get_master_branch(possible_transports)
3385
 
            master_branch.lock_write()
3386
 
        try:
3387
 
            if master_branch:
3388
 
                # pull from source into master.
3389
 
                master_branch.pull(self.source, overwrite, stop_revision,
3390
 
                    run_hooks=False)
3391
 
            return super(InterToBranch5, self).pull(overwrite,
3392
 
                stop_revision, _hook_master=master_branch,
3393
 
                run_hooks=run_hooks,
3394
 
                _override_hook_target=_override_hook_target)
3395
 
        finally:
3396
 
            if master_branch:
3397
 
                master_branch.unlock()
3398
 
 
3399
 
 
3400
 
InterBranch.register_optimiser(GenericInterBranch)
3401
 
InterBranch.register_optimiser(InterToBranch5)